Sommario:
- Passaggio 1: interfaccia SD
- Passaggio 2: mappatura dei pin GPIO ESP32
- Passaggio 3: requisiti per il pull-up SD
- Passaggio 4: hardware vario
- Passaggio 5: scheda di sblocco per slot per schede SD
- Passaggio 6: scollegare GPIO 2 durante il programma
- Passaggio 7: benchmark
- Passaggio 8: benchmark della modalità a 4 bit SD_MMC
- Passaggio 9: benchmark della modalità a 1 bit SD_MMC
- Passaggio 10: modalità SD SPI al benchmark del bus HSPI
- Passaggio 11: modalità SD SPI al benchmark del bus VSPI
- Passaggio 12: arrotondamento
Video: Seleziona l'interfaccia SD per ESP32: 12 passaggi (con immagini)
2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01
Queste istruzioni mostrano qualcosa sulla selezione di un'interfaccia SD per il tuo progetto ESP32.
Passaggio 1: interfaccia SD
Nella libreria SD Arduino originale, SD Interface utilizza la modalità di trasferimento bus SD SPI.
SD in realtà ha più modalità di trasferimento:
- Modalità bus SPI: ESP32 ha più di 1 bus SPI, può essere personalizzato durante l'inizializzazione
- Modalità bus SD a 1 bit / 4 bit: ESP32 dedica un'altra libreria chiamata SD_MMC per implementare l'API della modalità bus SD
- Modalità SD UHS-II: ESP32 non supportato
Rif.:
www.arduino.cc/en/reference/SD
en.wikipedia.org/wiki/SD_card
docs.espressif.com/projects/esp-idf/en/lat…
Passaggio 2: mappatura dei pin GPIO ESP32
Ecco la mappatura dei pin GPIO ESP32 predefinita:
Pin della scheda SD | Pin MicroSD | Nome | Bus SD a 4 bit | Bus SD a 1 bit | Bus SPI (pin HSPI / VSPInative) |
1 | 2 | RE3 | 13 | - | SS (15 / 5) |
2 | 3 | CMD | 15 | 15 | MOSI (13 / 23) |
3 | - | VSS | GND | GND | GND |
4 | 4 | VDD | 3,3 V | 3,3 V | 3,3 V |
5 | 5 | CLK | 14 | 14 | SCK (14 / 18) |
6 | 6 | VSS | GND | GND | GND |
7 | 7 | D0 | 2 | 2 | MISO (12 / 19) |
8 | 8 | D1 | 4 | - | - |
9 | 1 | re2 | 12 | - | - |
La mappatura dei pin GPIO del bus SD a 1 bit / 4 bit non può essere modificata.
Chiamata semplice SD_MMC begin() alla modalità bus SD a 4 bit iniziale:
SD_MMC.begin();
La modalità bus SD a 1 bit può essere selezionata nel metodo SD_MMC begin(), ad es.
SD_MMC.begin("/cdcard", true);
Il bus SPI (HSPI o VSPI) può essere selezionato durante la creazione dell'istanza SPIClass, ad es.
SPIClass spi = SPIClass(HSPI);
Come puoi vedere, i pin del bus SD a 1 bit / 4 bit condividono i pin con HSPI ma la mappatura dei pin della scheda SD non è la stessa. Quindi, se l'hardware è collegato in base alla mappa dei pin del bus SD, non può utilizzare direttamente i pin nativi HSPI. I pin GPIO possono essere sovrascritti nel metodo SPIClass begin(), ad es.
SPIClass spi = SPIClass(HSPI);
spi.begin(14 /* SCK */, 2 /* MISO */, 15 /* MOSI */, 13 /* SS */);
E anche la libreria SD può sovrascrivere il pin SS, il bus SPI e la frequenza del bus con il metodo SD begin(), ad es.
SD.begin(13 /* SS */, spi, 80000000);
Passaggio 3: requisiti per il pull-up SD
Se si desidera utilizzare la modalità bus SD a 4 bit, seguire i requisiti di pull-up SD ESP32, in particolare:
- Conflitti pull-up su GPIO13
- Conflitti tra Bootstrap e SDIO su DAT2
Rif.:
docs.espressif.com/projects/esp-idf/en/lat…
Passaggio 4: hardware vario
ESP32 ha tonnellate di kit di sviluppo e scheda di sviluppo, alcuni di essi hanno uno slot per schede MicroSD integrato.
Ecco alcuni esempi nella mia mano:
- TTGO T-Watch, è collegato ai pin GPIO 2, 13, 14 e 15 in base alla modalità bus SD a 1 bit, quindi può utilizzare la modalità bus SD a 1 bit e la modalità bus SPI
- M5Stack Series, è collegato ai pin GPIO 4, 18, 19 e 23 in base ai pin nativi VSPI, quindi può utilizzare le impostazioni predefinite della libreria SD [SD.begin(4)]
- ODROID-GO, si è connesso ai pin GPIO 18, 19, 22 e 23 in base ai pin nativi VSPI, quindi può utilizzare le impostazioni predefinite della libreria SD [SD.begin(22)]
- ESP32-CAM, è collegato ai pin GPIO 2, 4, 12, 13, 14 e 15 in base alla modalità bus SD a 4 bit, quindi può utilizzare tutte le modalità bus SD a 4 bit / 1 bit e la modalità bus SPI
- Scheda di sviluppo TTGO T8, collegata ai pin GPIO 2, 13, 14 e 15 in base alla modalità bus SD a 1 bit, quindi può utilizzare la modalità bus SD a 1 bit e la modalità bus SPI
www.lilygo.cn/prod_view.aspx?Id=1123
docs.m5stack.com/
wiki.odroid.com/odroid_go/odroid_go
wiki.ai-thinker.com/esp32-cam
github.com/LilyGO/TTGO-T8-ESP32
Passaggio 5: scheda di sblocco per slot per schede SD
La scheda di sviluppo con slot per schede MicroSD integrato potrebbe non collegare tutti i pin e la maggior parte non può utilizzare la modalità bus SD a 4 bit. Una singola scheda breakout per slot per schede SD offre una maggiore flessibilità.
Allo stesso tempo, molte schede breakout LCD aprono anche uno slot per schede SD a grandezza naturale. Tuttavia, la maggior parte di essi interrompe solo i pin della modalità SPI. Non è sufficiente utilizzarla come modalità bus SD a 4 bit, ma puoi comunque utilizzarla come modalità bus SD a 1 bit con questa mappatura di connessione:
LCD -> ESP32
SD_CS -> zero SD_MOSI -> 15 SD_MISO -> 2 SD_SCK -> 14
Passaggio 6: scollegare GPIO 2 durante il programma
La connessione in modalità bus SD a 4 bit impedisce a ESP32 di entrare in modalità programma. Ricordare di scollegare il GPIO 2 dalla scheda di breakout dello slot per schede SD DAT0 prima di caricare il nuovo programma.
Passaggio 7: benchmark
Ho scritto un semplice programma Arduino per il benchmark:
github.com/moononournation/ESP32_SD_Benchm…
Ecco l'hardware per il benchmark:
ESP32
NodeMCU ESP32-32S V1.1 (WROOM-32)
Slot per scheda SD
Una scheda breakout per slot per schede MicroSD
Scheda SD
Ho una MicroSD SanDisk da 8 GB e una vecchia MicroSD da 128 MB in mano.
Passaggio 8: benchmark della modalità a 4 bit SD_MMC
MicroSD SanDisk da 8 GB
20:27:46.000 -> Test di scrittura /test_1k.bin
20:27:59.399 -> Scrivi file utilizzato: 13404 ms, 312.914368 KB/s 20:27:59.399 -> Test di scrittura /test_2k.bin 20:28:17.248 -> Scrivi file utilizzato: 17834 ms, 235.185822 KB/s 20:28:17.248 -> Test di scrittura /test_4k.bin 20:28:21.122 -> File di scrittura utilizzato: 3873 ms, 1082.959961 KB/s 20:28:21.122 -> Test di scrittura /test_8k.bin 20:28:23.147 -> File di scrittura utilizzato: 2024 ms, 2072.284668 KB/s 20:28:23.147 -> Test di scrittura /test_16k.bin 20:28:27.237 -> File di scrittura utilizzato: 4097 ms, 1023.750061 KB/s 20:28:27.237 -> Test write /test_32k.bin 20:28:30.088 -> Scrivi file utilizzato: 2842 ms, 1475.828247 KB/s 20:28:30.088 -> Test write /test_64k.bin 20:28:31.882 -> Scrivi file utilizzato: 1811 ms, 2316.015381 KB/s 20:28:31.882 -> Lettura test /test_1k.bin 20:28:35.422 -> Lettura file utilizzato: 3520 ms, 1191.563599 KB/s 20:28:35.422 -> Lettura test /test_2k.bin 20: 28:38.813 -> Leggi file utilizzato: 3389 ms, 1237.622925 KB/s 20:28:38.813 -> Test letto /test_4k.bin 20:28:42.273 -> Leggi file utilizzato: 3474 ms, 1207.341431 KB/s 20:28:42.273 -> Test letto /test_8k.bin 20:28:45.752 - > File letto utilizzato: 3487 ms, 1202.840210 KB/s 20:28:45.752 -> Test letto /test_16k.bin 20:28:48.988 -> File letto utilizzato: 3213 ms, 1305.416748 KB/s 20:28:48.988 -> Test letto /test_32k.bin 20:28:52.077 -> Leggi file utilizzato: 3093 ms, 1356.063354 KB/s 20:28:52.077 -> Test letto /test_64k.bin 20:28:55.141 -> Leggi file utilizzato: 3080 ms, 1361.786987 KB/s
Vecchia MicroSD da 128 MB
20:30:43.309 -> E (274) sdmmc_sd: sdmmc_check_scr: send_scr ha restituito 0x109
20:30:43.309 -> Montaggio scheda fallito
Passaggio 9: benchmark della modalità a 1 bit SD_MMC
MicroSD SanDisk da 8 GB
20:31:45.194 -> Test di scrittura /test_1k.bin
20:31:59.506 -> File di scrittura utilizzato: 14325 ms, 292.796082 KB/s 20:31:59.506 -> Scrittura di test /test_2k.bin 20:32:17.686 -> File di scrittura utilizzato: 18163 ms, 230.925735 KB/s 20:32:17.686 -> Test di scrittura /test_4k.bin 20:32:21.291 -> File di scrittura utilizzato: 3611 ms, 1161.535278 KB/s 20:32:21.291 -> Test di scrittura /test_8k.bin 20:32:23.939 -> File di scrittura utilizzato: 2652 ms, 1581.562622 KB/s 20:32:23.939 -> Test di scrittura /test_16k.bin 20:32:28.397 -> File di scrittura utilizzato: 4448 ms, 942.964050 KB/s 20:32:28.397 -> Test write /test_32k.bin 20:32:31.835 -> Scrivi file utilizzato: 3429 ms, 1223.185791 KB/s 20:32:31.835 -> Test write /test_64k.bin 20:32:33.882 -> Scrivi file utilizzato: 2058 ms, 2038.048584 KB/s 20:32:33.882 -> Test di lettura /test_1k.bin 20:32:38.031 -> File di lettura utilizzato: 4146 ms, 1011.650757 KB/s 20:32:38.031 -> Test di lettura /test_2k.bin 20: 32:42.062 -> Leggi file utilizzato: 4019 ms, 1043.618774 KB/s 20:32:42.062 -> Test letto /test_4k.bin 20:32:46.170 -> Leggi file utilizzato: 4106 ms, 1021.506104 KB/s 20:32:46.170 -> Test letto /test_8k.bin 20:32:50.288 -> File letto utilizzato: 4121 ms, 1017.787903 KB/s 20:32:50.288 -> Test letto /test_16k.bin 20:32:54.112 -> File letto utilizzato: 3840 ms, 1092.266724 KB/s 20:32:54.112 -> Test read /test_32k.bin 20:32:57.840 -> Leggi file utilizzato: 3739 ms, 1121.771606 KB/s 20:32:57.840 -> Test read /test_64k.bin 20:33:01.568 -> Leggi file utilizzato: 3711 ms, 1130.235474 KB/s
Vecchia MicroSD da 128 MB
20:33:27.366 -> Test di scrittura /test_1k.bin
20:33:42.386 -> Scrivi file utilizzato: 15020 ms, 279.247925 KB/s 20:33:42.386 -> Test di scrittura /test_2k.bin 20:33:57.927 -> Scrivi file utilizzato: 15515 ms, 270.338654 KB/s 20:33:57.927 -> Test di scrittura /test_4k.bin 20:34:13.108 -> Scrivi file utilizzato: 15195 ms, 276.031860 KB/s 20:34:13.108 -> Test di scrittura /test_8k.bin 20:34:28.162 -> File di scrittura utilizzato: 15048 ms, 278.728333 KB/s 20:34:28.162 -> Test di scrittura /test_16k.bin 20:34:43.287 -> File di scrittura utilizzato: 15142 ms, 276.998016 KB/s 20:34:43.287 -> Test write /test_32k.bin 20:34:58.278 -> Scrivi file utilizzato: 14964 ms, 280.292969 KB/s 20:34:58.278 -> Test write /test_64k.bin 20:35:13.370 -> Scrivi file utilizzato: 15101 ms, 277.750092 KB/s 20:35:13.370 -> Lettura test /test_1k.bin 20:35:17.563 -> Lettura file utilizzato: 4197 ms, 999.357666 KB/s 20:35:17.563 -> Lettura test /test_2k.bin 20: 35:21.746 -> Leggi file utilizzato: 4191 ms, 1000.788330 KB/s 20:35:21.746 -> Test letto /test_4k.bin 20:35:25.942 -> Leggi file utilizzato: 4181 ms, 1003.182007 KB/s 20:35:25.942 -> Test letto /test_8k.bin 20:35:30.101 -> File letto utilizzato: 4176 ms, 1004.383118 KB/s 20:35:30.101 -> Test letto /test_16k.bin 20:35:34.279 -> File letto utilizzato: 4174 ms, 1004.864380 KB/s 20:35:34.279 -> Test read /test_32k.bin 20:35:38.462 -> Leggi file utilizzato: 4173 ms, 1005.105225 KB/s 20:35:38.462 -> Test read /test_64k.bin 20:35:42.612 -> Leggi file utilizzato: 4173 ms, 1005.105225 KB/s
Passaggio 10: modalità SD SPI al benchmark del bus HSPI
MicroSD SanDisk da 8 GB
08:41:19.703 -> Test di scrittura /test_1k.bin
08:41:53.458 -> File di scrittura utilizzato: 33743 ms, 124.301453 KB/s 08:41:53.458 -> Scrittura di test /test_2k.bin 08:42:10.000 -> File di scrittura utilizzato: 16540 ms, 253.585495 KB/s 08:42:10.000 -> Test di scrittura /test_4k.bin 08:42:17.269 -> File di scrittura utilizzato: 7298 ms, 574.719666 KB/s 08:42:17.308 -> Test di scrittura /test_8k.bin 08:42:22.640 -> File di scrittura utilizzato: 5345 ms, 784.715454 KB/s 08:42:22.640 -> Test di scrittura /test_16k.bin 08:42:32.285 -> File di scrittura utilizzato: 9662 ms, 434.103088 KB/s 08:42:32.285 -> Test write /test_32k.bin 08:42:36.659 -> Scrivi file utilizzato: 4355 ms, 963.100830 KB/s 08:42:36.659 -> Test write /test_64k.bin 08:42:39.594 -> Scrivi file utilizzato: 2949 ms, 1422.280151 KB/s 08:42:39.594 -> Lettura test /test_1k.bin 08:42:44.774 -> Lettura file utilizzato: 5192 ms, 807.839783 KB/s 08:42:44.774 -> Lettura test /test_2k.bin 08: 42:49.969 -> Leggi file utilizzato: 5189 ms, 808.306824 KB/s 08:42:49.969 -> Test letto /test_4k.bin 08:42:55.123 -> Leggi file utilizzato: 5161 ms, 812.692139 KB/s 08:42:55.158 -> Test letto /test_8k.bin 08:43:00.300 -> Leggi file utilizzato: 5176 ms, 810.336914 KB/s 08:43:00.334 -> Lettura test /test_16k.bin 08:43:05.277 -> Lettura file utilizzato: 4948 ms, 847.676636 KB/s 08:43:05.277 -> Lettura test /test_32k.bin 08:43:10.028 -> Leggi file utilizzato: 4773 ms, 878.756348 KB/s 08:43:10.028 -> Test letto /test_64k.bin 08:43:14.760 -> Leggi file utilizzato: 4731 ms, 886.557617 KB/s
Vecchia MicroSD da 128 MB
08:43:47.777 -> Test di scrittura /test_1k.bin
08:44:04.148 -> Scrivi file utilizzato: 16390 ms, 255.906281 KB/s 08:44:04.183 -> Test di scrittura /test_2k.bin 08:44:20.648 -> Scrivi file utilizzato: 16494 ms, 254.292709 KB/s 08:44:20.648 -> Test di scrittura /test_4k.bin 08:44:36.674 -> File di scrittura utilizzato: 16001 ms, 262.127625 KB/s 08:44:36.674 -> Test di scrittura /test_8k.bin 08:44:52.849 -> File di scrittura utilizzato: 16175 ms, 259.307831 KB/s 08:44:52.849 -> Test di scrittura /test_16k.bin 08:45:09.225 -> File di scrittura utilizzato: 16397 ms, 255.797043 KB/s 08:45:09.225 -> Test write /test_32k.bin 08:45:25.363 -> Scrivi file utilizzato: 16143 ms, 259.821838 KB/s 08:45:25.397 -> Test write /test_64k.bin 08:45:41.632 -> Scrivi file utilizzato: 16263 ms, 257.904694 KB/s 08:45:41.632 -> Lettura test /test_1k.bin 08:45:46.488 -> Lettura file utilizzato: 4856 ms, 863.736389 KB/s 08:45:46.488 -> Lettura test /test_2k.bin 08: 45:51.332 -> Leggi file utilizzato: 4840 ms, 866.591736 KB/s 08:45:51.332 -> Test letto /test_4k.bin 08:45:56.163 -> Leggi file utilizzato: 4834 ms, 867.667358 KB/s 08:45:56.163 -> Test letto /test_8k.bin 08:46:00.998 -> R ead file utilizzato: 4827 ms, 868.925598 KB/s 08:46:00.998 -> Test letto /test_16k.bin 08:46:05.808 -> Leggi file utilizzato: 4825 ms, 869.285828 KB/s 08:46:05.843 -> Test read /test_32k.bin 08:46:10.637 -> Leggi file utilizzato: 4824 ms, 869.466003 KB/s 08:46:10.637 -> Test letto /test_64k.bin 08:46:15.478 -> Leggi file utilizzato: 4825 ms, 869.285828 KB/s
Passaggio 11: modalità SD SPI al benchmark del bus VSPI
MicroSD SanDisk da 8 GB
08:54:17.412 -> Test di scrittura /test_1k.bin
08:54:48.398 -> Scrivi file utilizzato: 30994 ms, 135.326324 KB/s 08:54:48.398 -> Test di scrittura /test_2k.bin 08:55:06.079 -> Scrivi file utilizzato: 17677 ms, 237.274658 KB/s 08:55:06.079 -> Test di scrittura /test_4k.bin 08:55:13.357 -> File di scrittura utilizzato: 7274 ms, 576.615906 KB/s 08:55:13.357 -> Test di scrittura /test_8k.bin 08:55:18.691 -> File di scrittura utilizzato: 5323 ms, 787.958679 KB/s 08:55:18.691 -> Test di scrittura /test_16k.bin 08:55:28.336 -> File di scrittura utilizzato: 9669 ms, 433.788818 KB/s 08:55:28.336 -> Test write /test_32k.bin 08:55:32.646 -> Scrivi file utilizzato: 4309 ms, 973.382202 KB/s 08:55:32.646 -> Test write /test_64k.bin 08:55:35.551 -> Scrivi file utilizzato: 2915 ms, 1438.869263 KB/s 08:55:35.584 -> Lettura test /test_1k.bin 08:55:40.745 -> Lettura file utilizzato: 5183 ms, 809.242554 KB/s 08:55:40.745 -> Lettura test /test_2k.bin 08: 55:45.916 -> Leggi file utilizzato: 5182 ms, 809.398682 KB/s 08:55:45.949 -> Test letto /test_4k.bin 08:55:51.091 -> Leggi file utilizzato: 5162 ms, 812.534668 KB/s 08:55:51.091 -> Test di lettura /test_8k.bin 08:55:56.257 -> Leggi file utilizzato: 5177 ms, 810.180420 KB/s 08:55:56.293 -> Lettura test /test_16k.bin 08:56:01.244 -> Lettura file utilizzato: 4956 ms, 846.308289 KB/s 08:56:01.244 -> Lettura test /test_32k.bin 08:56:06.006 -> Leggi file utilizzato: 4764 ms, 880.416443 KB/s 08:56:06.006 -> Test letto /test_64k.bin 08:56:10.716 -> Leggi file utilizzato: 4728 ms, 887.120117 KB/s
Vecchia MicroSD da 128 MB
08:51:01.939 -> Test di scrittura /test_1k.bin
08:51:18.358 -> File di scrittura utilizzato: 16422 ms, 255.407623 KB/s 08:51:18.358 -> Scrittura di test /test_2k.bin 08:51:34.529 -> File di scrittura utilizzato: 16173 ms, 259.339874 KB/s 08:51:34.529 -> Test di scrittura /test_4k.bin 08:51:50.911 -> File di scrittura utilizzato: 16372 ms, 256.187653 KB/s 08:51:50.911 -> Test di scrittura /test_8k.bin 08:52:07.056 -> File di scrittura utilizzato: 16137 ms, 259.918457 KB/s 08:52:07.056 -> Test di scrittura /test_16k.bin 08:52:23.383 -> File di scrittura utilizzato: 16351 ms, 256.516663 KB/s 08:52:23.383 -> Test write /test_32k.bin 08:52:39.533 -> Scrivi file utilizzato: 16128 ms, 260.063507 KB/s 08:52:39.533 -> Test write /test_64k.bin 08:52:55.764 -> Scrivi file utilizzato: 16250 ms, 258.111023 KB/s 08:52:55.764 -> Test di lettura /test_1k.bin 08:53:00.645 -> File di lettura utilizzato: 4855 ms, 863.914307 KB/s 08:53:00.645 -> Test di lettura /test_2k.bin 08: 53:05.459 -> Leggi file utilizzato: 4839 ms, 866.770813 KB/s 08:53:05.459 -> Test letto /test_4k.bin 08:53:10.306 -> Leggi file utilizzato: 4833 ms, 867.846863 KB/s 08:53:10.306 -> Test letto /test_8k.bin 08:53:15.127 -> R ead file utilizzato: 4827 ms, 868.925598 KB/s 08:53:15.127 -> Test letto /test_16k.bin 08:53:19.963 -> Leggi file utilizzato: 4826 ms, 869.105652 KB/s 08:53:19.963 -> Test read /test_32k.bin 08:53:24.758 -> Leggi file utilizzato: 4824 ms, 869.466003 KB/s 08:53:24.792 -> Test read /test_64k.bin 08:53:29.592 -> Leggi file utilizzato: 4824 ms, 869.466003 KB/s
Passaggio 12: arrotondamento
La modalità bus SD a 4 bit offre le migliori prestazioni, la modalità bus SD a 1 bit è circa il 20% più lenta e la modalità SPI è circa il 50% più lenta. Uno dei motivi principali è che il livello del protocollo SD_MMC non implementa alcun tipo di blocco, ma SPI lo fa. E anche la modalità bus SD a 4 bit ha doppie linee dati, quindi teoricamente raddoppia la velocità. Ma la mia vecchia MicroSD non può supportare la modalità bus SD a 4 bit.
Consiglierò la modalità bus SD a 1 bit nella maggior parte dei casi, perché:
- buona performance
- migliore compatibilità con la scheda SD
- requisiti SD Pull-up più sciolti
- sono necessari solo 3 pin GPIO
- configurazione del codice minore
- molti dev kit, dev board e breakout board possono utilizzare questa modalità
Consigliato:
Iniziare con l'interfaccia del sensore I2C?? - Interfaccia il tuo MMA8451 utilizzando ESP32: 8 passaggi
Iniziare con l'interfaccia del sensore I2C?? - Interfaccia il tuo MMA8451 utilizzando ESP32: in questo tutorial imparerai tutto su come avviare, connettere e far funzionare il dispositivo I2C (accelerometro) con il controller (Arduino, ESP32, ESP8266, ESP12 NodeMCU)
Gesture Hawk: Robot controllato con gesti della mano che utilizza un'interfaccia basata sull'elaborazione delle immagini: 13 passaggi (con immagini)
Gesture Hawk: Robot controllato con gesti della mano che utilizza un'interfaccia basata sull'elaborazione delle immagini: Gesture Hawk è stato presentato in TechEvince 4.0 come una semplice interfaccia uomo-macchina basata sull'elaborazione delle immagini. La sua utilità sta nel fatto che non sono necessari sensori aggiuntivi o indossabili tranne un guanto per controllare l'auto robotica che funziona su diversi
Interfaccia wireless Bluetooth per calibri e indicatori Mitutoyo: 8 passaggi (con immagini)
Interfaccia wireless Bluetooth per calibri e indicatori Mitutoyo: oggi nel mondo esistono milioni di calibri, micrometri, indicatori e altri dispositivi Mitutoyo Digimatic. Molte persone come me usano questi dispositivi per raccogliere dati direttamente in un PC. Ciò elimina la necessità di accedere e digitare a volte centinaia
Attraversare i muri: interfaccia per cyclette di Google Street View: 12 passaggi (con immagini)
Riding Through Walls: Interfaccia per bici stazionaria di Google Street View: L'interfaccia per bici stazionaria di Google Street View ti consente di pedalare attraverso Google Street-View comodamente dal tuo salotto. Utilizzando alcuni semplici dispositivi elettronici, un Arduino, una cyclette, un computer e un proiettore o una TV
Interfaccia utente Android (remotexy) per controllare il servomotore utilizzando Arduino e Bluetooth: 7 passaggi (con immagini)
Interfaccia utente Android (remotexy) per controllare il servomotore utilizzando Arduino e Bluetooth: In questo Instructable ti fornirò un rapido passaggio per creare un'interfaccia utente Android utilizzando Remotexy Interface Maker per controllare il servomotore collegato ad Arduino Mega tramite Bluetooth. Questo video mostra come l'interfaccia utente controllerà la velocità e la posizione del servomotore