Introduzione a Python per ESP8266 ed ESP32: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

sfondo

L'ESP8266 e il suo fratello maggiore ESP32 sono microchip Wi-Fi a basso costo con stack TCP/IP completo e funzionalità di microcontrollore. Il chip ESP8266 è arrivato per la prima volta all'attenzione della comunità dei produttori nel 2014. Da allora, il prezzo basso (<5 USD), la sua capacità Wi-Fi, una memoria flash integrata di 1 o 4 MB e una varietà di sviluppi disponibili schede, ha reso il chip ESP uno dei microcontrollori più popolari per progetti WiFi e IoT fai da te.

MicroPython è un'implementazione snella ed efficiente del sempre più popolare linguaggio di programmazione Python che include un piccolo sottoinsieme della libreria standard Python ed è ottimizzato per l'esecuzione su microcontrollori.

La combinazione di questi due è un'opzione molto interessante per i progetti fai-da-te, sia per principianti che per utenti più avanzati.

Il progetto MiPy-ESP

Nel 2015 i miei primi progetti con ESP8266 sono iniziati con il chip ESP-01 utilizzando Arudions per l'esecuzione di comandi AT del chip tramite connessione seriale. Successivamente, negli anni successivi ho applicato il core Arduino per ESP8266 per la programmazione dei chip con il linguaggio C++. Funziona bene, ma per un appassionato di Python, la mia scoperta dell'implementazione MicroPython di Python 3 è stata un'ottima notizia.

Il progetto MiPy-ESP è un framework flessibile che applica MicroPython per progetti IoT Python full-stack sui microcontrollori della famiglia ESP.

Il framework è sviluppato dal team di sviluppatori software del comitato tecnico LeGarage (LG-TC-SWDT-01) con l'obiettivo di sostituire il codice basato su C++ già stabilito per le nostre applicazioni di microcontrollori.

Il progetto fornisce funzionalità di base come

• Procedure di connessione alla rete
• Chip access point webserver (per la connessione wifi e il servizio di pagine web con chip per I/O dati)
• Funzionalità MQTT
• Registrazione/debug
• Programmazione degli eventi del microcontrollore
• Routine di I/O hardware

Con uno script di codice compatto principale (main.py), il tutto con configurazione globale (config.py).

Questo codice mictocontroller viene eseguito con una solida manutenzione delle connessioni dei chip alla rete WiFi e ai broker MQTT. I moduli MicroPython esistenti per vari hardware possono essere facilmente integrati nel sistema.

Il framework MiPy-ESP è diventato la spina dorsale di tutti i nostri progetti IoT di elettronica per hobby che coinvolgono microcontrollori della famiglia ESP. È stato testato su diverse schede della famiglia ESP, come le schede NodeMCU, Wemos e Lolin.

Il seguente tutorial è una guida su come iniziare con i microcontrollori della famiglia ESP e MicroPython utilizzando il framework MiPy-ESP.

Passaggio 1: la scheda Wemos D1 Mini ESP8266

Il framework MiPy-ESP funziona con la maggior parte dei microcontrollori basati su ESP8266.

La mini scheda di sviluppo Wemos D1 è basata sul chip ESP-8266EX. Su un ingombro di 2,5 x 3,5 cm, è dotato di memoria flash da 4 MB, 11 pin di ingresso/uscita digitali, tutti i pin supportano interrupt, PWM, I2C, SPI, seriale e 1 ingresso analogico con ingresso massimo 3,3 V, può funzionare con alimentazione a 5 V, ha una connessione micro USB ed è compatibile con breadboard. Il prezzo basso e le sue dimensioni ridotte l'hanno resa la mia scheda ESP preferita.

Inoltre, la versione D1 mini pro della scheda è dotata dell'opzione per il collegamento di un'antenna esterna, aumentando notevolmente il raggio di connessione (+100 m di raggio). In aggiunta a ciò, la scheda viene fornita anche con una varietà di schede di estensione pronte all'uso con dimensioni compatte simili.

Passaggio 2: prepararsi per MicroPython sul chip ESP

In questo primo passaggio, lo farai

• Collega la scheda ESP tramite USB al tuo computer
• Installa il software Esptool per flashare il chip
• Cancella la memoria del chip
• Flashare il chip con il firmware MicroPython
• Installa Rshell per abilitare l'interazione della riga di comando con il tuo chip
• Installa mpy-cross (per la compilazione di file.py in binario)

Collegando la scheda al computer tramite USBBoards con una porta seriale USB integrata, l'UART è disponibile per il tuo PC ed è l'opzione più semplice per iniziare. Per le schede senza connessione USB, è possibile utilizzare un modulo FTDI con USB to seriale per collegare i pin GPIO per il flash collegati al mondo esterno, ma questo non è trattato in questo tutorial.

Per MicroPython che utilizza il codice MiPy-ESP, il requisito minimo per la dimensione del chip flash è 1 MB. C'è anche una build speciale per schede con 512kB, ma questa non ha supporto per un filesystem, da cui dipende MiPy-ESP.

Quando si utilizza un cavo USB, la scheda viene alimentata dal computer durante la connessione. Ciò consente anche la programmazione e il debug tramite la connessione seriale. Quando il codice del progetto viene caricato e il tuo progetto viene distribuito, l'alimentazione esterna viene applicata sui pin di alimentazione della scheda.

Installazione di EsptoolInformazioni sul software Esptool sono disponibili nel repository Esptool GitHub. Se vuoi usare Windows/Linux/OSX (MAC), il link sopra copre anche quello. Il pacchetto Python può essere installato da

pip install esptool

Per gli utenti Linux, i pacchetti per Esptool sono mantenuti per Debian e Ubuntu e possono anche essere installati con

sudo apt install esptool

Cancellazione della memoria flash ESPUtilizzando Esptool, si cancella quindi la memoria flash ESP con il comando

esptool.py --port /dev/ttyUSB0 erase_flash

Download del firmware di MicroPytonIl firmware di MicroPython risiede in un file.bin che può essere scaricato dal sito Web di MicroPython.

Il ramo principale del progetto corrente del repository è stato testato ed è operativo con Micropython v.1.12. Per garantire il successo con il framework MiPY-ESP, scaricare il file 'esp8266-20191220-v1.12.bin' da questo link e scrivere il firmware sul chip con il comando:

esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0 esp8266-20191220-v1.12.bin

Installazione di RshellIl pacchetto Rshell consente l'interazione della riga di comando con l'ambiente MicroPython installato sul chip. Può essere trovato in questo link. Rshell è una semplice shell che viene eseguita sull'host e utilizza il raw-REPL di MicroPython per inviare frammenti di python a pyboard per ottenere informazioni sul filesystem e per copiare file da e verso il filesystem di MicroPython. REPL sta per Read Evaluate Print Loop ed è il nome dato al prompt interattivo MicroPython a cui è possibile accedere su ESP8266. L'uso di REPL è di gran lunga il modo più semplice per testare il codice ed eseguire i comandi. Installa Rshell con il comando:

sudo pip install rshell

Installazione del compilatore mpy-cross MicroPython può essere applicato con file ascii.py caricati nel filesystem del chip. MicroPython definisce anche il concetto di file.mpy che è un formato di file contenitore binario che contiene codice precompilato e che può essere importato come un normale modulo.py. Compilando i file.py in.mpy, sarà disponibile più memoria RAM per il codice in esecuzione - e questo è necessario per avere un modulo principale funzionante del framework MiPy-ESP.

Per la distribuzione del codice MiPy-ESP, un compilatore incrociato di MicroPython mpy-cross compila gli script.py in.mpy prima del caricamento del chip. Installa il pacchetto mpy-cross seguendo le istruzioni in questo link. In alternativa, il comando mpy-cross può essere installato dal comando pip Python o eseguito dal percorso della cartella mpy-cross se si clona il repository MicroPython da GitHub qui.

Ora hai MicroPython e tutti gli strumenti necessari installati per iniziare a costruire il tuo primo progetto MiPy-ESP

Passaggio 3: iniziare con MiPy-ESP

In questo passaggio lo farai

Scarica il framework MyPy-ESP

Download del framework MiPy-ESP Il progetto MiPy-ESP è disponibile su GitHub in questo repository di codice. Da GitHub puoi scaricare la struttura del file del repository o clonarla sul tuo computer tramite

git clone

Con il repository di codice installato sul tuo computer, ora hai tutti i moduli di codice necessari per creare un progetto ESP IoT pronto all'uso. Maggiori dettagli sulla casella degli strumenti nel passaggio successivo.

Passaggio 4: l'architettura del framework MiPy-ESP

In questo passaggio lo farai

scopri il flusso di lavoro del codice MiPy-ESP

Architettura del codice MiPy-ESP

Tutti i moduli del framework Python si trovano nella cartella /src del repository di codice MiPY-ESP. La cartella src/core contiene i moduli principali che vanno in ogni progetto. La cartella src/drivers ha una selezione di moduli per vari hardware da collegare al tuo chip. La cartella src/utilities contiene moduli di utilità facoltativi da includere nel progetto.

I file main.py e config.py si trovano nella cartella src/. Questi sono i file principali da modificare per costruire il tuo progetto:

config.py:

Questo file è il file di configurazione globale per il tuo progetto. Ha varie impostazioni, tutte con commenti descrittivi nel file.

main.py:

Questo è lo script principale per il ciclo di codice del microcontrollore. Contiene il codice specifico dell'applicazione nel framework. All'avvio del chip, main.py esegue e importa tutti i moduli dipendenti dal progetto con gli input forniti dal file config.py. Il diagramma di flusso sopra mostra il layout dello script main.py.

La figura sopra descrive il flusso di lavoro di main.py:

1. All'avvio, il codice tenta di connettere il chip alla rete Wi-Fi Le reti applicate in precedenza e le relative password (crittografate sul chip) vengono archiviate nella memoria flash. Gli SSID di rete e le relative password possono essere forniti nel file wifi.json nel formato {" SSID1":"Password", "SSID":"Password2"}. Le reti fornite in questo file vengono archiviate, le password vengono crittografate e il file viene eliminato all'avvio.
2. Se non vengono trovate reti già note, il codice imposta un server web access point (AP) Il server SSID e la password del chip AP server sono impostati nel file config.py. Accedendo all'SSID del chip, viene servita una pagina Web per l'accesso del chip al Wi-Fi all'indirizzo 192.168.4.1. Le reti rilevate vengono mostrate in un menu o l'SSID può essere inserito manualmente (reti nascoste) insieme alla password Wi-Fi. Dopo aver connesso con successo il chip al Wi-Fi, il server AP si spegne e il codice main.py procede con i passaggi successivi.

3. Nella sezione Configurazione di main.py,

   • sono definite funzioni per lavori e callback (ecc. callback MQTT) ed eventi regolari.
   • Sono impostati diversi lavori a tempo per le funzioni in esecuzione.
   • Viene stabilito il client broker MQTT

4. Il codice quindi entra nel ciclo principale del microcontrollore,

   • controllando continuamente le connessioni di rete e broker MQTT,
   • abbonamenti MQTT,
   • I/O hardware
   • e lavori programmati.
   • In caso di perdita della connessione alla rete o al broker MQTT, il codice tenta di ristabilirlo.

Passaggio 5: preparazione del codice del progetto

In questo passaggio lo farai

• conoscere la struttura dei file del repository MiPy-ESP
• prepara il codice del tuo progetto per il caricamento del chip

Struttura della cartella del repository La figura sopra descrive la struttura della cartella del repository ed elenca i moduli correnti del framework. Il tuo progetto è in fasi nella cartella src/. I moduli del framework MiPy-ESP core risiedono in src/core, i moduli di utilità opzionali in src/utilities e i moduli hardware in src/drivers.

La maggior parte delle librerie hardware MicroPython disponibili può andare nella cartella driver/senza alcuna modifica. Tutti i driver presenti sono testati con il framework MiPy-ESP. Per quanto riguarda i moduli nella cartella utilità/, ne verranno aggiunti altri man mano che prenderanno vita.

Staging del codice del progetto Il codice specifico del tuo progetto dovrebbe essere posizionato nella cartella src/. Ci sono già i file main.py e config.py che puoi modificare. Copia anche le utilità di progetto desiderate da src/utilities e src/drivers in src/.

Nel caso in cui desideri fornire reti Wi-Fi e password note al chip, aggiungi il file wifi.json a src/.

Compilazione e preparazione per il caricamentoUn Makefile fornito può essere applicato per preparare i file per il trasferimento al chip compilando i file.py in /src, compilando i moduli principali e trasferendo i file compilati in una nuova cartella denominata build/ con il comando

fare costruire

I file in build sono pronti per essere caricati nel filesystem del chip. Per impostazione predefinita, main.py e config.py non sono compilati in binario, al fine di accedervi facilmente per l'ispezione dei chip distribuiti. Il comando:

rendere pulito

Elimina la build/ cartella e il suo contenuto.

Passaggio 6: compilazione e caricamento del codice sul microcontrollore

In questa sezione potrai

• carica i file preparati in build/ dall'ultima sezione
• avviare e monitorare il codice in esecuzione

Caricare build/ file con Rshell

Carica tutti i file nella directory /build sul chip ESP usando Rshell. Con il microcontrollore connesso a USB, dalla cartella build/ avvia Rshell con il comando

rshell -p /dev/ttyUSB0

Quindi ispezionare i file del chip (se presenti) da

ls /pyboard

Tutti i file sul chip possono essere cancellati da

rm /pyboard/*.*

Copia tutti i file di progetto in build/ sul chip:

cp *.* /pyboard

Quindi avvia il terminale Python interattivo con il comando

sostituire

Ora puoi richiamare i comandi Python o importare moduli e monitorare l'output seriale del chip dal modulo logger MiPy-ESP.

Riavvia il chip premendo il pulsante di ripristino o dalla riga di comando con

importare principale

o

macchina di importazione

poi

macchina.reset()

A seconda delle impostazioni di registrazione/debug nel file di configurazione del progetto, il repl ora mostrerà i messaggi di debug dal chip ESP sulla connessione seriale.

Questo dovrebbe, si spera, iniziare.