Implement gpiod event for TX and RX interrupt

Author: chandrawi

LoRaRF/SX126x.py

@@ -1,6 +1,7 @@
 from .base import LoRaSpi, LoRaGpio, BaseLoRa
 from typing import Optional
 import time
+from threading import Thread
 
 class SX126x(BaseLoRa) :
     """Class for SX1261/62/68 and LLCC68 LoRa chipsets from Semtech"""
@@ -639,7 +640,12 @@ def endPacket(self, timeout: int = TX_SINGLE) -> bool :
         self._transmitTime = time.time()
 
         # set operation status to wait and attach TX interrupt handler
-
+        if self._irq != None :
+            if isinstance(self._monitoring, Thread):
+                self._monitoring.join()
+            to = self._irqTimeout/1000 if timeout == self.TX_SINGLE else timeout/1000
+            self._monitoring = Thread(target=self._irq.monitor, args=(self._interruptTx, to))
+            self._monitoring.start()
         return True
 
     def write(self, data, length: int = 0) :
@@ -700,7 +706,16 @@ def request(self, timeout: int = RX_SINGLE) -> bool :
         self.setRx(rxTimeout)
 
         # set operation status to wait and attach RX interrupt handler
-
+        if self._irq != None :
+            if isinstance(self._monitoring, Thread):
+                self._monitoring.join()
+            to = self._irqTimeout/1000 if timeout == self.RX_SINGLE else timeout/1000
+            if timeout == self.RX_CONTINUOUS:
+                self._monitoring = Thread(target=self._irq.monitor_continuous, args=(self._interruptRxContinuous, to))
+                self._monitoring.setDaemon(True)
+            else:
+                self._monitoring = Thread(target=self._irq.monitor, args=(self._interruptRx, to))
+            self._monitoring.start()
         return True
 
     def listen(self, rxPeriod: int, sleepPeriod: int) -> bool :
@@ -731,7 +746,12 @@ def listen(self, rxPeriod: int, sleepPeriod: int) -> bool :
         self.setRxDutyCycle(rxPeriod, sleepPeriod)
 
         # set operation status to wait and attach RX interrupt handler
-
+        if self._irq != None :
+            if isinstance(self._monitoring, Thread):
+                self._monitoring.join()
+            to = self._irqTimeout/1000 if rxPeriod == self.RX_SINGLE else rxPeriod/1000
+            self._monitoring = Thread(target=self._irq.monitor, args=(self._interruptRx, to))
+            self._monitoring.start()
         return True
 
     def available(self) -> int :

LoRaRF/SX127x.py

@@ -1,6 +1,7 @@
 from .base import LoRaSpi, LoRaGpio, BaseLoRa
 from typing import Optional
 import time
+from threading import Thread
 
 class SX127x(BaseLoRa) :
     """Class for SX1276/77/78/79 LoRa chipsets from Semtech"""
@@ -468,7 +469,13 @@ def endPacket(self, timeout: int = 0) -> bool :
         self._transmitTime = time.time()
 
         # set TX done interrupt on DIO0 and attach TX interrupt handler
-
+        if self._irq != None :
+            self.writeRegister(self.REG_DIO_MAPPING_1, self.DIO0_TX_DONE)
+            if isinstance(self._monitoring, Thread):
+                self._monitoring.join()
+            to = self._irqTimeout/1000 if timeout == 0 else timeout/1000
+            self._monitoring = Thread(target=self._irq.monitor, args=(self._interruptTx, to))
+            self._monitoring.start()
         return True
 
     def write(self, data, length: int = 0) :
@@ -539,7 +546,17 @@ def request(self, timeout: int = 0) -> bool :
         self.writeRegister(self.REG_OP_MODE, self._modem | rxMode)
 
         # set RX done interrupt on DIO0 and attach RX interrupt handler
-
+        if self._irq != None :
+            self.writeRegister(self.REG_DIO_MAPPING_1, self.DIO0_RX_DONE)
+            if isinstance(self._monitoring, Thread):
+                self._monitoring.join()
+            to = self._irqTimeout/1000 if timeout == 0 else timeout/1000
+            if timeout == self.RX_CONTINUOUS:
+                self._monitoring = Thread(target=self._irq.monitor_continuous, args=(self._interruptRxContinuous, to))
+                self._monitoring.setDaemon(True)
+            else:
+                self._monitoring = Thread(target=self._irq.monitor, args=(self._interruptRx, to))
+            self._monitoring.start()
         return True
 
     def available(self) :
@@ -779,14 +796,16 @@ def writeRegister(self, address: int, data: int) :
 
         self._transfer(address | 0x80, data)
 
-    def readRegister(self, address: int) ->int:
+    def readRegister(self, address: int) -> int :
 
         return self._transfer(address & 0x7F, 0x00)
 
-    def _transfer(self, address: int, data: int) ->int:
+    def _transfer(self, address: int, data: int) -> int :
 
         buf = [address, data]
-        feedback = self._spi.xfer2(buf)
+        self._cs.output(LoRaGpio.LOW)
+        feedback = self._spi.transfer(buf)
+        self._cs.output(LoRaGpio.HIGH)
         if (len(feedback) == 2) :
             return int(feedback[1])
         return -1

LoRaRF/base.py

@@ -55,6 +55,33 @@ def input(self) -> int:
             chip.close()
         return value
 
+    def monitor(self, callback, timeout: float):
+        seconds = int(timeout)
+        chip = gpiod.Chip(self.chip)
+        line = chip.get_line(self.offset)
+        try:
+            line.request(consumer="LoRaGpio", type=gpiod.LINE_REQ_EV_RISING_EDGE)
+            if line.event_wait(seconds, int((timeout - seconds) * 1000000000)):
+                callback()
+        except: return
+        finally:
+            line.release()
+            chip.close()
+
+    def monitor_continuous(self, callback, timeout: float):
+        seconds = int(timeout)
+        while True:
+            chip = gpiod.Chip(self.chip)
+            line = chip.get_line(self.offset)
+            try:
+                line.request(consumer="LoRaGpio", type=gpiod.LINE_REQ_EV_RISING_EDGE)
+                if line.event_wait(seconds, int((timeout - seconds) * 1000000000)):
+                    callback()
+            except: continue
+            finally:
+                line.release()
+                chip.close()
+
 
 class BaseLoRa :