ESPertino ha tra i suoi punti di forza la connettività, resa possibile grazie alla presenza del modulo Wroom32 integrato sulla scheda e capace di garantire la comunicazione wireless via WiFi e Bluetooth Low Energy. Nell’applicazione descritta nell’articolo (in pieno stile IoT), ESPertino implementerà un Web Server, a cui ci su potrà collegare tramite un comune browser per interrogare o comandare lo stato di led, relè, o altri sensori e attuatori collegati alla scheda.
Introduzione
La board ESPertino, visibile in Figura 1, rappresenta un’ottima soluzione per realizzare diversi tipi di applicazioni IoT. Tra le caratteristiche che la contraddistinguono, ricordiamo anzitutto la connettività wireless, con interfacce sia di tipo Bluetooth Low Energy (BLE), che WiFi. L’IoT (Internet of Things) immagina uno scenario in cui una moltitudine di dispositivi elettronici (con funzioni e caratteristiche differenti tra loro), sono tutti interconnessi a una rete, e in grado di scambiarsi informazioni in tempo reale.
Figura 1: la board di prototipazione rapida ESPertino, particolarmente indicata per le applicazioni IoT
Per supportare l’IoT, che a sua volta è stato prescelto come veicolo principale nel processo di attuazione dell’Industry 4.0, è quindi fondamentale e imprescindibile che il dispositivo sia dotato di un’interfaccia di comunicazione ad alta velocità, robusta, affidabile, e possibilmente dotata di un meccanismo di protezione (cifratura) per garantire la sicurezza dei dati trasmessi sulla rete. La board ESPertino possiede tutte queste caratteristiche, grazie alla presenza di un modulo integrato ESP32 (Figura 2).
Figura 2: il modulo ESP32-Wroom-32 integrato sulla board ESPertino
Il modulo ESP-32, progettato e prodotto da Espressif Systems, possiede delle caratteristiche hardware e funzionali di assoluto rilievo. Inoltre, il modulo possiede tutte le certificazioni necessarie alla sua operatività, per cui può immediatamente essere impiegato senza preoccuparsi di dover sottoporre il dispositivo a ulteriori test e verifiche di conformità. Ecco una breve sintesi delle caratteristiche tecniche del componente:
- doppio microprocessore a basso assorbimento Xtensa® LX6 a 32 bit;
- 448 Kb di memoria ROM per il boot e per le funzioni destinate al core;
- 520 Kb di memoria SRAM integrata;
- 8 Kb di memoria SRAM in RTC SLOW;
- 8 Kb di memoria SRAM in RTC FAST;
- 1 Kbit di memoria EFUSE, e 256 bit per il MAC;
- interfaccia WiFi conforme a 802.11 b/g/n/d/e/i/k/r (802.11n fino a 150 Mbps);
- interfaccia Bluetooth conforme alle specifiche v4.2 BR/EDR e BLE;
- funzionamento Wi-Fi in modalità Station/softAP/SoftAP+station/P2P;
- funzionalità per la sicurezza tramite WPA/WPA2/WPA2-Enterprise/WPS;
- crittografia con algoritmi AES/RSA/ECC/SHA;
- supporto ai protocolli IPv4, IPv6, SSL, TCP/UDP/HTTP/FTP/MQTT;
- disponibilità di numerose interfacce e protocolli di comunicazione a livello hardware: scheda di memoria SD, UART, SPI, SDIO, I2C, PWM per pilotaggio di led, PWM per pilotaggio di motori, I2S, IR, GPIO, sensore touch capacitivo, ADC, DAC, sensore ad effetto Hall, sensore di temperatura;
- temperatura operativa compresa tra -40 °C e +85 °C;
- tensione operativa compresa tra 2,2 V e -3,6 V;
- assorbimento: 80 mA (valore tipico);
- dimensioni: 18 mm x 20 mm x 3 mm.
Oltre a queste caratteristiche tecniche di assoluto rispetto, il modulo presenta l’enorme vantaggio di essere programmabile utilizzando diversi linguaggi e ambienti di sviluppo integrati (Lua, Python, Arduino, ecc.). Sì, avete letto proprio bene, anche Arduino! Vista l’enorme diffusione e il successo riscontrati da Arduino (grazie anche alla sua semplicità di programmazione, che lo rende accessibili anche ai non “adepti”), alcuni appassionati hanno creato un plugin per l’IDE Arduino che permette di programmare il modulo Wroom-32 (e, di conseguenza, le board che lo integrano, come ESPertino). Per chi non avesse già installato questo plugin, ricordiamo che disponibile una descrizione esauriente sui passi da compiere.
L’applicazione oggetto di questo articolo prevede la creazione di un Web Server sulla board ESPertino, sfruttando le potenzialità messe a disposizione dal modulo Wroom-32. In particolare, vedremo come implementare un server a cui poter accedere via wireless (WiFi) da un dispositivo portatile (smartphone, tablet) o da un comune PC, utilizzando un comune browser di navigazione. Una volta collegati al web server, ESPertino ci invierà una pagina analoga a quella visualizzata in Figura 3.
Per questa applicazione (a cui ne seguiranno altre dello stesso tipo, ma più complesse e con l’utilizzo di ulteriori sensori ed attuatori), ci interessa verificare la funzionalità di web server utilizzando le risorse già disponibili sulla board, e più precisamente:
- il led utente (user led), collegato al GPIO 5 del modulo. Per come è stato collegato sulla scheda ESPertino, questo led si accende quando l’uscita associata al pin 5 è bassa, e viceversa si spegne quando l’uscita associata al pin 5 è alta;
- il relè 1, collegato al GPIO 12 del modulo. Per i relè, assumiamo che lo stato di uscita alta (HIGH) attivi il relè, mentre lo stato di uscita bassa (LOW) lo disattivi;
- il relè 2, collegato al GPIO 14 del modulo. Valgono le stesse considerazioni fatte in pecedenza a proposito del relè 1.
La struttura della pagina web, visibile in Figura 3, ci permetterà di eseguire da remoto le seguenti operazioni:
- modificare lo stato dell’uscita associata al GPIO 5, e quindi di accendere oppure spegnere il led utente;
- monitorare lo stato (acceso oppure spento) del led utente;
- modificare lo stato dell’uscita associata al GPIO 12, e quindi di attivare oppure disattivare il relè 1;
- monitorare lo stato (attivato oppure disattivato) del relè 1;
- modificare lo stato dell’uscita associata al GPIO 14, e quindi di attivare oppure disattivare il relè 2;
- monitorare lo stato (attivato oppure disattivato) del relè 2.
Figura 3: struttura della pagina web attraverso cui interagire con il server residente su ESPertino
ATTENZIONE: quello che hai appena letto è solo un estratto, l'Articolo Tecnico completo è composto da ben 2679 parole ed è riservato agli ABBONATI. Con l'Abbonamento avrai anche accesso a tutti gli altri Articoli Tecnici che potrai leggere in formato PDF per un anno. ABBONATI ORA, è semplice e sicuro.
Ti potrebbe interessare anche:
Firmware 2.0 #47: Renewable Energy/Smart Projects
Come trasferire uno stile pittorico su una fotografia con Python
Sensori intelligenti MEMS nelle applicazioni industriali
Progetto di un sistema di comunicazioni Wireless Long-Range con LoRa32 – Parte 2
AirGradient: il sensore della qualità dell’aria fai da te
Come sempre un ottimo articolo Stefano.
Ottima l’idea di continuare con la pubblicazione di articoli inerenti la scheda ESPertino. Come sempre il successo di una scheda è la disponibilità di esempi da cui trarre per le proprie necessità.
Attendo i tuoi prossimi articoli.
Bell’articolo. Con la scheda ESPertino si possono fare realmente tante cose, anche di natura completamente diversa e variegata.
Bellissima applicazione. Poco tempo fa ne feci una molto simile con Arduino Uno WI-FI. Tutto funzionava alla grande ma graficamente non era il massimo. In giro ho visto ci sono molte app o servizi web che consentono di realizzare una grafica attraverso librerie proprietarie. Tu ne hai mai provato qualcuno? sapresti consigliarmi?
Molto interessante. L’approccio a webserver e’ il mio preferito, poiche’ permette di avere una GUI verso l’utente che gira in tempo zero su qualsiasi piattaforma senza impazzire a scrivere App dedicate, in quanto basta che ci sia un web browser disponibile.
Il webserver implementato supporta anche chiamate asincrone con AJAX? ( XMLHttpRequest, etc)
Grazie
Ciao Riccardo, mi permetto di risponderti io, Stefano mi correggerà se dirò castronerie: la tecnologia AJAX interviene lato client (quindi browser), quindi il server non deve gestire nulla in maniera diversa rispetto ad una classica chiamata HTTP. Per cui direi che sì, il webserver supporta anche chiamate AJAX!
Grazie della precisazione Davide, quello mi era chiaro. Poiche’ pero’ con AJAX spesso si scambiano degli XML fra server e client appunto con richieste AJAX (vedi questo mio articolo a riguardo https://it.emcelettronica.com/lettore-rfid-scalabile-su-mysql-con-configuratore-webserverajax-da-raspberry-pi) mi chiedevo se il server fosse preparato a spedire eventualmente degli XML con questa tecnologia. Ho provato a guardare nello sketch, ma non lo trovo.
Credo che per il formato del payload bisogna utilizzare librerie terze, ed implementarne la gestione. A questo punto aspettiamo Stefano per la conferma 🙂
Non credo sia necessario. Se vedi nel mio articolo che ho citato qui sopra si tratta semplicemente di aggiungere nel web server un controllo su come arrivi la formattazione della GET, prevedendo che contenga un nome esplicito di XML.
Puoi vedere 1 esempio molto semplice qui:
https://www.w3schools.com/xml/ajax_xmlfile.asp
dove vedi come la chiamata sia nativa senza l’uso di librerie di terze parti:
xhttp.open(“GET”, “cd_catalog.xml”, true);
xhttp.send();
Questo va implementato lato server, che dovra’ “servire” il file a ogni GET che contiene quella formattazione (puoi vedere come io lo abbia realizzato qui https://github.com/riccardoventrella/HIDWebServer/blob/master/src/WebServer.c nella f() serveSnapShotXML).
Detto questo, chiaramente il server deve fornire questo servizio e il client deve accordarsi con lui per sapere il nome degli XML serviti.
Detto questo, lungi da me trasformare questa pagine in un articolo su AJAX e i webserver.
Sicuramente questo webserver fa molto bene il suo scopo, ovvero agire sui relays quindi prevedere anche un servizio di XML e’ chiaramente sovradimensionato.
Ho guardato cmq lo sketch, e non vedo alcun problema ad estenderlo, eventualmente, gestendo nel parser della GET anche un servizio di XML.
Volevo spiegare cmq brevemente perche’ ho pensato ad AJAX come estensione di quella applicazione, se magari qualcuno possa esserne interessato.
Come detto sopra, questo applicativo fa egregiamento il proprio dovere, accendendo i relays e postando la nuova pagina sul browser come risposta alla GET, in modo da dare all’utente un feedback sullo stato dei relays dopo il comando.
Questo va bene finche’ la pagina e’ piccola e contiene solo il post dei relays. Se immaginiamo un’applicazione futuribile del tutto, dove i relays sono solo parte di quello che deve vedere e gestire l’utente, pensare di ripostare tutta la pagina a ogni risposta e’ impensabile, poiche’ questa sfarfallerebbe troppo dando fastidio all’utente.
Qui viene incontro AJAX, dove la X sta appunto per XML (lo scrivo chiaramente per chi magari e’ a digiuno di questa tecnologia, non sono qui per insegnare nulla ad alcuno). Si puo’ quindi infatti pensare di formattare la risposta dello stato dal server al client in un comodo XML, contenente lo stato dei relays e tutto quanto serva. A quel punto, il client in modo nativo sara’ in grado di parserizzare l’XML in risposta e potra’ aggiornare solo alcune parti della pagina, quelle relative ai relays, senza doverla ripostare interamente.
Si puo’ anche andare oltre a questo. Immaginiamo che i relays siano controllabili anche da altri client fuori dal webserver (operatori a bordo o simili). A quel punto sarebbe bello che il browser venisse informato di cambiamenti nello stato dei relays. Questo puo’ essere nuovamente realizzato con AJAX, facendo in modo che il client richieda in modo temporizzato lo stato dei relays al server. Ad esempio, questo puo’ avvenire ogni 300ms o quando si vuole.
A quel punto il server ricevera’ la richiesta di GET dell’XML (qui non ci sara’ alcun comando di attuazione, ma solo 1 richiesta di servizio dell’XML) e servira’ il file al client, che lo parserizzera’, aggiornando la pagina circa 3 volte al secondo ma senza farla sfarfallare.
Ecco perche’ un estensione del server per supportare richieste asincrone di XML dai client potrebbe essere un’estensione interessante di questo articolo. Questo, come detto puo’ essere realizzato nativamente nello sketch, semplicemente rendendo piu’ articolo il parser della stringa della GET.
Un modo per realizzare delle interfacce con oggetti grafici è quello di urilizzare javascript e HTML5, sul veb si posono trovare dei canvas giá pronti (gauge, barre, tachimetri, ecc.). Esiste poi la libreria plotly.js, molto ricca di oggetti grafici con esempi giá pronti di utilizzo pratico.
Ne stavamo parlando sui commenti di un altro articolo: avere a disposizione un web server su ogni dispositivo embedded apre le strade ad applicazioni davvero interessanti. Una tra tutte: la domotica (argomento forse oramai troppo “chiacchierato”),
Si, infatti e’ bello come gli articoli si intreccino mettendo poi in rilievo approcci comuni.
Come ho gia’ avuto modo di dire, sicuramente la demotica e’ stata nel passato appannaggio delle “grandi soluzioni”, dove le ditte dettavano gli standard creando protocolli ad hoc (si veda appunto KNX).
Ora credo che, grazie a questa nuova IoT cosi’ spinta, si possa tornare a soluzioni piu’ custom, o cmq anche basate su degli standard dove anche noi “piccoli” sviluppatori si possa dire la nostra. Certo, a parte le tecnologie, quello che fa la differenza e’ avere le idee giuste al momento giusto. E per gente come me, spesso troppo focalizzata a divertirsi con la tecnologia, a volte si perde di vista la novita’ e non si sa cogliere l’attimo (lo dico chiaramente a me stesso come monito).
grazie dell’articolo, mi è arrivato oggi ESPertino, sicuramente applicherò le tue indicazioni. buona serata
Ecco la prima prova fatta con espertino …. tutto funziona alla grande adesso devo trovare il modo di assegnare un ip fisso al mio espertino in questo modo posso renderlo pubblico e vederlo dall’esterno ……. salutoni a tutti
Ottimo! Questo è un buon esempio da cui partire, ma tiene presente che ne seguiranno molto altri. Saluti e buon lavoro!
buona sera
ho ricevuto espertino da qualche giorno e volevo provare la scheda con il web server.
premetto che non sono molto esperto, ma ci provo.
nel file ho dovuto cambiare:
// ssid e password richiesti per la connessione alla rete WiFi
const char* ssid = “xxxxxxxxxx”; // inserite l’ssid della vostra rete WiFi
const char* password = “xxxxxxxxxxx”; // inserite la password della vostra rete WiFi
con:
// ssid e password richiesti per la connessione alla rete WiFi
char ssid[] = “xxxxxxxxxx”;
char password[] = “xxxxxxxxxxx”;
perchè mi dava questo errore:
invalid conversion from ‘const char*’ to ‘char*’ [-fpermissive]
poi
quando faccio la verifica dello sketch ottengo sempre questo:ATTENZIONE: la libreria SPI dichiara di funzionare sulle architetture (esp32) e potrebbe non essere compatibile con la tua scheda che utilizza l’architettura (ESPertino).
Poi carico lo sketch e vado a vedere il monitor seriale al posto dell’indirizzo IP
trovo scritto questo:
Guru Meditation Error of type LoadProhibited occurred on core 1. Exception was unhandled.
dove ho sbagliato?
ringrazio anticipatamente
L’articolo e il relativo sketch che lo accompagna sono stati scritti diversi mesi fa, utilizzando l’unico ambiente di sviluppo Arduino per ESP32 a quei tempi disponibile, cioè l’ambiente arduino-esp32 ufficiale rilasciato da Espressif Systems (il produttore del modulo ESP32). Trovi questo tool (e relative istruzioni di installazione) su GitHub all’indirizzo: https://github.com/espressif/arduino-esp32. Dal tuo log di errore mi sembra invece di capire che stai usando l’ambiente appositamente creato per ESPertino (anch’esso disponibile su GitHub). Prova a installare l’ambiente ufficiale (segui le istruzioni per il tuo sistema operativo presenti all’indirizzo di cui sopra), poi lancia l’ide Arduino, seleziona la board “ESP32 Dev Module” e prova a compilare. Non dovresti più avere errori di compilazione.
grazie
domani provo
buon giorno
ho seguito le vostre indicazioni e tutto funziona.
grazie
buona giornata
Ottimo! Buona giornata e buon divertimento con ESPertino.
Ciao a tutti, cerco di descrivere il problema;
Uso Windows Vista 32Bit e sto eseguendo il tutto tramite Chrome, scaricato Ide ok, scaricati drive usb silicon labs ok, porte com ok e vedo il modulo, ora mancano le librerie per avere nelle schede selezionabili ESPertino.
Dal link https//github.com/EMCelettronica/ESPertino sono andato su ( instruction for eindows) e tramite il sw git gui ho seguito la procedura, con esito credo positivo.
Il problema è che continuo a non vedere la scheda Espertino tra le schede selezionabili.
Ho tralasciato qualche passaggio? Anticipatamente vi ringrazio.
Ciao, precedentemente ho scritto per chiedere aiuto in merito all’installazione di librerie, ma il problema era legato a Chrome che con windows Vista non viene piu’ aggiornato, quindi non funzionava per scaricare il file zip delle librerie, risolto scaricando firefox, grazie.
Bene. Tieni presente che da GitHub (oltre a scaricare lo zip di un progetto) puoi anche utilizzare Git e clonare l’archivio. Il vantaggio di usare Git è che puoi in ogni momento allineare la tua versione a quella del repository su GitHub con un semplice comando (pull). Se usi lo zip devi ogni volta scaricarlo e sovrascrivere la versione precedente.
Su Linux/Unix e’ molto comodo usare git da shell, ma se uno e’ piu’ avvezzo a un’interfaccia grafica, io in passato ho usato questo su Windows:
https://sourceforge.net/projects/gitextensions/
trovandomi bene. Ma ce ne sono molti simili.
Come client Git per Windows vanno anche bene Tortoise Git e SmartGit, entrambi hanno un’interfaccia grafica decisamente migliore della GUI originale di Git.
Ciao Stefano, grazie, si Tortoise lo conosco, in particolare usato con plug-in dell’esplorar da tasto destro. Se posso, cmq, preferisco, lavorare da shell, questo perche’ spesso lavoro su Raspberry usando nano come editor tramite ssh, quindi non ho alcun appoggio GUI laggiù.
Anche Visual Studio ha cmq un ottimo plug-in integrato.
Ma solo a me capita che ogni tanto (tanto spesso) durante il funzionamento si blocchi e debba premere il reset ? Credevo fosse più stabile, così è inutilizzabile !
Questo è l’errore :
Guru Meditation Error of type IllegalInstruction occurred on core 0. Exception was unhandled.
Register dump:
PC : 0x401096bf PS : 0x00060530 A0 : 0x8010a054 A1 : 0x3ffce7d0
A2 : 0x6ed9eba1 A3 : 0xaf4ebaa1 A4 : 0x2c5f23dc A5 : 0x3f2fdb70
A6 : 0xa237c66f A7 : 0x7edc4dd7 A8 : 0xb2e480de A9 : 0xe3c450c8
A10 : 0xf7ffccc8 A11 : 0x7d6b05d1 A12 : 0x46f9eb21 A13 : 0x29840989
A14 : 0xe702151a A15 : 0x3979d05b SAR : 0x00000002 EXCCAUSE: 0x00000000
EXCVADDR: 0x00000000 LBEG : 0x4000c2e0 LEND : 0x4000c2f6 LCOUNT : 0x00000000
Backtrace: 0x401096bf:0x3ffce7d0 0x4010a054:0x3ffce880 0x4010a170:0x3ffce8a0 0x401077b9:0x3ffce920 0x40107839:0x3ffce9e0 0x401049c0:0x3ffcea10 0x40103951:0x3ffcea50 0x400f8d3a:0x3ffcead0 0x400f90fc:0x3ffceaf0 0x400f9a48:0x3ffcebc0 0x400934c4:0x3ffcebe0 0x40094d9e:0x3ffcec30
CPU halted.
Fai riferimento alle indicazioni fornite a lorenzo55 in questo stesso thread. Devi compilare con il plugin Arduino ufficiale di Espressif Systems (esp-idf). Una volta installato devi selezionare la board “ESP32 Dev Module”, compilare e uploadare.
ho installato la nuova versione di arduino, la 1.8.5. Provando a ricompilare lo Sketch mi da questo errore:
C:\Users\claud\Documents\Arduino\ESPertinoWebServer\ESPertinoWebServer.ino: In function ‘void setup()’:
ESPertinoWebServer:37: error: invalid conversion from ‘const char*’ to ‘char*’ [-fpermissive] ed evidenzia la linea: WiFi.begin(ssid, password); Comunque sono tornato alla versione precedente in attesa di risposte
Prova a togliere il “const” all’inizio delle due righe dove sono dichiarate le variabili ssid e password e ricompilare con la versione 1.8.5.
Essendo cmq dei parametri di input, formalmente sarebbe corretto lasciarli decorati col “const” entrambi.
Ho visto meglio ora lo sketch. Sicuramente rimuovendo il const dalla dichiarazione il problema dovrebbe andar a posto. A questo punto pero’, dal punto di vista del C++, direi che il problema risiede proprio nel metodo Begin della Wifi.
Seguendo i consigli del C++, i parametri di input dovrebbero essere tutti passati come const, proprio per avere una consistenza nella libreria.
Direi quindi che il vero fix dovrebbe essere di lasciare i const nella dichiarazione in testa allo sketch, ma di rendere const i parametri di input del metodo .Begin.
Chiaramente per l’utente hobbista non fa molta differenza, ma dal punto di vista della consistenza e’ molto diverso.
Il metodo “begin” della libreria WiFi fornita con l’SDK ESP32 di Espressif Systems è overloaded. Una forma accetta i parametri ssid e password come const char*, l’altra forma solo come char*. La seconda forma, tra l’altro, non fa altro che fare un cast dei parametri a const char* e richiamare la prima forma del metodo. Quindi le due forme sono equivalenti e interscambiabili tra loro. Nel caso di claudio51 sembra che il compilatore non abbia gestito correttamente l’overloading (sulla mia macchina compila senza errori con l’ide 1.8.5).
Grazie dell’approfondimento Stefano, non ho avuto modo di controllare la libreria direttamente.
Se posso esprimere un parere, non e’ buona norma avere 2 metodi overlodati in quel modo, in quanto ovviamente il compilatore puo’ aversene a male (come infatti accade).
Essendo parametri di input non possono essere che dei const. Quindi il metodo overlodato senza i const andrebbe rimosso in toto, con la contentezza del compilatore.
Peraltro, aggiungo che lasciando il solo metodo coi const, si potrebbe a quel punto tenere le dichiarazioni in testa allo sketch sia coi const che senza, poiche’ non ci sarebbe differenza.
Il problema e’ l’opposto infatti: non si puo’ passare un const a un metodo i cui parametri non lo sono. Il contrario invece non ha problemi: se il parametro e’ const, le variabili passate possono essere const o meno senza colpo ferire.
Ma se i parametri sono intesi come input, non ci possono essere dubbi sull’implementazione: devono essere const (come anche devono essere const i metodi che non modificano la classe).
Ho visto che usava la libreria standard di arduino, ora l’ho rimossa e compila correttamente. Come dall’articolo sull’installazione di ESPertino ho scaricato il pacchetto in /Documenti/Arduino/hardware/espressif/ESPertino. Come scegliere quali òlibrerie usare? Grazie
Ok, questo chiarisce il problema di compilazione. Per quanto riguarda gli ambienti, puoi mantenerli entrambi sul disco (uno in ../hardware/espressif/ESPertino e l’altro in ../hardware/espressif/esp32 se non ricordo male). I due ambienti (SDK) sono mutuamente esclusivi: selezioni l’uno o l’altro tramite la selezione della board nell’IDE (ESPertino oppure ESP32 DEv Module).
Se scrivi un tuo sketch da zero, è meglio utilizzare l’ambiente ESPertino. L’altro ti serve per compilare applicazioni come quella proposta in questo articolo, che erano state sviluppate quando l’ambiente ESPertino no era ancora disponibile.
Diciamo che problemi di questo genere non dovrebbero succedere, almeno lavorando con l’ambiente Arduino. Il bello di questa piattaforma è che permette a tutti e sottolineo proprio tutti di programmare microcontrollori avanzati con una miriade di sensori, senza avere un background completo nel campo della programmazione. In merito all’SDK per ESP32 ci sarebbero sicuramente delle migliorie e qualche fix da apportare (basta vedere il log di git relativo al progetto per rendersi conto del numero di commit eseguite). Tuttavia, tanto di cappello a chi ha realizzato il plugin ESP32 per Arduino: hanno permesso di programmare un SoC dual core come fosse un normale AVR, basandosi sull’ambiente di sviluppo nativo del modulo (che non è altro che FreeRTOS, ma qui mi fermo… non posso aggiungere altro…).
Ci mancherebbe, non voleva essere una critica (troppo) negativa a chi ha fatto la libreria. Pero’ in mezzo agli hobbisti ci sono sicuramente degli appassionati in erba che andrebbero abituati fin da subito all’uso corretto dei decoratori di scope, come il const.
Anni fa ero un purista del C, e mi avvicinavo timidamente e con diffidenza al C++ e alla sua complessità. Ma non appena ho inteso le potenzialità di un corretto uso dei const, non ho avuto piu’ dubbi su dove e quando usarlo (anche per il quando e’ proprio dettato dal discriminante input/output di un parametro).
Lo stesso sketch non necessiterebbe della decorazione const davanti alla dichiarazione, perche’ l’inizializzazione di un array di caratteri come stringa (come nello sketch) e’ const di default, quindi il const dovrebbe essere pleonastico.
Detto questo mi hai solleticato il palato: sono molto interessato al porting nativo di FreeRTOS su Arduino (o sulle piastre XXX-ino in genere). Conosco solo la versione per PIC32 e sarei molto interessato di vedere come si comporti FreeRTOS su Arduino, con le risorse limitate che ha rispetto ai target soliti per FreeRTOS.
Se fate un articolo in merito, sarebbe piu’ che ben accetto di sicuro.
Sì, arriverà un articolo su FreeRTOS@ESPertino. Questo potrebbe poi essere lo spunto per ulteriori approfondimenti e follow-up, come ad esempio la gestione dei thread su sistemi multi core (FreeRTOSufficiale è attualmente mono core).
Interessantissimo. FreeRTOS e’ un argomento che vedo sempre solo sfiorato in genere e relegato ad ambito piu’ o meno professionali.
E invece, insieme a Linux, dovrebbe essere un argomento di tutti e per tutti (sono un po’ indulgente e dogmatico a quest’ora, ma passatemela :-)).
Ancora due chiarimenti:
Come già riportato sopra da ZioTo73 dopo un po’ smette di funzionare ed è necessario premere Reset. Forse va in modalità sleep? Come evitarlo?
Come impostare un IP statico? Lo ho riacceso oggi e aveva cambiato indirizzo.
Grazie
La configurazione con IP statico verrà trattata in un prossimo articolo su ESPertino. Nel frattempo, potresti verificare se il tuo router consente di riservare degli indirizzi come statici (quindi non utilizzati dal DHCP server): se così è, puoi usare uno di questi come IP statico per la scheda ESPertino. Per quanto riguarda il problema di stabilità, posso vedere se riesco a riprodurlo. Verifica inoltre l’alimentazione che stai fornendo alla scheda, perchè con il WiFi acceso gli assorbimento salgono parecchio.
L’ideale sarebbe un’alimentatore esterno da 3A tipo quello del Raspberry 3
Esatto, infatti mi è stato consigliato di installare l’altro ambiente ma il mio problema non era in compilazione ma durante il funzionamento. Forse non mi ero spiegato bene, a me si compila e funziona correttamente, ma dopo un po’ smette di funzionare e mi da quell’errore.
Alimentato con un alimentatore da 2 A è rimasto attivo per tutta la serata, purtroppo questa mattina è stato necessario un reset. Ora è ancora attivo. Non so se la mancanza di richieste alla fine lo manda in sleep. Non ho idea di come questa funzione sia gestita.
Grazie, aspetto con ansia i prossimi articoli
Sembrerebbe quindi non un problema HW o di alimentazione. A naso, appunto, sembrerebbe un problema SW di come sia implementata la libreria. Puo’ darsi che il thread dove giri il web server venga messo in sleep quando e’ in attesa di connessioni in ingresso (ad esempio mi pare ci sia una modalità simile usando le socket su un sistema POSIX), pero’ il tutto dovrebbe essere gestito in modo che alla prima richiesta un interrupt risvegli il thread.
Quotando l’errore che riporta ZioTo73, ovvero:
“Guru Meditation Error of type IllegalInstruction occurred on core 0. Exception was unhandled.”
e infine “CPU Halted”
non credo ci possano essere dubbi sulla natura SW del problema, poiche’ il processore sta eseguendo un’istruzione “illegale”. Se questo per altro e capitato come sembra a diversi utenti, e’ quasi sicuramente un problema della libreria.
@claudio51 e @ZioTo73: provate a eseguire quanto segue.
1. modificate la linea 104 dello sketch nel modo seguente:
client.print(header_risp.c_str());
2. abilitate il massimo livello di informazioni di debug su seriale (IDE di Arduino -> Tools -> Core Debug Level: Verbose)
3. ricompilate, scaricate e provate
Fatemi sapere, grazie
Buona Domenica, ho provato le modifiche consigliate, ma dopo un certo tempo la pagina non viene più riconosciuta dal browser. A proposito vorrei segnalare questa pagina: https://mjrobot.org/iot-made-simple-playing-with-the-esp32-on-arduino-ide/ . I files sono scaricabili da : https://github.com/Mjrovai/ESP32.
Con le opportune modifiche ai pin girano anche su ESPertino, tra questi sketch ce n’è uno che legge temperatura ed umidità dal sensore DTH22 e lo trasmette ad intervalli regolari su una pagina web. Lasciato in funzione una intera giornata ha continuato a funzionare. Non conosco come ESPertino gestisca gli stati di sleep, ma penso che la differenza sia li.
Ciao claudio51 e ZioTo73,
se avete tempo, provate a modificare le linee 72-74 dello sketch come segue:
// lettura della richiesta HTTP, carattere per carattere
if (contatore < sizeof(buffer_riga)-1)
{
buffer_riga[contatore]=c;
contatore++;
}
Non so se risolverà il problema di stabilità, ma è comunque è una modifica che male non fa.
Una domanda per claudio51: l'esempio che non ti da problemi l'hai compilato utilizzando l'sdk di ESPertino oppure quello di esp-idf?
Grazie e saluti
Anche io l’ho messa sotto controllo da Sabato, con la modifica consigliata, ed ha funzionato ma ho avuto comunque un blocco, uno soltanto ma ho dovuto “resettare” la board. Purtroppo non avevo la seriale aperta e quindi non ho il log, comunque la cosa mi sembra piuttosto random. Io lascio tutto il tempo la scheda alimentata e di tanto in tanto mi connetto con il browser da PC o da cellulare(ma sempre sulla wifi locale), ed aziono i relays (qualche on/off), poi riprovo dopo alcuni minuti o alcune ore. In genere funziona, ma ieri ad esempio, dopo che stava funzionando (on-off compresi) da diverse ore, mi sono collegato, ho fatto un on-off sul relè 1 , un on-off sul relè 2 poi un on si nuovo sull’1 e si è bloccata (quindi la scheda non era in sleep o altro), da quel momento solo il reset mi ha fatto uscire da questa situazione.
Appena ho un minuto provo le modifiche suggerite. L’esempio preso dal sito l’ho compilato utilizzando l’sdk di ESPertino.
con le modifiche apportate, ha funzionato un’intera giornata, ma poi la pagina non era più raggiungibile ed è stato necessario un reset.
In questi giorni mi sono dato una infarinata su ESP32-IDF ed Eclipse e con un esempio trovato in rete ho installato un web Server su Espertino. Anche qui dopo ore o anche un giorno è necessario un reset.
Grazie claudio51. A questo punto penso che per generare il codice sia necessario utilizzare l’sdk ESPertino. Il mio sospetto è che vi sia qualche differenza tra l’sdk ESP-IDF e quello ESPertino nella gestione di qualche pin di I/O o di qualche periferica. A lungo andare (o casualmente, come nel caso di un pin flottante) potrebbe innescarsi un evento non gestito correttamente dal core ESP-IDF, con conseguente propagazione dell’eccezione e blocco dell’applicazione. Nei prossimi giorni vorrei compilare il web server con l’sdk ESPertino. Ti ricordi qual’era il problema generato in compilazione?
purtroppo lo stesso!
Cioè in compilazione non dava nessun problema, ma sia con l’SDK di Arduino sia con ESP32-IDF dopo un certo periodo la pagina web non è più raggiungibile ed è necessario un reset per attivarla
Quindi anche l’esempio preso in rete, compilato sia con sdk ESPertino che con sdk ESP-IDf dopo un certo periodo smette di rispondere?
Ciao Stefano, mi pare che Claudio citi l’SDK di Arduino (oltre che l’ESP32-IDF). E’ lo stesso SDK di Espertino?
si, uso l’ambiente Arduino con l’SDK di Espertino,. A volte non sono molto preciso nei termini.
Figurati, volevo solo capire. Sono sicuro che Stefano trovera’ una soluzione.
l’altra prova era con Eclipse e ESP32-IDF, ma entrambi dallo lo stesso problema. Non so se posso citare il sito con l’origine di questa ultima prova
Ok, comunque leggendo il forum ESP32-IDF (che per fortuna sembra molto attivo) si trovano dei problemi simili a quelli riscontrati da Claudio e da ZioTo73. Ad esempio sono stati riscontrati problemi sulla riconnessione WiFi, a cui EspressIf dovrebbe avere posto rimedio nel frattempo.
Quello che posso fare è compilare il web server con l’sdk ESPertino abilitando il massimo livello di debug (che visualizza su seriale tutti i log, compreso il core, driver e quant’altro) e fare uno zip con codice sorgente e codice binario. Lasciando attiva l’applicazione (con monitoraggio su PC della seriale) fino al blocco, si dovrebbe capire l’evento scatenante e, soprattutto, analizzare il log relativo al crash. Questo infatti, oltre al contenuto dei registri e al program counter, visualizza il contenuto del backtrace. L’sdk include poi dei tool che aiutano l’analisi del crash, mi sembra che su github ci sia anche un plugin per l’ide arduino, devo controllare.
Buongiorno
avendo necessità di impostare un’IP statico nel webserver di espertino, vorrei sapere se la funzione WiFi.config(); era stata implementata oppure ancora no
Grazie
Antonio
Salve, quando l’articolo è stato scritto la funzione WiFi.config() non funzionava correttamente. Leggendo questo post pubblicato sul forum espressif/arduino-esp32 (https://github.com/espressif/arduino-esp32/issues/540) sembrerebbe che il problema sia stato risolto lo scorso agosto. Le suggerisco di seguire le indicazioni fornite dall’utente me-no-dev (verso la fine della pagina sopra citata), che mostrano come impostare un IP statico nel caso si utilizzi la configuazione station (STA, come nel nostro caso) oppure access point (AP). Bisogna utilizzare l’ambiente espressif/arduino-esp-32, in quanto quello di ESPertino potrebbe non avere questo fix.
Buonasera mi sono cimentato con questo sketch ma provandolo mi da questo errore: Guru Meditation Error of type LoadProhibited occurred on core 1. Exception was unhandled.
Ho già letto qualcosa su questo forum ma nessuna soluzione sembra andar bene, sono state trovate altre soluzioni nel frattempo?
L’errore ti compare subito o dopo un certo tempo dall’accensione (cioè le prime interrogazioni hanno esito positivo)?
Scusi il ritardo, no è la prima cosa che compare. Nel monitor seriale inizia con: “Connessione alla rete WiFi: FASTWEB-1-18F243
Guru Meditation Error of type LoadProhibited occurred on core 1. Exception was unhandled.
Register dump: […]
“
Buongiorno
vorrei sapere come collegare e far funzionare una sd card all’unita espertino
Grazie
Antonio
Puoi utilizzare la libreria SD inclusa nell’ambiente Arduino (ESPertino oppure Espressif, il secondo penso sia più aggiornato):
https://github.com/espressif/arduino-esp32/tree/master/libraries/SD
I collegamenti sono indicati nella figura. Dovresti verificare con il datasheet di ESPertino se i GPIO utilizzati per il collegamento sono attualmente liberi: GPIO5 (utilizzato dalla libreria per il segnale CS) su ESPertino è già utilizzato per lo user led, quindi scegli un altro GPIO a piacere (dovrai ovviamente modificare lo sketch, fai riferimento alla libreria e agli esempi). Gli altri GPIO vanno controllati sul datasheet, forse sono già liberi. Anche se non indicato in figura, occorre utilizzare un porta-scheda SD che trovi facilmente dapertutto a basso prezzo.
Sempre al link di cui sopra puoi dare un’occhiata alle issues (secondo tab in alto), per sapere se ci sono dei problemi aperti e di che tipo..
Grazie Stefano,
ma pare dallo schema del datasheet di espertino che i pin preposti alla comunicazione SPI siano scollegati.
Mi puoi dare conferma?
I pin IO19 (MISO), IO18 (SCLK) e IO23 (MOSI) sono stati portati fuori dal modulo ESP-Wroom-32 e sono disponibili sui connettori di ESPertino. Dovresti quindi essere in grado di collegare la scheda SD. La configurazione dei pin suddetti in modo SPI è programmata dalla libreria SD, che a sua volta si appoggia alla libreria SPI, ma avviente tutto internamente al modulo. L’importante è che su ESPertino siano stati collegati i relativi pin (ho verificato sullo schema elettrico che è così). Quindi ti dovrebbe bastare fare i collegamenti e scegliere un altro GPIO (che sia configurabile in output) per il CS.
Buongiorno Stefano
E’ possibile “mescolare” utilizzando arduino ide sullo stesso espertino la funzione access point e web server? Sarebbe bello renderlo standalone
Buonasera skandy,
anzitutto mi fa molto piacere che abbia dimostrato interesse per l’applicazione descritta nell’articolo e, soprattutto, desideri maggiori informazioni sulla modalità access point (AP), non utilizzata nello sketch proposto ma supportata dal modulo ESP32.
Veniamo subito al dunque. L’attivazione della modalità AP è molto semplice: è sufficiente infatti partire dallo sketch originale apportando le modifiche descritte qui di seguito.
Nella funzione setup(), sostituire (magari commentandole) le righe di codice:
// connessione alla rete WiFi
Serial.println();
Serial.print(“Connessione alla rete WiFi: “);
Serial.println(ssid);
WiFi.begin(ssid, password);
// loop di attesa sino a quando la connessione viene stabilita
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(“.”);
}
Serial.println(“”);
Serial.println(“Connessione alla rete WiFi avvenuta con successo!”);
Serial.println(“indirizzo IP: “);
Serial.println(WiFi.localIP());
con le seguenti linee di codice:
// inizializzazione access point (nessuna password)
WiFi.softAP(“ESPertino”, “”);
IPAddress myIP = WiFi.softAPIP();
Serial.print(“Indirizzo IP AP: “);
Serial.println(myIP);
e vohila! ecco il web server in modalità AP!
In questa modalità ESPertino non si connette ad alcuna rete WiFi, perchè lui stesso diviene un AP. Dopo l’accensione, esegua una scansione delle rete WiFi con un PC o dispositivo mobile: vedrà una nuova rete che inizia con ESPxxx (la parte seguente è una sigla impostata dalla libreria dell’sdk). Si connetta quindi a questa rete (la password ora è nulla, ma può abilitarla inserendola nello sketch (secondo parametro dopo l’ssid). L’indirizzo IP dovrebbe essere 192.168.4.1 (default).Apra quindi un browser e digiti nella barra degli url 192.168.4.1 e vedrà compararire la pagina del web server ESPertino. Questa soluzione ha il vantaggio di non richiedere la connessione a una rete WiFi.
Spero con questo di avere soddisfatto la sua richiesta. Buon divertimento!
PS: ovviamente non potrà accedere ad internet utilizzando questa connessione…
Tenga presente che ho utilizzato l’sdk Arduino ESP32 di Espressif Systems (veda i post precedenti per il link), non l’sdk di ESPertino. Se ha problemi a far girare lo sketch, le consiglio di procedere nello stesso modo.
Salve,
Non vedo l’ora di provare il webserver, ma cliccando sul link dello sketch, vengo rimandato a questa pagina: https://it.emcelettronica.com/web-server-con-espertino/espertinowebserver
dalla quale, però, non è possibile scaricare nulla.
Grazie mille
Salve Antonio, il download è disponibile cliccando sulla seguente dicitura in verde: ESPertinoWebServer
Salve,
ho da poco iniziato ad usare la scheda Espertino, cercando di compilare lo sketch relativo al Web Server.
Anche a me da errori così come segnalato da lorenzo55 il 18 settembre 2017, cioè mi viene indicato il seguente errore:
invalid conversion from ‘const char*’ to ‘char*’ [-fpermissive].
Da premettere che ho installato l’ambiente arduino-esp32 ufficiale rilasciato da Espressif Systems (il produttore del modulo ESP32), prelevato dall’indirizzo: https://github.com/espressif
/arduino-esp32.
Il mio sistema operativo è Windows 10, 64 bit.
Come posso risolvere ?
Ringrazio in anticipo, distinti saluti.
ciao,
prova a sostituire le due dichiarazioni come ha fatto lorenzo55:
// ssid e password richiesti per la connessione alla rete WiFi
char ssid[] = “xxxxxxxxxx”;
char password[] = “xxxxxxxxxxx”;
Prima di compilare hai selezionato la board ESP32 Dev Module (menu tools->boards manager)?
Salve,
in effetti ciò che non riesco a trovare nel menu Tools->boards manager è proprio il modulo ESP32 Dev.
Eppure ho seguito tutti i passaggi indicati per l’installazione dell’ambiente arduino-esp32 ufficiale.
La directory in cui Arduino ha installato le directory indicate è:
c:/utenti/pierluigi/AppData/Arduino15/hardware/espressif/esp32.
Ringrazio e saluto per l’aiuto che mi vorrete dare.
Il percorso corretto è quello dove è installato l’IDE Arduino (la cartella hardware è già presente, non va creata). Esempio, sul mio PC:
C:\Program Files (x86)\Arduino\hardware
sotto hardware deve poi mettere espressif\esp32 con l’Arduino Core per ESP32
A quel punto l’IDE vedrà la nuova board (ESP32 Dev Module) e potrai selezionarla.
Puoi anche fare riferimento al mio articolo EOS relativo all’utilizzo di Telegram per ESPertino, un’applicazione che per la compilazione richiede l’Arduino Core ESP32 ufficiale.
Ricordati anche di lanciare il comando get.exe sotto ..\esp32\tools per scaricare il cross compiler.
Salve,
ringrazio per i suggerimenti dati.
Ho cambiato percorso e ho risolto, riuscendo a trovare nell’IDE di Arduino la board ESP32 Dev Module.
Ho compilato/verificato lo sketch per vedere se tutto era ok, ed in effetti è andato a buon fine.
Successivamente ho collegato la scheda ESPERTINO tramite cavo USB ad una porta, però, a differenza di prima, adesso non so perchè non riesco più a trovare la porta COM dove è collegata la scheda; nel senso che nell’IDE non si attiva la voce che permette di selezionare la porta COM (è come se la scheda non fosse collegata).
Ho provato ad installare manualmente i drives (CP210xVCPInstaller_x64.exe) scaricati dal sito ufficiale https://github.com/espressif/arduino-esp32.
Ribadisco che ho Windows 10 64 bit come sistema operativo.
Quale potrebbe essere il problema ?
Ringrazio ancora per la disponibilità.
B. sera, volevo sapere se avete trovato un listato per il webserver che funzioni correttamente senza il problema della disconnessione. Tutto sembra funzionare correttamente ma dopo un po bisogna resettare la scheda poichè non riceve più il comando. Grazie.
Purtroppo il problema non si verifica in modo deterministico e su tutte le board ESPertino quindi è difficile trovare una soluzione (sulla mia scheda, ad esempio, non sono mai riuscito a riprodurlo).
Leggendo comunque sul forum sia dell’ESP32 che dell’ESP8266 ho trovato una discussione su un problema analogo (mancata risposta del web server dopo qualche interrogazione via browser). Sembra che per qualche utente abbia funzionato la seguente modifica che puoi applicare allo sketch (il punto esatto è quando viene completato il messaggio di risposta HTTP da inviare al browser, fai riferimento ai commenti di INIZIO e FINE modifica che ho inserito):
…
header_risp += “\n”;
client.print(header_risp);
// inizio nuovo codice
delay(1);
client.stop();
// fine nuovo codice
break;
…
Fammi sapere se la modifica (2 sole istruzioni come puoi vedere) migliora il comportamento del web server.
B. giorno, ho provato su 3 schede diverse, purtroppo il problema persiste. Non vengono evidenziati problemi di alcun tipo, senza una spiegazione plausibile, a distanza di tempo non si riesce più a collegarsi.. Rimango in attesa se ha altri suggerimenti, altrimenti me ne farò una ragione. Saluti e grazie.
Buongiorno, come ulteriore strumento di indagine potrebbe fare quanto segue:
1) collegarsi ad altri router WiFi, anche con tethering da smartphone e vedere se cambia qualcosa
2) attivare la modalità access point (AP) come ho indicato in un precedente commento. La funzionalità del web server rimane intatta ma in questo caso non è più necessario disporre di router e rete WiFi. Verificare anche in questo caso se il problema sussiste
3) modificare la fase di inizializzazione come segue:
…
// inizializzazione della porta seriale: baudarate 115200
Serial.begin(115200);
Serial.setDebugOutput(true);
// connessione alla rete WiFi
Serial.println();
Serial.print(“Connessione alla rete WiFi: “);
Serial.println(ssid);
WiFi.begin(ssid, password);
// loop di attesa sino a quando la connessione viene stabilita
WiFi.persistent(false);
WiFi.mode(WIFI_STA);
while (WiFi.status() != WL_CONNECTED)
…
Grazie e saluti
Salve. Ho un problema con il Serial.println. Ho integrato il web server su una mia applicazione dove uso anche gli interrupt per testare un pin e un timer. Dopo la funzione WiFi.begin(), appena raggiunge lo status WL_CONNECTED e prova a scriverlo sul monitor seriale con Serial.println mi và in “CPU halted”. Disattivando tutti i Serial.println sucessivi al WiFi.begin() invece funziona regolarmente. Avete qualche suggerimento a tal proposito? Grazie.
Salve, mi risulta difficile darle delle indicazioni precise senza avere visibilità del suo sketch. Comunque, ecco qualche consiglio per indagare il problema:
1. compilare e scaricare lo sketch abilitando il massimo livello di debug trace in Arduino Ide (Tools->Core Debug Level->Verbose).
2. per risalire alla parte di codice che genera l’eccezione, deve installare il tool EspExceptionDecoder (https://github.com/me-no-dev/EspExceptionDecoder). Le istruzioni sono nel readme. Dovrà ricompilare e scaricare lo sketch dopo l’installazione di questo plugin per Arduino Ide.
3. sta usando il plugin Arduino per ESPertino o quello di Espressif Systems? Le consiglio di provare con quest’ultimo, perchè più aggiornato (https://github.com/espressif/arduino-esp32).
4. (ma forse dovrebbe essere la prima cosa da fare) commenti la gestione degli interrupt che ha introdotto nel suo sketch, verificando che la Serial funzioni. Inserisca poi le istruzioni relative all’abilitazione degli interrupt alla fine della funzione setup(), dopo la connessione WiFi e verifichi se il problema si risolve o meno. Gli interrupt che ha dichiarato possono interferire con i pin della seriale (1 e 3 di default)? E il timer?
5. Espressif Systems consiglia inoltre di utilizzare l’attributo IRAM_ATTR nelle ISR, ad esempio: void IRAM_ATTR isr() { … }. In questo modo la ISR viene eseguita in RAM evitando possibili crash (https://www.esp32.com/viewtopic.php?t=4978 e https://github.com/espressif/arduino-esp32/issues/855).
Salve e grazie mille per i suggerimenti che proverò senza dubbio. Ho anch’io una piccola modifica da suggerire sul listato del web-server. Ho notato che ogni tanto, non sò il perchè, ma il programma entra nel loop “while (client….” senza che ci sia un vero accesso da parte di alcun client ! Non c’è quindi alcuna richiesta da leggere e interpretare e solo un reset hardware lo sblocca. Io ho inserito una variabile “uint16_t cn_timeout;” con la quale forzo la disconessione del client quando non c’è una richiesta reale. Il listato si modifica in tal modo:
……
boolean riga_vuota = true;
cn_timeout=0;
while (client.connected() && cn_timeout++ 0) cn_timeout=0;
Serial.write(c);
……..
Spero sia di aiuto anche ad altri che hanno avuto un simile problema. Le faccio poi sapere dei risultati con le modifiche che mi ha suggerito. Grazie ancora. Saluti
Scusate. Ho visto che si è caricato male il listato. Lo riscrivo:
……
boolean riga_vuota = true;
cn_timeout=0;
while (client.connected() && cn_timeout++ 0) {
if (client.available()) {
char c = client.read();
if (c>0) cn_timeout=0;
Serial.write(c);
……..
Mi spiace, ma qualcosa mi taglia il listato in modo anomalo. Ci ritento:
” ………
boolean riga_vuota = true;
cn_timeout=0;
while (client.connected() && cn_timeout++ 0) cn_timeout=0;
Serial.write(c);
“
Se mi indicate una email, ve lo invio. Comunque la seconda è quasi corretta. Manca solo
“&& cn_timeout++ <1000) {". Scusate
La ringrazio per il valido contributo, paolo98. Probabilmente alcuni caratteri inseriti nell’editor dei commenti vengono interpretati come caratteri di formattazione html (ad esempio i simboli di maggiore e minore), bisognerebbe ricordarsi di utilizzare al loro posto le cosiddette entità (https://toolset.mrwebmaster.it/html/caratteri-speciali.html). Con il codice C/C++ ciò è particolarmente insidioso in quanto questi caratteri sono molto frequenti (capita spesso di vedere le istruzioni di #include < .. > troncate nel codice sorgente proprio per questo motivo).
Buongiorno
ho caricato tutto lo sketch con la board ESP32 Dev Mod.
La scheda ESPertino è attaccata tramite USB senza aver attaccato nulla a lei.
Carica senza errore terminando con “Hard resetting via RTS pin…”, ma quando apro Monitor Seriale non vedo nulla.
Come faccio a vedere l’IP?
Salve, se non vede nulla sul serial monitor (che deve essere impostato alla velocità utilizzata dallo sketch, cioè 115200 bps), provi a dare un reset alla scheda dopo aver eseguito l’upload dello sketch con Arduino IDE. Può essere che l’hard reset (inviato automaticamente dall’IDE alla fine del caricamento) non venga eseguito dalla scheda.
Ho notato che si poteva selezionare la velocità utilizzata dallo sketch solo dopo il suo commento.
Perfetto, funziona, grazie mille per la dritta.
Ottimo!
L’attivazione del relè da interfaccia web dovrebbe funzionare? Mi spiego meglio: con il relè in LOW ho continuità su due uscite del relè medesimo, fra la due e la tre. Immagino che questa sia la posizione NC. Se dall’interfaccia web porto lo stato su HiGH la continuità sul relè rimane sulle stesse porte, immagino che il comportamento corretto dovrebbe essere l’attivazione NO ovvero continuità fra uscita 1 e 2 e non più fra 2 e 3. Cosa sbaglio?
Grazie in anticipo
Gentile utente, dal momento che riscontra un’anomalia tra gli stati HIGH/LOW e le uscite, le consiglio di rivedere la configurazione dell’IDE e il caricamento dello sketch nell’ambiente di sviluppo integrato, in particolare la funzione setup () per l’ inizializzazione dei pin associati ai relè.
Verificare anche il collegamento dei relè alle interfacce di comunicazione del modulo: relè 1 collegato alla GPIO 12 e relè 2 collegato alla GPIO 14.
Grazie mille per la risposta. Ho risolto: SJ1 e SJ2 non erano chiusi, una goccia di stagno su entrambi e ora è tutto ok. Sarebbe stato più facile se sulla scheda accanto ai due contatti vi fosse stato serigrafato SJ1 e SJ2. Grazie.
Grazie a lei. Per qualsiasi cosa non esiti a contattarci.
Solo una curiosità: ma è normale che SJ1 e Sj2 non fossero in continuità? La scheda viene prodotta così oppure è una particolarità della mia?
Salve Stefano, non si tratta di una dimenticanza ma bensì di una scelta progettuale. In questo modo, infatti, l’utente può decidere se utilizzare i relè (saldando SJ1 e SJ2), oppure (lasciandoli aperti) utilizzare i due GPIO che comandano i relè per altri scopi (i due GPIO sono disponibili sul connettore di ESPertino, come può verificare nel datasheet). Se il progettista avesse tirato sul PCB due piste senza interruzione, i due GPIO sarebbero stati permanentemente assegnati ai relè. Si tratta quindi di una scelta di flessibilità.