NodeMCU Ver V2
ESP-12E

ultimo aggiornamento 23 agosto 2020

Indice

Descrizione;
Dove trovare il modulo;
Disposizione dei pin e loro funzione;
Foto del modulo;
Base per NodeMcu;
Programmazione delle scheda NodeMCU
Test dei led presenti sulla scheda
Test scheda NodeMCU
Realizzazione piccolo robot
- Esempio di codice ESP

Descrizione

La NodeMCU è una piattaforma open source sviluppata specificatamente per l'IOT, Essa include un firmware che funziona tramite il modulo Wi-Fi SoC ESP8266 e hardware con la base del modulo ESP-12 ed è programmabile in linguaggio Lua.
Questa scheda rappresenta l'evoluzione della precedente, è molto simile, la differenza più evidente è la sua dimensione è ora di 48x25 mm che meglio si adatta alle breadboard, il chip è stato aggiornato da un ESP-12 a un ESP-12E.
Per la comunicazione con il PC utilizza un chip CP2102 (oppure un CH340 nei primi modelli prodotti).

Dove trovare il modulo

Il modello nelle foto è una versione superata, il modulo ora in produzione può essere acquistato presso la ICStation con il codice 6034 ad un costo di circa 5 €

Disposizione dei pin e loro funzione

Foto del modulo

Base per NodeMcu

Per un più semplice interfacciamento con i dispositivi esterni è conveniente utilizzate una base come la ESP12E Motor shield (manuale) prodotta dalla DOIT dalle dimensioni di 58x43mm.

Lo shield permette di utilizzare al meglio la scheda di sviluppo estendendo le porte di uscita : interfaccia di alimentazione SPI, UART, GPIO, AI e 3,3V. Permette di comandare 2 motori e dispone di un interruttore di alimentazione.
Tensione per il motore: 4,5 V-36 V
Tensione per alimentazione scheda ESP: 4,5 V-9 V
Chip driver : L293D

La due morsettiere di alimentazione (motore e scheda) possono evitare interferenze, è comunque possibile effettuare un cortocircuito tra le due per usare una sola fonte di alimentazione in questo caso (V deve essere 4,5 ~ 9 V)

Assorbimento di corrente parte logica: 60mA (Vi = L), 22mA (Vi = H);
azionamento parziale funzionamento Io: 1.2A;
Perdita di potenza massima: 4 W (T = 90)
Segnale di controllo del livello di ingresso: 2.3 ≤VIH≤ VIN (high), -0.3 ≤ VVIL ≤ 1.5V (low);
Temperatura di lavoro: -25 ~ + 125
Tipo di azionamento: doppio controller h-bridge ad alta potenza
Kit porta di controllo Dev ESP12E: D1, D3 (motore A); D2, D4 (motore B)
Peso del modulo: circa 20 g

Programmazione delle scheda NodeMCU

Attenzione! Quella che segue è può essere considerata una traccia di come procedere alla programmazione della scheda, dato che in commercio si possono trovano varie versioni del modulo NODEMCU, questa guida potrebbe avere delle variazioni per il modello in vostro possesso.

Per programmare questa scheda saranno necessari:

Cavo USB micro-USB che permetta la trasmissione di dati
Driver CH340,IDE Arduino (il modulo è stato testato con l’IDE Arduino 1.8.5
Libreria di gestione ESP8266WiFi

Installato il driver CH340, se avete altre schede "cinesi" potreste aver installato questo driver per cui potere saltare questo passo, per maggiori informazioni vedere questo link, se questo è stato fatto collegando la scheda vedere la creazione della porta RS232

avviate l’IDE Arduino:Cliccate su “File > Impostazioni” si aprirà la finestra “Impostazioni”.

Inserite nella casella di testo inferiore della finestra (“URL aggiuntive per il gestore di schede”), l'ultimo che trovate disponibile da questo link e cliccate OK per continuare.

Dopo aver fatto questo primo passaggio possiamo installare la scheda, cliccando dalla schermata principale dell’IDE “Strumenti > Scheda > Gestore schede...” si aprirà la finestra “Gestore schede”

A questo punto nella barra “Filtrate la ricerca” scrivete “esp8266”, se avete eseguito i passaggi precedenti correttamente troverete l’opzione “Installa” disponibile. (Si raccomanda di installare l’ultima versione disponibile).

Dopo aver installato la scheda (150MB circa) potrete passare alla configurazione.

Nella schermata principale dell’IDE cliccate “Strumenti > Scheda > NodeMCU 1.0 (ESP-12E Module).

Cliccate nuovamente su “Strumenti > Upload Speed > 115200”.

Dopo aver fatto ciò avrete terminato la configurazione e l’installazione della scheda e siete pronti a programmare!

Test dei led presenti sulla scheda

La scheda NodeMCU ESP8266 presenta due led di colore blu tipo SMD 0603 con relativa resistenza limitatrice da 470 Ω, montati sulla scheda.

Il primo saldato sul sul PCB del NodeMCU è connesso al GPIO2
Il secondo sul PCB del modulo ESP-12 è connesso al GPIO16

Questo permette di fare dei test di collegamento senza dover dover collegare alcun componente esterno.

Nota
Entrambi i LED funzionano in modalità “invertita”, per quanto riguarda i livelli dei pin - quando il pin è ALTO il LED è spento; quando il pin è BASSO, il LED è acceso. Il LED acceso. GPIO2 lampeggia durante la programmazione ESP, poiché è collegato al U1TXDpin.
Sotto è riportato lo sketch utilizzabile, sarà sufficiente sostituire il numeo 16 con il 2 per testare il secondo led

void setup() {
  pinMode(16, OUTPUT);     // Initialize GPIO16 pin as an output
}

void loop() {
  digitalWrite(16, LOW);   // Turn the LED on by making the voltage LOW
  delay(1000);            // Wait for a second
  digitalWrite(16, HIGH);  // Turn the LED off by making the voltage HIGH
  delay(2000);            // Wait for two seconds
}

test_blink_esp-12.ino

Test Scheda NodeMCU

Per testare la scheda NodeMCU si è utilizzato un modulo KY-016 3 color LED module che è formato da un piccolo circuito stampato delle dimensioni di circa 15x16,5 mm con montato un pin header da 4 pin, sul modulo è presente un LED RGB dal diametro di 5 mm a catodo comune che emette i tre colori primari R, G, B.

Nello sketch utilizzato si fanno lampeggiare alternando i loro colori di base (rosso, verde, blu) all'interno di un loop infinito.
Componenti necessari:

Scheda NodeMCU V2
Modulo KY-016 3 color LED module
Cavi di collegamento
Pacco batterie 4x1,2V

test_esp-V2_ky-016.ino

/*####################################################################
  FILE: test_esp-V2_ky-016.ino
  VERSION: 1.0
  Descrizione: Programma per test Scheda NodeMCU ESP V2 tramite
  il modulo KY-016 3 color LED module

  Creato il 26/8/2018 da Adriano Gandolfo
  Sito web http://www.adrirobot.it
  Blog http://it.emcelettronica.com/author/adrirobot
  Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
  Istagram https://www.instagram.com/adrirobot/
  This example code is in the public domain.
  #################################################################### */

// Definizione dei pin di collegamento

#define redpin D1 // seleziona il pin per il LED rosso
#define greenpin D2 // seleziona il pin per il LED verde
#define bluepin D3 // seleziona il pin per il LED blu

void setup() {
  pinMode(redpin, OUTPUT); pinMode(greenpin, OUTPUT); pinMode(bluepin, OUTPUT);
}

void loop() {
  digitalWrite(redpin, HIGH); delay(500);
  digitalWrite(redpin, LOW); delay(500);
  digitalWrite(greenpin, HIGH); delay(500);
  digitalWrite(greenpin, LOW); delay(500);
  digitalWrite(bluepin, HIGH); delay(500);
  digitalWrite(bluepin, LOW); delay(500);
}

Realizzazione piccolo robot

Vediamo ora come realizzare un piccolo robot che potrà essere comandato tramite uno smartphone collegato tramite Wi-Fi alla scheda NodeMCU, per fare questo abbiamo bisogno di:


NodeMcu esp8266 con motorshield,	Piattaforma robot come per esempio la Feetech FT-002

Porta battere con due batterie Li-Ion 3,7V tipo ICR18650

Per le descrizione potrete vedere il seguenti link: Base per NodeMcu, robot Feetech FT-002, Porta batterie, sotto è riportato il semplice schema di collegamento

Per la gestione del robot si è utilizzata l'applicazione Blynk, disponibile sia per iOS e Android, l'applicazione è gratuita, chi non l'avesse mai utilizzata dovrà scaricarla e dopo essersi registrato si potrà utilizzarla.
Per il nostro robot utilizzeremo un semplice joystick virtuale, e lo imposteremo per lavorare con i pin virtuali.
Valori per entrambi gli assi da (-1) a 1.

Esempio di codice ESP

Il codice Esp è basato sul progetto Blynk predefinito per la gestione dei dati dal joystick al pin-1 virtuale. a seconda del dato ricevuto tramite una serie di IF sono eseguiti i comandi per l'attivazione dei motori.
Per il funzionamento del programma occorre inserire nel programma tre informazioni:

char auth[] = "YourAuthToken"; Inserire il codice fornito tramite e-mail dlal'applicazione

char ssid[] = "YourNetworkName"; Inserire il nome della rete a cui è collegato lo smartphone e i robot
char pass[] = "YourPassword"; Inserire la password di accesso alla rete.

Scarica il programma

/*
  Titolo: Blynk_robot_joystik.ino
  Semplice sketch per la gestione di un robot 2wd tramite app Blynk
  con ESP collegato in Wi-Fi

  Creato il 26/05/2019 da Adriano Gandolfo
  Sito web https://www.adrirobot.it
  Blog https://it.emcelettronica.com/author/adrirobot
  Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
  Istagram https://www.instagram.com/adrirobot/
  This example code is in the public domain.
*/

#define BLYNK_PRINT Serial
#include  <ESP8266WiFi.h>
#include  <BlynkSimpleEsp8266.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "YourAuthToken";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "YourNetworkName";
char pass[] = "YourPassword";

int PWMA = 5; //Right side
int PWMB = 4; //Left side
int DA = 0; //Right reverse
int DB = 2; //Left reverse

void setup() {
  // Debug console
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
  pinMode(PWMA, OUTPUT);
  pinMode(PWMB, OUTPUT);
  pinMode(DA, OUTPUT);
  pinMode(DB, OUTPUT);
}

void loop() {
  Blynk.run();

}

// Handling Joystick data
BLYNK_WRITE(V1) {
  int x = param[0].asInt();
  int y = param[1].asInt();
  if (x == -1 && y == -1) {       //Backward and Left
    digitalWrite(PWMA, LOW);
    digitalWrite(DA, LOW);

    digitalWrite(PWMB, HIGH);
    digitalWrite(DB, HIGH);
  } else if (x == -1 && y == 0) {  //Left Turn
    digitalWrite(PWMA, 450);
    digitalWrite(DA, HIGH);

    digitalWrite(PWMB, 450);
    digitalWrite(DB, LOW);
  } else if (x == -1 && y == 1) {  //Forward and Left
    digitalWrite(PWMA, LOW);
    digitalWrite(DA, LOW);

    digitalWrite(PWMB, HIGH);
    digitalWrite(DB, LOW);
  } else if (x == 0 && y == -1) {  //Backward
    digitalWrite(PWMA, HIGH);
    digitalWrite(DA, HIGH);

    digitalWrite(PWMB, HIGH);
    digitalWrite(DB, HIGH);
  } else if (x == 0 && y == 0) {  //Stay
    digitalWrite(PWMA, LOW);
    digitalWrite(DA, LOW);

    digitalWrite(PWMB, LOW);
    digitalWrite(DB, LOW);
  } else if (x == 0 && y == 1) {  //Forward
    digitalWrite(PWMA, HIGH);
    digitalWrite(DA, LOW);

    digitalWrite(PWMB, HIGH);
    digitalWrite(DB, LOW);
  } else if (x == 1 && y == -1) {  //Backward and Right
    digitalWrite(PWMA, HIGH);
    digitalWrite(DA, HIGH);

    digitalWrite(PWMB, LOW);
    digitalWrite(DB, LOW);
  } else if (x == 1 && y == 0) {  //Right turn
    digitalWrite(PWMA, 450);
    digitalWrite(DA, LOW);

    digitalWrite(PWMB, 450);
    digitalWrite(DB, HIGH);
  } else if (x == 1 && y == 1) {  //Forward and Right
    digitalWrite(PWMA, HIGH);
    digitalWrite(DA, LOW);

    digitalWrite(PWMB, LOW);
    digitalWrite(DB, LOW);
  }
}

Elenco revisioni:
23/08/2020	Aggiornato pagina, inserito test led
26/05/2019	Aggiornato pagina
26/08/2018	Emissione preliminare

Private Policy Cookie Policy