ESP32Cam primi approcci

 Veramente orami e' qualche mese che ho ricevuto dalla Cina il mio primo ESP32Cam, un mostriciattolo che ha a bordo il ESP32 uno slot per MicroSD card, una telecamera ed una serie di pin a cui poter collegare il ....resto del mondo!

Ho gia' fatto un sacco di progettini con l'ESP32, tutti in C, utilizzando la IDE di Arduino e la modalita' "classica" di programmazione: upload via seriale del firmware compilato attraverso la Ide di Arduino .

Su questo sistema di operare, ci sono in rete migliaia di Tutorial anche blasonati, come per esempio quelli di Adafruit, mentre per quanto riguarda Python e MicroPython, ancora non si trova un granche'.

Considerato pero' che ho imparato a programmare con Python, vorrei imparare anche a sviluppare qualcosa di mio su ESP con questo linguaggio.

Quindi , vediamo un po' come fare per far diventare produttiva la giornata!

Intanto, primo consiglio, in rete si trovano diverse fonnti che vendono la scheda ESP32Cam, io consiglio quella completa  della sua basetta con presa USB e interfaccia seriale integrata, che e' molto comoda, viene riconosciuta subito dal sistema operativo, e ci evita di dover ricorre a fili volanti e interfacce seriali posticce, per poter lavorare. Costa pochissino (meno di 1 euro) e non ci sono motivi per non utilizzarla, almeno per la fase di prototipazione, quando fare l'upload del firmware e' una operazione frequente. Quando la parte di sviluppo sara' terminata, se volessimo utilizzare bene gli spazi, potremmo sempre sfilare la basetta seriale e, magari costruirne una apposita con i sensori di cui necessitiamo gia' previste e montati onboard.Quindi nel caso si volesse optare per la soluzione con scheda seriale esterna questi sono le connessioni da effettuare:

Il ponticello tra GPIO0 e GND e' indispensabile per "dire" al microcontrollore che siamo in flash mode e che stiamo per inviare il firmware.

Recuperare l'ultima versione del firmware dal sito 

Dal alto pc, se siamo su Linux, il comando per fare upload del sistema operativo MicroPython si deve utilizzare :

$ esptool.py –chip esp32 -p <nome_porta> write_flash -z 0x1000 <path_del_firmware>

Se siamo su windows ed abbiamo difficolta' ad installare il sistema di siluppo di Espressif (esptools), possiamo :

Scaricare il Flash Dowload Tools qui   ( questa e' l'ultima versione, prebdere ovviamente la versione piu' recente) basta scompattarlo in una cartella ed siamo  subito operativi.

Fare click sul file  flash_download_tool_3.8.5.exe e scegliere il tasto Developer Mode e nella successiva finestra il tasto relativo al modello di ESP che abbiamo a disposizione.

Si aprira' questa finestra:

All'interno della quale va soltanto caricato il path del firmware appena scaricato del MicroPython. Gli altgri parametri dovrebbero andare bene senza essere toccati.

 A questo punto fare ERASE per cancellare la memoria flash da alti eventuali upload.

Poi  START, per iniziare l'upload.

Se tutto e' andato bene. ci trovermo, al termine del processo, il nostro ESP32Cam che sara' pronto per essere programmato in Python. Bastera' quindi collegarlo con PuTTY (per esempio) sulla porta COM che windows gli avra' assegnato. nel mio caso la COM10.

Alla prima connessione il nostro ESP rispondera' con il prompt di Python e sara' gia' pienamente operativo.

Cosa fare adesso?

Adesso abbiamo il mostriciattolo che risponde ai comandi, ma ancora non e' collegato alla rete e non puo' essere collegato da remoto. Quindi la prima cosa da fare e' farlo collegare alla rete.

Ci viene in aiuto la documentazione ufficiale di MicroPython per ESP32

import network

wlan = network.WLAN(network.STA_IF) # create station interface
wlan.active(True)       # activate the interface
wlan.scan()             # scan for access points
wlan.isconnected()      # check if the station is connected to an AP
wlan.connect('essid', 'password') # connect to an AP
wlan.config('mac')      # get the interface's MAC address
wlan.ifconfig()         # get the interface's IP/netmask/gw/DNS addresses

ap = network.WLAN(network.AP_IF) # create access-point interface
ap.config(essid='ESP-AP') # set the ESSID of the access point
ap.config(max_clients=10) # set how many clients can connect to the network
ap.active(True)         # activate the interface

Fatta la connessione al router casalingo (modificare opportunamente essid e password nel codice sopra con quelli corretti per la connessione al proprio router)

Attiviamo il WEBREPL per poter effettuare la connessione da remoto ed utilizzare la funzionalita' di upload e download dei file dal sistema operativo del ESP32Cam ( si perche' il sistema che abbiamo caricato si comporta come un vero e proprio sistema operativo sul quale possiamo caricare, scrivere leggere e cancellare file.

PS Se utilizziamo Linux e' tutto piu' semplice, come sempre, esiste infatti una applicazione ampy che basta chiamare per fare direttamente l'upload da terminale cosi:

$ ampy -p dev/ttyUSB0 put boot.py

Ma stiamo utilizzando windows, mio malgrado, quindi , secondo me, la maniera piu' veloce per ottenere il buon funzionamento del ESP32Cam e' questo, cioe' passare da WEBREPL per fare l'upload dei file che ci interessa caricare sul sistema.

import webrepl_setup

Con questa riga, e poi seguendo le richieste del programma, si stabilisce una password e si abilita la partenza del WEBREPL ad ogni restart o reset del sistema.

Proviamo se tutto funziona a dovere:

Da un qualsiasi browser connettere: http://micropython.org/webrepl/#1p2.168.NUMERO_IP_ESP:8266/

Inserire naturalmente l' IP dell'ESP32Cam, ed utilizzare la porta 8266 come specificato. Dovrebbe rispondere il nuovo sistema con la richiesta diella password di accesso che abbiamo creato con la prima chiamata del WEBREPL. Dare la password corretta ed il sistema rispondera' con il prompt di MicroPython

Ok a questo punto che siamo connessi e abbiamo il WEBREPL attivato, non ci resta altro che rendere queste modifiche permanenti in maniera che ad ogni statup del sistema questo si connetta al router in automatico e renda disponibile l'interfaccia remota per poter essere contattato anche se non direttamente collegato al pc.

Dal WEBREPL scarichiamo il file boot.py e modifichiamo la parte relativa ala connessione, per renderla automatica cosi:

fare il get del file boot.py

modificarlo con :

<code>

# This file is executed on every boot (including wake-boot from deepsleep)

import esp

esp.osdebug(None)

import webrepl

webrepl.start()

def do_connect():

    import network

    wlan = network.WLAN(network.STA_IF)

    wlan.active(True)

    if not wlan.isconnected():

        print('connecting to network...')

        wlan.connect('essid', 'password')

        while not wlan.isconnected():

            pass

    print('network config:', wlan.ifconfig())

do_connect()

</code>

E fare l'upload del file appena modificato con l'apposita funzione disponibile sul browser

A questo punto siamo pronti. Basta resettare (anche togliendo l'alimentazione) il nostro ESP32Cam ed al riavvio, in automatico si collleghera' al router e sara' connettibile tramite interfaccia WEBREPL all'indirizzo : IP_del_ESP:8266 da un qualsiasi browser.

Buon divertimento 

TecnoGeppetto

 

DHT11 ESP8266 NEOPIXEL e Micropython

 Ho ripreso in mano il mio ESP8266 per approfondirne la conoscenza. Nell'ultimo post ho imparato a caricare il Micropython ed a collegare il mio ESP8266 da remoto con WebREPL.

In questo modo e' possibile caricare i file di programma nel file system del ESP8266, in modo da poterli poi far "girare" chiamandoli direttamente da termionale o madandoli in esecuzione direttamente al boot, utilizzando il file di sistema boot.py.

Infatti il MicroPython, gia' dalla sua istallazione prevede il file boot.py che in automatico la macchina chiama ad ogni reboot, quindi e' facile poter far partire tutti i programmi che vogliamo opportunamente impostando solamente  quest'ultimo file.

Avevo in un cassetto un ESP8266 superstite da alcuni altri passati esperimenti, al quale era gia' collegato e funzionante una barretta di 8 led Neopixel ed un sensore DHT11.

Niente di meglio per fare amicizia con il sistema Micropython.

Ho iniziato ad impostare la rete in modo fisso, in maniera che ad ogni reboot l'ESP si colleghi in automatico con il router di casa, semplicemente copiando le istruzioni necessarie nel file  boot.py (le stesse che abbiamo visto nel post di ieri).

Fatto questo e reso automatica la partenza del sistema WebREPL come visto ieri, impostando la password.

Ho iniziato a caricare tramite WebREPL il file di un semplice programma che legge la temperatura dal sensore e la stampa sulla consolle.

TEMP.PY :

#questo programma legge la temperatura e l'umidita' dal sensore DHT11 
#collegato al Pin 14 del ESP8266 (il pin contrassegnato con D5)

from machine import Pin
#from time import sleep
import dht 
#sensor = dht.DHT22(Pin(14))
sensor = dht.DHT11(Pin(14))

def get_temp():
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    return [temp,hum]


def leggi_temp():
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    print('Temperature: %3.1f C' %temp)
    print('Humidity: %3.1f %%' %hum)
    

Poi ho caricato un secondo file leds.py che gestira' i leds della barretta di Neopixel con a bordo il famoso led WS2812B.

LEDS.PY :

# questo programma scrive colori su neopixel ws2812B
# i neopixel sono collegati al Pin 5 che e' marcato D1 sulla scheda esp8266

import machine, neopixel
from time import sleep
import temp
n = 8 #numero dei pixel disponibili
p = 5 #pin sul quale sono collegati i led

np = neopixel.NeoPixel(machine.Pin(p), n)

def temp_leds():
    lista = temp.get_temp()
    if lista[0] <= 16:
        np[0] = (0,0,5)
        np[1] = (0,0,0)
        np[2] = (0,0,0)
        np[3] = (0,0,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 17:
        np[0] = (0,0,5)
        np[1] = (0,0,5)
        np[2] = (0,0,0)
        np[3] = (0,0,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 18:
        np[0] = (0,5,3)
        np[1] = (0,5,3)
        np[2] = (0,5,0)
        np[3] = (0,0,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 19:
        np[0] = (0,5,3)
        np[1] = (0,5,3)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 20:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 21:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (5,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 22:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (5,0,0)
        np[6] = (5,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 23:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (5,0,0)
        np[6] = (5,0,0)
        np[7] = (5,0,0)
        np.write()
    else:
        np[0] = (3,0,0)
        np[1] = (3,0,0)
        np[2] = (3,0,0)
        np[3] = (3,0,0)
        np[4] = (5,0,0)
        np[5] = (5,0,0)
        np[6] = (5,0,0)
        np[7] = (5,0,0)
        np.write()
def smooth_red():
    for led in range(8):
        for i in range(50):
            np[led] = (i, 0, 0)
            np.write()
            sleep(0.025)

def spengi_leds():
    for i in range(8):
        np[i] = (0, 0, 0)
    np.write()

def smooth_green():
    for led in range(8):
        for i in range(50):
            np[led] = (0, i, 0)
            np.write()
            sleep(0.025)

def smooth_blu():
    for led in range(8):
        for i in range(50):
            np[led] = (0, i, 0)
            np.write()
            sleep(0.025)
        

Inizialmente ho fatto amicizia con i colori (attenzione a non far partire alla massima intensita' tutti i led assieme che potrebbe essere dannoso per l'alimentazione del computer al quale e' collegato l'ESP, a causa del  troppo assorbimento - circa 60 mA per ogni led)

Infine li ho inseriti nel file di boot.py per far si che possano funzionare gia' dal reboot:

Il sistema cosi impostato, legge la temperatura una sola volta all'accensione, e in funzione del valore letto, accende i led di colore blu se la temperatura e' al di sotto dei 16 - 17 gradi
di colore verde per valori tra i 17 ed i 20 gradi e di rosso se la temperatura supera i 20 gradi.
I led si accendono in modo che la scala sia "parlante" in funzione dell'aumento della temperatura.
Cioe' < 16 gradi solo il primo led - poi via via fino a 24 gradi con tutti e 8 i led accesi.

E' ovvio che il tutto e' fatto per test e per fare conoscenza! Per fare un device intelligente, la temperatura va letta ad iintervalli costanti ed aggiornata la scla dei led in conseguenza. Ma non era questo lo scopo dei miei test di oggi (comunque bastano altre due righe di codice per farlo!)

BOOT.PY

# This file is executed on every boot (including wake-boot from deepsleep)
#import esp
#esp.osdebug(None)
import uos, machine
#uos.dupterm(None, 1) # disable REPL on UART(0)
import gc
import webrepl
import network
import temp
import leds
sta_if = network.WLAN(network.STA_IF)
sta_if.connect("XXXXXXXXXXXXXXXXXX","XXXXXXXXXXX") # Connect to an AP
print("LA mia connessione e' attiva e questo e' il mio indirizzo: ", sta_if.ifconfig())
webrepl.start()
gc.collect()
temp.leggi_temp()

leds.temp_leds()


Oggi sono arrivato fino qui!
A domani (forse ) per la prossima puntata.
TecnoGeppetto