Visualizzazione post con etichetta python. Mostra tutti i post
Visualizzazione post con etichetta python. Mostra tutti i post

venerdì 22 gennaio 2021

ESP32Cam gestione dei Led della scheda

 Continua la serie di articoli sulla scheda ESP32Cam che inquesto periodo e' sotto i miei riflettori; Con questo articolo parliamo della attivazione e della gestione del LED principale e del Led di servizio. Infatti la scheda ha un bel Led 5050 sulla parte frontale, molto luminoso, che risponde al GPIO 4 ed un Led Rosso sulla scheda interna, vicino al modulo ESP vero e proprio, che viene utilizzato anche dal sistema per messaggi di stato.

Il MicroPython ci consente di gestire piuttosto facilmente questi due led semplicemente alzando o abbassando il livello dei Pin relativi. Bisogna comunque fare attenzione al fatto che il GPIO 4 al quale e' collegato il Led principale Bianco, e' anche utilizzato per la gestione della scheda MicroSD, infatti sul GPIO 4 e' collegata anche il segnale DATA1 della comunicazione tra il microcontrollore e la MicroSD, quindi non e' possibile utilizzare le due periferiche contemporaneamente.


Per il LED Bianco

from machine import Pin
import time

LEDb = Pin(4, Pin.OUT) 
while True:
    LEDb.value(1)
    time.sleep_ms(500)
    LEDb.value(0)
    time.sleep_ms(500)


Per il LED Rosso

#gestione del LED di servizio Rosso della scheda sul GPIO33
LEDr = Pin(33, Pin.OUT) 
while True:
    LEDr.value(1)
    time.sleep_ms(500)
    LEDr.value(0)
    time.sleep_ms(500)

Nota che il LED Rosso funziona alla rovescia rispetto all'altro quindi si accendera' con il Pin 33 basso, mentre si spengera' con il Pin 33 tenuto alto.


Buoni esperimenti

TecnoGeppetto



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



 





mercoledì 13 gennaio 2021

Collegare un Encoder rotativo con switch a Raspberry Pi

 Alla ricerca di una soluzione valida per la costruzione della Radio Web, ma soprattutto per sperimentare nel senso piu' ampio del termine, mi sono imbattuto su questa libreria che gestisce tutte le fuinzionalita' del' encoder compreso lo switch a pulsante. Fa al caso mio!


L'Encoder consente di associare alla rotazione del suo asse a funzioni gestite da un programma, la funzione piu' comune e' quella di alzare o abbassare il volume, ma puo' essere anche utilizzato per spostarsi in un menu', per guidare un robot, per gestire lo spostamento della frequenza di un VFO di una radio, ecc..

La libreria che ho trovato consente di fare tutte queste cose con estrema facilita'.

La prima cosa che ho fatto e' cablare il mio Encoder con la Raspberry deputata al sacrificio di queste ultime prove.


Ho collegato  il segnale di CLOCK al PIN 18,il DATA al PIN 17 ed infine il PIN SWITCH al PIN 27, ma la disposizione dei PIN e' completamente arbitraria.

Le resistenze di pull-up che si vedono indicate nello schema qui accanto (se avete un encoder di questo tipo, sono gia' inserite nel circuito) invece non lo ho collegate, ma ho utilizzato la funzione di pull-up interna sui PIN della mia Raspberry Pi, per rendere ancora piu' semplice il circuito.



Nella foto qui accanto ho segnato i PIN che ho utilizzato nel mio circuito ed il positivo a 3,3 volts, non ho segnato il GND che e' presente in abbondanza sui PIN di Raspberry Pi.
A questo punto installiamo la libreria come indicato sulla documentazione:

Installation

  • Install the pigpio library (check pigpio documentation for alternative installation method)
  • sudo apt-get update
  • sudo apt-get install pigpio python-pigpio python3-pigpio
  • Install the pigpio_encoder library
  • pip install pigpio_encoder (consider add --user option)
  • start pigpio daemon
  • sudo pigpiod

Con l'uso della libreria bastano solo poche righe di codice per ottenere un programma funzionante che rileva attraverso gli interrupt di sistem, il movimento dell'asse dell'Encoder o la pressione dello stesso che attivera' lo switch. Viene anche tenuto conte del tempo di pressione del tasto per consentire di associare due funzioni differenti alla pressione dell'asse dell'Encoder, come vedremo con le funzioni: sw_short() e sw_long()

Questo un semplice programma di test che se fatto girare consente di assicurarsi che tutto sia montato correttamente.

from pigpio_encoder import pigpio_encoder

def rotary_callback(counter):
    print("Counter value: ", counter)

def sw_short():
    print("Switch short press")

def sw_long():
    print("Switch long press")

my_rotary = pigpio_encoder.Rotary(clk=18, dt=17, sw=27)
my_rotary.setup_rotary(min=10, max=300, scale=5, debounce=200, rotary_callback=rotary_callback)
my_rotary.setup_switch(debounce=200, long_press=True, sw_short_callback=sw_short, sw_long_callback=sw_long)

my_rotary.watch()

Qui a fianco il montaggio su una basetta di legno

Buon divertimento

TecnoGeppetto


domenica 10 gennaio 2021

Ambiente virtuale in Python

 Creare un ambiente virtuale e' molto utile per evitare di continuare ad installare librerie direttamente nel sistema principale. infatti quando facciamo i nostri test e prove varie, abbiamo spesso bisogno di caricare nuove librerie e driver per tentare di far funzionare quelle che sono le nostre idee di progetto. Continuando a caricare tutto nel sistema princpale e' possibile che alcune delle librerie caricate possano andare in conflitto con altre, gia' presenti nel sistema. 


Per evitare tutto cio' allora, si puo' utilizzare  questa funzione interna di Python che consente di costruire un ambiente virtuale all'interno del quale poi potremo caricare qualsiasi libreria senza con questo fare delle modifiche permanenti al sistema. Cioe' tutto quello che caricheremo nel sistema virtuale, rimarra' valido li dentro, ma non avra' nessun effetto sul sitema principale.

Come si fa' ? 


$ python -m virtualenv .venv

$ source .venv/bin/activate

Fatto!

con activate lo attiviamo e siamo gia' pronti per poter caricare qualsiasi cosa vogliamo senza fare piu' nessun danno nel sistema principale.


sabato 2 gennaio 2021

utilizzare Github per sviluppare codice

 Durante l'ultimo mese, ho imparato ad utilizzare Git  per il versionamento del codice (almeno per le operazioni principali), la conseguenza naturale, poi, e' quella di usare Github per appoggiare il siftware dei vari progetti in sviluppo ed avere cosi' la possibilita' di averlo disponibile da qualsiasi computer in qualsiasi momento, con tutte le peculiarita' del verisonamento.

Riepilogo  qui sotto le principali operazioni da effettuare per tenere aggiornato il proprio account ed le relative verisoni del codice prodotto.

Prima cosa ovviamente e' essere a disposizione di un account su Github, poi avere installato  Git sul proprio pc. Io mi trovo bene ad utilizzare Linux per lo sviluppo, dove  l'installazione e' immediata con:

$ sudo apt-get update

$ apt-get install git

La prima operazione da fare in Git, dentro la cartella contenente il progetto, e' dire a Git che quella e' una cartella da considerare, con il comando :

$ git init

Questo crea una caretlla nascosta .git  che il sistema utilizzara' per tutte le operazioni necessarie.

Per maggiore praticita', nel caso che si voglia pubblicare su Github il nostro codice, e' preferibile creare il progetto vuoto direttamente su Github, scaricarlo in locale e popolare in un secondo momento la cartella del progetto, per poi fare l' upload sul sito. Vediamo come.

Su Github creo un nuovo Repository:


Scelgo il nome del progetto:


ed aggiungo i file necessari per il versionamento. Il README e' il file che descrive in modo testuale il progetto, una sorta di home page del progetto stesso. .gitignore servira' poi per evitare di caricare degli eventuali file non necessari nel repository (spesso utilizzato per evitare di caricare i file di configurazione che possono contenere  Token o Password personali). Per quanto riguarda license, non e' indispensabile, anche perche' stiamo "giocando" ed i file non sono certo importanti, comunque aggiungerne una  non fa male e costa pochissimo!. smile!



Aggiunto il nome del file e salvato il nuovo repository, possiamo passare lato pc, per completare il processo:
Entriamo nella cartella dei progetti,
con il comando $ git clone https://INDIRIZZO_DEL_REPOSITORY.GIT
Il corretto indirizzo del nuovo repository appena costruito sara reperibile qui:



Con il tasto evidenziato nella immagine qui sopra sara' semplice copiare il link direttamente in memoria facendo semplicemente un click.

Questo comando crea una cartella con il nome del progetto e scarica tutti i file del progetto appena creati su Github, direttamente nella nuova cartella creata sul pc.
 Ci troveremo quindi la cartella .../progetti/NOME_DEL_NUOVO_PROGETTO

A questo punto se abbiamo gia' del materiale bastera' copiarlo in questa cartella, oppure creare nella catella almeno un nuovo file nel linguaggio desiderato.
Per esempio test.py con il comando 


Scrivere il codice necessario, salvare.
Per aggiungere il nuovo file al repository c'e' bisogno ancora di alcuni passaggi:


git status rende la situazione del git, evidenziando appunto il nuovo file aggiunto alla coda. 
Nel caso voglio aggiungere un file che in precendeza avevo ignorato (cioe' aggiunto nel file .gitignore per non tenerne traccia in git) dovr' utilizzare la forma:
$ git add -f file_in_precedenza_ignorato
A questo punto deve essere fatto il commit che serve per rendere ufficiali e registrate le modifiche effettuate.

con il comando :

$ git commit -m "testo descrittivo della modifica appena effettuata"

Che rende, come vedete in figura, la lista dei file aggiunti al commit

Per pubblicare sul nostro repository su Github a questo punto basta fare :


Con $ git push tutte le variazioni effettuate nel commit vengono rese disponibili su Github, quindi tutti i file si troveranno anche sul repository del progetto


Buon divertimento 

TecnoGeppetto


giovedì 31 dicembre 2020

MQTT publisher sistema di test del protocollo MQTT

 Chi non volesse costruire il device come trattato negli articoli precedenti, ma avesse comunque necessita' di veder funzionare il sistema basato sui pacchetti di messaggi MQTT, puo' sempre far girare un software sul pc che simula il device stesso e che fornisce messaggi sul broket MQTT necessari.

Per questi test ho scelto il broker messo a disposizione dal progetto Eclipse che potete trovare qui 

Per far questo, sempre attraverso il progetto Eclipse ho trovato un codice che con poche righe consente di inviare messaggi ad un qualsiasi broker MQTT ad intervalli regolari

Utilizzando sempre il sitema Linux su WSL in Windows, nella mia shell, sempre nella cartella mqtt_client, ho creato un nuovo file chiamato publisher.py che crea una connessione con il broker MQTT, ed invia una serie di messaggi sul topic scelto ( nel mio caso TecnoGeppetto/topic

publisher.py

import paho.mqtt.client as mqtt
import time

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    
client = mqtt.Client()
client.on_connect = on_connect
client.connect("broker.emqx.io", 1883, 60)

# send a message to the TecnoGeppetto/topic every 10 second, 50 times in a row
for i in range(50):
    # the four parameters are topic, sending content, QoS and whether retaining the message respectively
    client.publish('TecnoGeppetto/topic', payload=i, qos=0, retain=False)
    print(f"send {i} to TecnoGeppetto/topic")
    time.sleep(1)

client.loop_forever()

Quindi, su un sistema sul quale gira python 3 e sul quale e' installata la libreria paho.mqtt.client bastera' chiamare python3 publisher.py per ottenere una serie di 50 messaggi ogni 10 secondi pubblicati sul broker pubblico scelto sul topic preferito (nel caso del codice in oggetto, sul topic  TecnoGeppetto/topic

Naturalmente i messaggi potranno essere ricevuto su un'altra shell sulla quale gira il software subcriber, descritto nel post precedente.


Buon divertimento 

TecnoGeppetto




Client MQTT subscriber e publisher per linux - Raspberry Pi

 A seguire gli esperimenti di questi giorni, oggi mi sono dedicato alla configurazione su linux di un sistema per leggere i messaggi inviati dal sensore. Ho cercato un client MQTT che potesse essere utilizzato da linea di comando ed ho trovato e configurato questo che adesso decrivero'.


Ho trovato il progetto Eclipse che fa al caso mio, hanno sviluppato una libreria disponibile su github per la gestione delle comunicazioni con un broker MQTT che si chiama paho che risolve la maggior parte dei problemi e consente con 4 righe di codice  di ottenere cio' di cui ho bisogno.

I passi necessari per far funzionare tutto sono questi:

su linux ( io per praticita' utilizzo una shell linux in WSL su windows, perche' in questo periodo sto usando un pc con windows) creo la mia direttory di progetto che ho chiamato mqtt_client 


quindi entro nella cartella appena creata con 


quindi creo il file che conterra' il codice del programma MQTT client subscriber


edito il contenuto del file con i dati del mio broker MQTT pubblico  scelto.

file  subscribe.py:

# subscribe.py
import paho.mqtt.client as mqtt

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    # subscribe, which need to put into on_connect
    # if reconnect after losing the connection with the broker, it will continue to subscribe to the raspberry/topic topic
    client.subscribe("TecnoGeppetto/topic")

# the callback function, it will be triggered when receiving messages
def on_message(client, userdata, msg):
    print(f"{msg.topic} {msg.payload}")
    
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

# set the will message, when the system is powered off, or the network is interrupted abnormally, it will send the will message to other clients
client.will_set('TecnoGeppetto/status', b'{"status": "Off"}')

# create connection, the three parameters are broker address, broker port number, and keep-alive time respectively
client.connect("broker.emqx.io", 1883, 60)

# set the network loop blocking, it will not actively end the program before calling disconnect() or the program crash
client.loop_forever()

Naturalmente per far funzionare tutto sulla distribuzione linux che ho scelto e' presente python 3.xx, se non lo fosse e' necessario installarlo  assieme a pip3 che servira' per installare la libreria di cui si fa       l' import nel codice.

sudo apt install python3

poi

pip3 install paho-mqtt

A questo punto per far girare il client in ricezione sui topic scelti nel codice ( nel caso qui pubblicato TecnoGeppetto/topic  , basta chiamare 



Nel caso di problemi di connesisone il sistema rende un codice di errore, questa di seguito e' la legenda dei possibili codici

0: connection succeeded
1: connection failed - incorrect protocol version
2: connection failed - invalid client identifier
3: connection failed - the broker is not available
4: connection failed - wrong username or password
5: connection failed - unauthorized
6-255: undefined
If it is other issues, you can check the network situation, or check whether `paho-mqtt` has been installed.


Naturalmente il topic da scegliere deve essere lo stesso sul quale trasmette il sensore, in modo da poter regolarmente ricevere il messaggio trasmesso ogni volta dal sensore.


Buon divertimento 

TecnoGeppetto




domenica 27 dicembre 2020

Programmare Esp32Cam con Python anche da remoto

La parte discorsiva la faro' in un secondo momento. 

Collegare Esp32Cam completo di modulo seriale alla USB del pc tramite cavo USB-C tenendo premuto il tasto IO0, che deve essere premuto per mettere il microcontrollore in flash mode. far partire il tools predisposto da Espressif.


Controllare tra i dispositivi di Windows che nome e' stato asseganto alla seriale, nel mio caso COM7 

Ho cancellato completamente la Flash con l'apposito tasto rifatto il boot  del device scollegandolo e ricollegandolo tenendo premuto il tasto IO0 . 
A questo punto fatto il download del firmware col tasto START.

 Se tutto e' andato a buon fine adesso ci ritroviamo con un device esp32 che risponde , se interrogato via seriale, con il prompt di python. 

Quindi collegare il device alla seriale, chiamarlo con un programma che legge i dati da seriale, per esempio putty su windows o minicom su debian, con la velocita' settata a 115200b e rispondera' il classico >>> di python.

Per poter lavorare sul nostro ESP32 senza connetterlo al pc tramite cavo vanno fatti due passi importanti: 

Collegare il device ad una rete (la stessa dove si trovera' anche il tuo pc) Abilitare la funzione WebREPL del micropython che consente di "parlare" con il prompt tramite una connessione wifi. 

Qui tutte le piu' importanti comandi per lavorare con l'interfaccia wifi :

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

Qui invece come attivare il WebREPL:
  import webrepl_setup
import webrepl
webrepl.start()

# or, start with a specific password
webrepl.start(password='mypass')



Attivato WebREPL andra' impostata la password che l'utente dovra' digitare all'accesso da remoto, per poter programmare il device.
Buon divertimento
TecnoGeppetto