Merge pull request #972 from cla7aye15I4nd/dev

Add "external device" module and LCD1602

Author: cla7aye15I4nd

examples/mcu/stm32f411_i2c_lcd.py

@@ -1,129 +1,31 @@
 import sys
+
 sys.path.append("../..")
 
 from qiling.core import Qiling
 from qiling.const import QL_VERBOSE
+from qiling.hw.external_device.lcd.lcd1602 import PyGameLCD1602
 
-import pygame
-import threading
-        
-
-class LCD:
-    @classmethod
-    def get_pattern(cls, ch):
-        lo = (ch >> 0) & 0xf
-        up = (ch >> 4) & 0xf
-        with open('LCD1602A.txt') as f:
-            lines = f.read().splitlines()[lo * 9 + 1: lo * 9 + 9]
-            pattern = [line[up * 6 + 1: up * 6 + 6] for line in lines]
-
-        return pattern
-
-    @classmethod
-    def make_screen(cls, infos):
-        sc = []
-        for info in infos:
-            ps = [LCD.get_pattern(x) for x in info]            
-            ln  = [''.join(p[r] for p in ps) for r in range(8)]
-            sc += ln
-
-        return sc
-
-class LCD1602(LCD):    
-    def __init__(self) -> None:
-        super().__init__()
-
-        self.rows, self.cols = 2, 16
-        self.cheight, self.cwidth = 8, 5        
-        
-        self.cur_row, self.cur_col = 0, 0
-         
-        self.buf = []
-        self.data = [[ord(' ') for _ in range(self.cols)] for _ in range(self.rows)]
-        self.pixels = LCD.make_screen(self.data)
-
-        self.address = 0x3f << 1
-
-    def is_activate(self, i, j):
-        return self.pixels[i][j] == '#'
-
-    def render(self):
-        size = 10
-        margin, interval = size * 4, size // 2
-
-        width  = margin * 2 + size * (self.cols * self.cwidth) + interval * (self.cols - 1)
-        height = margin * 2 + size * (self.rows * self.cheight) + interval * (self.rows - 1)
-
-        runable = True
-        clock = pygame.time.Clock()
-        win = pygame.display.set_mode((width, height))
-
-        pygame.display.set_caption("LCD 1602A")
 
-        while runable:            
-            for event in pygame.event.get():
-                if event.type == pygame.QUIT:
-                    runable = False
-            
-            clock.tick(60)
-            pygame.draw.rect(win, "#c9f6cd", ((size, size), (width - size*2, height - size*2)), border_radius=size)
-            for i in range(self.rows * self.cheight):
-                for j in range(self.cols * self.cwidth):
-                    x = margin + size * j + interval * (j // self.cwidth)
-                    y = margin + size * i + interval * (i // self.cheight)
+def create(path, lcd):
+    ql = Qiling([path], archtype="cortex_m", profile="stm32f411", verbose=QL_VERBOSE.DEBUG)
 
-                    color = "#446644" if self.is_activate(i, j) else "#bbeebb"
-                    pygame.draw.rect(win, color, ((x, y), (size-1, size-1)))
-
-            pygame.display.update()            
-
-        print('LCD quit')
-        pygame.quit()
-
-    def send(self, buf):
-        for data in buf:
-            self.buf.append(data)
-
-            if len(self.buf) == 4:
-                up = self.buf[0] & 0xf0
-                lo = self.buf[3] & 0xf0
-                cmd = up | (lo >> 4)
-
-                if self.buf[0] & 0x1:                
-                    if self.cur_col < 16 and self.cur_row < 2:
-                        self.data[self.cur_row][self.cur_col] = cmd                
-                        self.cur_col += 1
-                    self.pixels = LCD.make_screen(self.data)
-                
-                elif cmd == 0x1:
-                    self.data = [[ord(' ') for _ in range(self.cols)] for _ in range(self.rows)]
-                    self.pixels = LCD.make_screen(self.data)
-                
-                elif up == 0x80:
-                    self.cur_row, self.cur_col = 0, lo >> 4
-
-                elif up == 0xc0:
-                    self.cur_row, self.cur_col = 1, lo >> 4                
-
-                self.buf = []
-
-    def run(self):
-        threading.Thread(target=self.render).start()
-
-def make(path, lcd):
-    ql = Qiling([path],
-        archtype="cortex_m", profile="stm32f411", verbose=QL_VERBOSE.DEFAULT)
-
-    ql.hw.create('i2c1').connect(lcd)
+    ql.hw.create('i2c1')
     ql.hw.create('rcc')
     ql.hw.create('gpioa')
-    ql.hw.create('gpiob')    
+    ql.hw.create('gpiob')   
+
+    ql.hw.i2c1.watch()
+    ql.hw.i2c1.connect(lcd)    
 
+    ql.hw.systick.set_ratio(100)
+
     return ql
 
 if __name__ == "__main__":
-    lcd = LCD1602()
-    lcd.run()
+    lcd = PyGameLCD1602()    
 
-    make("../rootfs/mcu/stm32f411/i2c-lcd.hex", lcd).run(count=700000)
-    make("../rootfs/mcu/stm32f411/lcd-plus.hex", lcd).run(count=2000000)
+    create("../rootfs/mcu/stm32f411/i2c-lcd.hex", lcd).run(count=50000)
+    create("../rootfs/mcu/stm32f411/lcd-plus.hex", lcd).run(count=100000)
+
+    lcd.quit()

qiling/hw/connectivity.py

@@ -11,6 +11,27 @@
 from qiling.hw.peripheral import QlPeripheral
 
 
+class PeripheralTube(queue.Queue):
+    def __init__(self):
+        super().__init__()
+
+    def readable(self) -> bool:
+        return not self.empty()
+
+    def read(self, numb:int = 4096) -> bytes:
+        data = bytearray()
+        for _ in range(numb):
+            if not self.readable():
+                break
+            data.append(self.get())
+
+        return bytes(data)
+
+    def write(self, data: bytes):
+        for byte in bytearray(data):
+            self.put(byte)
+
+
 class QlConnectivityPeripheral(QlPeripheral):
     class Type(ctypes.Structure):
         """ Define the reigister fields of peripheral.
@@ -31,64 +52,58 @@ class Type(ctypes.Structure):
     def __init__(self, ql: Qiling, label: str, limit:int = 1):
         super().__init__(ql, label)
 
-        self.rtube = queue.Queue()
-        self.wtube = queue.Queue()
+        self.itube = PeripheralTube()
+        self.otube = PeripheralTube()
 
         self.limit = limit
         self.device_list = []
 
     def has_input(self):
-        return not self.rtube.empty()
+        return self.itube.readable()
 
     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)
+        self.itube.write(data)        
 
     def recv(self, numb:int = 4096) -> bytes:
         """ Receive data from peripheral
 
             Example:
-                data = ql.hw.i2c1.send()
+                data = ql.hw.i2c1.recv()
         """
-        data = bytearray()
-        while self.can_recv() and numb != 0:
-            data.append(self.wtube.get())
-            numb -= 1
-
-        return bytes(data) 
-
-    def can_recv(self):
-        return not self.wtube.empty()
+        return self.otube.read(numb)
 
     def send_to_user(self, data: int):
         """ send single byte to user
-        """
-        
-        self.wtube.put(data)
+        """        
+        self.otube.put(data)
 
     def recv_from_user(self) -> bytes:
         """ Read single byte from user input
-        """
-        
-        return self.rtube.get()
+        """        
+        return self.itube.get()
 
     def connect(self, device):
         if len(self.device_list) < self.limit:
             self.device_list.append(device)
 
     @staticmethod
     def device_handler(func):
+        """ Send one byte to all devices
+        """
         def wrapper(self):            
-            if self.device_list and self.can_recv():
-                data = self.recv(numb=1)			
+            if len(self.device_list) > 0:                
+                if self.otube.readable():
+                    data = self.recv(1)
+                    for device in self.device_list:
+                        device.send(data)
+
                 for device in self.device_list:
-                    device.send(data)
+                    device.step()
 
             func(self)
 

qiling/hw/external_device/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# 
+# Cross Platform and Multi Architecture Advanced Binary Emulation Framework
+#

qiling/hw/external_device/lcd/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# 
+# Cross Platform and Multi Architecture Advanced Binary Emulation Framework
+#