From 1e05e4a0099199f97ed9c25e5ccd54f4bbc5d1bd Mon Sep 17 00:00:00 2001
From: VzxPLnHqr <VzxPLnHqr@proton.me>
Date: Mon, 6 May 2024 16:00:11 -0700
Subject: [PATCH] add the emulator files (needs refactor to support multiple
 platforms)

---
 src/seedsigner/emulator/desktopDisplay.py     | 158 ++++++++++++++++++
 src/seedsigner/emulator/virtualGPIO.py        | 151 +++++++++++++++++
 src/seedsigner/emulator/webcamvideostream.py  |  73 ++++++++
 src/seedsigner/gui/renderer.py                |   6 +-
 src/seedsigner/hardware/buttons.py            |  68 +++-----
 src/seedsigner/hardware/camera.py             |  38 ++---
 .../resources/icons/emulator_icon.png         | Bin 0 -> 2574 bytes
 7 files changed, 424 insertions(+), 70 deletions(-)
 create mode 100644 src/seedsigner/emulator/desktopDisplay.py
 create mode 100644 src/seedsigner/emulator/virtualGPIO.py
 create mode 100644 src/seedsigner/emulator/webcamvideostream.py
 create mode 100644 src/seedsigner/resources/icons/emulator_icon.png

diff --git a/src/seedsigner/emulator/desktopDisplay.py b/src/seedsigner/emulator/desktopDisplay.py
new file mode 100644
index 000000000..d4c5cfdd6
--- /dev/null
+++ b/src/seedsigner/emulator/desktopDisplay.py
@@ -0,0 +1,158 @@
+######################################################################
+#  Seedsigner desktop display driver and button emulator
+#
+#  by: @EnteroPositivo (Twitter, Gmail, GitHub)
+
+
+
+import time
+
+from seedsigner.emulator.virtualGPIO import GPIO
+from seedsigner.hardware.buttons import HardwareButtons
+
+from tkinter import *
+import tkinter as tk
+
+
+from PIL import ImageTk
+
+import threading
+import os
+
+EMULATOR_VERSION = '0.5'
+        
+
+class desktopDisplay(threading.Thread):
+    """class for desktop display."""
+    root=0
+    def __init__(self):
+        self.width = 240
+        self.height = 240
+
+        # Multithreading
+        threading.Thread.__init__(self)
+        self.start()
+
+    def callback(self):
+        self.root.quit()
+        self.root.destroy()
+        # terminate the main thread forcefully
+        pid = os.getpid()
+        os.kill(pid,9)
+
+    def run(self):
+        """run thread"""    
+        self.root = tk.Tk()
+        
+        from seedsigner.controller import Controller
+        controller = Controller.get_instance()
+        title= "SeedSigner Emulator v"+EMULATOR_VERSION+ " / "+controller.VERSION;
+
+        print("*****************************************************");
+        print(title);
+        print("https://github.com/enteropositivo/seedsigner-emulator");
+        print("*****************************************************");
+
+        self.root.title(title)
+
+        self.root.protocol("WM_DELETE_WINDOW", self.callback)
+        self.root.geometry("480x260+240+240")
+        self.root.configure(bg='orange')
+        self.root.iconphoto(False, tk.PhotoImage(file='seedsigner/resources/icons/emulator_icon.png'))
+        # ....
+
+
+        self.label=Label(self.root)
+        self.label.pack()
+
+        self.joystick=Frame(self.root)
+        self.joystick.pack()
+        self.joystick.place(x=20, y=85)
+        self.joystick.configure(bg='orange')
+        
+        pixel = tk.PhotoImage(width=1, height=1)
+        
+
+        self.btnL = Button(self.joystick, image=pixel,  width=20, height=20,  command = HardwareButtons.KEY_LEFT_PIN, bg='white')
+        self.btnL.grid(row=1, column=0)
+        self.bindButtonClick(self.btnL)
+
+        self.btnR = Button(self.joystick, image=pixel,  width=20, height=20, command = HardwareButtons.KEY_RIGHT_PIN, bg='white')
+        self.btnR.grid(row=1, column=2)
+        self.bindButtonClick(self.btnR)
+
+        self.btnC = Button(self.joystick, image=pixel,  width=20, height=20, command = HardwareButtons.KEY_PRESS_PIN)
+        self.btnC.grid(row=1, column=1)
+        self.bindButtonClick(self.btnC)
+
+        self.btnU = Button(self.joystick, image=pixel,  width=20, height=20, command = HardwareButtons.KEY_UP_PIN, bg='white')
+        self.btnU.grid(row=0, column=1)
+        self.bindButtonClick(self.btnU)
+
+        self.btnD = Button(self.joystick, image=pixel,  width=20, height=20, command = HardwareButtons.KEY_DOWN_PIN, bg='white')
+        self.btnD.grid(row=2, column=1)
+        self.bindButtonClick(self.btnD)
+
+        self.btn1 = Button(self.root, image=pixel,  width=40, height=20,  command = HardwareButtons.KEY1_PIN, bg='white')
+        self.btn1.place(x=400, y=60)
+        self.bindButtonClick(self.btn1)
+
+        self.btn2 = Button(self.root, image=pixel,  width=40, height=20,  command = HardwareButtons.KEY2_PIN, bg='white')
+        self.btn2.place(x=400, y=116)
+        self.bindButtonClick(self.btn2)
+
+        self.btn3 = Button(self.root, image=pixel,  width=40, height=20,  command = HardwareButtons.KEY3_PIN, bg='white')
+        self.btn3.place(x=400, y=172)
+        self.bindButtonClick(self.btn3)
+
+        
+        def key_handler(event):
+            
+            if(event.keysym=="Up"): GPIO.set_input(HardwareButtons.KEY_UP_PIN, GPIO.HIGH)
+            if(event.keysym=="Down"): GPIO.set_input(HardwareButtons.KEY_DOWN_PIN, GPIO.HIGH)
+            if(event.keysym=="Left"): GPIO.set_input(HardwareButtons.KEY_LEFT_PIN, GPIO.HIGH)
+            if(event.keysym=="Right"): GPIO.set_input(HardwareButtons.KEY_RIGHT_PIN, GPIO.HIGH)
+
+            if(event.keysym in ("1", "KP_1") ): GPIO.set_input(HardwareButtons.KEY1_PIN, GPIO.HIGH)
+            if(event.keysym in ("2", "KP_2") ): GPIO.set_input(HardwareButtons.KEY2_PIN, GPIO.HIGH)
+            if(event.keysym in ("3", "KP_3") ): GPIO.set_input(HardwareButtons.KEY3_PIN, GPIO.HIGH)
+
+            if(event.keysym=="Return"): GPIO.set_input(HardwareButtons.KEY_PRESS_PIN, GPIO.HIGH)
+
+        self.root.bind("<Key>", key_handler)
+
+        self.root.resizable(width = True, height = True)
+        self.root.mainloop()
+     
+ 
+    def bindButtonClick(self, objBtn):
+        objBtn.bind("<Button>", self.buttonDown)
+        objBtn.bind("<ButtonRelease>", self.buttonUp)
+
+    def buttonDown(self, objBtn):
+        gpioID = (objBtn.widget.config('command')[-1])
+        GPIO.set_input(gpioID, GPIO.HIGH)
+
+    def buttonUp(self, objBtn):
+        gpioID = (objBtn.widget.config('command')[-1])
+        GPIO.set_input(gpioID, GPIO.LOW)   
+
+    def setGPIO(self, pin):
+        GPIO.fire_raise_event(pin)
+
+    def ShowImage(self,Image2,Xstart,Ystart):
+        while(self.root==0): time.sleep(0.1)
+        imwidth, imheight = Image2.size
+        if imwidth != self.width or imheight != self.height:
+            raise ValueError('Image must be same dimensions as display \
+                ({0}x{1}).' .format(self.width, self.height))
+
+        self.tkimage= ImageTk.PhotoImage(Image2, master=self.root)
+        self.label.configure(image=self.tkimage)
+        self.label.image=self.tkimage
+        self.label.place(x=125, y=10)
+       
+        
+    def clear(self):
+        """Clear contents of image buffer"""
+ 
\ No newline at end of file
diff --git a/src/seedsigner/emulator/virtualGPIO.py b/src/seedsigner/emulator/virtualGPIO.py
new file mode 100644
index 000000000..7a6aadcbb
--- /dev/null
+++ b/src/seedsigner/emulator/virtualGPIO.py
@@ -0,0 +1,151 @@
+######################################################################
+#  virtualGPIO allows program with the same GPIO code as allways
+#  to test your code on a desktop enviroment
+#
+#  by: @EnteroPositivo (Twitter, Gmail, GitHub)
+#   
+#  Code adapted from: https://roderickvella.wordpress.com/2016/06/28/raspberry-pi-gpio-emulator/
+
+
+import time
+
+
+dictionaryPins = {}
+raisedPin=""
+
+class GPIO:
+
+    #constants
+    LOW = 0 
+    HIGH = 1
+    OUT = 2
+    IN = 3
+    PUD_OFF = 4
+    PUD_DOWN = 5
+    PUD_UP = 6
+    BCM = 7
+    BOARD = 101
+
+    SLEEP_TIME_S=0.1
+    SLEEP_TIME_L=1.5
+
+    #GPIO LIBRARY Functions
+    def setmode(mode):
+        time.sleep(GPIO.SLEEP_TIME_L)
+            
+    def setwarnings(flag):
+        pass
+
+    def setup(channel, state, initial=-1,pull_up_down=-1):
+        global dictionaryPins
+        
+        #check if channel is already setup
+        if str(channel) in dictionaryPins:
+            raise Exception('GPIO is already setup')
+
+        if(state == GPIO.OUT):
+            #GPIO is set as output, default OUT 0
+            objTemp =  PIN("OUT")
+            if(initial == GPIO.HIGH):
+                objTemp.Out = "1"
+                
+            dictionaryPins[str(channel)] =objTemp
+            #drawGPIOOut(channel)
+            
+        elif(state == GPIO.IN):
+            #set input
+            objTemp =  PIN("IN")
+            if(pull_up_down == -1):
+                objTemp.pull_up_down = "PUD_DOWN" #by default pud_down
+                objTemp.In = "0"
+            elif(pull_up_down == GPIO.PUD_DOWN):
+                objTemp.pull_up_down = "PUD_DOWN"
+                objTemp.In = "0"
+             
+            elif(pull_up_down == GPIO.PUD_UP):
+                objTemp.pull_up_down = "PUD_UP"
+                objTemp.In = "1"
+                
+            #drawBindUpdateButtonIn(str(channel),objTemp.In)
+            dictionaryPins[str(channel)] =objTemp
+
+
+    def output(channel, outmode):
+        global dictionaryPins
+        channel = str(channel)
+
+        if channel not in dictionaryPins:
+            #if channel is not setup
+            raise Exception('GPIO must be setup before used')
+        else:
+            objPin = dictionaryPins[channel]
+            if(objPin.SetMode == "IN"):
+                #if channel is setup as IN and used as an OUTPUT
+                raise Exception('GPIO must be setup as OUT')
+
+        
+        if(outmode != GPIO.LOW and outmode != GPIO.HIGH):
+            raise Exception('Output must be set to HIGH/LOW')
+            
+        objPin = dictionaryPins[channel]
+        if(outmode == GPIO.LOW):
+            objPin.Out = "0"
+        elif(outmode == GPIO.HIGH):
+            objPin.Out = "1"
+
+
+    def input(channel):
+        global dictionaryPins, raisedPin
+        global raisedPin
+
+        #print(channel)
+        channel = str(channel)
+        
+        if channel not in dictionaryPins:
+            #if channel is not setup
+            raise Exception('GPIO must be setup before used')
+        else:
+            objPin = dictionaryPins[channel]
+            if(objPin.SetMode == "OUT"):
+                #if channel is setup as OUTPUT and used as an INPUT
+                raise Exception('GPIO must be setup as IN')
+       
+        objPin = dictionaryPins[channel]
+
+        if(channel==raisedPin):
+            raisedPin=""
+            return GPIO.LOW
+        else:
+            return GPIO.HIGH
+
+
+
+    def cleanup():
+        pass
+
+    def add_event_detect(channel,edge,callback):
+        GPIO.risecallback=callback
+    
+    def set_input(gpioID, state):
+        global raisedPin
+
+        #print( "Emulator GPIO:", gpioID, " = ", str(state))
+        if(state==GPIO.HIGH):
+            raisedPin=str(gpioID)
+            GPIO.risecallback(gpioID)
+        else:
+            raisedPin=""
+
+
+           
+            
+       
+class PIN():
+    SetMode = "None" #IN/OUT/NONE
+    Out = "0"
+    pull_up_down = "PUD_OFF" #PUD_UP/PUD_DOWN/PUD_OFF
+    In = "1"
+
+    def __init__(self, SetMode):
+        self.SetMode = SetMode
+        self.Out = "0"    
diff --git a/src/seedsigner/emulator/webcamvideostream.py b/src/seedsigner/emulator/webcamvideostream.py
new file mode 100644
index 000000000..322b94bd8
--- /dev/null
+++ b/src/seedsigner/emulator/webcamvideostream.py
@@ -0,0 +1,73 @@
+
+from threading import Thread
+import time
+import cv2
+
+
+class WebcamVideoStream:
+	def __init__(self, resolution=(320, 240), framerate=32, format="bgr", **kwargs):
+		# initialize the camera
+		self.camera = cv2.VideoCapture(0)
+		self.set_resolution(resolution)
+				
+		# initialize the frame and the variable used to indicate
+		# if the thread should be stopped
+		self.frame = None
+		self.should_stop = False
+		self.is_stopped = True
+
+	def start(self):
+		# start the thread to read frames from the video stream
+		t = Thread(target=self.update, args=())
+		t.daemon = True
+		t.start()
+		self.is_stopped = False
+		return self
+
+	def hasCamera(self):
+		return 	self.camera.isOpened()
+
+	def update(self):
+
+		if self.hasCamera():
+
+			# keep looping infinitely until the thread is stopped
+			while(not self.should_stop):
+				# grab the frame from the stream and clear the stream in
+				# preparation for the next frame
+				ret, stream = self.camera.read()
+				stream = cv2.resize(stream, (240,240))
+				stream = cv2.cvtColor(stream,cv2.COLOR_BGR2RGB)
+				time.sleep(0.05)
+				self.frame = stream
+
+			self.is_stopped = True
+			self.should_stop = False
+			return
+
+		else:
+			self.is_stopped = True
+			self.should_stop = False
+			return
+
+
+
+	def read(self):
+		return self.frame
+	
+	def single_frame():
+		cap = cv2.VideoCapture(0)
+		ret, frame = cap.read()
+		return frame
+
+	def stop(self):
+		# indicate that the thread should be stopped
+		self.should_stop = True
+
+		# Block in this thread until stopped
+		while not self.is_stopped:
+			pass
+
+	def set_resolution(self, resolution):
+		self.camera.set(3, resolution[0])
+		self.camera.set(4, resolution[1])	
diff --git a/src/seedsigner/gui/renderer.py b/src/seedsigner/gui/renderer.py
index 9534a7747..7ada21ead 100644
--- a/src/seedsigner/gui/renderer.py
+++ b/src/seedsigner/gui/renderer.py
@@ -2,7 +2,8 @@
 from threading import Lock
 
 from seedsigner.gui.components import Fonts, GUIConstants
-from seedsigner.hardware.ST7789 import ST7789
+#from seedsigner.hardware.ST7789 import ST7789
+from seedsigner.emulator.desktopDisplay import desktopDisplay
 from seedsigner.models.singleton import ConfigurableSingleton
 
 
@@ -24,7 +25,8 @@ def configure_instance(cls):
         cls._instance = renderer
 
         # Eventually we'll be able to plug in other display controllers
-        renderer.disp = ST7789()
+        #renderer.disp = ST7789()
+        renderer.disp = desktopDisplay()
         renderer.canvas_width = renderer.disp.width
         renderer.canvas_height = renderer.disp.height
 
diff --git a/src/seedsigner/hardware/buttons.py b/src/seedsigner/hardware/buttons.py
index 8d42105d0..b5d78d758 100644
--- a/src/seedsigner/hardware/buttons.py
+++ b/src/seedsigner/hardware/buttons.py
@@ -1,33 +1,21 @@
 from typing import List
-import RPi.GPIO as GPIO
+#import RPi.GPIO as GPIO
+from seedsigner.emulator.virtualGPIO import GPIO
 import time
 
 from seedsigner.models.singleton import Singleton
 
 class HardwareButtons(Singleton):
-    if GPIO.RPI_INFO['P1_REVISION'] == 3: #This indicates that we have revision 3 GPIO
-        print("Detected 40pin GPIO (Rasbperry Pi 2 and above)")
-        KEY_UP_PIN = 31
-        KEY_DOWN_PIN = 35
-        KEY_LEFT_PIN = 29
-        KEY_RIGHT_PIN = 37
-        KEY_PRESS_PIN = 33
-
-        KEY1_PIN = 40
-        KEY2_PIN = 38
-        KEY3_PIN = 36
-
-    else:
-        print("Assuming 26 Pin GPIO (Raspberry P1 1)")
-        KEY_UP_PIN = 5
-        KEY_DOWN_PIN = 11
-        KEY_LEFT_PIN = 3
-        KEY_RIGHT_PIN = 15
-        KEY_PRESS_PIN = 7
-
-        KEY1_PIN = 16
-        KEY2_PIN = 12
-        KEY3_PIN = 8
+    
+    KEY_UP_PIN = 6
+    KEY_DOWN_PIN = 19
+    KEY_LEFT_PIN = 5
+    KEY_RIGHT_PIN = 26
+    KEY_PRESS_PIN = 13
+
+    KEY1_PIN = 21
+    KEY2_PIN = 20
+    KEY3_PIN = 16
 
     @classmethod
     def get_instance(cls):
@@ -138,7 +126,7 @@ def update_last_input_time(self):
 
     def add_events(self, keys=[]):
         for key in keys:
-            GPIO.add_event_detect(key, self.GPIO.RISING, callback=HardwareButtons.rising_callback)
+            GPIO.add_event_detect(0, 0, callback=HardwareButtons.rising_callback)
 
 
     def rising_callback(channel):
@@ -178,26 +166,16 @@ def has_any_input(self) -> bool:
 # TODO: Implement `release_lock` functionality as a global somewhere. Mixes up design
 #   patterns to have a static constants class plus a settable global value.
 class HardwareButtonsConstants:
-    if GPIO.RPI_INFO['P1_REVISION'] == 3: #This indicates that we have revision 3 GPIO
-        KEY_UP = 31
-        KEY_DOWN = 35
-        KEY_LEFT = 29
-        KEY_RIGHT = 37
-        KEY_PRESS = 33
-
-        KEY1 = 40
-        KEY2 = 38
-        KEY3 = 36
-    else:
-        KEY_UP = 5
-        KEY_DOWN = 11
-        KEY_LEFT = 3
-        KEY_RIGHT = 15
-        KEY_PRESS = 7
-
-        KEY1 = 16
-        KEY2 = 12
-        KEY3 = 8
+
+    KEY_UP = 6
+    KEY_DOWN = 19
+    KEY_LEFT = 5
+    KEY_RIGHT = 26
+    KEY_PRESS = 13
+
+    KEY1 = 21
+    KEY2 = 20
+    KEY3 = 16        
 
     OVERRIDE = 1000
 
diff --git a/src/seedsigner/hardware/camera.py b/src/seedsigner/hardware/camera.py
index 59ff41016..b48a3129c 100644
--- a/src/seedsigner/hardware/camera.py
+++ b/src/seedsigner/hardware/camera.py
@@ -1,8 +1,10 @@
 import io
 
-from picamera import PiCamera
+#from picamera import PiCamera
 from PIL import Image
-from seedsigner.hardware.pivideostream import PiVideoStream
+#from seedsigner.hardware.pivideostream import PiVideoStream
+from seedsigner.emulator.webcamvideostream import WebcamVideoStream
+
 from seedsigner.models.settings import Settings, SettingsConstants
 from seedsigner.models.singleton import Singleton
 
@@ -26,19 +28,24 @@ def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="b
         if self._video_stream is not None:
             self.stop_video_stream_mode()
 
-        self._video_stream = PiVideoStream(resolution=resolution,framerate=framerate, format=format)
+        #self._video_stream = PiVideoStream(resolution=resolution,framerate=framerate, format=format)
+        self._video_stream = WebcamVideoStream(resolution=resolution,framerate=framerate, format=format)        
         self._video_stream.start()
 
 
     def read_video_stream(self, as_image=False):
         if not self._video_stream:
             raise Exception("Must call start_video_stream first.")
+
+        if not self._video_stream.hasCamera(): 
+            raise Exception("Can not open Webcam")
+
         frame = self._video_stream.read()
         if not as_image:
             return frame
         else:
             if frame is not None:
-                return Image.fromarray(frame.astype('uint8'), 'RGB').convert('RGBA').rotate(90 + self._camera_rotation)
+                return Image.fromarray(frame.astype('uint8'), 'RGB').rotate(90 + self._camera_rotation)
         return None
 
 
@@ -54,27 +61,12 @@ def start_single_frame_mode(self, resolution=(720, 480)):
         if self._picamera is not None:
             self._picamera.close()
 
-        self._picamera = PiCamera(resolution=resolution, framerate=24)
-        self._picamera.start_preview()
-
 
     def capture_frame(self):
-        if self._picamera is None:
-            raise Exception("Must call start_single_frame_mode first.")
-
-        # Set auto-exposure values
-        self._picamera.shutter_speed = self._picamera.exposure_speed
-        self._picamera.exposure_mode = 'off'
-        g = self._picamera.awb_gains
-        self._picamera.awb_mode = 'off'
-        self._picamera.awb_gains = g
-
-        stream = io.BytesIO()
-        self._picamera.capture(stream, format='jpeg')
-
-        # "Rewind" the stream to the beginning so we can read its content
-        stream.seek(0)
-        return Image.open(stream).rotate(90 + self._camera_rotation)
+        
+        frame = WebcamVideoStream.single_frame()
+        return Image.fromarray(frame ).rotate(90 + self._camera_rotation)
+
 
 
     def stop_single_frame_mode(self):
diff --git a/src/seedsigner/resources/icons/emulator_icon.png b/src/seedsigner/resources/icons/emulator_icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf4da943627d7208692a0a18f218cbb40e4974b0
GIT binary patch
literal 2574
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

literal 0
HcmV?d00001