Thread safe pipe for connectivity periperhal IO

Author: cla7aye15I4nd

qiling/hw/char/stm32f4xx_usart.py

@@ -6,9 +6,10 @@
 import ctypes
 
 from qiling.hw.peripheral import QlPeripheral
+from qiling.hw.connectivity import QlConnectivityPeripheral
 from qiling.hw.const.stm32f4xx_usart import USART_SR, USART_CR1
 
-class STM32F4xxUsart(QlPeripheral):
+class STM32F4xxUsart(QlConnectivityPeripheral):
     class Type(ctypes.Structure):
         """ the structure available in :
 			stm32f413xx.h
@@ -56,9 +57,6 @@ def __init__(self, ql, label, intn=None):
 
         self.intn = intn
 
-        self.recv_buf = bytearray()
-        self.send_buf = bytearray()
-
     @QlPeripheral.debug_info()
     def read(self, offset: int, size: int) -> int:
         buf = ctypes.create_string_buffer(size)
@@ -92,32 +90,13 @@ def transfer(self):
             data = self.usart.DR
 
             self.usart.SR |= USART_SR.TXE            
-            self.send_buf.append(data)
+            self.send_to_user(data)
 
         if not (self.usart.SR & USART_SR.RXNE): 
             # TXE bit must had been cleared
-            if self.recv_buf:
+            if self.can_recv():
                 self.usart.SR |= USART_SR.RXNE
-                self.usart.DR = self.recv_buf.pop(0)        
-        
-
-    def send(self, data: bytes):
-        """ send user data into USART.
-
-        Args:
-            data (bytes): Input Data
-        """        
-        self.recv_buf += data
-
-    def recv(self) -> bytes:
-        """ receive data from USART.
-
-        Returns:
-            bytes: USART send buffer data
-        """
-        data = bytes(self.send_buf)
-        self.send_buf.clear()
-        return data
+                self.usart.DR = self.recv_from_user()
 
     def step(self):
         self.transfer()

qiling/hw/connectivity.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# 
+# Cross Platform and Multi Architecture Advanced Binary Emulation Framework
+#
+
+
+import ctypes
+import queue
+
+from qiling.core import Qiling
+from qiling.hw.peripheral import QlPeripheral
+
+
+class QlConnectivityPeripheral(QlPeripheral):
+    class Type(ctypes.Structure):
+        """ Define the reigister fields of peripheral.
+
+            Example:
+                fields_ = [
+                    ('SR'  , ctypes.c_uint32),
+                    ('DR'  , ctypes.c_uint32),
+                    ('BRR' , ctypes.c_uint32),
+                    ('CR1' , ctypes.c_uint32),
+                    ('CR2' , ctypes.c_uint32),
+                    ('CR3' , ctypes.c_uint32),
+                    ('GTPR', ctypes.c_uint32),
+                ]
+        """        
+        _fields_ = []
+
+    def __init__(self, ql: Qiling, label: str):
+        super().__init__(ql, label)
+        
+        self.rtube = queue.Queue()
+        self.wtube = queue.Queue()
+
+    def send(self, data: bytes):
+        """ Send data into the peripheral.
+            
+            Example:
+                ql.hw.usart1.send(b'hello')
+        """
+
+        for byte in bytearray(data):
+            self.rtube.put(byte)
+
+    def recv(self, numb:int = 4096) -> bytes:
+        """ Receive data from peripheral
+
+            Example:
+                data = ql.hw.i2c1.send()
+        """
+        data = bytearray()
+        while not self.wtube.empty() and numb != 0:
+            data.append(self.wtube.get())
+            numb -= 1
+
+        return bytes(data)
+    
+    def can_recv(self):
+        return not self.rtube.empty()
+
+    def recv_from_user(self) -> bytes:
+        """ Read single byte from user input
+        """
+        
+        return self.rtube.get()
+
+    def send_to_user(self, data: int):
+        """ send single byte to user
+        """
+        
+        self.wtube.put(data)