EByte LoRa E32 & MicroPython: esplorazione della libreria MicroPython – 2

La libreria Ebyte LoRa E32 è uno strumento completo progettato per facilitare la comunicazione senza fili con i moduli LoRa. Sviluppato per programmatori ed appassionati di tecnologia, la libreria garantisce un’interfaccia fluida con i dispositivi LoRa E32 di Ebyte usando MicroPython, una implementazione snella ed efficiente del linguaggio di programmazione Python 3.

Qui la mia selezione di dispositivi AliExpress (433MHz 5Km) - AliExpress (433MHz 8Km) - AliExpress (433MHz 16Km) - AliExpress (868MHz 915MHz 5.5Km) - AliExpress (868MHz 915MHz 8Km)

Possono operare su una distanza da 3000m a 8000m e hanno molte funzionalità e parametri.

Quindi ho creato questa libreria per semplificarne l’uso.

Libreria

Per installare la libreria, puoi scaricarla da questo repository GitHub:

Oppure puoi installarla tramite Pypi con il comando:

pip install ebyte-lora-e32

Su Thonny IDE, puoi utilizzare Strumenti --> Gestione plugin... .

Schema dei Pin

Come puoi vedere, è possibile impostare varie modalità tramite i pin M0 e M1.

Per il prossimo test, utilizzeremo la modalità Normale.

Alcuni pin possono essere utilizzati staticamente, ma se li colleghi al microcontrollore e li configuri nella libreria, guadagnerai in prestazioni (AUX), e potrai controllare tutte le modalità tramite software, ma spiegheremo meglio dopo.

Schema completamente connesso

Come ho già detto, non è essenziale collegare tutti i pin all’uscita del microcontroller, puoi mettere i pin M0 e M1 su HIGH o LOW per ottenere la configurazione desiderata, e se non colleghi AUX, la libreria imposta un ritardo ragionevole per essere sicuri che l’operazione sia completata.

Pin AUX

Durante la trasmissione, i dati possono essere utilizzati per svegliare l’MCU esterno e ritornare HIGH al termine del trasferimento dati.

Quando riceve, AUX va su LOW e ritorna HIGH quando il buffer è vuoto.

Viene anche utilizzato per l’autoverifica al fine di ripristinare il funzionamento regolare (all’accensione e in modalità sleep/programma).

Cablaggio

esp32

uart2 = UART(2)
lora = LoRaE32('433T20D', uart2, aux_pin=15, m0_pin=21, m1_pin=19)

Raspberry Pi Pico

E qui c’è lo schema di collegamento, per questo test, è possibile rimuovere la connessione del pin AUX. È anche possibile vedere che utilizzo una porta Seriale diversa dalla predefinita perché si differenzia dall’ambiente Arduino.

Impostazione predefinita di MicroPython

Presta attenzione UART(1) utilizza pin diversi in MicroPython rispetto all’ambiente Arduino Serial1

# Crea un oggetto UART per comunicare con il modulo LoRa con Raspberry Pi Pico
uart2 = UART(1)
lora = LoRaE32('433T20D', uart2, aux_pin=2, m0_pin=10, m1_pin=11)

Serial predefinita Arduino

La Serial predefinita di Arduino è diversa da MicroPython, qui uno schema per utilizzare la stessa interfaccia.

Per lo standard di pinout Arduino, è necessario modificare la dichiarazione UART in modo che
uart2 = UART(1, rx=Pin(9), tx=Pin(8))

Costruttore

Ho realizzato un insieme di numerosi costruttori perché possiamo avere più opzioni e situazioni da gestire.

# Creare un oggetto UART per comunicare con il modulo LoRa con ESP32
# uart2 = UART(2)
# Creare un oggetto LoRaE32, passando l'oggetto UART e le configurazioni dei pin
# lora = LoRaE32('433T20D', uart2, aux_pin=15, m0_pin=21, m1_pin=19)

# Creare un oggetto UART per comunicare con il modulo LoRa con Raspberry Pi Pico
#uart2 = UART(1)
# Utilizzare i pin Serial1 dell'ambiente Arduino su Raspberry Pi Pico
uart2 = UART(1, rx=Pin(9), tx=Pin(8))

lora = LoRaE32('433T20D', uart2, aux_pin=2, m0_pin=10, m1_pin=11)

Il segmento di codice fornito dimostra come impostare una connessione UART (Universal Asynchronous Receiver/Transmitter) con un modulo LoRa, specificamente un dispositivo Ebyte LoRa E32, utilizzando i microcontrollori ESP32 o Raspberry Pi Pico. L’UART è un dispositivo hardware o un protocollo che aiuta nella comunicazione seriale tra due dispositivi.

Inizialmente, il codice imposta l’interfaccia UART, che viene utilizzata per la comunicazione seriale tra il microcontroller (sia ESP32 che Raspberry Pi Pico) e il modulo LoRa.

Nel caso di ESP32, l’oggetto UART verrebbe inizializzato come uart2 = UART(2). Questa riga è commentata nel codice fornito perché l’impostazione è dimostrata per Raspberry Pi Pico.

Per il Raspberry Pi Pico, vengono presentate due alternative. La prima è una semplice inizializzazione: uart2 = UART(1). La seconda specifica i pin particolari per RX (ricezione dati) e TX (trasmissione dati): uart2 = UART(1, rx=Pin(9), tx=Pin(8)). Questa riga imposta il canale UART su 1 e specifica che il Pin 9 è per la ricezione dati (rx) e il Pin 8 è per la trasmissione dati (tx).

Il passaggio successivo è creare un’istanza della classe LoRaE32. Il costruttore LoRaE32() viene utilizzato per inizializzare l’oggetto denominato lora. Accetta quattro parametri:

1. Il nome del modello del modulo Ebyte LoRa E32, in questo caso ‘433T20D’.
2. L’oggetto UART (uart2), che consente la comunicazione seriale con il modulo LoRa.
3. Il numero del pin AUX, che viene utilizzato per funzioni ausiliarie come indicare lo stato operativo del modulo o per l’handshaking. Qui, è impostato su 2 per Raspberry Pi Pico.
4. I numeri dei pin M0 e M1, che vengono utilizzati per passare il modulo tra diverse modalità operative. In questo caso, sono impostati su 10 e 11, rispettivamente, per Raspberry Pi Pico.

Inizializzando l’oggetto lora con questi parametri, il microcontroller è pronto per interagire con il modulo LoRa, e si può iniziare a configurare e utilizzare il modulo per la comunicazione wireless.

Ricordati di decommentare o modificare il codice in base al microcontroller che stai utilizzando, sia che si tratti di ESP32 o di Raspberry Pi Pico.

begin()

Il comando begin viene utilizzato per avviare la Serial e impostare i pin in modalità di input e output.

code = lora.begin()
print(ResponseStatusCode.get_description(code))

Le righe di codice fornite vengono utilizzate per avviare il modulo LoRa e stampare una descrizione del codice di stato di risposta ottenuto durante il processo di inizializzazione.

1. code = lora.begin(): Questa riga di codice chiama la funzione begin() sull’oggetto lora, che era stato precedentemente istanziato come un’istanza della classe LoRaE32. La funzione begin() è tipicamente utilizzata per inizializzare il modulo LoRa e prepararlo per la comunicazione. Questa funzione potrebbe includere passaggi come impostare il modulo LoRa nella modalità corretta, controllare che stia rispondendo correttamente, o persino eseguire alcune configurazioni iniziali. La funzione restituisce un codice di stato che indica se il processo di inizializzazione è stato eseguito con successo o se si sono verificati degli errori.
2. print(ResponseStatusCode.get_description(code)): Questa riga viene utilizzata per stampare una descrizione leggibile del codice di stato di risposta che è stato restituito dalla funzione begin(). La funzione get_description() è un metodo della classe ResponseStatusCode, che è progettata per mappare i valori dei codici di stato alle loro descrizioni corrispondenti. Passando il code restituito da begin() a get_description(), è possibile ottenere una descrizione testuale del risultato dell’inizializzazione, che può essere molto utile per il debugging. Ad esempio, se l’inizializzazione è stata eseguita con successo, potresti ottenere una descrizione come “Successo”, mentre se si è verificato un errore, potresti ottenere un messaggio che indica il tipo di errore.

Metodo di configurazione e informazione

Ci sono molti metodi per gestire la configurazione e ottenere informazioni sul dispositivo.

getConfiguration

Nel contesto di un modulo LoRa E32, mantenere una chiara consapevolezza della sua configurazione corrente può essere cruciale per gestire efficacemente le sue operazioni. A tal proposito, la capacità di recuperare e comprendere la configurazione del modulo è fondamentale. Il codice Python fornito sopra dimostra un metodo semplice per realizzare questo compito utilizzando le librerie lora_e32 e lora_e32_operation_constant.

from lora_e32 import LoRaE32, print_configuration, Configuration
from lora_e32_operation_constant import ResponseStatusCode

code, configuration = lora.get_configuration()

print(ResponseStatusCode.get_description(code))
print_configuration(configuration)

La classe LoRaE32, che è centrale per interagire con il modulo LoRa, e la funzione print_configuration, che traduce i dati di configurazione in un formato leggibile dall’uomo. Importa anche la classe Configuration che rappresenta la configurazione del modulo e la classe ResponseStatusCode per interpretare la risposta della funzione get_configuration().

----------------------------------------
HEAD : 0b11000000 192

AddH : 0
AddL : 2
Chan : 23  ->  433

SpeedParityBit    : 0b0  ->  8N1 (Default)
SpeedUARTDatte : 0b11  ->  9600bps (default)
SpeedAirDataRate  : 0b10  ->  2.4kbps (default)
OptionTrans       : 0b1  ->  Fixed transmission (first three bytes can be used a
s high/low address and channel)
OptionPullup      : 0b1  ->  TXD, RXD, AUX are push-pulls/pull-ups (default)    
OptionWakeup      : 0b0  ->  250ms (default)
OptionFEC         : 0b1  ->  Turn on Forward Error Correction Switch (Default)
OptionPower       : 0b0  ->  20dBm (Default)
----------------------------------------

La parte finale del codice stampa la configurazione utilizzando la funzione print_configuration(). Questa funzione fornisce una panoramica strutturata delle impostazioni attuali del modulo LoRa, offrendo un’istantanea dei suoi parametri operativi. Questi parametri includono vari dettagli, come l’intestazione del messaggio di configurazione, l’indirizzo del dispositivo, il canale operativo, le impostazioni di velocità e le impostazioni di trasmissione, inclusi la modalità, la modalità I/O, il tempo di risveglio wireless, la correzione degli errori e la potenza di trasmissione. Comprendere questi parametri è fondamentale per diagnosticare problemi operativi, ottimizzare le prestazioni e garantire una trasmissione dati di successo sulla rete LoRa.

setConfiguration

Configurare il modulo LoRa E32 per soddisfare specifiche esigenze operative è un aspetto essenziale per utilizzarlo efficacemente. Questo codice Python illustra come definire e impostare la configurazione di un modulo LoRa, offrendo una chiara dimostrazione della flessibilità e del controllo forniti dalla libreria lora_e32.

configuration_to_set = Configuration('433T20D')
configuration_to_set.ADDL = 0x02
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION

code, confSetted = lora.set_configuration(configuration_to_set)

Il processo inizia con la creazione di un oggetto Configuration. Questo oggetto rappresenta l’intera configurazione del modulo LoRa. L’utente imposta i parametri della configurazione in base alle proprie esigenze specifiche. In questo esempio, la configurazione è adattata al modello ‘433T20D’ del modulo LoRa, e la parte inferiore dell’indirizzo (ADDL) è impostata su 0x02. Anche la modalità di trasmissione fissa viene impostata utilizzando una costante della classe FixedTransmission.

Una volta che l’oggetto di configurazione è stato definito in modo adeguato, viene passato alla funzione set_configuration() dell’oggetto LoRaE32. Questa funzione carica la configurazione definita sul modulo LoRa, modificando efficacemente il suo funzionamento in base alle nuove impostazioni.

class Configuration:
class Speed:
    def __init__(self, model):
        self.model = model

        self.airDataRate = AirDataRate.AIR_DATA_RATE_010_24
        self.uartBaudRate = UARTBaudRate.BPS_9600
        self.uartParity = UARTParity.MODE_00_8N1


class Option:
    def __init__(self, model):
        self.model = model

        self.transmissionPower = TransmissionPower(self.model).get_transmission_power().get_default_value()
        self.fec = ForwardErrorCorrectionSwitch.FEC_1_ON
        self.wirelessWakeupTime = WirelessWakeUpTime.WAKE_UP_250
        self.ioDriveMode = IODriveMode.PUSH_PULLS_PULL_UPS
        self.fixedTransmission = FixedTransmission.TRANSPARENT_TRANSMISSION


class Configuration:
    def __init__(self, model):
        self.HEAD = 0
        self.ADDH = 0
        self.ADDL = 0
        self.SPED = Speed(model)
        self.CHAN = 23
        self.OPTION = Option(model)

Il codice offre anche uno scorcio della struttura della classe Configuration, mostrando le sue classi annidate Speed e Option. Queste classi incapsulano diversi aspetti della configurazione del modulo LoRa, come la velocità di trasmissione dei dati e varie opzioni operative. È importante notare che le classi contengono una moltitudine di parametri, ognuno con costanti predefinite per una configurazione più facile e affidabile. Questi parametri includono il tasso di dati aerei, la velocità di baud UART, la parità UART, la potenza di trasmissione, l’interruttore di correzione degli errori in avanti, il tempo di risveglio wireless, la modalità di guida I/O e la trasmissione fissa.

La struttura annidata della classe Configuration e l’uso di costanti predefinite sottolineano l’approccio organizzato e intuitivo della libreria lora_e32 nella gestione della configurazione del modulo LoRa. Questo design modulare permette agli sviluppatori di adattare il funzionamento del modulo LoRa alle loro esigenze specifiche, consentendo un utilizzo più efficiente ed efficace della tecnologia.

Opzione di configurazione di base

Dettaglio SPED

Bit di parità UART: La modalità UART può essere diversa tra le parti di comunicazione

Velocità di trasmissione UART: la velocità di trasmissione UART può essere diversa tra le parti comunicanti. La velocità di trasmissione UART non ha nulla a che fare con i parametri di trasmissione wireless e non influenzerà le funzionalità di trasmissione/ricezione wireless.

Velocità dei dati in aria: più bassa è la velocità dei dati in aria, maggiore è la distanza di trasmissione, migliore è la performance anti-interferenza, e più lungo è il tempo di trasmissione; la velocità dei dati in aria deve essere costante per entrambe le parti della comunicazione.

OPTION detail

Modalità di trasmissione: I primi tre byte di ogni frame di dati dell’utente possono essere utilizzati come indirizzo alto/basso e canale in modalità di trasmissione fissa. Il modulo cambia il suo indirizzo e canale quando viene trasmesso. E tornerà alle impostazioni originali dopo aver completato il processo.

Modalità di guida IO: questo bit viene utilizzato per la resistenza di pull-up interna del modulo. Aumenta anche l’adattabilità del livello in caso di un drain aperto. Ma in alcuni casi, potrebbe essere necessaria una resistenza di pull-up esterna.

Tempo di risveglio wireless: il modulo di trasmissione & ricezione lavora in modalità 0, il cui tempo di ritardo è invalido & può essere un valore arbitrario; il trasmettitore che lavora in modalità uno può inviare continuamente il codice preambolo del tempo corrispondente quando il ricevitore opera in modalità 2, il tempo indica l’intervallo di monitoraggio (risveglio wireless). Solo i dati dal trasmettitore che lavora in modalità uno possono
essere ricevuti.

FEC: dopo aver disattivato FEC, la velocità effettiva di trasmissione dei dati aumenta mentre la capacità di anti-interferenza diminuisce. Inoltre, la distanza di trasmissione è relativamente breve, e entrambe le parti della comunicazione devono essere sulla stessa pagina riguardo l’attivazione o la disattivazione di FEC.

Potenza di trasmissione

Esistono differenze tra i dispositivi in base alla potenza, ad esempio i moduli da 20dBm hanno:

I moduli da 27dBm hanno:

E i moduli da 30dBm:

Inoltre, le frequenze cambiano a seconda della versione del modello.

Invio ricezione messaggio

Innanzitutto, dobbiamo introdurre un metodo semplice ma utile per verificare se qualcosa è nel buffer di ricezione.

if lora.available() > 0:

È semplice restituire quanti byte hai nel flusso corrente.

Modalità di trasmissione normale

La modalità di trasmissione normale/trasparente invia messaggi a tutti i dispositivi con lo stesso indirizzo e canale.

Il primo metodo è sendMessage ed è usato per inviare una stringa a un dispositivo in Modalità normale.

message = 'Ciao, mondo!'
code = lora.send_transparent_message(message)
print("Invio messaggio: {}", ResponseStatusCode.get_description(code))

L’altro dispositivo semplicemente esegue il loop.

while True:
    if lora.available() > 0:
        code, value = lora.receive_message()
        print(ResponseStatusCode.get_description(code))

        print(value)
        utime.sleep_ms(2000)

Presta attenzione se ricevi più messaggi nel buffer, e non vuoi leggerli tutti in una volta, devi utilizzare un parametro delimiter

Usa dizionario

C’è un metodo alternativo che permette di inviare un dizionario.

lora.send_transparent_dict({'pippo': 'fisso', 'pippo2': 'fisso2'})

E il rispettivo metodo del ricevitore.

        code, value = lora.receive_dict()

Modalità fissa invece della modalità normale

In un certo modo, ho creato un insieme di metodi da utilizzare con la trasmissione fissa

Trasmissione fissa

Devi solo cambiare il metodo di invio perché il dispositivo di destinazione non riceve il preambolo con indirizzo e canale quando si imposta la modalità fissa.

La trasmissione fissa ha più scenari

Se invii a un dispositivo specifico (secondo scenario di trasmissione fissa), devi aggiungere ADDL, ADDH e CHAN per identificarlo direttamente.

code = lora.send_fixed_message(0, 0x01, 23, message)

Se desideri inviare un messaggio a tutti i dispositivi in un canale specifico, puoi utilizzare questo metodo.

code = lora.send_broadcast_message(23, message)

Se desideri ricevere tutti i messaggi di trasmissione nella rete, devi impostare il tuo ADDH e ADDL con BROADCAST_ADDRESS.

# Imposta la configurazione ai valori predefiniti e stampa la configurazione aggiornata nella console
# Non necessario se già configurato
configuration_to_set = Configuration('433T20D')
# Con BROADCAST_ADDRESS riceviamo tutti i messaggi
configuration_to_set.ADDL = BROADCAST_ADDRESS
configuration_to_set.ADDH = BROADCAST_ADDRESS
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
code, confSetted = lora.set_configuration(configuration_to_set)
print("Imposta configurazione: {}", ResponseStatusCode.get_description(code))

Grazie