LoRa punto a punto en Raspberry PLC
Conexiones
Familia Raspberry PLC
El Raspberry PI PLC utiliza los siguientes pines para comunicarse con el módulo LoRa RN2483:
- PIN RESET: 0x4008
- SLAVE SELECT: 17
Además del pin de reset, el módulo se comunica con la placa Raspberry PI 4B a través de un expansor UART, que utiliza el SPI de la placa Raspberry PI.
Familia Touchberry Panel
Las pantallas Touchberry utilizan el siguiente pin para comunicarse con el módulo LoRa RN2483:
- PIN RESET: 0x2003
Además del pin de reset, el módulo se comunica con la placa Raspberry PI 4B a través de un expansor UART que utiliza I2C de la placa Raspberry PI. La dirección para el puerto de expansión I2C es 0x78.
Funcionamiento del módulo
Inicialización del módulo
Antes de configurar el módulo LoRa, realiza las siguientes comprobaciones para asegurarte de que el Raspberry PLC está listo para trabajar con el módulo:
- Asegúrate de tener instalada la biblioteca librpiplc .
- Comprueba que el archivo /boot/config.txt termina con estas líneas (si no, sustituye la configuración [all] anterior por esta):
- Establece el pin de reset del módulo LoRa en HIGH (Reemplaza [RPIPLC_Version] y [RPIPLC_Model] con tu versión y modelo. Sigue esta sección para más información):
- Configura el puerto a 57600 baudios:
[all] dtparam=spi=on gpio=8=pd dtoverlay=spi0-1cs,cs0_pin=7 dtoverlay=w5500,cs=0,int_pin=6 dtparam=i2c_arm=on dtoverlay=i2c-rtc,ds3231 dtoverlay=sc16is752-spi1-rpiplc-v4,xtal=14745600 enable_uart=1
sudo ~/test/[RPIPLC_Version]/[RPIPLC_Model]/set-digital-output EXP1_RST 1
stty 57600 -F /dev/ttySC0
Interacción con el módulo
Para enviar datos al módulo RN2483, utiliza este comando:
echo -e "[COMMAND]\r" > /dev/ttySC0
Los comandos disponibles se encuentran en el Manual de usuario del módulo RN2483.
Los comandos básicos para enviar "Hello" a través de LoRa son:
echo -e "mac pause\r" > /dev/ttySC0
echo -e "radio set freq 868000000\r" > /dev/ttySC0
echo -e "radio tx 48656c6c6f\r" > /dev/ttySC0
Para recibir un mensaje:
echo -e "mac pause\r" > /dev/ttySC0
echo -e "radio set freq 868000000\r" > /dev/ttySC0
echo -e "radio rx 0\r" > /dev/ttySC0
Por un total de 15 segundos, el módulo estará en modo recepción hasta que reciba un mensaje o expire el tiempo. Este tiempo límite puede modificarse o eliminarse con el comando "radio set wdt [time]\r". Sustituye [time] por un número de milisegundos (configúralo a 0 para eliminar el tiempo límite).
Cada vez que se envía un comando al módulo, este responde dependiendo del resultado de la operación. Para leer las respuestas, abre una terminal y escribe:
cat /dev/ttySC0
Por ejemplo, después de ejecutar el comando radio rx 0, el módulo responderá si el comando fue exitoso y, posteriormente, responderá nuevamente con los datos recibidos.
Uso en Python
Además de interactuar mediante comandos de terminal, puedes usar un script en Python para enviar y recibir mensajes con otro módulo LoRa. Revisa el siguiente ejemplo:
#!/usr/bin/env python3 from lora import LoRa debug = False # print debug information of current command in REPL timeout_s = None # timeout of serial and lora reception timeout_l = 0 lora_mode = input("Type mode (tx | rx): ") lora = LoRa("/dev/ttySC0", timeout_s, timeout_l, debug) if lora_mode == "tx": while True: # transmit data i = input("Write message to send! ").encode() lora.send_str(i) elif lora_mode == "rx": while True: rx_str = lora.recv_str() print("Received: " + rx_str) else: print("Wrong mode! tx or rx") exit
#!/usr/bin/env python3 from lora import LoRa debug = False # print debug information of current command in REPL timeout_s = None # timeout of serial and lora reception timeout_l = 0 lora_mode = input("Type mode (tx | rx): ") lora = LoRa("/dev/ttySC0", timeout_s, timeout_l, debug) if lora_mode == "tx": while True: # transmit data i = input("Write message to send! ").encode() lora.send_str(i) elif lora_mode == "rx": while True: rx_str = lora.recv_str() print("Received: " + rx_str) else: print("Wrong mode! tx or rx") exit
Como ves, este script sirve tanto para enviar como para recibir, según la primera entrada "tx" o "rx". Ten en cuenta que en modo RX el programa no termina hasta que recibe datos. Para cambiarlo, fija un "timeout_l" mayor que 0 para detener el modo de recepción al cabo de "timeout_l" segundos.
Para poder ejecutar el código, también necesitarás el archivo lora.py, que puedes descargar aquí:
lora.py
Antes de configurar el módulo, comprueba que el Raspberry PLC está bien configurado:
- Comprueba que librpiplc está instalado.
- Comprueba que el archivo /boot/config.txt termina con las siguientes líneas (si no, añade esta configuración y reinicia el PLC):
- Pon el pin de reset del módulo LoRa en HIGH. Comprueba que la carpeta test existe en tu directorio personal. Si no, puedes descargarla desde este enlace. Basta con llamar a esta URL con wget y extraer el contenido.
- Configura el puerto a 57600 baudios con:
[all] dtparam=spi=on gpio=8=pd dtoverlay=spi0-1cs,cs0_pin=7 dtoverlay=w5500,cs=0,int_pin=6 dtparam=i2c_arm=on dtoverlay=i2c-rtc,ds3231 dtoverlay=sc16is752-spi1-rpiplc-v4,xtal=14745600 enable_uart=1
sudo ~/test/[RPIPLC_Version]/[RPIPLC_Model]/set-digital-output EXP1_RST 1
stty 57600 -F /dev/ttySC0
Inicialización del módulo
Para trabajar con el módulo LoRa, el GPIO 0x2003 debe estar en estado HIGH, pero esto puede hacerse fácilmente desde el código.
Interacción con el módulo
La forma más fácil de interactuar con el módulo RN2483 es usando Python. Un código simple de ejemplo sería:
#!/usr/bin/python # -*- coding:utf-8 -*- import smbus import time address = 0x78 gpio_address = 0x20 busNumber = 1 bus = smbus.SMBus(busNumber) macPause = [0x6D, 0x61, 0x63, 0x20, 0x70, 0x61, 0x75, 0x73, 0x65, 0x0D, 0x0A] str = "" class expBoard: def __init__(self, addr, port): self.addr = addr self.bus = smbus.SMBus(port) def write_block_data(self, byte, array): self.bus.write_i2c_block_data(self.addr, byte, array) def write_data(self, value): self.bus.write_byte(self.addr, value) def write_byte_data(self, add, value): self.bus.write_byte_data(self.addr, add, value) def read_data(self): self.bus.read_byte(self.addr) def read_nbytes_data(self, data, n): return self.bus.read_i2c_block_data(self.addr, data, n) i2c_bus = expBoard(address, busNumber) i2c_bus_2 = expBoard(gpio_address, busNumber) i2c_bus_2.write_byte_data(0x01, 0x08) i2c_bus.write_data(123) time.sleep(0.7) i2c_bus.write_data(17) time.sleep(0.1) while True: print("---> {}".format(str.join(chr(n) for n in macPause))) i2c_bus.write_block_data(0x00, macPause) time.sleep(0.7) rx = i2c_bus.read_nbytes_data(0x00, len("4294967245")+2) list = [chr(n) for n in rx] print(str.join(list))
#!/usr/bin/python # -*- coding:utf-8 -*- import smbus import time address = 0x78 gpio_address = 0x20 busNumber = 1 bus = smbus.SMBus(busNumber) macPause = [0x6D, 0x61, 0x63, 0x20, 0x70, 0x61, 0x75, 0x73, 0x65, 0x0D, 0x0A] str = "" class expBoard: def __init__(self, addr, port): self.addr = addr self.bus = smbus.SMBus(port) def write_block_data(self, byte, array): self.bus.write_i2c_block_data(self.addr, byte, array) def write_data(self, value): self.bus.write_byte(self.addr, value) def write_byte_data(self, add, value): self.bus.write_byte_data(self.addr, add, value) def read_data(self): self.bus.read_byte(self.addr) def read_nbytes_data(self, data, n): return self.bus.read_i2c_block_data(self.addr, data, n) i2c_bus = expBoard(address, busNumber) i2c_bus_2 = expBoard(gpio_address, busNumber) i2c_bus_2.write_byte_data(0x01, 0x08) i2c_bus.write_data(123) time.sleep(0.7) i2c_bus.write_data(17) time.sleep(0.1) while True: print("---> {}".format(str.join(chr(n) for n in macPause))) i2c_bus.write_block_data(0x00, macPause) time.sleep(0.7) rx = i2c_bus.read_nbytes_data(0x00, len("4294967245")+2) list = [chr(n) for n in rx] print(str.join(list))
Observando el código:
- La dirección I2C para la comunicación serial es 0x78. La dirección 0x20 se usa para interactuar con las E/S del módulo de expansión.
- Primero habilitamos el módulo poniendo el pin de reset (0x2003) en HIGH. Luego, reiniciamos el módulo escribiendo 123 y establecemos el baudrate en 57600 con 17.
- En la función while True, enviamos el comando "macPause" repetidamente, mientras leemos la respuesta del módulo. Esperamos la cadena "4294967245\r\n", por lo que leemos exactamente los bytes deseados (12).
Este es un ejemplo básico de cómo usar el módulo LoRa. Para un diseño más complejo, reemplaza los comandos con los que desees.
No hay comentarios por ahora.