EByte LoRa E32 & MicroPython: uno sguardo dettagliato alla configurazione – 3

Nel mondo dell’Internet of Things (IoT) e della comunicazione wireless, le tecnologie di trasmissione a lungo raggio e a basso consumo energetico sono fondamentali per collegare dispositivi su distanze significative. La tecnologia LoRa (Long Range) è una di queste innovazioni, e i moduli della serie LoRa E32 di Ebyte sono rinomati per la loro facilità d’uso e versatilità in varie applicazioni. Questo articolo intitolato “Ebyte LoRa E32 & MicroPython: Configurazione” approfondisce gli aspetti pratici dell’interfacciamento e della configurazione dei moduli Ebyte LoRa E32 utilizzando MicroPython, una variante di Python snella ed efficiente per microcontrollori.

Iniziamo esplorando le basi della tecnologia LoRa e le specifiche del modulo E32. Successivamente, ci addentriamo nel nucleo dell’articolo – allestire l’ambiente, stabilire una connessione e guidarvi attraverso il processo di configurazione del modulo Ebyte LoRa E32 utilizzando MicroPython. Vi accompagneremo in ogni passaggio, dall’installazione e inizializzazione alle impostazioni dettagliate di configurazione, assicurando che possiate massimizzare le capacità del vostro modulo LoRa E32. Che siate hobbisti, sviluppatori professionisti o semplicemente curiosi della comunicazione wireless, questa guida completa vi doterà delle conoscenze per sfruttare il potere della tecnologia LoRa nei vostri progetti.

I miei dispositivi LoRa AliExpress (433MHz 5Km) - AliExpress (433MHz 8Km) - AliExpress (433MHz 16Km) - AliExpress (868MHz 915MHz 5.5Km) - AliExpress (868MHz 915MHz 8Km)

Come ho già specificato, ho creato una libreria dedicata per questo dispositivo perché la configurazione e la modalità di trasmissione non sono così semplici da gestire.

Libreria

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

Oppure potete installarla tramite Pypi con il comando:

pip install ebyte-lora-e32

Su Thonny IDE, potete usare Strumenti --> Gestisci plug-in... .

Pinout

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

Per il prossimo semplice test, useremo la modalità Normale.

Alcuni pin possono essere utilizzati staticamente, ma se li connettete al microcontrollore e li configurate nella libreria, guadagnate in prestazioni e potete controllare tutte le modalità tramite software, ma lo spiegheremo meglio in seguito.

Schemi di connessione per la programmazione

Per l’uso di base, abbiamo usato questa configurazione. Tuttavia, in questa configurazione si lavora solo in “Modalità Normale” e gestiremo solo il pin dinamico necessario (RX, TX) per semplificare il processo.

Configurazione Normale (trasparente)

esp32

Ecco la mia selezione di esp32 ESP32 Dev Kit v1 - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 - WeMos Lolin32 mini - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S

Lo schema di cablaggio è abbastanza semplice, e per ora ho messo direttamente a terra M0 e M1 per il test.

Raspberry Pi Pico

Ecco il diagramma di collegamento, per questo test, puoi rimuovere il collegamento del pin AUX. Puoi anche vedere che uso una porta seriale predefinita diversa perché differisce dall’ambiente Arduino.

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

Per il pinout standard Arduino, devi cambiare la dichiarazione UART così
uart2 = UART(1, rx=Pin(9), tx=Pin(8))

Cablaggio per la modalità di programmazione/sonno

Per configurarlo, devi impostare M0 e M1 su alto (ricorda di usare 3.3v).

esp32

In questa modalità, puoi gestire la configurazione del dispositivo

Raspberry Pi Pico

Ecco il diagramma di collegamento, per questo test, puoi rimuovere il collegamento del pin AUX. Puoi anche vedere che uso una porta seriale predefinita diversa perché differisce dall’ambiente Arduino.

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

Per il pinout standard Arduino, devi cambiare la dichiarazione UART così
uart2 = UART(1, rx=Pin(9), tx=Pin(8))

Opzioni di configurazione di base

Puoi trovare le opzioni di configurazione nell’articolo della Libreria.

Ottenere la configurazione

Esempio di sketch Arduino

# Autore: Renzo Mischianti
# Sito Web: www.mischianti.org
#
# Descrizione:
# Questo script inizializza il modulo E32 LoRa con MicroPython, recupera la configurazione attuale e la stampa sulla console.
# Il codice dimostra come usare la libreria LoRaE32 per interagire con il modulo e leggere la sua configurazione.
#
# Nota: Questo codice è stato scritto e testato usando MicroPython su una scheda ESP32.
#       Funziona con altre schede, ma potrebbe essere necessario cambiare i pin UART.

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

uart2 = UART(2)

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

code = lora.begin()
print("Inizializzazione: {}", ResponseStatusCode.get_description(code))

code, configuration = lora.get_configuration()

print("Recupero configurazione: {}", ResponseStatusCode.get_description(code))

print_configuration(configuration)

Ecco il risultato dello sketch

----------------------------------------
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)
----------------------------------------

Il processo inizia importando le classi e le funzioni richieste dai moduli lora_e32 e lora_e32_operation_constant. La classe LoRaE32 rappresenta il modulo LoRa, la funzione print_configuration è utilizzata per stampare i dettagli della configurazione in un formato leggibile, e la classe Configuration rappresenta la configurazione del modulo. La classe ResponseStatusCode è utilizzata per interpretare il codice di stato restituito dalla funzione get_configuration().

La riga code, configuration = lora.get_configuration() chiama la funzione get_configuration() sull’oggetto lora (che rappresenta il modulo LoRa) per recuperare la configurazione attuale del modulo. La funzione restituisce due valori: un codice di stato (code), che indica se l’operazione è stata eseguita con successo, e la configurazione attuale (configuration).

Il codice di stato viene stampato in un formato facilmente comprensibile utilizzando la funzione ResponseStatusCode.get_description(code), che prende come argomento il codice di stato e restituisce una descrizione corrispondente. Ciò fornisce un feedback su se l’operazione get_configuration() sia stata eseguita con successo.

La funzione print_configuration(configuration) viene poi utilizzata per stampare la configurazione recuperata in un formato leggibile. Questa funzione prende come argomento l’oggetto configuration e ne stampa gli attributi.

La configurazione include vari parametri che determinano il funzionamento del modulo LoRa:

• HEAD: Questo è l’intestazione del messaggio di configurazione. Il suo valore è fisso a 192 (0b11000000 in forma binaria).
• AddH e AddL: Questi sono rispettivamente le parti alta e bassa dell’indirizzo del dispositivo. In questo caso, l’indirizzo è 0.2.
• Chan: Questo è il numero del canale, che è mappato su una frequenza. In questo caso, il canale 23 corrisponde a una frequenza di 433 MHz.

La configurazione include anche parametri per le impostazioni di velocità:

• SpeedParityBit: Imposta il bit di parità UART. Il predefinito (0b0) corrisponde a 8N1, il che significa 8 bit di dati, nessun bit di parità e 1 bit di stop.
• SpeedUARTDatte: Imposta il baud rate UART. Il predefinito (0b11) corrisponde a 9600 bps (bit al secondo).
• SpeedAirDataRate: Imposta il tasso di dati aereo. Il predefinito (0b10) corrisponde a 2.4 kbps (kilobit al secondo).

La configurazione include ulteriori opzioni per le impostazioni di trasmissione:

• OptionTrans: Determina la modalità di trasmissione. Un valore di 0b1 indica la modalità di trasmissione fissa, dove i primi tre byte del messaggio sono utilizzati come indirizzo alto e basso e il canale.
• OptionPullup: Imposta la modalità I/O per i pin TXD, RXD e AUX. Il predefinito (0b1) indica la modalità push-pull/pull-up.
• OptionWakeup: Imposta il tempo di risveglio wireless. Il predefinito (0b0) corrisponde a 250 ms.
• OptionFEC: Abilita o disabilita la correzione degli errori in avanti (Forward Error Correction). Il predefinito (0b1) attiva il FEC.
• OptionPower: Imposta la potenza di trasmissione. Il predefinito (0b0) corrisponde a 20 dBm.

Chiamando get_configuration() e stampando il risultato, puoi controllare le impostazioni attuali del tuo modulo LoRa e verificare che sia configurato come previsto.

Impostare la configurazione

Naturalmente, quando hai una configurazione che vuoi cambiare per il tuo scopo, penso che tu possa ottenere la configurazione da un dispositivo, modificarla come desideri e impostarla.

Al metodo set_configuration puoi passare un parametro aggiuntivo permanentConfiguration, che ti permette di perdere la configurazione allo spegnimento se imposti False.

    def set_configuration(self, configuration, permanentConfiguration=True) -> (ResponseStatusCode, Configuration):

Ecco lo sketch:

# Author: Renzo Mischianti
# Website: www.mischianti.org
#
# Description:
# This script demonstrates how to use the E32 LoRa module with MicroPython.
# It initializes the module, retrieves the current configuration,
# sets a new configuration, and restores the default configuration.
# It also includes examples of sending and receiving data using the module.
#
# Note: This code was written and tested using MicroPython on a ESP32 board.
#       It works with other boards, but you may need to change the UART pins.

from lora_e32 import LoRaE32, print_configuration, Configuration
from lora_e32_constants import OperatingFrequency, FixedTransmission, WirelessWakeUpTime, TransmissionPower, \
    TransmissionPower20, AirDataRate, UARTParity, UARTBaudRate
from lora_e32_operation_constant import ResponseStatusCode
from machine import UART, Pin

# Create a UART object to communicate with the LoRa module with ESP32
# uart2 = UART(2)
# Create a LoRaE32 object, passing the UART object and pin configurations
# lora = LoRaE32('433T20D', uart2, aux_pin=15, m0_pin=21, m1_pin=19)

# Create a UART object to communicate with the LoRa module with Raspberry Pi Pico
#uart2 = UART(1)
# Use the Serial1 pins of Arduino env on the 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)

# Initialize the LoRa module and print the initialization status code
code = lora.begin()
print("Initialization: {}", ResponseStatusCode.get_description(code))

##########################################################################################
# GET CONFIGURATION
##########################################################################################

# Retrieve the current configuration of the LoRa module and print it to the console
code, configuration = lora.get_configuration()
print("Retrieve configuration: {}", ResponseStatusCode.get_description(code))
print("------------- CONFIGURATION BEFORE CHANGE -------------")
print_configuration(configuration)

##########################################################################################
# SET CONFIGURATION
# To set the configuration, you must set the configuration with the new values
##########################################################################################

# Create a new Configuration object with the desired settings
configuration_to_set = Configuration('433T20D')
configuration_to_set.ADDL = 0x02
configuration_to_set.ADDH = 0x01
configuration_to_set.CHAN = 23
configuration_to_set.OPTION.operatingFrequency = OperatingFrequency.FREQUENCY_433
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
configuration_to_set.OPTION.wakeUpTime = WirelessWakeUpTime.WAKE_UP_250
configuration_to_set.OPTION.transmissionPower = TransmissionPower('433T20D').\
                                                    get_transmission_power().POWER_20
# or
# configuration_to_set.OPTION.transmissionPower = TransmissionPower20.POWER_20
configuration_to_set.SPED.airDataRate = AirDataRate.AIR_DATA_RATE_100_96
configuration_to_set.SPED.uartParity = UARTParity.MODE_00_8N1
configuration_to_set.SPED.uartBaudRate = UARTBaudRate.BPS_9600

# Set the new configuration on the LoRa module and print the updated configuration to the console
code, confSetted = lora.set_configuration(configuration_to_set)

Ecco il risultato sulla console

print_configuration(confSetted)
Initialization: {} Success
Retrieve configuration: {} Success
------------- CONFIGURATION BEFORE CHANGE -------------
----------------------------------------
HEAD : 0b11000000 192

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

SpeedParityBit    : 0b0  ->  8N1 (Default)
SpeedUARTDatte : 0b11  ->  9600bps (default)
SpeedAirDataRate  : 0b10  ->  2.4kbps (default)
OptionTrans       : 0b0  ->  Transparent transmission (default)
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)
----------------------------------------
------------- CONFIGURATION AFTER CHANGE -------------
Success
----------------------------------------
HEAD : 0b11000000 192

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

SpeedParityBit    : 0b0  ->  8N1 (Default)
SpeedUARTDatte : 0b11  ->  9600bps (default)
SpeedAirDataRate  : 0b100  ->  9.6kbps
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 libreria è abbastanza semplice, ma nel prossimo capitolo testeremo varie opzioni del dispositivo.

Descrizione dei valori

I parametri di configurazione per il modulo Ebyte LoRa E32 sono incapsulati in diverse classi Python. Ecco una breve descrizione di ogni classe e la funzione dei suoi parametri:

UARTParity: Questa classe gestisce il bit di parità della comunicazione UART. Il bit di parità è utilizzato per il rilevamento degli errori, e sono disponibili diverse modalità – 8N1 (Senza parità), 8O1 (Parità dispari), 8E1 (Parità pari). L’impostazione predefinita è 8N1.

• Valori possibili: MODE_00_8N1 (8N1), MODE_01_8O1 (8O1), MODE_10_8E1 (8E1)

UARTBaudRate: Questo parametro determina il baud rate per la comunicazione UART. Il baud rate definisce la velocità di trasmissione, specificando quanti bit possono essere trasmessi al secondo. Varia da 1200bps a 115200bps, con 9600bps come impostazione predefinita.

• Valori possibili: BAUD_RATE_1200, BAUD_RATE_2400, BAUD_RATE_4800, BAUD_RATE_9600 (predefinito), BAUD_RATE_19200, BAUD_RATE_38400, BAUD_RATE_57600, BAUD_RATE_115200

AirDataRate: Il tasso di dati aereo determina la velocità di trasmissione over-the-air del modulo LoRa, che varia da 0.3kbps a 19.2kbps. Il tasso di dati aereo predefinito è 2.4kbps.

• Valori possibili: AIR_DATA_RATE_0_3KBPS, AIR_DATA_RATE_1_2KBPS, AIR_DATA_RATE_2_4KBPS (predefinito), AIR_DATA_RATE_4_8KBPS, AIR_DATA_RATE_9_6KBPS, AIR_DATA_RATE_19_2KBPS

FixedTransmission: Questa impostazione determina la modalità di trasmissione del modulo. Può essere Trasmissione Trasparente, dove il dispositivo invia i dati così come sono, o Trasmissione Fissa, dove i primi tre byte possono essere utilizzati come indirizzo alto/basso e canale. La Trasmissione Trasparente è l’impostazione predefinita.

• Valori possibili: MODE_TRANSPARENT, MODE_FIXED

IODriveMode: Questa impostazione determina la modalità di pilotaggio dei pin TXD, RXD e AUX. Possono essere in modalità open-collector o push-pull/pull-up. Il predefinito è la modalità push-pull/pull-up .

• Valori possibili: MODE_OPEN_COLLECTOR, MODE_PUSH_PULL

WirelessWakeUpTime: Questa impostazione controlla il tempo di risveglio per la comunicazione wireless. Varia da 250ms a 2000ms, con il predefinito di 250ms.

• Valori possibili: WAKE_UP_TIME_250, WAKE_UP_TIME_500, WAKE_UP_TIME_750, WAKE_UP_TIME_1000, WAKE_UP_TIME_1250, WAKE_UP_TIME_1500, WAKE_UP_TIME_1750, WAKE_UP_TIME_2000

ForwardErrorCorrectionSwitch: Questo parametro controlla la funzione di correzione degli errori in avanti (FEC). Il FEC è utilizzato per controllare gli errori nella trasmissione dei dati su canali di comunicazione inaffidabili o rumorosi. L’impostazione predefinita è di attivare il FEC.

• Valori possibili: FEC_OFF, FEC_ON (predefinito)

TransmissionPowerXX: Queste classi definiscono la potenza di trasmissione del modulo LoRa E32. Una maggiore potenza di trasmissione significa un raggio di trasmissione più lungo ma anche un maggiore consumo di energia. Ci sono diverse classi per diversi livelli massimi di potenza, da 20dBm fino a 37dBm.

• Valori possibili: POWER_20DBM, POWER_27DBM, POWER_30DBM, POWER_33DBM, POWER_37DBM

Ogni classe ha metodi per ottenere la descrizione e i valori predefiniti dei suoi parametri. Queste classi rendono più facile la configurazione e l’impostazione del modulo LoRa E32, fornendo flessibilità e controllo sul suo funzionamento.

Grazie