Implement "reliable Datagram mode"

examples/rfm9x_header.py

@@ -0,0 +1,36 @@
+# Example to display raw packets including header
+# Author: Jerry Needell
+#
+import board
+import busio
+import digitalio
+import adafruit_rfm9x
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 915.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip.
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D25)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+
+# Initialze RFM radio
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+
+# Wait to receive packets.
+print("Waiting for packets...")
+# initialize flag and timer
+while True:
+    # Look for a new packet: only accept if addresses to my_node
+    packet = rfm9x.receive(with_header=True)
+    # If no packet was received during the timeout then None is returned.
+    if packet is not None:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw header):", [hex(x) for x in packet[0:4]])
+        print("Received (raw payload): {0}".format(packet[4:]))
+        print("RSSI: {0}".format(rfm9x.last_rssi))
+        # send reading after any packet received

examples/rfm9x_node1.py

@@ -0,0 +1,62 @@
+# Example to send a packet periodically between addressed nodes
+# Author: Jerry Needell
+#
+import time
+import board
+import busio
+import digitalio
+import adafruit_rfm9x
+
+
+# set the time interval (seconds) for sending packets
+transmit_interval = 10
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 915.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip.
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D25)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+# Initialze RFM radio
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+
+# enable CRC checking
+rfm9x.enable_crc = True
+# set node addresses
+rfm9x.node = 1
+rfm9x.destination = 2
+# initialize counter
+counter = 0
+# send a broadcast message from my_node with ID = counter
+rfm9x.send(
+    bytes("Startup message {} from node {}".format(counter, rfm9x.node), "UTF-8")
+)
+
+# Wait to receive packets.
+print("Waiting for packets...")
+now = time.monotonic()
+while True:
+    # Look for a new packet: only accept if addresses to my_node
+    packet = rfm9x.receive(with_header=True)
+    # If no packet was received during the timeout then None is returned.
+    if packet is not None:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw header):", [hex(x) for x in packet[0:4]])
+        print("Received (raw payload): {0}".format(packet[4:]))
+        print("Received RSSI: {0}".format(rfm9x.last_rssi))
+    if time.monotonic() - now > transmit_interval:
+        now = time.monotonic()
+        counter = counter + 1
+        # send a  mesage to destination_node from my_node
+        rfm9x.send(
+            bytes(
+                "message number {} from node {}".format(counter, rfm9x.node), "UTF-8"
+            ),
+            keep_listening=True,
+        )
+        button_pressed = None

examples/rfm9x_node1_ack.py

@@ -0,0 +1,64 @@
+# Example to send a packet periodically between addressed nodes with ACK
+# Author: Jerry Needell
+#
+import time
+import board
+import busio
+import digitalio
+import adafruit_rfm9x
+
+# set the time interval (seconds) for sending packets
+transmit_interval = 10
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 915.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip.
+# set GPIO pins as necessary -- this example is for Raspberry Pi
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D25)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+# Initialze RFM radio
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+
+# enable CRC checking
+rfm9x.enable_crc = True
+# set delay before sending ACK
+rfm9x.ack_delay = 0.1
+# set node addresses
+rfm9x.node = 1
+rfm9x.destination = 2
+# initialize counter
+counter = 0
+ack_failed_counter = 0
+# send startup message from my_node
+rfm9x.send_with_ack(bytes("startup message from node {}".format(rfm9x.node), "UTF-8"))
+
+# Wait to receive packets.
+print("Waiting for packets...")
+# initialize flag and timer
+time_now = time.monotonic()
+while True:
+    # Look for a new packet: only accept if addresses to my_node
+    packet = rfm9x.receive(with_ack=True, with_header=True)
+    # If no packet was received during the timeout then None is returned.
+    if packet is not None:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw header):", [hex(x) for x in packet[0:4]])
+        print("Received (raw payload): {0}".format(packet[4:]))
+        print("RSSI: {0}".format(rfm9x.last_rssi))
+        # send reading after any packet received
+    if time.monotonic() - time_now > transmit_interval:
+        # reset timeer
+        time_now = time.monotonic()
+        counter += 1
+        # send a  mesage to destination_node from my_node
+        if not rfm9x.send_with_ack(
+            bytes("message from node node {} {}".format(rfm9x.node, counter), "UTF-8")
+        ):
+            ack_failed_counter += 1
+            print(" No Ack: ", counter, ack_failed_counter)

examples/rfm9x_node1_bonnet.py

@@ -0,0 +1,124 @@
+# Example to send a packet periodically between addressed nodes
+# Author: Jerry Needell
+#
+import board
+import busio
+import digitalio
+
+# Import the SSD1306 module.
+import adafruit_ssd1306
+import adafruit_rfm9x
+
+# Button A
+btnA = digitalio.DigitalInOut(board.D5)
+btnA.direction = digitalio.Direction.INPUT
+btnA.pull = digitalio.Pull.UP
+
+# Button B
+btnB = digitalio.DigitalInOut(board.D6)
+btnB.direction = digitalio.Direction.INPUT
+btnB.pull = digitalio.Pull.UP
+
+# Button C
+btnC = digitalio.DigitalInOut(board.D12)
+btnC.direction = digitalio.Direction.INPUT
+btnC.pull = digitalio.Pull.UP
+
+# Create the I2C interface.
+i2c = busio.I2C(board.SCL, board.SDA)
+
+# 128x32 OLED Display
+reset_pin = digitalio.DigitalInOut(board.D4)
+display = adafruit_ssd1306.SSD1306_I2C(128, 32, i2c, reset=reset_pin)
+# Clear the display.
+display.fill(0)
+display.show()
+width = display.width
+height = display.height
+
+
+# set the time interval (seconds) for sending packets
+transmit_interval = 10
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 915.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip.
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D25)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+
+# Initialze RFM radio
+
+# Attempt to set up the rfm9x Module
+try:
+    rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+    display.text("rfm9x: Detected", 0, 0, 1)
+except RuntimeError:
+    # Thrown on version mismatch
+    display.text("rfm9x: ERROR", 0, 0, 1)
+
+display.show()
+
+# enable CRC checking
+rfm9x.enable_crc = True
+
+# set node addresses
+rfm9x.node = 1
+rfm9x.destination = 2
+# initialize counter
+counter = 0
+# send a broadcast message from my_node with ID = counter
+rfm9x.send(
+    bytes("Startup message {} from node {}".format(counter, rfm9x.node), "UTF-8")
+)
+
+# Wait to receive packets.
+print("Waiting for packets...")
+button_pressed = None
+while True:
+    # Look for a new packet: only accept if addresses to my_node
+    packet = rfm9x.receive(with_header=True)
+    # If no packet was received during the timeout then None is returned.
+    if packet is not None:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw header):", [hex(x) for x in packet[0:4]])
+        print("Received (raw payload): {0}".format(packet[4:]))
+        print("Received RSSI: {0}".format(rfm9x.last_rssi))
+    # Check buttons
+    if not btnA.value:
+        button_pressed = "A"
+        # Button A Pressed
+        display.fill(0)
+        display.text("AAA", width - 85, height - 7, 1)
+        display.show()
+    if not btnB.value:
+        button_pressed = "B"
+        # Button B Pressed
+        display.fill(0)
+        display.text("BBB", width - 75, height - 7, 1)
+        display.show()
+    if not btnC.value:
+        button_pressed = "C"
+        # Button C Pressed
+        display.fill(0)
+        display.text("CCC", width - 65, height - 7, 1)
+        display.show()
+        # send reading after any button pressed
+    if button_pressed is not None:
+        counter = counter + 1
+        # send a  mesage to destination_node from my_node
+        rfm9x.send(
+            bytes(
+                "message number {} from node {} button {}".format(
+                    counter, rfm9x.node, button_pressed
+                ),
+                "UTF-8",
+            ),
+            keep_listening=True,
+        )
+        button_pressed = None

examples/rfm9x_node2.py

@@ -0,0 +1,60 @@
+# Example to send a packet periodically between addressed nodes
+# Author: Jerry Needell
+#
+import time
+import board
+import busio
+import digitalio
+import adafruit_rfm9x
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 915.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip.
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D25)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+
+# Initialze RFM radio
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+
+# enable CRC checking
+rfm9x.enable_crc = True
+# set node addresses
+rfm9x.node = 2
+rfm9x.destination = 1
+# initialize counter
+counter = 0
+# send a broadcast message from my_node with ID = counter
+rfm9x.send(bytes("startup message from node {} ".format(rfm9x.node), "UTF-8"))
+
+# Wait to receive packets.
+print("Waiting for packets...")
+# initialize flag and timer
+time_now = time.monotonic()
+while True:
+    # Look for a new packet: only accept if addresses to my_node
+    packet = rfm9x.receive(with_header=True)
+    # If no packet was received during the timeout then None is returned.
+    if packet is not None:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw header):", [hex(x) for x in packet[0:4]])
+        print("Received (raw payload): {0}".format(packet[4:]))
+        print("Received RSSI: {0}".format(rfm9x.last_rssi))
+        # send reading after any packet received
+        counter = counter + 1
+        # after 10 messages send a response to destination_node from my_node with ID = counter&0xff
+        if counter % 10 == 0:
+            time.sleep(0.5)  # brief delay before responding
+            rfm9x.identifier = counter & 0xFF
+            rfm9x.send(
+                bytes(
+                    "message number {} from node {} ".format(counter, rfm9x.node),
+                    "UTF-8",
+                ),
+                keep_listening=True,
+            )