Robot Car con nodeMCU - Software

Questo e' il terzo e' ultimo post di una serie che descrive la realizzazione del progetto RobotCar con nodeMCU controllato da applicazione Android.

I post precedenti sono: RobotCar - Assemblaggio e RobotCar con nodeMCU

I questo post conclusivo descrivo e condivido il software per l'applicazione Andoird realizzato con AppInventor e lo scketch per il nodeMCU per il controllo del RobotCar.

RobotCar Android Controller

Siccome questo progetto e' rivolto per dei giovanissimi ho realizzato l'applicazione per Android con l'ottimo MIT App Inventor.

L'app Android e' molto semplice e' puo' essere estesa a piacere.

Ha la funzione principale di spiegare come controllare un dispositivo remoto con delle semplici chiamate HTTP GET.

Per i piu' esperti, dico subito che il meccanismo di comunicazione e' molto antiquato ed utilizza dei parametri nella URL come si faceva a meta' anni 90. 

Tuttavia, siccome e' orinetato a dei giovanissimi, ho scelto questa modalita' per renderla comprensibile.

Per chi realizza il progetto suggerisco di implementare un server REST. Tuttavia' sono solo dettagli.

Interfaccia Grafica

Come anticipato l'interfaccia grafica e' semplicissima. E' composta da 4 pulsanti che rappresentano le 4 direzioni di movimento del RobotCar.

Gli oggetti utilizzati sono i seguenti

Ho utilizzato un layout a tabella (5 righe e 5 colonne). Ho anche usato due label (senza testo) per ottenere uno spaziamento corretto dei pulsanti.

Per chi vuole usare l'app direttamente senza realizzarla in AppInventor ho messo il file APK sul mio GitHub [RobotCar - Progetto Completo]

Blocchi AppInventor

Il "codice" e' molto semplice come l'interfaccia.

Questa app presuppone che il RobotCar sia in ascolto all'indirizzo 192.168.10.10. Ovviamente potete cambiarlo con un indirizzo IP di vostro gradimento (il RobotCar crea un rete WiFI chiamata RoboCar-01).

Il codice fa si' che ad ogni pressione di un pulsante di controllo, una HTTP GET venga inviata al RobotCar con un parametro chiamato comado che puo' assumere un valore corrispondente alla direzione di movimento desiderata:

• AVANTI
• INDIETRO
• DESTRA
• SINISTRA
• FERMO

Da notare che il comando FERMO, che fa immediatamente fermare il RobotCar, viene inviato quando il pulsante viene rilasciato.

Quindi il RobotCar si muove, nella direzione prescelta, finché' il pulsante rimane premuto.

RobotCar WebServer per nodeMCU

Il RobotCar e' controllato da un nodeMCU fissato sul suo telatio.
Ho implementato un semplice WebServer sul nodeMCU in modo da poter ricevere i comandi provenienti dall'app Android e da attuare il controllo sui motori.

	#include <ESP8266WebServer.h>
	#define HTTP_WEB_PORT 80
	#define WIFI_RETRY_DELAY 500
	#define MAX_WIFI_INIT_RETRY 50
	#define MOTORE_SX_PIN1 D0
	#define MOTORE_SX_PIN2 D1
	#define MOTORE_DX_PIN1 D3
	#define MOTORE_DX_PIN2 D4
	#define AVANTI 1
	#define INDIETRO 0
	const char* wifi_ssid = "RobotCar-01";
	IPAddress local_IP(192,168,10,10);
	IPAddress gateway(192,168,10,10);
	IPAddress subnet(255,255,255,0);
	ESP8266WebServer http_server(HTTP_WEB_PORT);
	void setup(void) {
	Serial.begin(115200);
	pinMode(MOTORE_SX_PIN1, OUTPUT);
	pinMode(MOTORE_SX_PIN2, OUTPUT);
	pinMode(MOTORE_DX_PIN1, OUTPUT);
	pinMode(MOTORE_DX_PIN2, OUTPUT);
	Serial.println("Configurazione RoboCar WiFi AP..........");
	WiFi.softAPConfig(local_IP, gateway, subnet);
	WiFi.softAP(wifi_ssid);
	Serial.print("RoboCar WiFi AP IP Address = ");
	Serial.println(WiFi.softAPIP());
	config_server_routing();
	http_server.begin();
	Serial.println("RoboCar HTTP Server Started");
	}
	void config_server_routing() {
	http_server.on("/", HTTP_GET, []() { http_server.send(200, "text/html", "Benvenuto sul ESP8266 RoboCar Web Server"); });
	http_server.on("/robocar", HTTP_GET, muovi_robocar);
	}
	void muovi_robocar() {
	String comando = String(http_server.arg(0));
	Serial.print("Ricevuto comando = ");
	Serial.println(comando);
	http_server.send(200, "text/html", "robocar - comando ricevuto");
	if (comando == "AVANTI")
	robocar_avanti();
	else if (comando == "INDIETRO")
	robocar_indietro();
	else if (comando == "DESTRA")
	robocar_destra();
	else if (comando == "SINISTRA")
	robocar_sinistra();
	else if (comando == "FERMO")
	robocar_fermo();
	}
	void motore_sx_avanti() {
	Serial.println("motore_sx avanti");
	digitalWrite(MOTORE_SX_PIN1, HIGH);
	digitalWrite(MOTORE_SX_PIN2, LOW);
	}
	void motore_sx_indietro() {
	Serial.println("motore_sx");
	digitalWrite(MOTORE_SX_PIN1, LOW);
	digitalWrite(MOTORE_SX_PIN2, HIGH);
	}
	void motore_sx_fermo() {
	Serial.println("motore_sx fermo");
	digitalWrite(MOTORE_SX_PIN1, LOW);
	digitalWrite(MOTORE_SX_PIN2, LOW);
	}
	void motore_dx_avanti() {
	Serial.println("motore_dx");
	digitalWrite(MOTORE_DX_PIN1, HIGH);
	digitalWrite(MOTORE_DX_PIN2, LOW);
	}
	void motore_dx_indietro() {
	Serial.println("motore_dx");
	digitalWrite(MOTORE_DX_PIN1, LOW);
	digitalWrite(MOTORE_DX_PIN2, HIGH);
	}
	void motore_dx_fermo() {
	Serial.println("motore_dx fermo");
	digitalWrite(MOTORE_DX_PIN1, LOW);
	digitalWrite(MOTORE_DX_PIN2, LOW);
	}
	void robocar_avanti() {
	motore_sx_avanti();
	motore_dx_avanti();
	}
	void robocar_indietro() {
	motore_sx_indietro();
	motore_dx_indietro();
	}
	void robocar_destra() {
	motore_dx_avanti();
	}
	void robocar_sinistra() {
	motore_sx_avanti();
	}
	void robocar_fermo() {
	motore_sx_fermo();
	motore_dx_fermo();
	}
	void loop(void) {
	http_server.handleClient();
	}

view raw RoboCarWeb.ino hosted with ❤ by GitHub

I GPIO del nodeMCU da utilizzare sono definiti nelle linee 5 - 9. 

Il codice imposta il nodeMCU in modalita' AccessPoint e crea una rete WiFi chiamata RobotCar-01

Nella linea 43 configuro il webserver per eseguire la funzione muovi_robocar al ricevimento di un HTTP GET all'url: http://192.168.10.10/robocar

La funzione muovi_robocar  e' molto semplice e in funzione del parametro comando, letto dalla query HTTP, richiama al funzione di movimento del RobotCar relativa.

Ogni funzione di movimento del RobotCar, aziona i motori destro e sinistro in modo appropriato.

Test del RobotCar

Concludo questo progetto con il test del RobotCar