Educazione Spaziale: Il Kit Mars Rover GalaxyRVR Potenziato con Booster di Segnale e Luce
Il Kit Mars Rover GalaxyRVR di SunFounder è uno strumento innovativo ed educativo per esplorare la robotica e la tecnologia spaziale. Basato su Arduino, questo kit è modellato sui rover marziani della NASA, dotato di un sistema di sospensione a bilanciere che consente un movimento fluido su diversi terreni. Le specifiche tecniche chiave includono una telecamera che fornisce una vista in prima persona, sensori per il rilevamento e l’evitamento di ostacoli e capacità programmabili per funzionalità personalizzate. Questo kit serve come modo pratico e coinvolgente per imparare sulla robotica, la programmazione e le tecnologie per l’esplorazione spaziale.
Progettato per accendere la curiosità e favorire l’apprendimento, questo kit combina il brivido dell’esplorazione spaziale con l’esperienza pratica nella robotica. Riproducendo la meccanica dei veri rover marziani, offre agli appassionati, studenti ed educatori l’opportunità unica di immergersi nel mondo della tecnologia spaziale e della robotica, colmando il divario tra l’apprendimento teorico e l’applicazione pratica.
Puoi acquistarlo qui.
Design
Questo design sofisticato è fondamentale non solo per la mobilità del rover, ma offre anche uno sguardo approfondito sulle sfide e sulle soluzioni ingegneristiche dei veicoli di esplorazione spaziale del mondo reale.
Specifiche Tecniche
La prodezza tecnica del Kit Mars Rover GalaxyRVR di SunFounder è evidenziata dalla sua telecamera, sensori per il rilevamento di ostacoli e programmazione basata su Arduino. La telecamera offre una vista in prima persona, simulando la prospettiva di esplorare un paesaggio marziano. I suoi sensori sono abili nel rilevare e navigare attorno agli ostacoli, fondamentali per replicare le sfide affrontate dai veri rover su terreni irregolari. L’elemento di programmazione basato su Arduino aggiunge una dimensione educativa, consentendo agli utenti di immergersi nella codifica e nella robotica, migliorando sia le loro competenze tecniche che la comprensione della tecnologia spaziale. Queste caratteristiche rendono il GalaxyRVR non solo uno strumento per l’esplorazione, ma anche una risorsa educativa completa.
- Scheda SunFounder R3: Una scheda microcontrollore basata sull’ATmega328P, simile in funzione all’Arduino Uno. Ha 14 pin di input/output digitali, 6 ingressi analogici, un risuonatore ceramico a 16 MHz, connessione USB, jack di alimentazione, header ICSP e pulsante di reset. È il cuore del rover, guidando le sue varie funzioni.
Arduino UNO Arduino UNO - Arduino MEGA 2560 R3 - Arduino Nano - Arduino Pro Mini
- Shield GalaxyRVR: Questo shield è progettato per una facile connessione di vari componenti alla scheda SunFounder R3. Include una porta di ricarica, una porta batteria, un pulsante di reset e diversi indicatori di carica, alimentazione e batteria. Dispone inoltre di molteplici porte per motori, strisce LED RGB, evitamento ostacoli, adattatore per fotocamera e sensori ad ultrasuoni, insieme a un interruttore modalità per la ESP32-CAM e la porta del pannello solare.
- ESP32 CAM: Si tratta di un modulo fotocamera con capacità Bluetooth e Wi-Fi. Supporta varie interfacce come UART, SPI, I2C e PWM e può gestire l’output delle immagini in formati come JPEG, BMP e Scala di Grigi. Il modulo è progettato per essere efficiente dal punto di vista energetico e operare in un’ampia gamma di temperature.
ESP32-CAM and programmer AliExpress ESP32-CAM programmer - AliExpress ESP32-CAM bundle
- Scheda Adattatore per Fotocamera: Questa scheda è progettata per collegare l’ESP32-CAM al rover. Include diversi pin per il reset dell’ESP32-CAM, dati seriali, pin dell’orologio per il QMC6310, RXD e TXD per il caricamento del codice e un ingresso di alimentazione a 5V DC.
- Modulo Ultrasonico: Il sensore di distanza ultrasonico HC-SR04 viene utilizzato per misurazioni non a contatto da 2 cm a 400 cm. Include un trasmettitore ultrasonico, un ricevitore e un circuito di controllo. Il modulo funziona con un’alimentazione di 5V e può essere facilmente collegato tramite i suoi quattro pin.
- Modulo di Evitamento Ostacoli IR: Essenziale per le capacità di navigazione del rover, permettendo di rilevare ed evitare ostacoli.
- Striscia LED RGB: Queste strisce vengono utilizzate per effetti visivi e indicatori, aggiungendo una dimensione estetica al rover.
- Motori TT: Alimentano il movimento del rover, fondamentali per la sua mobilità.
- Pannello Solare: Fornisce una fonte di energia rinnovabile, permettendo al rover di essere alimentato in modo sostenibile.
- Batteria 18650: Agisce come principale fonte di alimentazione per il rover.
Processo di Assemblaggio
Il processo di assemblaggio e l’ambiente di programmazione del Kit Mars Rover GalaxyRVR di SunFounder offrono una combinazione di sfida e opportunità di apprendimento, adatte agli appassionati di vari livelli di abilità.
Processo di Assemblaggio:
- L’assemblaggio del GalaxyRVR è un’esperienza pratica. Richiede attenzione ai dettagli, poiché coinvolge diverse parti piccole e passaggi intricati.
- Il processo è progettato per essere educativo, con ogni passaggio che offre una visione della meccanica di costruzione del rover. È simile a costruire un modello, ma con componenti più complessi e funzionali.
- Il livello di difficoltà è moderato. È abbastanza impegnativo per essere coinvolgente per coloro con un po’ di esperienza nella costruzione di kit o modelli, ma non eccessivamente complesso per i principianti.
- Le istruzioni sono generalmente chiare, ma alcuni passaggi potrebbero richiedere un po’ di problem-solving per migliorare l’esperienza di apprendimento.
Disimballando il GalaxyRVR: Il pacchetto rivela tre sotto-pacchetti contenenti ruote e istruzioni aperte. L’eccitazione cresce mentre inizia l’assemblaggio del rover.
All’interno del primo sotto-pacchetto, un tesoro di componenti aspetta. Il pacchetto rivela l’Arduino UNO, lo shield GalaxyRVR, l’ESP32-CAM, il supporto per l’ESP32-CAM, due sensori IR, il sensore Ultrasonico e un mot ore servo per gestire la posizione verticale della telecamera. Questi elementi cruciali formeranno la spina dorsale della funzionalità del GalaxyRVR.
Nel secondo sotto-pacchetto vengono svelate la fonte di alimentazione essenziale e i componenti meccanici. Questo pacchetto contiene il pacco batteria al litio, che alimenterà le avventure del GalaxyRVR, oltre a sei motori che guideranno i suoi movimenti. Include inoltre elementi in alluminio per il telaio di base, preparando il terreno per la robusta costruzione del rover.
Il terzo sotto-pacchetto completa il puzzle di assemblaggio del GalaxyRVR con una varietà di componenti rimanenti. Include un assortimento di cavi per collegare le varie parti, garantendo una comunicazione senza interruzioni all’interno del rover. Inoltre, contiene il pannello solare, un componente integrale per un’alimentazione sostenibile. Parti in acrilico sono trovate anche all’interno, contribuendo alla struttura generale e al design del rover. Inoltre, sono inclusi strumenti essenziali come cacciaviti, facilitando il processo di assemblaggio e assicurando che nessun dettaglio sia trascurato. Questa collezione completa di componenti garantisce che ogni aspetto del GalaxyRVR si unisca in modo impeccabile.
Il primo passo dell’assemblaggio cattura l’inizio del viaggio di costruzione del GalaxyRVR. Mostra le fasi iniziali dell’assemblaggio della struttura di base, estendendola alle sue massime dimensioni. Questo passaggio è fondamentale, preparando il terreno per l’assemblaggio completo del rover e la successiva esplorazione del suo ambiente.
Un’altra prospettiva.
In questo passo dell’assemblaggio, il GalaxyRVR compie un significativo passo avanti nel suo processo costruttivo. I motori, l’Arduino UNO e lo shield GalaxyRVR vengono abilmente attaccati, formando il cuore dei sistemi meccanici ed elettronici del rover. Ogni cavo è collegato meticolosamente, garantendo una comunicazione senza interruzioni tra i componenti. Questo passaggio segna una pietra miliare cruciale nel dare vita al GalaxyRVR, preparando il terreno per la sua funzionalità dinamica.
Questa immagine fornisce una chiara vista della parte inferiore del rover, evidenziando la precisa posizione in cui il pacco batteria è stato fissato in modo sicuro. Questo passaggio essenziale garantisce che il GalaxyRVR abbia una fonte di alimentazione affidabile per le sue missioni ed esplorazioni.
Questa fotografia mostra un momento cruciale nel processo di assemblaggio del GalaxyRVR. I sensori IR e ultrasonici sono stati sapientemente attaccati e cablati, migliorando le capacità di navigazione del rover. Inoltre, le ruote sono state abilmente assemblate, preparando il terreno per la mobilità e l’esplorazione del rover.
In questa vista dettagliata, si può vedere il modulo ESP32-CAM completamente assemblato, montato saldamente sul suo supporto mobile. Questa configurazione consente al rover di catturare immagini e video con precisione, migliorando le sue capacità di osservazione per l’esplorazione remota.
Questa prospettiva offre una vista della parte inferiore del rover, dove la protezione in acrilico funge da salvaguardia per i suoi componenti delicati. Questo strato protettivo preserva l’elettronica vitale del rover, assicurando la loro sicurezza durante le missioni e aggiungendo un ulteriore strato di resilienza al GalaxyRVR.
Questa vista dall’alto evidenzia la struttura di supporto del pannello solare, un componente chiave del GalaxyRVR. Il supporto assicura che il pannello solare sia posizionato ottimalmente per sfruttare la luce solare, fornendo energia sostenibile per le operazioni del rover e consentendo un’esplorazione estesa.
In questa vista dettagliata posteriore, si può vedere il pannello solare completamente assemblato. È saldamente attaccato alla struttura del rover, pronto per catturare energia solare dall’ambiente. Questo componente gioca un ruolo cruciale nell’alimentare il GalaxyRVR durante le sue missioni, rendendolo più versatile e sostenibile.
Questa immagine affascinante mostra il Kit Mars Rover GalaxyRVR di SunFounder in tutto il suo splendore, completamente assemblato e pronto per l’azione. Ogni componente è stato abilmente integrato, dalla sua struttura meccanica ai suoi sistemi elettronici. Il GalaxyRVR incarna lo spirito di esplorazione e innovazione, pronto a intraprendere viaggi eccitanti e avventure educative.
Modalità di Gioco
Sei impaziente di iniziare subito il tuo viaggio marziano? La nostra Modalità di Gioco è perfettamente adatta a chi non vede l’ora di immergersi nell’azione. Dotato di codice pre-caricato in fabbrica, puoi tuffarti direttamente nell’azione dopo aver assemblato il tuo GalaxyRVR. Usa l’app SunFounder Controller, intuitiva e facile da usare, per esplorare le sue miriadi di funzioni, tra cui la guida in prima persona, il passaggio tra modalità di evitamento ostacoli e modalità di inseguimento, e persino il controllo vocale.
Guida Rapida:
- Iniziamo con il GalaxyRVR.
- La prima volta che usi il tuo GalaxyRVR, si raccomanda di collegare prima un cavo USB di tipo C per caricare completamente la batteria. Poi accendi l’alimentazione.
- Per attivare la ESP32 CAM, sposta l’interruttore di modalità in posizione Run e premi il pulsante di reset per riavviare la scheda R3. Vedrai poi una luce ciano lampeggiare sulla striscia inferiore.
- Installa SunFounder Controller dall’APP Store(iOS) o Google Play(Android).
- Collegati alla rete GalaxyRVR.
- Per una comunicazione ottimale tra il tuo dispositivo mobile e il Rover, dovrai collegarli alla stessa rete locale (LAN) fornita da GalaxyRVR.
- Trova GalaxyRVR nell’elenco delle reti disponibili sul tuo dispositivo mobile (tablet o smartphone), inserisci la password 12345678 e connettiti ad essa.
- La modalità di connessione predefinita è la modalità AP. Dopo esserti collegato, potrebbe apparire un avviso che informa che non c’è accesso a internet su questa rete. In tal caso, scegli “Rimani connesso”.
- Configura un controller.
- Per creare un controller su SunFounder Controller, tocca l’icona +.
- I controller preimpostati sono disponibili per alcuni prodotti, qui scegliamo GalaxyRVR. Dargli un nome o semplicemente tocca Conferma.
- Una volta all’interno, l’app cercherà automaticamente il GalaxyRVR. Dopo un momento, vedrai un avviso che dice “Connesso con Successo”.
- Se non connesso, si prega di confermare che il Wi-Fi sia connesso a GalaxyRVR.
- Puoi anche toccare il pulsante app_connect per connetterti manualmente. Dopo una breve attesa, dovresti vedere apparire GalaxyRVR(IP). Toccalo per stabilire una connessione.
- Ora, toccando il pulsante app_run ti permette di visualizzare il feed video dal vivo dalla telecamera e controllare l’auto utilizzando i widget forniti.
Esploriamo ora le funzioni di ogni widget:
- Servo(D): Controlla il meccanismo di inclinazione della telecamera del Rover, consentendoti di osservare un intervallo più ampio.
- Evita(E): Attiva la modalità di evitamento ostacoli del Rover. Le distanze di rilevamento preim postate per ciascun modulo di evitamento ostacoli possono variare. È necessario un aggiustamento manuale.
- Segui(F): Attiva la modalità di inseguimento del Rover. Le distanze di rilevamento preimpostate per ciascun modulo di evitamento ostacoli possono variare. È necessario un aggiustamento manuale.
- Stop(I): Interrompe immediatamente tutti i movimenti del Rover.
- STT(J): Premi questo widget per avviare il riconoscimento vocale e far eseguire al Rover azioni corrispondenti.
- Farò(L): Per accendere/spegnere il LED sulla ESP32 CAM.
- Widget Acceleratore su K e Q: Il widget acceleratore nell’area K controlla i motori sinistri del Rover, mentre quello nell’area Q controlla i motori destri. Coordinando entrambi i widget, il GalaxyRVR può muoversi in qualsiasi direzione.
- IR Sinistro(N): Mostra le letture dal modulo di evitamento ostacoli sinistro.
- Ultrasonico(O): Mostra la distanza misurata dal modulo ultrasonico.
- IR Destro(P): Mostra le letture dal modulo di evitamento ostacoli destro.
Evita(E): Tocca il widget Evita(E) per attivare la modalità di evitamento ostacoli.
Prima di abilitare questa modalità, potrebbe essere necessario regolare le distanze di rilevamento dei sensori in base al tuo ambiente attuale, poiché le impostazioni di fabbrica potrebbero non essere ideali in tutte le situazioni.
Se la distanza di rilevamento dei due moduli a infrarossi è troppo corta, il Mars Rover potrebbe urtare contro ostacoli. Al contrario, se la portata è troppo lunga, il Rover potrebbe iniziare a deviare troppo lontano da un ostacolo, potenzialmente interrompendo la sua navigazione.
Ecco come puoi regolare le impostazioni:
- Inizia regolando il modulo di evitamento ostacoli destro. Durante il trasporto, le collisioni possono far inclinare il trasmettitore e il ricevitore sul modulo a infrarossi. Pertanto, è necessario regolarli manualmente.
- Posiziona un ostacolo a circa 20 cm direttamente di fronte al modulo destro. La scatola in cui è arrivato il nostro kit Rover è una buona scelta per questo! Ora, gira il potenziometro sul modulo fino a quando la luce indicatrice sul modulo si accende appena. Poi, continua a muovere l’ostacolo avanti e indiet ro per controllare se la luce indicatrice si accende alla distanza desiderata. Se la luce non si accende alla distanza corretta o se rimane accesa senza spegnersi, dovrai regolare l’altro potenziometro.
- Ripeti lo stesso processo per l’altro modulo.
Modalità Corso
Il GalaxyRVR, un prodotto di SunFounder, offre una sezione di documentazione nota come “Modalità Corso.” Questa è progettata per coloro che hanno già esplorato la Modalità di Gioco e sono ansiosi di approfondire la meccanica di funzionamento di ogni funzione. L’obiettivo principale di questa modalità è fornire agli utenti una comprensione completa delle funzionalità e permettere loro di modificare gli effetti in base alle proprie preferenze e idee.
Aspetto Educativo
- Apprendimento Strutturato: La modalità di programmazione è strutturata meticolosamente, con ogni funzione classificata in un progetto separato. In totale, ci sono 17 progetti distinti. Questo approccio modulare assicura che gli studenti possano concentrarsi su un aspetto alla volta, rendendo il processo di apprendimento più gestibile e sistematico.
- Spiegazioni Dettagliate: Ogni progetto è accompagnato da un set di codici e dalle rispettive spiegazioni. Ciò assicura che gli studenti non solo sappiano cosa fa un particolare pezzo di codice, ma comprendano anche la logica e il ragionamento sottostanti. Un approccio così dettagliato rafforza l’apprendimento e promuove una comprensione più profonda dell’argomento.
- Esperienza Pratica con Arduino: I progetti all’interno della modalità di programmazione utilizzano il linguaggio di programmazione Arduino. Questo offre agli studenti l’opportunità di familiarizzare con una delle piattaforme microcontrollori più popolari. Prima di immergersi nei progetti, agli utenti viene guidata l’installazione dell’IDE Arduino e delle librerie necessarie, assicurando di avere tutti gli strumenti necessari per iniziare il loro viaggio di programmazione.
- Vasta Gamma di Progetti: I 17 progetti coprono una vasta gamma di funzionalità, dai movimenti di base e controllo remoto a funzionalità più avanzate come rilevamento AI da un’app e evitamento ostacoli. Questa diversità assicura che gli studenti siano esposti a vari aspetti della robotica e della programmazione, rend endo la loro esperienza di apprendimento olistica e completa.
- Viaggio alla Scoperta: La modalità di programmazione non è solo codifica; si tratta di intraprendere un viaggio alla scoperta. Man mano che gli studenti avanzano nei progetti, incontreranno sfide, risolveranno problemi e, soprattutto, vedranno prendere vita le loro idee. Questo approccio di apprendimento esperienziale è inestimabile nell’infondere fiducia e nel promuovere l’amore per la robotica e la programmazione.
La Modalità Corso è uno strumento educativo. Colma il divario tra teoria e pratica, permettendo agli utenti di applicare ciò che hanno imparato in scenari del mondo reale. Che tu sia un principiante che cerca di iniziare nel mondo della robotica o un programmatore esperto che cerca di espandere i propri orizzonti, la Modalità di Programmazione del GalaxyRVR offre un’esperienza ricca, coinvolgente e, soprattutto, educativa.
Piccoli miglioramenti
Per quanto riguarda altri dispositivi, vorrei suggerire alcuni miglioramenti.
Aggiungere un’antenna
Un ulteriore miglioramento può essere apportato al GalaxyRVR ESP32-CAM aggiungendo un’antenna per migliorare la ricezione del segnale. Questa modifica consente un segnale più stabile e potente, permettendo al rover di comunicare in modo più affidabile con il dispositivo di controllo remoto. L’antenna può essere posizionata strategicamente per massimizzare la copertura del segnale, permettendo al GalaxyRVR di svolgere le sue funzioni più efficacemente, specialmente in ambienti dove la connettività potrebbe essere ridotta. Questo miglioramento è particolarmente utile nell’esplorazione di aree più grandi o di fronte a sfide di comunicazione a lunga distanza.
Ecco l'antenna che uso 8dbi WiFi antenna
Aggiungere una gestione della luce
Puoi trovare questo sviluppo anche in questo articolo.
Qui, aggiungo un riassunto.
Qui l'ESP32-CAM e la scheda programmatrice AliExpress ESP32-CAM programmer - AliExpress ESP32-CAM bundle
Dal punto di vista tecnico, il Rover GalaxyRVR sfrutta le capacità del modulo ESP32-CAM per le sue funzioni di streaming video.
Per coloro che hanno seguito i miei scritti tecnici, ho trattato ampiamente l’ESP32-CAM in una serie di articoli. Uno di questi articoli affronta specificamente l’integrazione di un meccanismo di controllo della torcia, intitolato “ESP32-CAM: aggiornare CameraWebServer con la funzionalità di flash“. Dato questo precedente esplorazione, diventa un passo logico sfruttare questa conoscenza per le esigenze di illuminazione del GalaxyRVR.
Il nostro percorso tecnico prevede un approccio su due fronti:
- Modifica del Firmware: Miriamo a modificare il ai-camera-firmware, migliorandone le capacità per supportare la nuova funzionalità di illuminazione.
- Miglioramento dell’Interfaccia: Sarà introdotto un nuovo widget nel dashboard di controllo del GalaxyRVR. Questo widget è progettato per attivare la torcia e fornire un controllo granulare sulla sua intensità, garantendo adattabilità a diverse condizioni di illuminazione.
Per un’immersione più profonda nelle complessità tecniche dell’ESP32-CAM e delle sue varie applicazioni, ti invito ad esplorare l’elenco completo degli articoli disponibili qui.
Comunicazione tra Arduino e ESP32-CAM
L’interazione tra l’ESP32-CAM e il Firmware Arduino del GalaxyRVR è orchestrata attraverso due canali di comunicazione principali: Seriale e WebSocket.
L’interfaccia seriale funge da canale di comunicazione principale. Attraverso questa interfaccia, il Firmware Arduino del GalaxyRVR utilizza comandi specifici per inizializzare e configurare l’ESP32-CAM.
GalaxyRVR version 1.1.0
Initialzing...
SET+RESET
...[OK]
ESP32 firmware version 1.3.1
SET+NAMEGalaxyRVR
...[OK]
SET+TYPEGalaxyRVR
...[OK]
SET+SSIDGalaxyRVR
...[OK]
SET+PSK12345678
...[OK]
SET+MODE2
...[OK]
SET+PORT8765
...[OK]
SET+START
...[OK]
WebServer started on ws://192.168.4.1:8765
Okie!
[CAM_I] camera stream start on: http://192.168.4.1:9000/mjpg
Durante la fase di inizializzazione, una serie di comandi Seriali vengono inviati per configurare l’ESP32-CAM per operare in modalità AP (Access Point). La stretta di mano inizia con il GalaxyRVR che annuncia la sua versione come “GalaxyRVR version 1.1.0” e inizia l’inizializzazione. Seguono poi una serie di comandi:
- SET+RESET per resettare le impostazioni, ricevendo un riconoscimento con “…[OK]”.
- L’ESP32-CAM poi annuncia la sua versione del firmware come “Versione firmware ESP32 1.3.1”.
- SET+NAMEGalaxyRVR per impostare il nome del dispositivo.
- SET+TYPEGalaxyRVR per definire il tipo di dispositivo.
- SET+SSIDGalaxyRVR e SET+PSK12345678 per configurare le credenziali di rete.
- SET+MODE2 per configurare il dispositivo in modalità AP.
- SET+PORT8765 per specificare la porta del server WebSocket.
- Infine, viene inviato SET+START per avviare la connessione, e al successo, l’ESP32-CAM conferma con “WebServer avviato su ws://192.168.4.1:8765” e “Okie!”. Inoltre, lo streaming della telecamera inizia ed è accessibile su “http://192.168.4.1:9000/mjpg“.
D’altra parte, il WebSocket, implementato nel firmware ai -camera, funge da mezzo di comunicazione secondario. Questo canale è principalmente utilizzato dall’app SunFounder Control per inviare comandi all’ESP32-CAM. I messaggi inviati tramite WebSocket sono strutturati in un formato posizionale.
Il codice che gestisce questo si trova in ai-camera-firmware/ws_server.cpp
[...]
// receive text
case WStype_TEXT:{
ws_connected = true;
out = intToString(payload, length);
// reset ping_pong time
lastPingPong = millis();
if (strcmp(out.c_str(), "ping") == 0) {
Serial.println("[APPSTOP]");
return;
}
// ------------- send simplified text -------------
DynamicJsonDocument recvBuffer(WS_BUFFER_SIZE);
deserializeJson(recvBuffer, out);
String result = "WS+";
// REGIONS
for (int i=0; i<REGIONS_LENGTH; i++){
String region = String(REGIONS[i]);
String value;
if (recvBuffer[region].is<JsonArray>()) {
for (int j=0; j<recvBuffer[region].size(); j++) {
value += recvBuffer[region][j].as<String>();
if (j != recvBuffer[region].size()-1) value += ',';
}
} else {
value = recvBuffer[region].as<String>();
}
if (value == "true") value = "1";
else if (value == "false") value = "0";
if (value != "null") result += value;
if (i != REGIONS_LENGTH - 1) result += ';';
}
// send
if (millis() - last_send_time > SEND_INTERVAL ) {
Serial.println(result);
last_send_time = millis();
}
break;
}
// For everything else: do nothing
[...]
Durante la fase di inizializzazione, una serie di comandi Seriali vengono inviati per configurare l’ESP32-CAM per operare in modalità AP (Access Point). La stretta di mano inizia con il GalaxyRVR che annuncia la sua versione come “Versione Arduino Car 1.4.5” e inizia l’inizializzazione. Seguono poi una serie di comandi:
- SET+RESET per resettare le impostazioni, ricevendo un riconoscimento con “…[OK]”.
- L’ESP32-CAM poi annuncia la sua versione del firmware come “Versione firmware ESP32 1.3.1”.
- SET+NAMEGalaxyRVR per impostare il nome del dispositivo.
- SET+TYPEGalaxyRVR per definire il tipo di dispositivo.
- SET+SSIDGalaxyRVR e SET+PSK12345678 per configurare le credenziali di rete.
- SET+MODE2 per configurare il dispositivo in modalità AP.
- SET+PORT8765 per specificare la porta del server WebSocket.
- Infine, viene inviato SET+START per avviare la connessione, e al successo, l’ESP32-CAM conferma con “WebServer avviato su ws://192.168.4.1:8765” e “Okie!”. Inoltre, lo streaming della telecamera inizia ed è accessibile su “http://192.168.4.1:9000/mjpg“.
D’altra parte, il WebSocket, implementato nel firmware ai -camera, funge da mezzo di comunicazione secondario. Questo canale è principalmente utilizzato dall’app SunFounder Control per inviare comandi all’ESP32-CAM. I messaggi inviati tramite WebSocket sono strutturati in un formato posizionale.
Il codice che gestisce questo si trova in ai-camera-firmware/ws_server.cpp
[...]
// receive text
case WStype_TEXT:{
ws_connected = true;
out = intToString(payload, length);
// reset ping_pong time
lastPingPong = millis();
if (strcmp(out.c_str(), "ping") == 0) {
Serial.println("[APPSTOP]");
return;
}
// ------------- send simplified text -------------
DynamicJsonDocument recvBuffer(WS_BUFFER_SIZE);
deserializeJson(recvBuffer, out);
String result = "WS+";
// REGIONS
for (int i=0; i<REGIONS_LENGTH; i++){
String region = String(REGIONS[i]);
String value;
if (recvBuffer[region].is<JsonArray>()) {
for (int j=0; j<recvBuffer[region].size(); j++) {
value += recvBuffer[region][j].as<String>();
if (j != recvBuffer[region].size()-1) value += ',';
}
} else {
value = recvBuffer[region].as<String>();
}
if (value == "true") value = "1";
else if (value == "false") value = "0";
if (value != "null") result += value;
if (i != REGIONS_LENGTH - 1) result += ';';
}
// send
if (millis() - last_send_time > SEND_INTERVAL ) {
Serial.println(result);
last_send_time = millis();
}
break;
}
// For everything else: do nothing
[...]
Ogni messaggio arriva in formato JSON, e ogni posizione nel messaggio corrisponde a un valore specifico. Nell’app SunFounder Control, ogni widget o elemento di controllo è rappresentato da una lettera unica. Ognuna di queste lettere corrisponde a una specifica posizione nell’array dei messaggi. Ad esempio, la lettera “L” rappresenta l’undicesimo valore nel messaggio.
Alla ricezione di un messaggio WebSocket, il firmware dell’ESP32-CAM lo traduce in un messaggio Seriale, come WS+;;;;;;;;;;;100;;;;;;;;;;;;;;. Questo formato indica che la posizione rappresentata dalla lettera “L” ha un valore di 100. L’ESP32-CAM invia quindi questo messaggio Seriale al firmware Arduino del GalaxyRVR. Alla ricezione, il firmware Arduino elabora il messaggio e attiva la funzione o azione corrispondente. In sostanza, l’app SunFounder Control comunica comandi utente tramite WebSocket all ‘ESP32-CAM, che poi traduce questi comandi in messaggi Seriali. Questi messaggi vengono successivamente elaborati dal firmware Arduino del GalaxyRVR per eseguire funzioni o azioni specifiche.
Modifica del firmware ai-camera per gestire la luce
Prima di tutto, devi scaricare il firmware ai-camera da GitHub. Puoi utilizzare il client git o scaricare direttamente da qui.
Ora apri il file ino dal tuo IDE preferito (Arduino IDE funziona bene e per configurare le schede ESP32, fai riferimento a “ESP32-CAM: pinout, specifiche e configurazione Arduino IDE“).
Dipendenze
- WebSockets di Markus Sattler
- ArduinoJson
Impostazioni Flash
Board: "ESP32 Dev Module"
Upload Speed: "115200" ## You can try more but some device don't work
CPU Frequency: "240MHz (WiFi/BT)"
Flash Frequency: "80MHz"
Flash Mode: "QIO"
Flash Size: "4MB (32Mb)"
Partition Scheme: "Huge APP (3MB No OTA/1MB SPIFFS)"
Core Debug Level: "None"
PSRAM: "Enabled"
Arduino Runs On: "Core 1"
Events Run On: "Core 1"
Procedi ora alla modifica del file ws_server.cpp. Prima, aggiungi 2 define per centralizzare la configurazione:
#include "pins.h"
#define BRIGHTNESS_MULTIPLIER 0.5
#define CAMERA_PIN_FLASH 4
Poi, modifica il codice per analizzare l’undicesimo valore e impostarlo su LED.
// receive text
case WStype_TEXT:{
ws_connected = true;
out = intToString(payload, length);
// reset ping_pong time
lastPingPong = millis();
if (strcmp(out.c_str(), "ping") == 0) {
Serial.println("[APPSTOP]");
return;
}
// ------------- send simplified text -------------
DynamicJsonDocument recvBuffer(WS_BUFFER_SIZE);
deserializeJson(recvBuffer, out);
String result = "WS+";
// REGIONS
for (int i=0; i<REGIONS_LENGTH; i++){
String region = String(REGIONS[i]);
String value;
if (recvBuffer[region].is<JsonArray>()) {
for (int j=0; j<recvBuffer[region].size(); j++) {
value += recvBuffer[region][j].as<String>();
if (j != recvBuffer[region].size()-1) value += ',';
}
} else {
value = recvBuffer[region].as<String>();
}
if (value == "true") value = "1";
else if (value == "false") value = "0";
if (value != "null") result += value;
if (i != REGIONS_LENGTH - 1) result += ';';
if (i==11 && value != "null" && value != "" && ledPrecValue != value.toInt()) {
// Serial.print(i);Serial.print(" - ");
// Serial.println(value);
ledPrecValue = value.toInt();
analogWrite(CAMERA_PIN_FLASH, (int)ledPrecValue*BRIGHTNESS_MULTIPLIER);
}
}
// send
if (millis() - last_send_time > SEND_INTERVAL ) {
Serial.println(result);
last_send_time = millis();
}
break;
}
// For everything else: do nothing
Il codice è molto semplice. Controllo il valore dell’undicesimo elemento e lo ottengo, applico un moltiplicatore che è inferiore ad uno perché, con la massima potenza, il flash a volte riceve troppa energia e blocca il dispositivo (quindi puoi preservare l’energia), e imposto con il PWM il valore al pin del flash della fotocamera (nel mio caso il pin 4 come descritto nell’articolo collegato precedentemente).
if (i==11 && value != "null" && value != "" && ledPrecValue != value.toInt()) {
// Serial.print(i);Serial.print(" - ");
// Serial.println(value);
ledPrecValue = value.toInt();
analogWrite(CAMERA_PIN_FLASH, (int)ledPrecValue*BRIGHTNESS_MULTIPLIER);
}
}
Ora, dobbiamo impostare il widget corretto nella posizione corretta; la posizione L è l’undicesimo elemento, e devi mettere lì il widget di controllo.
Per farlo, apri il controller SunFounder e aggiungi il controllo GalaxyRVR. Dopo di ciò, clicca sul pulsante di modifica nell’angolo in alto a destra.
Cambio solo il nome e il valore iniziale.
E ora, in azione, dentro l’armadio, vai a scoprire dove si trova lo zaino.
Ecco il Rover in azione.
