Nel Bionic Spider Robot Kit hai già imparato come funziona il ragno bionico e hai già realizzato alcuni progetti con esso. Più recentemente è stato aggiunto il controllo del robot tramite un’app per smartphone.

Dato che il controllo tramite il display touch non è particolarmente piacevole, questo post del blog presenterà un controllo alternativo con un joystick.

 

Hardware

Sono disponibili due versioni come joystick, una può KY-023 è possibile utilizzare il modulo. Tuttavia, poiché qui sarebbe necessario molto cablaggio, questo è consigliabile Scudo per joystick PS2, anch'esso collegato direttamente a un microcontrollore Uno È possibile inserire il layout.

Poiché il microcontrollore deve comunicare con il robot, è necessario un microcontrollore con funzionalità WiFi. Inoltre sono necessari due ADC per ciascuno degli assi X e Y, motivo per cui qui è necessario utilizzare un ESP32.

(L'ESP8266 ha solo un ingresso ADC.)

 

Per realizzare il progetto è necessario:

NodoMCU ESP32 D1 R32

Scudo per joystick PS2

(opzionale) Batteria blocco 9V + Clip per batteria

e ovviamente assemblato Kit robot ragno bionico

 

Poiché gli ingressi analogici dei due assi del joystick si trovano su GPIO 2 e 4, che sono collegati all'ADC2, non possono essere utilizzati contemporaneamente con il modulo WLAN. Le connessioni IO 34 e IO35 (ADC1) si trovano direttamente accanto a loro, quindi la funzionalità può essere facilmente stabilita utilizzando un ponticello.

Figura 1: ponte metallico tra le connessioni

Collegare i connettori come mostrato sopra.
Poiché il LED integrato è collegato al GPIO 2, il pin deve essere rimosso qui, altrimenti la connessione influenzerebbe il valore della tensione dell'asse X.

Lo stesso vale per il pin D12, poiché ciò interrompe il processo di avvio e quindi l'avvio con lo schermo attaccato non sarebbe possibile. In corrispondenza di questo collegamento si trova il pulsante centrale del joystick, pertanto non può più essere utilizzato. Se si vuole comunque implementarlo è necessario ricollegarlo ad una porta libera.

 

Figura 2: Scudo con modifiche

 

Lo schermo può essere semplicemente collegato al D1 R32. Assicurati che il piccolo interruttore nell'angolo sinistro sia acceso 3v3 in caso contrario l'ESP32 potrebbe danneggiarsi a causa della tensione eccessiva di 5V.

Software

Se è la prima volta che programmi un ESP32/ESP8266 nell'IDE di Arduino, copia i seguenti URL nell'IDE di Arduino in: File->Preferenze->URL gestione schede aggiuntive:  https://dl.espressif.com/dl/package_esp32_index.json

http://arduino.esp8266.com/stable/package_esp8266com_index.json

 

e installa i pacchetti ESP32 ed ESP8266 nell'amministrazione della scheda.

 

Il protocollo ESPNOW, facile da usare grazie alla libreria integrata, è adatto per il trasferimento dei dati tra i microcontrollori.

Il vantaggio di questo protocollo è che i pacchetti di dati possono essere trasmessi anche senza server e WLAN, quindi la comunicazione è possibile ovunque e senza hardware aggiuntivo.

Inoltre i pacchetti vengono inviati in modo semplice, senza complicate autenticazioni come nella WLAN, il che significa che è possibile ottenere una trasmissione molto veloce quasi in tempo reale.

 

Per la comunicazione sono necessari gli indirizzi hardware dei due dispositivi, i cosiddetti indirizzi MAC (Media Access Control). Questi si trovano in una parte protetta della memoria e possono essere assegnati in modo univoco a un dispositivo.

Tramite questo i pacchi possono essere inviati al destinatario corretto.

 

1 Determinare gli indirizzi MAC

Poiché gli indirizzi si trovano nella memoria protetta, possono essere letti anche con un programma breve separato, poiché questo non cambia quando la memoria viene riscritta.

 

Caricare il programma sui due microcontrollori:

#ifdef ESP32   #include <WiFi.h> #endif #ifdef ESP8266   #include <ESP8266WiFi.h> #endif void setup() {   WiFi.mode(WIFI_STA);   Serial.begin(115200);   delay(2000);   Serial.println(); } void loop() {   Serial.print("Mac Adress:");   Serial.println(WiFi.macAddress());   delay(5000); }

 

Puoi ottenere il codice qui(macAdress.ino) scaricare.

 

Dopo che i programmi sono stati caricati sul microcontrollore, sul monitor seriale viene ora visualizzato il corrispondente indirizzo MAC (velocità di trasmissione: 115200). Annotarli per il seguente programma.

 

2 controller di codice

Il modulo joystick dispone di 6 pulsanti singoli e di un joystick a due assi con pulsante integrato.

Per mantenere il progetto il più semplice possibile, solo la direzione del movimento o i pulsanti premuti vengono trasmessi come stringa come segue:

Joystick su: CMD_FWD

Joystick giù: CMD_BWD

Joystick a destra: CMD_RGT

Joystick a sinistra: CMD_LFT

 

Pulsante A: BTN_A

Pulsante B: BTN_B

ecc...

 

Per garantire che un nuovo comando possa essere inviato solo se quello precedente è stato eseguito, il destinatario invia una conferma. Solo una volta ricevuto questo si potrà inviare un nuovo comando.
Affinché la comunicazione non venga completamente bloccata in caso di errore, il feedback è necessario solo dopo aver trasmesso con successo i dati al destinatario. Inoltre, lo stato verrà ripristinato automaticamente dopo 10 secondi se non è stata inviata alcuna conferma.

 

Codice:
Per ragioni di chiarezza, qui vengono riportati solo alcuni estratti a scopo esplicativo. Alla fine è possibile scaricare il codice completo.

#define X 34 #define Y 35 #define A 26 #define B 25 #define C 17 #define D 16 #define E 27 #define F 14 uint8_t receiverAddress[] = {0xA4, 0xCF, 0x12, 0xDC, 0xCF, 0x3A}; int calibY, calibX; bool status = true; long sentTime;

All'inizio vengono definiti i pin GPIO dei rispettivi assi dei pulsanti/joystick in modo che possano essere utilizzati più facilmente e chiaramente in seguito nel programma.
Viene quindi definito l'indirizzo MAC del ricevitore; questo deve essere nel formato esadecimale mostrato con 0x come prefisso:
A4:CF:... -> 0xA4, 0xCF,...

Le seguenti variabili servono per la calibrazione e il controllo per inviare i comandi solo se il precedente è già stato eseguito.

void onDataRecv(const esp_now_recv_info_t *info, const uint8_t *data, int data_len) {   char dataTemp[data_len];   memcpy(dataTemp, data, data_len);//Copy data bytes in char Array   Serial.println(dataTemp);   if(String(dataTemp).indexOf("RDY") >= 0) {//data contains RDY     Serial.println("RST");     status = true;   } } void onDataSent(const wifi_tx_info_t *tx_info, esp_now_send_status_t sendStatus) {     Serial.print("Sendestatus: ");     Serial.println(sendStatus == ESP_NOW_SEND_SUCCESS ? "Success" : "Error");     if(sendStatus == ESP_NOW_SEND_SUCCESS) {       status = false; //marking sent       sentTime = millis(); //store time for limitation     } }

Questi due metodi sono i metodi di richiamata per ricevere e inviare tramite ESPNOW.

I dati ricevuti dalla funzione di ricezione vengono prima memorizzati in a car Array copiato per poi controllare il contenuto della parola chiave. Se questo viene ricevuto, lo stato verrà ripristinato vero impostato e i comandi possono essere inviati nuovamente.

La funzione di callback di invio controlla lo stato dell'invio e imposta la variabile di stato false.false, in modo che un comando non venga inviato nuovamente subito dopo. Inoltre il tempo di esecuzione attuale del programma viene bufferizzato tramite la funzione millis(), poiché lo stato dovrebbe essere resettato dopo 10 secondi.

 

In setup() vengono chiamati solo i comandi di configurazione della libreria ESPNOW, seguiti dalla calibrazione degli assi del joystick e dalla configurazione GPIO.

In loop() vengono misurati i valori degli assi del joystick e lo stato viene ripristinato dopo 10 secondi.

La seguente logica valuta la posizione degli assi del joystick:

if(status) {     if(valX < -50 || valY < -50 || valX > 50 || valY > 50) {       Serial.println("trig");       if(abs(valX) > abs(valY)) {         if(valX < 0) {           Serial.println("LEFT");           String msg = "CMD_LFT";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }         else {           Serial.println("Right");           String msg = "CMD_RGT";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }       }       else {         if(valY < 0) {           Serial.println("BWD");           String msg = "CMD_BWD";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }         else {           Serial.println("FWD");           String msg = "CMD_FWD";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }       }     }

Innanzitutto viene controllato se i valori degli assi superano il valore limite di 50. Ciò è necessario perché sia i potenziometri attraverso i quali viene letta la posizione degli assi, sia il convertitore analogico-digitale (ADC) si muovono minimamente intorno al valore zero (la cosiddetta deriva), anche nella posizione zero.

Se un asse è al di sopra del valore di soglia, i valori della grandezza dei due assi vengono confrontati tra loro. In questo modo è possibile determinare quale asse è stato spostato di più ed è quindi indicativo.

Dopo aver selezionato l'asse è sufficiente verificare se il valore è positivo o negativo per fornire l'esatta istruzione di direzione ESPNOW poter inviare.

 

Puoi vedere il programma completo qui(Controller.ino) Scaricalo e caricalo sull'ESP32 selezionando la scheda e la porta corrette.

3 robot di codifica

La struttura di base e in particolare il ESPNOW I metodi di callback sono quasi equivalenti al precedente programma del controller.
La differenza principale qui è che nel metodo di callback di ricezione i dati non vengono confrontati direttamente ma vengono memorizzati in una stringa

cmq = Stringa(dataTemp);

e poi valutato in loop().

 

In setup() anche i servomotori vengono inizializzati e impostati sulla posizione zero.

 

La valutazione segue quindi nel loop() cmq stringhe:

if(cmd.length() > 0) {     if(cmd.indexOf("CMD_FWD") >= 0) {       Serial.println("FWD");       forward();     }     else if(cmd.indexOf("CMD_BWD") >= 0) {       Serial.println("BWD");       back();     }     else if(cmd.indexOf("CMD_RGT") >= 0) {       Serial.println("RGT");       rightmove();     }     else if(cmd.indexOf("CMD_LFT") >= 0) {       Serial.println("LFT");       leftmove();     }     else if(cmd.indexOf("BTN_A") >= 0) {       Serial.println("A");       dance1();     }     else if(cmd.indexOf("BTN_B") >= 0) {       Serial.println("B");       dance2();     }     else if(cmd.indexOf("BTN_C") >= 0) {       Serial.println("C");       hello();     }     else if(cmd.indexOf("BTN_D") >= 0) {       Serial.println("D");       pushup();     }     else if(cmd.indexOf("BTN_E") >= 0) {       Serial.println("D");       turnright();     }     else if(cmd.indexOf("BTN_F") >= 0) {       Serial.println("D");       turnleft();     }         cmd = "";     const char* ack = "RDY";     esp_now_send(senderAddress, (uint8_t*)ack, strlen(ack));     Serial.println("ACK gesendet");   }

Se la lunghezza della stringa è maggiore di 0 significa che nella stringa è stato scritto un nuovo comando. Il contenuto viene quindi nuovamente confrontato con il rispettivo comando e viene eseguita la funzione associata del robot.

Dopo la valutazione, la conferma viene inviata al responsabile del trattamento.

 

In particolare alle funzioni dei 6 pulsanti è possibile assegnare qualsiasi funzione del robot.

 

I metodi di movimento del robot bionico si trovano in un file separato dall'ultima lezione sul robot. Puoi farlo qui (Comandi.h) Scaricatelo e poi copiatelo nella directory del progetto.

 

Puoi vedere il programma completo qui (Spider.ino) Scaricalo e caricalo sull'ESP8266 selezionando la scheda e la porta corrette. Non dimenticare di copiare il file dei movimenti del robot menzionato sopra nella directory

 

Conclusione

In questo post del blog, lo scudo del joystick e un ESP32 D1 R32 sono diventati un controller completamente funzionale per Ragno bionico costruito, che può trasmettere comandi al robot tramite WiFi con ESPNOW.

Il progetto lascia anche molto potenziale per la propria riprogettazione, ad esempio altri comandi possono essere eseguiti utilizzando i singoli pulsanti, ma è anche possibile eseguire schemi di movimento programmati premendo un pulsante.

Divertitevi a replicarlo :)