EByte LoRa E32 & MicroPython: un’analisi approfondita sui tipi di trasmissione – 4


Nel nostro continuo viaggio per svelare gli intricati strati della tecnologia IoT, spostiamo la nostra attenzione su un aspetto fondamentale dei sistemi interconnessi: la trasmissione dei dati.

EByte LoRa E32 & MicroPython: a deep dive into transmission types
EByte LoRa E32 & MicroPython: a deep dive into transmission types

La trasmissione dei dati costituisce il sistema circolatorio di qualsiasi configurazione IoT, fornendo informazioni da un nodo all’altro. In questo contesto, mettiamo in evidenza due potenti strumenti: i moduli LoRa E32 di EByte e il linguaggio di programmazione MicroPython.

Questo articolo, il quarto della nostra serie, fornisce un’analisi approfondita dei diversi tipi di trasmissione che possono essere realizzati con il modulo LoRa E32 di EByte utilizzando MicroPython. Comprendendo queste modalità di trasmissione, gli sviluppatori possono sfruttare efficacemente il potere di questi strumenti e personalizzare le loro applicazioni per soddisfare specifiche esigenze.

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

Nella prima parte, abbiamo utilizzato una trasmissione trasparente, quindi inviamo a tutti e riceviamo da tutti con lo stesso indirizzo e canale.

Ma non è uno scenario standard, e di solito vogliamo inviare a un punto specifico e ricevere una risposta.

Se hai problemi con il blocco del dispositivo, devi inserire una resistenza di pull-up da 4,7k ohm o collegarlo meglio al pin AUX del dispositivo.

Schemi di connessione

Per un utilizzo di base, abbiamo utilizzato questa configurazione. Tuttavia, in questa configurazione, si sta lavorando solo in “Modalità normale”, e gestiremo dinamicamente solo i pin necessari (RX, TX) per semplificare il processo.

Configurazione normale (trasparente)

ESP32

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

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

E32ESP32
M0GND (Imposta modalità normale)
M1GND (Imposta modalità normale)
RXTX2 (Pull-up 4,7KΩ)
TXRX2 (Pull-up 4,7KΩ)
AUXNon collegato (meglio se si imposta un pin, ma non necessario per questo test)
VCC5v
GNDGND

Raspberry Pi Pico

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

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

E32esp32
M0GND (Imposta modalità normale)
M1GND (Imposta modalità normale)
RXTX1 GPIO4 (PullUP 4,7KΩ)
TXRX1 GPIO5 (PullUP 4,7KΩ)
AUX2 (meglio se imposti un pin, ma non necessario per questo test)
VCC5v
GNDGND

Per la disposizione standard di Arduino, è necessario modificare la dichiarazione UART in questo modo:
uart2 = UART(1, rx=Pin(9), tx=Pin(8))

Trasmissione trasparente

La trasmissione trasparente è una modalità di trasmissione dati in cui i dati vengono inviati e ricevuti senza alcun filtro basato sull’indirizzo. Ciò significa che i dati inviati dal dispositivo trasmittente sono disponibili per essere ricevuti da qualsiasi dispositivo entro il suo raggio d’azione, senza tener conto dell’indirizzo univoco del dispositivo ricevente.

Nel contesto del modulo EByte LoRa E32, quando opera in modalità trasmissione trasparente, il modulo invia dati che possono essere raccolti da tutti gli altri dispositivi E32 entro il suo raggio d’azione. Questo è simile a una trasmissione broadcast, in cui lo stesso messaggio viene inviato a tutti i dispositivi in una determinata area.

Questa modalità di trasmissione è particolarmente utile quando c’è la necessità di diffondere la stessa informazione a più dispositivi contemporaneamente. Ad esempio, in un’applicazione IoT come un sistema di monitoraggio meteorologico, un nodo sensore potrebbe utilizzare la trasmissione trasparente per inviare dati meteorologici a tutti gli altri nodi nella rete contemporaneamente.

Tuttavia, è importante notare che, sebbene la trasmissione trasparente possa essere efficace per la diffusione di informazioni, potrebbe non essere adatta per situazioni che richiedono uno scambio di dati sicuro o mirato, poiché manca della specificità della comunicazione basata sull’indirizzo.

Invio di un messaggio di testo

# Autore: Renzo Mischianti
# Sito web: www.mischianti.org
#
# Descrizione:
# Questo script dimostra come utilizzare il modulo E32 LoRa con MicroPython.
# Invio di una stringa
#
# Nota: Questo codice è stato scritto e testato con MicroPython su una scheda ESP32.
#       Funziona con altre schede, ma potrebbe essere necessario modificare i pin UART.

from lora_e32 import LoRaE32, Configuration
from machine import UART, Pin

from lora_e32_operation_constant import ResponseStatusCode

# Crea un oggetto UART per comunicare con il modulo LoRa con ESP32
uart2 = UART(2)
# Crea 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)

# Crea un oggetto UART per comunicare con il modulo LoRa con Raspberry Pi Pico
# uart2 = UART(1)
# Usa 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)

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

# Imposta la configurazione ai valori predefiniti e stampa la configurazione aggiornata sulla console
# Non è necessario se è già configurato
# configuration_to_set = Configuration('433T20D')
# code, confSetted = lora.set_configuration(configuration_to_set)
# print("Imposta configurazione: {}", ResponseStatusCode.get_description(code))

# Invia un messaggio di testo (trasparente)
message = 'Ciao, mondo!'
code = lora.send_transparent_message(message)
print("Invia messaggio: {}", ResponseStatusCode.get_description(code))

Se hai già modificato la configurazione, devi ripristinare il parametro di base:

configuration_to_set = Configuration('433T20D')
code, confSetted = lora.set_configuration(configuration_to_set)
print("Imposta configurazione: {}", ResponseStatusCode.get_description(code))

Invia un dizionario

# Author: Renzo Mischianti
# Website: www.mischianti.org
#
# Description:
# This script demonstrates how to use the E32 LoRa module with MicroPython.
# Sending dictionary
#
# Note: This code was written and tested using MicroPython on an ESP32 board.
#       It works with other boards, but you may need to change the UART pins.

from lora_e32 import LoRaE32, Configuration
from machine import UART

from lora_e32_operation_constant import ResponseStatusCode

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

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

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
# configuration_to_set = Configuration('433T20D')
# code, confSetted = lora.set_configuration(configuration_to_set)
# print("Set configuration: {}", ResponseStatusCode.get_description(code))

# Send a dictionary message (transparent)
data = {'key1': 'value1', 'key2': 'value2'}
code = lora.send_transparent_dict(data)
print("Send message: {}", ResponseStatusCode.get_description(code))

Trasmissione fissa

La trasmissione fissa è una modalità di trasmissione dati che utilizza l’indirizzo hardware specifico di un dispositivo per la comunicazione. Ciò significa che il dispositivo trasmittente invia dati specificamente a un dispositivo ricevente con un indirizzo conosciuto. È simile all’invio di una lettera per posta in cui il mittente scrive l’indirizzo del destinatario sulla busta per garantire che raggiunga la destinazione desiderata.

Nel contesto del modulo EByte LoRa E32, quando opera in modalità di trasmissione fissa, il modulo invia dati specificamente a un altro modulo E32 con un indirizzo designato. Ciò significa che anche se ci sono altri moduli E32 entro la portata, solo quello con l’indirizzo specifico riceverà i dati.

In sostanza, la trasmissione fissa fornisce un metodo di comunicazione più sicuro e mirato rispetto a modalità come la trasmissione trasparente, poiché assicura che solo il destinatario previsto riceva i dati trasmessi.

Trasmissione fissa: punto a punto

Questa modalità di trasmissione è particolarmente utile quando c’è la necessità di stabilire una comunicazione sicura uno a uno tra due dispositivi. Ad esempio, in un’applicazione IoT come un sistema di sicurezza domestica, un sensore di porta potrebbe utilizzare la trasmissione fissa per inviare dati di allarme specificamente al pannello di controllo principale del sistema di sicurezza.

Quindi, prima di tutto, dobbiamo impostare i pin M0 e M1 su HIGH per entrare in modalità programma/standby e impostare l’indirizzo corretto e il flag di trasmissione fissa.

Se desideriamo replicare la condizione del mittente nell’immagine superiore, dobbiamo effettuare questa configurazione.

# Imposta la configurazione ai valori predefiniti e stampa la configurazione aggiornata sulla console
# Non necessario se già configurato
configuration_to_set = Configuration('433T20D')
configuration_to_set.ADDL = 0x02 # Indirizzo di questo mittente, nessun ricevitore
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
code, confSetted = lora.set_configuration(configuration_to_set)
print("Imposta configurazione: {}", ResponseStatusCode.get_description(code))

Successivamente, per il dispositivo ricevente, dobbiamo impostare questa configurazione.

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
configuration_to_set = Configuration('433T20D')
configuration_to_set.ADDL = 0x01 # Address of this receive no sender
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
code, confSetted = lora.set_configuration(configuration_to_set)
print("Set configuration: {}", ResponseStatusCode.get_description(code))

Now we just sent a message to the specified device.

# Send a string message (fixed)
message = 'Hello, world!'
code = lora.send_fixed_message(0, 0x01, 23, message)

The receiver is more transparent because the device manages the address and channel.

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

        print(value)
        utime.sleep_ms(2000)

Quindi, puoi verificare che nessun dato sia arrivato.

Invia lo sketch (Se non colleghi prima tutti i pin, devi metterlo in modalità programma e poi ripristinare la modalità normale):

# Author: Renzo Mischianti
# Website: www.mischianti.org
#
# Description:
# This script demonstrates how to use the E32 LoRa module with MicroPython.
# Sending string to a specified address (receiver)
# ADDH = 0x00
# ADDL = 0x02
# CHAN = 23
#
# Note: This code was written and tested using MicroPython on an ESP32 board.
#       It works with other boards, but you may need to change the UART pins.

from lora_e32 import LoRaE32, Configuration
from machine import UART

from lora_e32_constants import FixedTransmission
from lora_e32_operation_constant import ResponseStatusCode

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

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

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
configuration_to_set = Configuration('433T20D')
configuration_to_set.ADDL = 0x02 # Address of this sender no receiver
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
code, confSetted = lora.set_configuration(configuration_to_set)
print("Set configuration: {}", ResponseStatusCode.get_description(code))

# Send a string message (fixed)
message = 'Hello, world!'
code = lora.send_fixed_message(0, 0x01, 23, message)
# The receiver must be configured with ADDH = 0x00, ADDL = 0x01, CHAN = 23
print("Send message: {}", ResponseStatusCode.get_description(code))

Codice del ricevitore (Se non colleghi prima tutti i pin, devi mettere in modalità programma e poi ripristinare la modalità normale) :

# Author: Renzo Mischianti
# Website: www.mischianti.org
#
# Description:
# This script demonstrates how to use the E32 LoRa module with MicroPython.
# It includes examples of sending and receiving string using both transparent and fixed transmission modes.
# The code also configures the module's address and channel for fixed transmission mode.
# Address and channel of this receiver:
# ADDH = 0x00
# ADDL = 0x01
# CHAN = 23
#
# Can be used with the send_fixed_string and send_transparent_string scripts
#
# Note: This code was written and tested using MicroPython on an ESP32 board.
#       It works with other boards, but you may need to change the UART pins.

from lora_e32 import LoRaE32, Configuration
from machine import UART
import utime

from lora_e32_constants import FixedTransmission
from lora_e32_operation_constant import ResponseStatusCode

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

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

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
configuration_to_set = Configuration('433T20D')
configuration_to_set.ADDL = 0x01 # Address of this receive no sender
configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
code, confSetted = lora.set_configuration(configuration_to_set)
print("Set configuration: {}", ResponseStatusCode.get_description(code))

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

        print(value)
        utime.sleep_ms(2000)

Se cambi l’indirizzo o il canale nello sketch del ricevitore, non riceverai più messaggi.

Trasmissione fissa: broadcast

In considerazione di ciò, la Trasmissione fissa: broadcast è una modalità specializzata di trasmissione in cui i dati vengono specificamente trasmessi da un dispositivo a tutti gli altri entro la sua portata, simile alla Trasmissione trasparente. Tuttavia, la differenza cruciale sta nel livello di controllo sul destinatario del messaggio.

Nella Trasmissione fissa: broadcast, anche se i dati vengono inviati a tutti i dispositivi entro la portata, il mittente può determinare e controllare specificamente il destinatario utilizzando l’indirizzo hardware unico. In contrasto, la Trasmissione trasparente trasmette dati a tutti i dispositivi entro la portata senza alcuna filtrazione o controllo sul destinatario.

Questa distinzione fornisce un ulteriore livello di flessibilità al mittente nella Trasmissione fissa: broadcast, consentendogli di dirigere la trasmissione verso un dispositivo specifico, anche quando si trasmette a tutti i dispositivi nella portata. Questo non è possibile nella Trasmissione trasparente, che può solo trasmettere a tutti i dispositivi senza alcun controllo sul destinatario.

Con la mia libreria, è possibile utilizzare questo metodo di trasmissione.

messaggio = 'Ciao, mondo!'
codice = lora.send_broadcast_message(23, messaggio)
print("Invia messaggio: {}", ResponseStatusCode.get_description(codice))

Il ricevitore, come descritto, ha lo stesso codice perché il dispositivo gestisce il preambolo con Indirizzo e Canale.

Ecco lo sketch del mittente (Se non colleghi prima tutti i pin, devi metterlo in modalità programma e poi ripristinare la modalità normale):

# Author: Renzo Mischianti
# Website: www.mischianti.org
#
# Description:
# This script demonstrates how to use the E32 LoRa module with MicroPython.
# Sending string to all  address of the same channel we are using
#
# Note: This code was written and tested using MicroPython on an ESP32 board.
#       It works with other boards, but you may need to change the UART pins.

from lora_e32 import LoRaE32, Configuration
from machine import UART

from lora_e32_constants import FixedTransmission
from lora_e32_operation_constant import ResponseStatusCode

# Initialize the LoRaE32 module
uart2 = UART(2)
lora = LoRaE32('433T20D', uart2, aux_pin=15, m0_pin=19, m1_pin=21)
code = lora.begin()
print("Initialization: {}", ResponseStatusCode.get_description(code))

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
# configuration_to_set = Configuration('433T20D')
# configuration_to_set.ADDL = 0x02  # Address of this sender no receiver
# configuration_to_set.OPTION.fixedTransmission = FixedTransmission.FIXED_TRANSMISSION
# code, confSetted = lora.set_configuration(configuration_to_set)
# print("Set configuration: {}", ResponseStatusCode.get_description(code))

# Send a string message (fixed)
message = 'Hello, world!'
code = lora.send_broadcast_message(23, message)
# The receiver must be configured with ADDH = 0x00, ADDL = 0x01, CHAN = 23
print("Send message: {}", ResponseStatusCode.get_description(code))

Trasmissione fissa: monitoraggio

La Trasmissione fissa: monitoraggio è una modalità specializzata di trasmissione dati che fornisce una comunicazione unidirezionale da un dispositivo trasmittente specifico a un ricevitore designato. Questa modalità si concentra sulla costante sorveglianza e segnalazione dei dati dal mittente al ricevitore.

Nel contesto del modulo EByte LoRa E32, quando opera in modalità di trasmissione fissa: monitoraggio, il modulo invia dati destinati a un modulo E32 specifico (il monitor). Ciò garantisce un flusso di dati dedicato dal trasmettitore al monitor. Altri dispositivi nell’intervallo, anche se capaci di ricevere la trasmissione, vengono essenzialmente ignorati.

Questa modalità di trasmissione è particolarmente utile in scenari in cui è richiesta la monitoraggio e tracciamento in tempo reale dei dati da parte di un dispositivo o sensore specifico. Ad esempio, in un contesto IoT industriale, un sensore collocato in una macchina critica potrebbe utilizzare la trasmissione fissa: monitoraggio per inviare dati in tempo reale a un sistema di monitoraggio centralizzato.

Complessivamente, la trasmissione fissa: monitoraggio fornisce una linea di comunicazione sicura e ininterrotta da un trasmettitore a un ricevitore designato, rendendola ideale per applicazioni che richiedono uno streaming dedicato unidirezionale di dati a fini di monitoraggio.

Devi impostare ADDL e ADDH come segue:

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
configuration_to_set = Configuration('433T20D')
# With BROADCASS ADDRESS we receive all message
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("Set configuration: {}", ResponseStatusCode.get_description(code))

All’inizio, ricevi tutti i messaggi in un determinato CANALE.

E il messaggio ricevuto diventa (Se non colleghi prima tutti i pin, devi metterlo in modalità programma e poi ripristinare la modalità normale) :

# Author: Renzo Mischianti
# Website: www.mischianti.org
#
# Description:
# This script demonstrates how to use the E32 LoRa module with MicroPython.
# Receiving string from all address by setting BROADCAST ADDRESS
#
# Note: This code was written and tested using MicroPython on an ESP32 board.
#       It works with other boards, but you may need to change the UART pins.

from lora_e32 import LoRaE32, Configuration, BROADCAST_ADDRESS
from machine import UART
import utime

from lora_e32_constants import FixedTransmission
from lora_e32_operation_constant import ResponseStatusCode

# Initialize the LoRaE32 module
uart2 = UART(2)
lora = LoRaE32('433T20D', uart2, aux_pin=15, m0_pin=19, m1_pin=21)
code = lora.begin()
print("Initialization: {}", ResponseStatusCode.get_description(code))

# Set the configuration to default values and print the updated configuration to the console
# Not needed if already configured
configuration_to_set = Configuration('433T20D')
# With BROADCASS ADDRESS we receive all message
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("Set configuration: {}", ResponseStatusCode.get_description(code))

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

        print(value)
        utime.sleep_ms(2000)

Grazie


Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *