enable interrupt handling for received packets - add transmit example

Author: jerryneedell

.pylintrc

@@ -156,7 +156,7 @@ ignored-classes=optparse.Values,thread._local,_thread._local
 # (useful for modules/projects where namespaces are manipulated during runtime
 # and thus existing member attributes cannot be deduced by static analysis. It
 # supports qualified module names, as well as Unix pattern matching.
-ignored-modules=board
+ignored-modules=board,RPi.GPIO
 
 # Show a hint with possible names when a member name was not found. The aspect
 # of finding the hint is based on edit distance.

adafruit_rfm9x.py

@@ -646,7 +646,7 @@ def enable_crc(self, val):
                 self._read_u8(_RH_RF95_REG_1E_MODEM_CONFIG2) & 0xfb
             )
 
-    def send(self, data, timeout=2.,
+    def send(self, data, timeout=2., keep_listening=False,
              tx_header=(_RH_BROADCAST_ADDRESS, _RH_BROADCAST_ADDRESS, 0, 0)):
         """Send a string of data using the transmitter.
            You can only send 252 bytes at a time
@@ -685,9 +685,13 @@ def send(self, data, timeout=2.,
         while not timed_out and not self.tx_done:
             if (time.monotonic() - start) >= timeout:
                 timed_out = True
-        # Go back to idle mode after transmit.
-        self.idle()
-        # Clear interrupts.
+        # Listen again if necessary and return the result packet.
+        if keep_listening:
+            self.listen()
+        else:
+        # Enter idle mode to stop receiving other packets.
+            self.idle()
+        # Clear interrupt.
         self._write_u8(_RH_RF95_REG_12_IRQ_FLAGS, 0xFF)
         if timed_out:
             raise RuntimeError('Timeout during packet send')
@@ -699,7 +703,7 @@ def receive(self, timeout=0.5, keep_listening=True, with_header=False,
         """Wait to receive a packet from the receiver. Will wait for up to timeout_s amount of
            seconds for a packet to be received and decoded. If a packet is found the payload bytes
            are returned, otherwise None is returned (which indicates the timeout elapsed with no
-           reception).
+           reception).  If timeout is None it isnot used ( for use with interrupts)
            If keep_listening is True (the default) the chip will immediately enter listening mode
            after reception of a packet, otherwise it will fall back to idle mode and ignore any
            future reception.
@@ -716,17 +720,18 @@ def receive(self, timeout=0.5, keep_listening=True, with_header=False,
            If rx_filter is not 0xff and packet[0] does not match rx_filter then
            the packet is ignored and None is returned.
         """
-        # Make sure we are listening for packets.
-        self.listen()
-        # Wait for the rx done interrupt.  This is not ideal and will
-        # surely miss or overflow the FIFO when packets aren't read fast
-        # enough, however it's the best that can be done from Python without
-        # interrupt supports.
-        start = time.monotonic()
         timed_out = False
-        while not timed_out and not self.rx_done:
-            if (time.monotonic() - start) >= timeout:
-                timed_out = True
+        if timeout is not None:
+            # Make sure we are listening for packets.
+            self.listen()
+            # Wait for the rx done interrupt.  This is not ideal and will
+            # surely miss or overflow the FIFO when packets aren't read fast
+            # enough, however it's the best that can be done from Python without
+            # interrupt supports.
+            start = time.monotonic()
+            while not timed_out and not self.rx_done:
+                if (time.monotonic() - start) >= timeout:
+                    timed_out = True
         # Payload ready is set, a packet is in the FIFO.
         packet = None
         if not timed_out:

examples/rfm9x_rpi_interrupt.py

@@ -0,0 +1,73 @@
+# Simple demo of sending and recieving data with the RFM95 LoRa radio.
+# Author: Tony DiCola
+import time
+import board
+import busio
+import digitalio
+import RPi.GPIO as io
+import adafruit_rfm9x
+
+
+# setup interrupt callback function
+def rfm9x_callback(rfm9x_irq):
+    global packet_received  #pylint: disable=global-statement
+    print("IRQ detected ",rfm9x_irq, rfm9x.rx_done)
+    # check to see if this was a rx interrupt - ignore tx
+    if rfm9x.rx_done:
+        packet = rfm9x.receive(timeout = None)
+        if packet is not None:
+            packet_received = True
+            # Received a packet!
+            # Print out the raw bytes of the packet:
+            print('Received (raw bytes): {0}'.format(packet))
+            print([hex(x) for x in packet])
+            print('RSSI: {0}'.format(rfm9x.rssi))
+
+
+# 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, use these if wiring up the breakout according to the guide:
+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)
+
+# Note that the radio is configured in LoRa mode so you can't control sync
+# word, encryption, frequency deviation, or other settings!
+
+# You can however adjust the transmit power (in dB).  The default is 13 dB but
+# high power radios like the RFM95 can go up to 23 dB:
+rfm9x.tx_power = 23
+
+# configure the interrupt pin and event handling.
+RFM9X_G0 = 22
+io.setmode(io.BCM)
+io.setup(RFM9X_G0, io.IN,pull_up_down=io.PUD_DOWN)         # activate input
+io.add_event_detect(RFM9X_G0,io.RISING)
+io.add_event_callback(RFM9X_G0,rfm9x_callback)
+
+packet_received = False
+# Send a packet.  Note you can only send a packet up to 252 bytes in length.
+# This is a limitation of the radio packet size, so if you need to send larger
+# amounts of data you will need to break it into smaller send calls.  Each send
+# call will wait for the previous one to finish before continuing.
+rfm9x.send(bytes("Hello world!\r\n","utf-8"), keep_listening = True)
+print('Sent Hello World message!')
+
+# Wait to receive packets.  Note that this library can't receive data at a fast
+# rate, in fact it can only receive and process one 252 byte packet at a time.
+# This means you should only use this for low bandwidth scenarios, like sending
+# and receiving a single message at a time.
+print('Waiting for packets...')
+while True:
+    time.sleep(.1)
+    if packet_received:
+        rfm9x.send(bytes("back at you\r\n","utf-8"), keep_listening = True)
+        print('received message!')
+        packet_received = False

examples/rfm9x_transmit.py

@@ -0,0 +1,59 @@
+# Example to send a packet periodically
+# Author: Jerry Needell
+#
+import time
+import board
+import busio
+import digitalio
+import adafruit_rfm9x
+
+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)
+
+# Note that the radio is configured in LoRa mode so you can't control sync
+# word, encryption, frequency deviation, or other settings!
+
+# You can however adjust the transmit power (in dB).  The default is 13 dB but
+# high power radios like the RFM95 can go up to 23 dB:
+rfm9x.tx_power = 23
+
+
+# initialize counter
+counter = 0
+#send a broadcast mesage
+rfm9x.send(bytes("message number {}".format(counter),"UTF-8"))
+
+# Wait to receive packets.
+print('Waiting for packets...')
+#initialize flag and timer
+send_reading=False
+time_now=time.monotonic()
+while True:
+    # Look for a new packet - wait up to 5 seconds:
+    packet = rfm9x.receive(timeout=5.0)
+    # 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 bytes): {0}'.format(packet))
+        # send reading after any packet received
+    if time.monotonic()-time_now>transmit_interval:
+        #reset timeer
+        time_now=time.monotonic()
+        #clear flag to send data
+        send_reading=False
+        counter = counter + 1
+        rfm9x.send(bytes("message number {}".format(counter),"UTF-8"))