Site icon Renzo Mischianti

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

Ebyte LoRa E32 & MicroPython: esplorando la libreria

Ebyte LoRa E32 & MicroPython: esplorando la libreria

Spread the love

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.

Ebyte LoRa E32 & MicroPython: esplorazione della libreria
LoRa E32-TTL-100

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

EByte LoRa E32 MicroPython: PyPi, libreria pip Thonny

Schema dei Pin

EByte LoRa Exx piedinatura
Nr. PinElemento PinDirezione PinApplicazione Pin
1M0Input(weak pull-up)Lavora con M1 & decide sulle quattro modalità operative. Il floating non è consentito, può essere a terra.
2M1Input(weak pull-up)Lavora con M1 & decide sulle quattro modalità operative. Il floating non è consentito. Può essere a terra.
3RXDInputLe entrate UART TTL si collegano al pin di uscita TXD esterno (MCU, PC). Può essere configurato come input a drain aperto o pull-up.
4TXDOutputLavora con M0 & decide sulle quattro modalità operative. Il floating non è consentito. Può essere a terra.

5

AUX

Output
Le uscite UART TTL si collegano al pin di ingresso RXD esterno (MCU, PC). Può essere configurato come uscita a drain aperto o push-pull.
6VCCAlimentazione 2.3V~5.5V DC
7GNDTerra

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

ModalitàM1M0Spiegazione
Normale00UART e il canale wireless sono pronti per l’uso
Risveglio01Utilizzato per impostare i parametri. La trasmissione e la ricezione sono disabilitate.
Risparmio energetico10Uguale a normale, ma viene aggiunto un codice di preambolo ai dati trasmessi per risvegliare il ricevitore.
Sonno11Utilizzato per impostare i parametri. La trasmissione e la ricezione sono disabilitate.

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.

LoRa E32 AUX Pin in trasmissione

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

LoRa E32 pin AUX in ricezione

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

LoRa e32 AUX pin in autoverifica

Cablaggio

esp32

ESP32 DOIT DEV KIT v1 pinout
Ebyte LoRa E22 device esp32 dev kit v1 breadboard full connection
M0D21
M1D19
TXPIN RX2 (PullUP 4,7KΩ)
RXPIN TX3 (PullUP 4,7KΩ)
AUXPIN D18 (PullUP 4,7KΩ) (D15 per svegliarsi)
VCC5V
GNDGND
uart2 = UART(2)
lora = LoRaE32('433T20D', uart2, aux_pin=15, m0_pin=21, m1_pin=19)

Raspberry Pi Pico

Raspberry Pi Pico rp2040 pinout a bassa risoluzione

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

Raspberry Pi Pico EByte LoRa Exx completamente connesso MicroPython
E32Raspberry Pi Pico
M010
M111
RXTX1 GPIO4 (PullUP 4,7KΩ)
TXRX1 GPIO5 (PullUP 4,7KΩ)
AUX2 (PullUP 4,7KΩ)
VCC5v
GNDGND

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.

Raspberry Pi Pico EByte LoRa Exx completamente connesso
E32Raspberry Pi Pico
M010
M111
RXTX1 GPIO8 (PullUP 4,7KΩ)
TXRX1 GPIO9 (PullUP 4,7KΩ)
AUX2 (PullUP 4,7KΩ)
VCC5v
GNDGND

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

ADDHByte dell’indirizzo alto del modulo (predefinito 00H)00H-FFH
ADDLByte dell’indirizzo basso del modulo (predefinito 00H)00H-FFH
SPEDInformazioni sulla velocità di trasmissione dei dati e bit di parità aerea
CHANCanale di comunicazione (410M + CHAN*1M), predefinito 17H (433MHz), valido solo per dispositivi 433MHz controllare sotto per verificare la corretta frequenza del vostro dispositivo00H-1FH
OPTIONTipo di trasmissione, impostazioni pull-up, tempo di risveglio, FEC, Potenza di trasmissione

Dettaglio SPED

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

7 6 Bit di parità UART Valore costante
008N1 (default)MODE_00_8N1
018O1MODE_01_8O1
108 E1MODE_10_8E1
118N1 (uguale a 00)MODE_11_8N1

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.

543 TTL UART baud rate(bps) Valore costante
0001200UART_BPS_1200
0012400UART_BPS_2400
0104800UART_BPS_4800
0119600 (predefinito)UART_BPS_9600
10019200UART_BPS_19200
10138400UART_BPS_38400
11057600UART_BPS_57600
111115200UART_BPS_115200

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.

210 Velocità dati aria(bps) Valore costante
0000.3kAIR_DATA_RATE_000_03
0011.2kAIR_DATA_RATE_001_12
0102.4k (predefinito)AIR_DATA_RATE_010_24
0114.8kAIR_DATA_RATE_011_48
1009.6kAIR_DATA_RATE_100_96
10119.2kAIR_DATA_RATE_101_192
11019.2k (uguale a 101)AIR_DATA_RATE_110_192
11119.2k (uguale a 101)AIR_DATA_RATE_111_192

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.

7 Bit di abilitazione trasmissione fissa (simile a MODBUS) Valore costante
0Modalità di trasmissione trasparenteFT_TRANSPARENT_TRANSMISSION
1Modalità di trasmissione fissaFT_FIXED_TRANSMISSION

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.

6 Modalità di guida IO (predefinita 1) Valore costante
1Uscite push-pull di TXD e AUX, ingressi pull-up di RXDIO_D_MODE_PUSH_PULLS_PULL_UPS
0Uscite open-collector di TXD e AUX, ingressi open-collector di RXDIO_D_MODE_OPEN_COLLECTOR

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.

543 Tempo di risveglio wireless Valore costante
000250ms (predefinito)WAKE_UP_250
001500msWAKE_UP_500
010750msWAKE_UP_750
0111000msWAKE_UP_1000
1001250msWAKE_UP_1250
1011500msWAKE_UP_1500
1101750msWAKE_UP_1750
1112000msWAKE_UP_2000

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.

2 Interruttore FEC Valore costante
0Disattiva FECFEC_0_OFF
1Attiva FEC (predefinito)FEC_1_ON

Potenza di trasmissione

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

10 Potenza di trasmissione (approssimazione) Valore costante
0020dBm (predefinito)POWER_20
0117dBmPOWER_17
1014dBmPOWER_14
1110dBmPOWER_10

I moduli da 27dBm hanno:

10 Potenza di trasmissione (approssimazione) Valore costante
0027dBm (predefinito)POWER_27
0124dBmPOWER_24
1021dBmPOWER_21
1118dBmPOWER_18

E i moduli da 30dBm:

10 Potenza di trasmissione (approssimazione) Valore costante
0030dBm (predefinito)POWER_30
0127dBmPOWER_27
1024dBmPOWER_24
1121dBmPOWER_21

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

Freq. modelloValore di partenza da aggiungere al Canale
433410
170130
470370
868862
900862
915900

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.

Scenari di trasmissione LoRa E32, le linee sono i canali.

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

Scenari di trasmissione LoRa E32, le linee sono i canali

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


Spread the love
Exit mobile version