Sketch fascicolo NodeMCU Le Schede e le Applicazioni

Questi sono gli sketch inerenti il libro “NodeMCU: le schede e le applicazioni” di Paolo Capobussi, edizioni SanditLibri.
Per la comprensione e l’utilizzo degli stessi si faccia riferimento al libro.

 

 

***********************************************************************
PAG. 23 ***************************************************************

/*** Global variables ***/

/*** Function declaration ***/

unsigned int LED_pin = D0 //dichiara il pin del LED sulla NodeMCU

void setup() {
pinMode(LED_pin, OUTPUT); //predispone il pin LED come uscita
}

void loop() {
digitalWrite(LED_pin, LOW); //accende il LED interno
delay(1000); //attende 1 secondo
digitalWrite(LED_pin, HIGH); //spegne il LED interno
delay(3000); //attende 3 secondi
}

***********************************************************************
PAG. 24 ***************************************************************

/*** Global variables ***/
int pinRosso=D5;
int pinGiallo=D6;
int pinVerde=D7;

/*** Function declaration ***/
void spegnere (int LED);
void accendere (int LED);

void setup()
{

}

void loop()
{
accendere(pinVerde);
delay(5000);
accendere(pinGiallo);
delay(2000);
spegnere(pinVerde);
spegnere(pinGiallo);
accendere(pinRosso);
delay(4000);
spegnere(pinRosso);
}

/*** Function definition ***/
void spegnere (int LED) {
pinMode(LED,OUTPUT);
digitalWrite(LED,LOW);
}
void accendere (int LED) {
pinMode(LED,OUTPUT);
digitalWrite(LED,HIGH);
}

************************************************************************
PAG. 27 ****************************************************************

#define LED D1 //LED collegato a D1

#define LUMIN 1023 //luminosità massima

void setup() {
pinMode(LED, OUTPUT); //il LED pin è un’uscita
}

void loop() {
analogWrite(LED, 0); //spegni il LED
delay(1000);
for (int i=1;i<=LUMIN;i++){ //incrementa di 1
analogWrite(LED, i); //fino a LUMIN max
delay(10); //attendi 10 ms
}
}

************************************************************************
PAG. 32 ****************************************************************

int pinLED = D1;

void setup(){
Serial.begin(9600);
analogWrite(pinLED, 0);
}

void loop(){
float dutycycle = analogRead(A0);
Serial.print(“duty-cycle: “);
Serial.println((dutycycle/1024)*100);
analogWrite(pinLED, dutycycle);
delay(200);
}

************************************************************************
PAG. 35 ****************************************************************

const byte pinInterrupt = D7;
volatile byte contatoreInterrupt = 0;
int numerodiInterrupt = 0;

void setup() {

Serial.begin(9600);
pinMode(pinInterrupt, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(pinInterrupt), gestoreInterrupt, FALLING);
}

void gestoreInterrupt() {
contatoreInterrupt++;
}

void loop() {
if(contatoreInterrupt>0){

contatoreInterrupt–;
numerodiInterrupt++;

Serial.print(“Un Interrupt! In totale: “);
Serial.println(numerodiInterrupt);
}
}

************************************************************************
PAG. 35 / I ************************************************************

#include <Wire.h>

void setup() {
Serial.begin(9600); /* inizializza seriale monitor */
Wire.begin(D5, D6); /* attiva I2C con SDA=D5 e SCL=D6 */
}

void loop() {
Wire.beginTransmission(5); /* inizia trasmissione allo slave 5 */
Wire.write(“Ciao, sono NodeMCU”); /* invia dati */
Wire.endTransmission(); /* ferma la trasmissione */

Wire.requestFrom(5, 9); /* richiedi 9 byte allo slave 5 */
while(Wire.available()){ /*fino a che ci sono dati */
char car = Wire.read(); /* leggi un byte alla volta */
Serial.print(car); /* fallo vedere sul monitor */
}
Serial.println();
delay(1000);
}

************************************************************************
PAG. 35 / II ***********************************************************

#include <Wire.h>

void setup() {
Wire.begin(5); /* attiva I2C con indirizzo 5 */
Wire.onReceive(riceviEvento); /* quando ricevi dal master */
Wire.onRequest(richiestaEvento); /* quando il master ti richiede dati */
Serial.begin(9600); /* attiva seriale per monitor */
}

void loop() {
delay(100);
}

/* quando ricevi dal master esegui questa funzione */
void riceviEvento(int quanti) {
while (0 <Wire.available()) {
char car = Wire.read(); /* ricevi un byte alla volta */
Serial.print(car); /* fallo vedere sul monitor */
}
Serial.println(); /* vai a capo */
}

/* quando il master ti richiede dei dati */
void richiestaEvento() {
Wire.write(“Ciao Node”); /*invia i dati al master */
}

************************************************************************
PAG. 42 ****************************************************************

#include<SPI.h> /* includi libreria SPI */

char reg[]=”Ciao slave, ti mando questa stringa\n”;

void setup() {
Serial.begin(115200); /* inizializza seriale a 115200 baud */
SPI.begin(); /* inizializza SPI */
}

void loop() {
for(int i=0; i<sizeof reg; i++) /* fino a che ci sono caratteri */
/* trasferisci allo slave il contenuto di reg */
SPI.transfer(reg[i]);
delay(1000);
}

************************************************************************
PAG. 43 ****************************************************************

#include <SPI.h> /* includi libreria SPI */

char reg[100];
volatile byte i;
volatile bool ric_ok; /* flag di avvenuta ricezione */

void setup (void)
{
Serial.begin (115200);
SPCR |= bit(SPE); /* Ablita SPI in modo slave */
pinMode(MISO, OUTPUT); /* pin MISO come OUTPUT */
i = 0;
ric_ok = false;
SPI.attachInterrupt(); /* abilita interrupt per SPI */
}

void loop (void)
{
if (ric_ok) /* se ricezione avvenuta */
{
reg[i] = 0;
Serial.print(reg); /* stampa su monitor */
i = 0;
ric_ok = false;
}
}

// routine di interrupt per SPI
ISR (SPI_STC_vect)
{
cli(); /* disattivo interrupt fino a che finisce questo */
char c = SPDR; /* prendi il dato dal SPI Data Register (SPDR) */
if (i <sizeof reg)
{
reg[i++] = c; /* metti il byte ricevuto in un array */
if (c == ‘\n’){ /* fino a trovare ritorno a capo di fine messaggio */
ric_ok = true; /* ricezione completata */
}
}
sei(); /* rimetto attivi gli interrupt */
}

************************************************************************
PAG. 44 ****************************************************************

/*
* ESP8266 in Deep-sleep
*/

void setup() {
Serial.begin(9600);
Serial.setTimeout(3000);

// Wait for serial to initialize.
while(!Serial) { }

// Dopo aver caricato lo sketch, collegare D0 a RST
Serial.println(“Buonanotte, vado in deep-sleep per trenta secondi”);
ESP.deepSleep(30e6);
}

void loop() {
}

************************************************************************
PAG. 47 ****************************************************************

// Esempio di codice per inviare temperatura e umidità a thingspeak.com
// Hardware: NodeMCU, DHT11

#include <ESP8266WiFi.h> //per usare WiFi sulla NodeMCU
#include <ESP8266WiFiMulti.h> //per esplorare la presenza di più reti
#include <DHT.h> //versione 1.2.3 – per i sensori DHT (11 o 22)
//_non_ aggiornare la versione di DHT.h
#include <ThingSpeak.h> //per comunicare con piattaforma ThinkSpeak (TS)

ESP8266WiFiMulti wifiMulti;

#define DHTPIN D3 //pin dove è connesso il sensore dht11
DHT dht(DHTPIN, DHT11); //nelle vecchie versioni serviva un terzo parametro di ritardo
//in caso di processori veloci ma non è più necessario
//perché l’eventuale aggiustamento avviene in automatico

unsigned long myChannelNumber = XXXXXX; //ID canale di ThingSpeak
//(lo si legge in alto a sinistra su TS)
const char * myWriteAPIKey = “XXXXXXXXXXXXXXXX”; //Chiave API di scrittura di TS
const char* server = “api.thingspeak.com”; //server di TS a cui ci si collega

WiFiClient client; //Attivazione client WiFi sulla NodeMCU

void setup()
{
wifiMulti.addAP(“SSID”, “password”); // Lista delle reti “SSID”,”password”
wifiMulti.addAP(“SSID”, “password”);

Serial.begin(115200); // Apertura canale seriale

Serial.println(“Connessione …”);
int i = 0;
while (wifiMulti.run() != WL_CONNECTED) { // Attesa di connessione al segnale più forte
// tra quelli delle reti precedentemente indicate
delay(1000);
Serial.print(‘.’);
}

Serial.println(‘\n’);
Serial.print(“SSID:\t\t”);
Serial.println(WiFi.SSID()); // SSID al quale ci si connette
Serial.print(“IP address:\t”);
Serial.println(WiFi.localIP()); // IP locale della NodeMCU

delay(10);
dht.begin(); //attivazione sensore
ThingSpeak.begin(client); //attivazione client verso TS

}

void loop() {

float dht_h = dht.readHumidity(); //legge valore umidità dal sensore
float dht_t = dht.readTemperature(); //legge valore temperatura dal sensore

if (isnan(dht_h) || isnan(dht_t)) { //se vengono letti dati inconsistenti
Serial.println(“Lettura dal sensore fallita!”);
delay(1000);
return;
}
else { //stampa i valori verso la seriale
Serial.print(“DHT11 temp:\t”);
Serial.print(dht_t);
Serial.print(” ºC \n”);
Serial.print(“DHT11 humi:\t”);
Serial.print(dht_h);
Serial.print(“\n”);
}

if (client.connect(server, 80)) { //se il server TS è connesso
ThingSpeak.setField(1, dht_t); //invia al campo 1 il valore di temperatura
ThingSpeak.setField(2, dht_h); //invia al campo 2 il valore di umidità
ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);

}

client.stop();
Serial.println(“Attesa… \n”);
delay(20000); //TS ha bisogno di almeno 15 secondi
//tra una lettura e l’altra
}

************************************************************************
PAG. 54 ****************************************************************

#include <TimeLib.h>
#include <NtpClientLib.h>
#include <ESP8266WiFiMulti.h> //per esplorare la presenza di più reti

ESP8266WiFiMulti wifiMulti;

byte timeZone = 1; //zona oraria Italia (+1) (vedi timeanddate.com)
byte minutesTimeZone = 0;
int tempo = 0;

void setup()
{
// connessione alla rete wifi
wifiMulti.addAP(“Geppo_Limbi”, “3607717858077051”); // Lista delle reti “SSID”,”password”
wifiMulti.addAP(“Geppo_Limbi”, “3607717858077051”);

Serial.begin(115200); // Apertura canale seriale
Serial.println(“Connessione…”);

int i = 0;
while (wifiMulti.run() != WL_CONNECTED) { // Attesa di connessione al segnale più forte
// tra quelli delle reti precedentemente indicate
delay(1000);
Serial.print(‘.’);
}

Serial.println(“”);
Serial.println(“WiFi connesso”);
Serial.println(“indirizzo IP: “);
Serial.println(WiFi.localIP());
Serial.println(“”);

//server NTP, zona oraria, ora legale, minuti zona oraria
NTP.begin (“time.inrim.it”, timeZone, true, minutesTimeZone);
NTP.setInterval (60000);
}

void loop()
{

Serial.println(NTP.getTimeDateString ());

if (NTP.getTime() – tempo <= 0) {
digitalWrite(D4, HIGH);
}
else
{
digitalWrite(D4,LOW);
}
Serial.println(NTP.getTime());
Serial.println(tempo);
delay(10000);

int tempo = NTP.getTime();
}

************************************************************************
PAG. 60 ****************************************************************

#include <ESP8266WiFi.h>

void setup()
{
Serial.begin(115200);
Serial.println();

Serial.print(“Attiva come soft AP… “);
boolean result = WiFi.softAP(“La_mia_prima_rete”, “La_mia_password”);
if(result == true)
{
Serial.println(“Pronti!”);
}
else
{
Serial.println(“Errore!”);
}
}

void loop()
{
Serial.printf(“Stazioni connesse= %d\n”, WiFi.softAPgetStationNum());
delay(3000);
}

************************************************************************
PAG. 61 ****************************************************************

#include “ESP8266WiFi.h”

void setup()
{
Serial.begin(115200);
Serial.println();

WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
}

void loop()
{
Serial.print(“Scansione reti… “);
int n = WiFi.scanNetworks();
Serial.print(n);
Serial.println(” reti trovate”);
for (int i = 0; i < n; i++)
{
Serial.printf(WiFi.SSID(i), WiFi.channel(i));
}
Serial.println();

delay(5000);
}

************************************************************************
PAG. 62 ****************************************************************

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h> //necessaria per gestire il server

//nome e password della rete ospite
const char* ssid = “SSID”; //SSID, lasciare le virgolette
const char* password = “PASSWORD”; //Password, lasciare le virgolette

ESP8266WebServer server(80);//sulla porta 80, standard

char LEDpin = D3; //pin dove attaccare il LED
bool LEDstatus = LOW; //che è normalmente spento

void setup() {
Serial.begin(115200);
delay(100);
pinMode(LEDpin, OUTPUT);

Serial.println(“Connessione a… “);
Serial.println(ssid);

//connessione alla rete locale
WiFi.begin(ssid, password);

//controlla esito connessione
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.print(“.”);
}
Serial.println(“”);
Serial.println(“WiFi connessa!”);
Serial.print(“IP: “); Serial.println(WiFi.localIP());

server.on(“/”, handle_OnConnect);
server.on(“/ledon”, handle_ledon);
server.on(“/ledoff”, handle_ledoff);
server.onNotFound(handle_NotFound);

server.begin();
Serial.println(“Server HTTP pronto!”);
}
void loop() {
server.handleClient();
if(LEDstatus)
digitalWrite(LEDpin, HIGH);
else
digitalWrite(LEDpin, LOW);
}

void handle_OnConnect() {
LEDstatus = LOW;
server.send(200, “text/html”, SendHTML(false));
}

void handle_ledon() {
LEDstatus = HIGH;
server.send(200, “text/html”, SendHTML(true));
}

void handle_ledoff() {
LEDstatus = LOW;
server.send(200, “text/html”, SendHTML(false));
}

void handle_NotFound(){
server.send(404, “text/plain”, “Not found”);
}

String SendHTML(char led){
String ptr = “<!DOCTYPE html>\n”;
ptr +=”<html>\n”;
ptr +=”<head>\n”;
ptr +=”<title>LED Control</title>\n”;
ptr +=”</head>\n”;
ptr +=”<body>\n”;
ptr +=”<h1>LED</h1>\n”;
ptr +=”<p>Click to switch LED on and off.</p>\n”;
ptr +=”<form method=\”get\”>\n”;
if(led)
ptr +=”<input type=\”button\” value=\”LED OFF\” onclick=\”window.location.href=’/ledoff’\”>\n”;
else
ptr +=”<input type=\”button\” value=\”LED ON\” onclick=\”window.location.href=’/ledon’\”>\n”;
ptr +=”</form>\n”;
ptr +=”</body>\n”;
ptr +=”</html>\n”;
return ptr;
}

************************************************************************
PAG. 67 ****************************************************************

char Servopin = D1;

void setup(){
analogWriteFreq(50); //regola la frequenza PWM a 50Hz
Serial.begin(9600);
int dutycycle = 69;
pinMode(D5, INPUT);
}

void loop(){
float dutycycle = analogRead(A0); //leggi valori potenziometro
if(dutycycle> 1023) dutycycle = 1023; //correggi valore max potenziometro
int dutycycle = 69; map(dutycycle,0,1023,25,120); //converti i valori da 25 a 120 */

Serial.println(digitalRead(D5));
if(digitalRead(D5)==1){
int dutycycle=95;
analogWrite(Servopin, dutycycle); //invia valori corretti al servo
delay(500);
Serial.println(dutycycle);
dutycycle = 69;
analogWrite(Servopin, dutycycle);
}

delay(100);
}

************************************************************************
PAG. 69 ****************************************************************

bool d1 = HIGH; //coppia di pin che definisce la polarità
bool d2 = LOW; //e quindi la direzione del motore

//routine di gestione direzione su interrupt
void motor_direction(){
d1 = !d1;
d2 = !d2;
for(int i = 0; i<10000; i++)
for(int j =0; j<10000; j++);
}

void setup() {
Serial.begin(9600);
pinMode(D5, OUTPUT); // uscita PWM (variazione velocità)
pinMode(D6, OUTPUT); // alimentazione motore
pinMode(D7, OUTPUT); // alimentazione motore
pinMode(D8, INPUT_PULLUP); //ingresso interrupt dato dal pulsante
attachInterrupt(D8, motor_direction, HIGH);
//quando il pin 8 va ALTO invoca l’interrupt
}

void loop() {
int pwm_adc;
pwm_adc = analogRead(A0); //ingresso potenziometro controllo velocità
digitalWrite(D6,d1); //manda la voluta polarità al motore
digitalWrite(D7,d2); //in coppia con questo
analogWrite(D5,pwm_adc); //invia il segnale PWM per il numero di giri
delay(100);
}

************************************************************************
PAG. 72 ****************************************************************

int LED = D4;

void setup() {
pinMode(LED, OUTPUT);
Serial.begin(9600); /* velocità comunicazione seriale in baud */
}

void loop() {

if (Serial.available()) /* se c’è un dato disponibile sulla porta seriale */
{
char data_received;
data_received = Serial.read(); /* leggi dalla scheda bluetooth */
if (data_received == ‘1’) /* se il carattere ascii è 1 */
{
digitalWrite(LED, HIGH); /* accendi il led */
Serial.write(“\nLED ACCESO\n”); /* invia messaggio alla bluetooth */
}
else if (data_received == ‘0’)
{
digitalWrite(LED, LOW); /* spegni il led */
Serial.write(“\nLED SPENTO\n”); /* invia messaggio alla bluetooth */
}
if (data_received == ‘1’||data_received == ‘0’) {
Serial.write(“\nScegli ON o OFF\n”);
}
}
}

************************************************************************
PAG. 76 ****************************************************************

// Visualizzazione reti wifi attive su display tft 128*160
// Sketch basato sulla libreria UTFT-ESP Copyright (C)2015 Dimitris Lampridis
// https://github.com/gnulabis/UTFT-ESP a sua volta basata sulla libreria UTFT di
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// Questo programma richiede le librerie ESP8266WiFi.h e UTFT.h
//

#include “ESP8266WiFi.h”
#include <UTFT.h>

// Dichiarazione delle font utilizzate
extern uint8_t SmallFont[];

// Questi pin dipendono dal modello di TFT utilizzato:

#define SDA D5
#define SCK D6
#define CS D1
#define RST D2
#define A0 D3

UTFT myGLCD(ST7735,SDA,SCK,CS,RST,A0);

void setup ( ) {

WiFi.mode(WIFI_STA);
WiFi.disconnect( );
delay(100);

// Preparazione TFT
myGLCD.InitLCD ( );
myGLCD.setFont ( SmallFont );
myGLCD.clrScr ( ); //pulisce il display
}

void loop ( ) {

int n = WiFi.scanNetworks(); //esplora le reti
myGLCD.clrScr(); //pulisce il display

for (int i = 0; i < n; ++i) {

// Scrivi i dati definendo prima sfondo e colore

myGLCD.setBackColor (0,100,255);
myGLCD.setColor (0, 255, 0);
myGLCD.print (String(“N. RETI TROVATE: “), LEFT, 0);
myGLCD.print (String(n), RIGHT, 0);
myGLCD.setColor (255, 255, 255);
myGLCD.setBackColor (255, 0, 0);
myGLCD.print (String(WiFi.SSID(i)), LEFT, i*15+13 );
myGLCD.print (String(WiFi.RSSI(i)), RIGHT, i*15+13 );
myGLCD.setBackColor (0, 0, 255);
myGLCD.setColor (0, 209, 242);
myGLCD.print (String(“VIVISCIENZA.IT”), RIGHT, 114);

delay(500);
}
delay (5000);
}

************************************************************************
************************************************************************