trying to fing hang cause

Author: jerryneedell

adafruit_rfm9x.py

@@ -532,7 +532,7 @@ def rssi(self):
         # Remember in LoRa mode the payload register changes function to RSSI!
         return self._read_u8(_RH_RF95_REG_1A_PKT_RSSI_VALUE) - 137
 
-    def send(self, data):
+    def send(self, data, timeout_s = 1.):
         """Send a string of data using the transmitter.  You can only send 252
         bytes at a time (limited by chip's FIFO size and appended headers). Note
         this appends a 4 byte header to be compatible with the RadioHead library.
@@ -560,12 +560,15 @@ def send(self, data):
         self.transmit()
         # Wait for tx done interrupt with explicit polling (not ideal but
         # best that can be done right now without interrupts).
-        while not self.tx_done:
-            pass
-        # Clear interrupts.
-        self._write_u8(_RH_RF95_REG_12_IRQ_FLAGS, 0xFF)
+        start = time.monotonic()
+        timed_out = False
+        while not timed_out and not self.tx_done:
+            if (time.monotonic() - start) >= timeout_s:
+                timed_out = True
         # Go back to idle mode after transmit.
         self.idle()
+        # Clear interrupts.
+        self._write_u8(_RH_RF95_REG_12_IRQ_FLAGS, 0xFF)
 
     def receive(self, timeout_s=0.5, keep_listening=True):
         """Wait to receive a packet from the receiver. Will wait for up to
@@ -585,32 +588,35 @@ def receive(self, timeout_s=0.5, keep_listening=True):
         # enough, however it's the best that can be done from Python without
         # interrupt supports.
         start = time.monotonic()
-        while not self.rx_done:
+        timed_out = False
+        while not timed_out and not self.rx_done:
             if (time.monotonic() - start) >= timeout_s:
-                return None  # Exceeded timeout.
-        # Clear interrupt.
-        self._write_u8(_RH_RF95_REG_12_IRQ_FLAGS, 0xFF)
+                timed_out = True
         # Payload ready is set, a packet is in the FIFO.
         packet = None
-        # Enter idle mode to stop receiving other packets.
-        self.idle()
-        # Grab the length of the received packet and check it has at least 5
-        # bytes to indicate the 4 byte header and at least 1 byte of user data.
-        length = self._read_u8(_RH_RF95_REG_13_RX_NB_BYTES)
-        if length < 5:
-            packet = None
-        else:
-            # Have a good packet, grab it from the FIFO.
-            # Reset the fifo read ptr to the beginning of the packet.
-            current_addr = self._read_u8(_RH_RF95_REG_10_FIFO_RX_CURRENT_ADDR)
-            self._write_u8(_RH_RF95_REG_0D_FIFO_ADDR_PTR, current_addr)
-            # Read the first 4 bytes to grab the header.
-            self._read_into(_RH_RF95_REG_00_FIFO, self._BUFFER, length=4)
-            length -= 4
-            # Next read the remaining data into a result packet buffer.
-            packet = bytearray(length)
-            self._read_into(_RH_RF95_REG_00_FIFO, packet)
-        # Listen again if necessary and return the result packet.
+        if not timed_out:
+            # Grab the length of the received packet and check it has at least 5
+            # bytes to indicate the 4 byte header and at least 1 byte of user data.
+            length = self._read_u8(_RH_RF95_REG_13_RX_NB_BYTES)
+            if length < 5:
+                packet = None
+            else:
+                # Have a good packet, grab it from the FIFO.
+                # Reset the fifo read ptr to the beginning of the packet.
+                current_addr = self._read_u8(_RH_RF95_REG_10_FIFO_RX_CURRENT_ADDR)
+                self._write_u8(_RH_RF95_REG_0D_FIFO_ADDR_PTR, current_addr)
+                # Read the first 4 bytes to grab the header.
+                self._read_into(_RH_RF95_REG_00_FIFO, self._BUFFER, length=4)
+                length -= 4
+                # Next read the remaining data into a result packet buffer.
+                packet = bytearray(length)
+                self._read_into(_RH_RF95_REG_00_FIFO, packet)
+            # 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)
         return packet