Introduction
According to the LoRa Alliance, Low-Power, Wide-Area Networks (LPWAN) are projected to support a major portion of the billions of devices forecasted for the Internet of Things (IoT). LoRaWAN is designed from the bottom up to optimize LPWANs for battery lifetime, capacity, range, and cost. LoRa and LoRaWAN permit long-range connectivity for the Internet of Things (IoT) devices in different types of industries. According to Wikipedia, LoRaWAN defines the communication protocol and system architecture for the network, while the LoRa physical layer enables the long-range communication link.
LoRa
Long Range (LoRa), the low-power wide-area network (LPWAN) protocol developed by Semtech, sits at layer 1, the physical layer, of the seven-layer OSI model (Open Systems Interconnection model) of computer networking. The physical layer defines the means of transmitting raw bits over a physical data link connecting network nodes. LoRa uses license-free sub-gigahertz radio frequency (RF) bands, including 433 MHz, 868 MHz (Europe), 915 MHz (Australia and North America), and 923 MHz (Asia). LoRa enables long-range transmissions with low power consumption.
LoRaWAN
LoRaWAN is a cloud-based medium access control (MAC) sublayer (layer 2) protocol but acts mainly as a network layer (layer 3) protocol for managing communication between LPWAN gateways and end-node devices as a routing protocol, maintained by the LoRa Alliance. The MAC sublayer and the logical link control (LLC) sublayer together make up layer 2, the data link layer, of the OSI model.
LoRaWAN is often cited as having greater than a 10-km-wide coverage area in rural locations. However, according to other sources, it is generally more limited. According to the Electronic Design article, 11 Myths About LoRaWAN, a typical LoRaWAN network range depends on numerous factors—indoor or outdoor gateways, the payload of the message, the antenna used, etc. On average, in an urban environment with an outdoor gateway, you can expect up to 2- to 3-km-wide coverage, while in the rural areas it can reach beyond 5 to 7 km. LoRa’s range depends on the “radio line-of-sight.” Radio waves in the 400 MHz to 900 MHz range may pass through some obstructions, depending on their composition, but will be absorbed or reflected otherwise. This means that the signal can potentially reach as far as the horizon, as long as there are no physical barriers to block it.
In the following hands-on post, we will explore the use of the LoRa and LoRaWAN protocols to transmit and receive sensor data, over a substantial distance, between an IoT device, containing a number of embedded sensors, and an IoT gateway.
Recommended Hardware
For this post, I have used the following hardware.
IoT Device with Embedded Sensors
I have used an Arduino single-board microcontroller as an IoT sensor, actually an array of sensors. The 3.3V AI-enabled Arduino Nano 33 BLE Sense board (Amazon: USD 36.00), released in August 2019, comes with the powerful nRF52840 processor from Nordic Semiconductors, a 32-bit ARM Cortex-M4 CPU running at 64 MHz, 1MB of CPU Flash Memory, 256KB of SRAM, and a NINA-B306 stand-alone Bluetooth 5 low energy (BLE) module.
The Sense also contains an impressive array of embedded sensors:
- 9-axis Inertial Sensor (LSM9DS1): 3D digital linear acceleration sensor, a 3D digital
angular rate sensor, and a 3D digital magnetic sensor - Humidity and Temperature Sensor (HTS221): Capacitive digital sensor for relative humidity and temperature
- Barometric Sensor (LPS22HB): MEMS nano pressure sensor: 260–1260 hectopascal (hPa) absolute digital output barometer
- Microphone (MP34DT05): MEMS audio sensor omnidirectional digital microphone
- Gesture, Proximity, Light Color, and Light Intensity Sensor (APDS9960): Advanced Gesture detection, Proximity detection, Digital Ambient Light Sense (ALS), and Color Sense (RGBC).
The Arduino Sense is an excellent, low-cost single-board microcontroller for learning about the collection and transmission of IoT sensor data.
IoT Gateway
An IoT Gateway, according to TechTarget, is a physical device or software program that serves as the connection point between the Cloud and controllers, sensors, and intelligent devices. All data moving to the Cloud, or vice versa goes through the gateway, which can be either a dedicated hardware appliance or software program.
I have used an a third-generation Raspberry Pi 3 Model B+ single-board computer (SBC), to serve as an IoT Gateway. This Raspberry Pi model features a 1.4GHz Cortex-A53 (ARMv8) 64-bit quad-core processor System on a Chip (SoC), 1GB LPDDR2 SDRAM, dual-band wireless LAN, Bluetooth 4.2 BLE, and Gigabit Ethernet (Amazon: USD 42.99).
To follow along with the post, you could substitute the Raspberry Pi for any Linux-based machine to run the included sample Python script.
LoRa Transceiver Modules
To transmit the IoT sensor data between the IoT device, containing the embedded sensors, and the IoT gateway, I have used the REYAX RYLR896 LoRa transceiver module (Amazon: USD 19.50 x 2). The transceiver modules are commonly referred to as a universal asynchronous receiver-transmitter (UART). A UART is a computer hardware device for asynchronous serial communication in which the data format and transmission speeds are configurable.
According to the manufacturer, REYAX, the RYLR896 contains the Semtech SX1276 long-range, low power transceiver. The RYLR896 module provides ultra-long range spread spectrum communication and high interference immunity while minimizing current consumption. This transceiver operates at both the 868 and 915 MHz frequency ranges. We will be transmitting at 915 MHz for North America, in this post. Each RYLR896 module contains a small, PCB integrated, helical antenna.
Security
The RYLR896 is capable of the AES 128-bit data encryption. Using the Advanced Encryption Standard (AES), we will encrypt the data sent from the IoT device to the IoT gateway, using a 32 hex digit password (128 bits / 4 bits/hex digit = 32 hex digits). Using hexadecimal notation, the password is limited to digits 0–9 and characters A–F.
USB to TTL Serial Converter Adapter
Optionally, to configure, test, and debug the RYLR896 LoRa transceiver module directly from your laptop, you can use a USB to TTL serial converter adapter. I currently use the IZOKEE FT232RL FTDI USB to TTL Serial Converter Adapter Module for 3.3V and 5V (Amazon: USD 9.49 for 2). The 3.3V RYLR896 module easily connects to the USB to TTL Serial Converter Adapter using the TXD/TX, RXD/RX, VDD/VCC, and GND pins. We use serial communication to send and receive data through TX (transmit) and RX (receive) pins. The wiring is shown below: VDD to VCC, GND to GND, TXD to RX, and RXD to TX.
The FT232RL has support for baud rates up to 115,200 bps, which is the speed we will use to communicate with the RYLR896 module.
Arduino Sketch
For those not familiar with Arduino, a sketch is the name that Arduino uses for a program. It is the unit of code that is uploaded into non-volatile flash memory and runs on an Arduino board. The Arduino language is a set of C and C++ functions. All standard C and C++ constructs supported by the avr-g++ compiler should work in Arduino.
For this post, the sketch, lora_iot_demo.ino, contains all the code necessary to collect and securely transmit the environmental sensor data, including temperature, relative humidity, barometric pressure, RGB color, and ambient light intensity, using the LoRaWAN protocol. All code for this post, including the sketch, can be found on GitHub.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* | |
| Description: Transmits Arduino Nano 33 BLE Sense sensor telemetry over LoRaWAN, | |
| including temperature, humidity, barometric pressure, and color, | |
| using REYAX RYLR896 transceiver modules | |
| http://reyax.com/wp-content/uploads/2020/01/Lora-AT-Command-RYLR40x_RYLR89x_EN.pdf | |
| Author: Gary Stafford | |
| */ | |
| #include <Arduino_HTS221.h> | |
| #include <Arduino_LPS22HB.h> | |
| #include <Arduino_APDS9960.h> | |
| const int UPDATE_FREQUENCY = 5000; // update frequency in ms | |
| const float CALIBRATION_FACTOR = –4.0; // temperature calibration factor (Celsius) | |
| const int ADDRESS = 116; | |
| const int NETWORK_ID = 6; | |
| const String PASSWORD = "92A0ECEC9000DA0DCF0CAAB0ABA2E0EF"; | |
| const String DELIMITER = "|"; | |
| void setup() | |
| { | |
| Serial.begin(9600); | |
| Serial1.begin(115200); // default baud rate of module is 115200 | |
| delay(1000); // wait for LoRa module to be ready | |
| // needs all need to be same for receiver and transmitter | |
| Serial1.print((String)"AT+ADDRESS=" + ADDRESS + "\r\n"); | |
| delay(200); | |
| Serial1.print((String)"AT+NETWORKID=" + NETWORK_ID + "\r\n"); | |
| delay(200); | |
| Serial1.print("AT+CPIN=" + PASSWORD + "\r\n"); | |
| delay(200); | |
| Serial1.print("AT+CPIN?\r\n"); // confirm password is set | |
| if (!HTS.begin()) | |
| { // initialize HTS221 sensor | |
| Serial.println("Failed to initialize humidity temperature sensor!"); | |
| while (1); | |
| } | |
| if (!BARO.begin()) | |
| { // initialize LPS22HB sensor | |
| Serial.println("Failed to initialize pressure sensor!"); | |
| while (1); | |
| } | |
| // avoid bad readings to start bug | |
| // https://forum.arduino.cc/index.php?topic=660360.0 | |
| BARO.readPressure(); | |
| delay(1000); | |
| if (!APDS.begin()) | |
| { // initialize APDS9960 sensor | |
| Serial.println("Failed to initialize color sensor!"); | |
| while (1); | |
| } | |
| } | |
| void loop() | |
| { | |
| updateReadings(); | |
| delay(UPDATE_FREQUENCY); | |
| } | |
| void updateReadings() | |
| { | |
| float temperature = getTemperature(CALIBRATION_FACTOR); | |
| float humidity = getHumidity(); | |
| float pressure = getPressure(); | |
| int colors[4]; | |
| getColor(colors); | |
| String payload = buildPayload(temperature, humidity, pressure, colors); | |
| // Serial.println("Payload: " + payload); // display the payload for debugging | |
| Serial1.print(payload); // send the payload over LoRaWAN WiFi | |
| displayResults(temperature, humidity, pressure, colors); // display the results for debugging | |
| } | |
| float getTemperature(float calibration) | |
| { | |
| return HTS.readTemperature() + calibration; | |
| } | |
| float getHumidity() | |
| { | |
| return HTS.readHumidity(); | |
| } | |
| float getPressure() | |
| { | |
| return BARO.readPressure(); | |
| } | |
| void getColor(int c[]) | |
| { | |
| // check if a color reading is available | |
| while (!APDS.colorAvailable()) | |
| { | |
| delay(5); | |
| } | |
| int r, g, b, a; | |
| APDS.readColor(r, g, b, a); | |
| c[0] = r; | |
| c[1] = g; | |
| c[2] = b; | |
| c[3] = a; | |
| } | |
| void displayResults(float t, float h, float p, int c[]) | |
| { | |
| Serial.print("Temperature: "); | |
| Serial.println(t); | |
| Serial.print("Humidity: "); | |
| Serial.println(h); | |
| Serial.print("Pressure: "); | |
| Serial.println(p); | |
| Serial.print("Color (r, g, b, a): "); | |
| Serial.print(c[0]); | |
| Serial.print(", "); | |
| Serial.print(c[1]); | |
| Serial.print(", "); | |
| Serial.print(c[2]); | |
| Serial.print(", "); | |
| Serial.println(c[3]); | |
| Serial.println("———-"); | |
| } | |
| String buildPayload(float t, float h, float p, int c[]) | |
| { | |
| String readings = ""; | |
| readings += t; | |
| readings += DELIMITER; | |
| readings += h; | |
| readings += DELIMITER; | |
| readings += p; | |
| readings += DELIMITER; | |
| readings += c[0]; | |
| readings += DELIMITER; | |
| readings += c[1]; | |
| readings += DELIMITER; | |
| readings += c[2]; | |
| readings += DELIMITER; | |
| readings += c[3]; | |
| String payload = ""; | |
| payload += "AT+SEND="; | |
| payload += ADDRESS; | |
| payload += ","; | |
| payload += readings.length(); | |
| payload += ","; | |
| payload += readings; | |
| payload += "\r\n"; | |
| return payload; | |
| } |
AT Commands
Communications with the RYLR896’s long-range modem is done using AT commands. AT commands are instructions used to control a modem. AT is the abbreviation of ATtention. Every command line starts with “AT”. That is why modem commands are called AT commands, according to Developer’s Home. A complete list of AT commands can be downloaded as a PDF from the RYLR896 product page.
To efficiently transmit the environmental sensor data from the IoT sensor to the IoT gateway, the sketch concatenates the sensor values together in a single string. The string will be incorporated into AT command to send the data to the RYLR896 LoRa transceiver module. To make it easier to parse the sensor data on the IoT gateway, we will delimit the sensor values with a pipe (|), as opposed to a comma. The maximum length of the payload (sensor data) is 240 bytes.
Below, we see an example of an AT command used to send the sensor data from the IoT sensor and the corresponding unencrypted data received by the IoT gateway. Both strings contain the LoRa transmitter Address ID, payload length, and the payload. The data received by the IoT gateway also contains the Received signal strength indicator (RSSI), and Signal-to-noise ratio (SNR).
Configure, Test, and Debug
As discussed earlier, to configure, test, and debug the RYLR896 LoRa transceiver modules without the use of the IoT gateway, you can use a USB to TTL serial converter adapter. The sketch is loaded on the Arduino Sense (the IoT device) and actively transmits data through one of the RYLR896 modules (shown below right). The other RYLR896 module is connected to your laptop’s USB port, via the USB to TTL serial converter adapter (shown below left). Using a terminal and the screen command, or the Arduino desktop application’s Serial Terminal, we can receive the sensor data from the Arduino Sense.
Using a terminal on your laptop, we first need to locate the correct virtual console (aka virtual terminal). On Linux or Mac, the virtual consoles are represented by device special files, such as /dev/tty1, /dev/tty2, and so forth. To find the virtual console for the USB to TTL serial converter adapter plugged into the laptop, use the following command.
ls -alh /dev/tty.*
We should see a virtual console with a name similar to /dev/tty.usbserial-.
... /dev/tty.Bluetooth-Incoming-Port ... /dev/tty.GarysBoseQC35II-SPPDev ... /dev/tty.a483e767cbac-Bluetooth- ... /dev/tty.usbserial-A50285BI
To connect to the RYLR896 module via the USB to TTL serial converter adapter, using the virtual terminal, we use the screen command and connect at a baud rate of 115,200 bps.
screen /dev/tty.usbserial-A50285BI 115200
If everything is configured and working correctly, we should see data being transmitted from the Arduino Sense and received by the local machine, at five second intervals. Each line of unencrypted data transmitted will look similar to the following, +RCV=116,25,22.18|41.57|99.74|2343|1190|543|4011,-34,47. In the example below, the AES 128-bit data encryption is not enabled on the Arduino, yet. With encryption turned on the sensor data (the payload) would appear garbled.
Even easier than the screen command, we can also use the Arduino desktop application’s Serial Terminal, as shown in the following short screen recording. Select the correct Port (virtual console) from the Tools menu and open the Serial Terminal. Since the transmitted data should be secured using AES 128-bit data encryption, we need to send an AT command (AT+CPIN) containing the transceiver module’s common password, to correctly decrypt the data on the receiving device (e.g., AT+CPIN=92A0ECEC9000DA0DCF0CAAB0ABA2E0EF).
Receiving Data on IoT Gateway
The Raspberry Pi will act as an IoT gateway, receiving the environmental sensor data from the IoT device, the Arduino. The Raspberry Pi will run a Python script, rasppi_lora_receiver.py, which will receive and decrypt the data payload, parse the sensor values, and display the values in the terminal. The script uses the pyserial, the Python Serial Port Extension. This Python module encapsulates the access for the serial port.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import logging | |
| import time | |
| from argparse import ArgumentParser | |
| from datetime import datetime | |
| import serial | |
| from colr import color as colr | |
| # LoRaWAN IoT Sensor Demo | |
| # Using REYAX RYLR896 transceiver modules | |
| # Author: Gary Stafford | |
| # Requirements: python3 -m pip install –user -r requirements.txt | |
| # To Run: python3 ./rasppi_lora_receiver.py –tty /dev/ttyAMA0 –baud-rate 115200 | |
| # constants | |
| ADDRESS = 116 | |
| NETWORK_ID = 6 | |
| PASSWORD = "92A0ECEC9000DA0DCF0CAAB0ABA2E0EF" | |
| def main(): | |
| logging.basicConfig(filename='output.log', filemode='w', level=logging.DEBUG) | |
| args = get_args() # get args | |
| payload = "" | |
| print("Connecting to REYAX RYLR896 transceiver module…") | |
| serial_conn = serial.Serial( | |
| port=args.tty, | |
| baudrate=int(args.baud_rate), | |
| timeout=5, | |
| parity=serial.PARITY_NONE, | |
| stopbits=serial.STOPBITS_ONE, | |
| bytesize=serial.EIGHTBITS | |
| ) | |
| if serial_conn.isOpen(): | |
| set_lora_config(serial_conn) | |
| check_lora_config(serial_conn) | |
| while True: | |
| serial_payload = serial_conn.readline() # read data from serial port | |
| if len(serial_payload) > 0: | |
| try: | |
| payload = serial_payload.decode(encoding="utf-8") | |
| except UnicodeDecodeError: # receiving corrupt data? | |
| logging.error("UnicodeDecodeError: {}".format(serial_payload)) | |
| payload = payload[:–2] | |
| try: | |
| data = parse_payload(payload) | |
| print("\n———-") | |
| print("Timestamp: {}".format(datetime.now())) | |
| print("Payload: {}".format(payload)) | |
| print("Sensor Data: {}".format(data)) | |
| display_temperature(data[0]) | |
| display_humidity(data[1]) | |
| display_pressure(data[2]) | |
| display_color(data[3], data[4], data[5], data[6]) | |
| except IndexError: | |
| logging.error("IndexError: {}".format(payload)) | |
| except ValueError: | |
| logging.error("ValueError: {}".format(payload)) | |
| # time.sleep(2) # transmission frequency set on IoT device | |
| def eight_bit_color(value): | |
| return int(round(value / (4097 / 255), 0)) | |
| def celsius_to_fahrenheit(value): | |
| return (value * 1.8) + 32 | |
| def display_color(r, g, b, a): | |
| print("12-bit Color values (r,g,b,a): {},{},{},{}".format(r, g, b, a)) | |
| r = eight_bit_color(r) | |
| g = eight_bit_color(g) | |
| b = eight_bit_color(b) | |
| a = eight_bit_color(a) # ambient light intensity | |
| print(" 8-bit Color values (r,g,b,a): {},{},{},{}".format(r, g, b, a)) | |
| print("RGB Color") | |
| print(colr("\t\t", fore=(127, 127, 127), back=(r, g, b))) | |
| print("Light Intensity") | |
| print(colr("\t\t", fore=(127, 127, 127), back=(a, a, a))) | |
| def display_pressure(value): | |
| print("Barometric Pressure: {} kPa".format(round(value, 2))) | |
| def display_humidity(value): | |
| print("Humidity: {}%".format(round(value, 2))) | |
| def display_temperature(value): | |
| temperature = celsius_to_fahrenheit(value) | |
| print("Temperature: {}°F".format(round(temperature, 2))) | |
| def get_args(): | |
| arg_parser = ArgumentParser(description="BLE IoT Sensor Demo") | |
| arg_parser.add_argument("–tty", required=True, help="serial tty", default="/dev/ttyAMA0") | |
| arg_parser.add_argument("–baud-rate", required=True, help="serial baud rate", default=1152000) | |
| args = arg_parser.parse_args() | |
| return args | |
| def parse_payload(payload): | |
| # input: +RCV=116,29,23.94|37.71|99.89|16|38|53|80,-61,56 | |
| # output: [23.94, 37.71, 99.89, 16.0, 38.0, 53.0, 80.0] | |
| payload = payload.split(",") | |
| payload = payload[2].split("|") | |
| payload = [float(i) for i in payload] | |
| return payload | |
| def set_lora_config(serial_conn): | |
| # configures the REYAX RYLR896 transceiver module | |
| serial_conn.write(str.encode("AT+ADDRESS=" + str(ADDRESS) + "\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("Address set?", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+NETWORKID=" + str(NETWORK_ID) + "\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("Network Id set?", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+CPIN=" + PASSWORD + "\r\n")) | |
| time.sleep(1) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("AES-128 password set?", serial_payload.decode(encoding="utf-8")) | |
| def check_lora_config(serial_conn): | |
| serial_conn.write(str.encode("AT?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("Module responding?", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+ADDRESS?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("Address:", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+NETWORKID?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("Network id:", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+IPR?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("UART baud rate:", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+BAND?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("RF frequency", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+CRFOP?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("RF output power", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+MODE?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("Work mode", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+PARAMETER?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("RF parameters", serial_payload.decode(encoding="utf-8")) | |
| serial_conn.write(str.encode("AT+CPIN?\r\n")) | |
| serial_payload = (serial_conn.readline())[:–2] | |
| print("AES128 password of the network", | |
| serial_payload.decode(encoding="utf-8")) | |
| if __name__ == "__main__": | |
| main() |
Prior to running the Python script, we can test and debug the connection from the Arduino Sense to the Raspberry Pi using a general application such as Minicom. Minicom is a text-based modem control and terminal emulator program. To install Minicom on the Raspberry Pi, use the following command.
sudo apt-get install minicom
To run Minicom or the Python script, we will need to know the virtual console of the serial connection (Serial1 in the script) used to communicate with the RYLR896 module, wired to the Raspberry Pi. This can found using the following command.
dmesg | grep -E --color 'serial|tty'
Search for a line, similar to the last line, shown below. Note the name of the virtual console, in my case, ttyAMA0.
[ 0.000000] Kernel command line: coherent_pool=1M bcm2708_fb.fbwidth=656 bcm2708_fb.fbheight=416 bcm2708_fb.fbswap=1 vc_mem.mem_base=0x1ec00000 vc_mem.mem_size=0x20000000 dwc_otg.lpm_enable=0 console=tty1 root=PARTUUID=509d1565-02 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait quiet splash plymouth.ignore-serial-consoles [ 0.000637] console [tty1] enabled [ 0.863147] uart-pl011 20201000.serial: cts_event_workaround enabled [ 0.863289] 20201000.serial: ttyAMA0 at MMIO 0x20201000 (irq = 81, base_baud = 0) is a PL011 rev2
To view the data received from the Arduino Sense, using Minicom, use the following command, substituting the virtual console value, found above.
minicom -b 115200 -o -D /dev/ttyAMA0
If successful, we should see output similar to the lower right terminal window. Data is being transmitted by the Arduino Sense and being received by the Raspberry Pi, via LoRaWAN. In the below example, the AES 128-bit data encryption is not enabled on the Arduino, yet. With encryption turned on the sensor data (the payload) would appear garbled.
IoT Gateway Python Script
To run the Python script on the Raspberry Pi, use the following command, substituting the name of the virtual console (e.g., /dev/ttyAMA0).
python3 ./rasppi_lora_receiver.py \ --tty /dev/ttyAMA0 --baud-rate 115200
The script starts by configuring the RYLR896 and outputting that configuration to the terminal. If successful, we should see the following informational output.
Connecting to REYAX RYLR896 transceiver module... Address set? +OK Network Id set? +OK AES-128 password set? +OK Module responding? +OK Address: +ADDRESS=116 Firmware version: +VER=RYLR89C_V1.2.7 Network Id: +NETWORKID=6 UART baud rate: +IPR=115200 RF frequency +BAND=915000000 RF output power +CRFOP=15 Work mode +MODE=0 RF parameters +PARAMETER=12,7,1,4 AES-128 password of the network +CPIN=92A0ECEC9000DA0DCF0CAAB0ABA2E0EF
Once configured, the script will receive the data from the Arduino Sense, decrypt the data, parse the sensor values, and format and display the values within the terminal.
The following screen recording shows a parallel view of both the Arduino Serial Monitor (upper right window) and the Raspberry Pi’s terminal output (lower right window). The Raspberry Pi (receiver) receives data from the Arduino (transmitter). The Raspberry Pi successfully reads, decrypts, interprets, and displays the sensor data, including displaying color swatches for the RGB and light intensity sensor readings.
Conclusion
In this post, we explored the use of the LoRa and LoRaWAN protocols to transmit environmental sensor data from an IoT device to an IoT gateway. Given its low energy consumption, long-distance transmission capabilities, and well-developed protocols, LoRaWAN is an ideal long-range wireless protocol for IoT devices.
This blog represents my own viewpoints and not of my employer, Amazon Web Services (AWS). All product names, logos, and brands are the property of their respective owners.
Programmatic Ponderings 
#1 by Ajay Patra on September 19, 2021 - 11:03 am
Can I use LoRa SX1278 model instead of RYLR896.
Link to the product – https://www.electronicscomp.com/ai-thinker-lora-ra-01-rf-transceiver-module
#2 by MrNams on September 20, 2021 - 12:29 pm
We can encrypt data, but I could not understand how to make receiver to listen to only particular sender,
I have two transmitter Lora Module transmits some data, consider these as T1 and T2, and one receiver Lora modules R1.
Here receiver module R1 receives data from both transmitter T1 and T2,
So how can we make R1 to receive data from only T1?
#3 by Amin Hamidi on October 28, 2021 - 1:56 pm
Hi Gary,
Thank you for this article I found it very helpful. However, when trying to use the RPi-4 as a gateway I noticed that I may need a LoRa hat for it but I couldn’t find what you used in this tutorial. I would really appreciate it if you can get back to me with what you used.
Thanks,