fix frequency setter - add timeout to send - set default baudrate to 5MH

Author: jerryneedell

README.rst

@@ -39,8 +39,19 @@ This is easily achieved by downloading
 
 Usage Example
 =============
-
 See examples/rfm69_simpletest.py for a simple demo of the usage.
+Note: the default baudrate for the SPI is 50000000 (5MHz). 
+The maximum setting is 10Mhz but 
+transmission errors have been observed expecially when using breakout boards.
+For breakout boards or other configurations where the boards are separated,
+it may be necessary to reduce the baudrate for reliable data transmission.
+The baud rate may be specified as an keyword parameter when initializing the board.
+To set it to 1000000 use :
+.. code-block:: python# Initialze RFM radio
+.. code-block:: python
+    # Initialze RFM radio
+     rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ,baudrate=1000000)
+
 
 Contributing
 ============
@@ -94,4 +105,4 @@ Now, once you have the virtual environment activated:
 
 This will output the documentation to ``docs/_build/html``. Open the index.html in your browser to
 view them. It will also (due to -W) error out on any warning like Travis will. This is a good way to
-locally verify it will pass.
+locally verify it will pass.

adafruit_rfm69.py

@@ -289,7 +289,7 @@ def __set__(self, obj, val):
     payload_ready = _RegisterBits(_REG_IRQ_FLAGS2, offset=2)
 
     def __init__(self, spi, cs, reset, frequency, *, sync_word=b'\x2D\xD4',
-                 preamble_length=4, encryption_key=None, high_power=True, baudrate=10000000):
+                 preamble_length=4, encryption_key=None, high_power=True, baudrate=5000000):
         self._tx_power = 13
         self.high_power = high_power
         # Device support SPI mode 0 (polarity & phase = 0) up to a max of 10mhz.
@@ -673,10 +673,12 @@ def frequency_deviation(self, val):
         self._write_u8(_REG_FDEV_MSB, fdev >> 8)
         self._write_u8(_REG_FDEV_LSB, fdev & 0xFF)
 
-    def send(self, data):
-        """Send a string of data using the transmitter.  You can only send 60 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.
+    def send(self, data, timeout=2.):
+        """Send a string of data using the transmitter.
+           You can only send 60 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.
+           The timeout is just to prevent a hang (arbitrarily set to 2 seconds)
         """
         # Disable pylint warning to not use length as a check for zero.
         # This is a puzzling warning as the below code is clearly the most
@@ -707,10 +709,17 @@ def send(self, data):
         # best that can be done right now without interrupts).
         while not self.packet_sent:
             pass
+        start = time.monotonic()
+        timed_out = False
+        while not timed_out and not self.packet_sent:
+            if (time.monotonic() - start) >= timeout:
+                timed_out = True
         # Go back to idle mode after transmit.
         self.idle()
+        if timed_out:
+            raise RuntimeError('Timeout during packet send')
 
-    def receive(self, timeout_s=0.5, keep_listening=True):
+    def receive(self, timeout=0.5, keep_listening=True):
         """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
@@ -726,37 +735,39 @@ 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.payload_ready:
-            if (time.monotonic() - start) >= timeout_s:
-                return None  # Exceeded timeout.
+        timed_out = False
+        while not timed_out and not self.payload_ready:
+            if (time.monotonic() - start) >= timeout:
+                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()
-        # Read the data from the FIFO.
-        with self._device as device:
-            self._BUFFER[0] = _REG_FIFO & 0x7F  # Strip out top bit to set 0
-                                                # value (read).
-            device.write(self._BUFFER, end=1)
-            # Read the length of the FIFO.
-            device.readinto(self._BUFFER, end=1)
-            fifo_length = self._BUFFER[0]
-            # Handle if the received packet is too small to include the 4 byte
-            # RadioHead header--reject this packet and ignore it.
-            if fifo_length < 4:
-                # Invalid packet, ignore it.  However finish reading the FIFO
-                # to clear the packet.
-                device.readinto(self._BUFFER, end=fifo_length)
-                packet = None
-            else:
-                # Read the 4 bytes of the RadioHead header.
-                device.readinto(self._BUFFER, end=4)
-                # Ignore validating any of the header bytes.
-                # Now read the remaining packet payload as the result.
-                fifo_length -= 4
-                packet = bytearray(fifo_length)
-                device.readinto(packet)
-        # Listen again if necessary and return the result packet.
-        if keep_listening:
-            self.listen()
+        if not timed_out:
+            # Read the data from the FIFO.
+            with self._device as device:
+                self._BUFFER[0] = _REG_FIFO & 0x7F  # Strip out top bit to set 0
+                                                    # value (read).
+                device.write(self._BUFFER, end=1)
+                # Read the length of the FIFO.
+                device.readinto(self._BUFFER, end=1)
+                fifo_length = self._BUFFER[0]
+                # Handle if the received packet is too small to include the 4 byte
+                # RadioHead header--reject this packet and ignore it.
+                if fifo_length < 4:
+                    # Invalid packet, ignore it.  However finish reading the FIFO
+                    # to clear the packet.
+                    device.readinto(self._BUFFER, end=fifo_length)
+                    packet = None
+                else:
+                    # Read the 4 bytes of the RadioHead header.
+                    device.readinto(self._BUFFER, end=4)
+                    # Ignore validating any of the header bytes.
+                    # Now read the remaining packet payload as the result.
+                    fifo_length -= 4
+                    packet = bytearray(fifo_length)
+                    device.readinto(packet)
+            # Listen again if necessary and return the result packet.
+            if keep_listening:
+                self.listen()
         return packet

examples/rfm69_simpletest.py

@@ -51,7 +51,7 @@
 while True:
     packet = rfm69.receive()
     # Optionally change the receive timeout from its default of 0.5 seconds:
-    #packet = rfm69.receive(timeout_s=5.0)
+    #packet = rfm69.receive(timeout=5.0)
     # If no packet was received during the timeout then None is returned.
     if packet is None:
         print('Received nothing! Listening again...')