Add support for HW revision B/flagship, add RGB LED setting in theme for flagship revision

Author: mathoudebine

config.yaml

@@ -11,16 +11,15 @@ config:
   THEME: 3.5inchTheme2_theme
 
 display:
-  # Display size (in portrait orientation)
+  # Display resolution in portrait orientation
+  # Do not use this setting to rotate display! Display orientation is managed by themes
   DISPLAY_WIDTH: 320
   DISPLAY_HEIGHT: 480
 
   # Display Brightness
   # Set this as the desired %, 0 being completely dark and 100 being max brightness
   BRIGHTNESS: 20
 
-  # Display orientation is configured by themes
-
   # Display revision: A or B (for "flagship" version, use B)
   # To identify your revision: https://github.com/mathoudebine/turing-smart-screen-python/wiki/Hardware-revisions
   REVISION: A

library/display.py

@@ -1,5 +1,7 @@
 from library import config
-from library.lcd_comm_rev_a import LcdCommRevA, Orientation
+from library.lcd_comm import Orientation
+from library.lcd_comm_rev_a import LcdCommRevA
+from library.lcd_comm_rev_b import LcdCommRevB
 
 THEME_DATA = config.THEME_DATA
 CONFIG_DATA = config.CONFIG_DATA
@@ -18,18 +20,27 @@ def __init__(self):
         if CONFIG_DATA["display"]["REVISION"] == "A":
             self.lcd = LcdCommRevA()
         elif CONFIG_DATA["display"]["REVISION"] == "B":
-            pass
+            self.lcd = LcdCommRevB()
         else:
             print("Unknown display revision '", CONFIG_DATA["display"]["REVISION"], "'")
 
     def initialize_display(self):
+        # Send initialization commands
+        self.lcd.InitializeComm()
+
+        # Reset screen in case it was in an unstable state
+        self.lcd.Reset()
+
         # Clear screen (blank)
         self.lcd.SetOrientation(Orientation.PORTRAIT)  # Bug: orientation needs to be PORTRAIT before clearing
         self.lcd.Clear()
 
         # Set brightness
         self.lcd.SetBrightness()
 
+        # Set backplate RGB LED color (for supported HW only)
+        self.lcd.SetBackplateLedColor()
+
         # Set orientation
         self.lcd.SetOrientation()
 
@@ -53,7 +64,7 @@ def display_static_text(self):
                     text=THEME_DATA['static_text'][text].get("TEXT"),
                     x=THEME_DATA['static_text'][text].get("X", 0),
                     y=THEME_DATA['static_text'][text].get("Y", 0),
-                    font=THEME_DATA['static_text'][text].get("FONT", "roboto/Roboto-Regular.ttf"),
+                    font=THEME_DATA['static_text'][text].get("FONT", "roboto-mono/RobotoMono-Regular.ttf"),
                     font_size=THEME_DATA['static_text'][text].get("FONT_SIZE", 10),
                     font_color=THEME_DATA['static_text'][text].get("FONT_COLOR", (0, 0, 0)),
                     background_color=THEME_DATA['static_text'][text].get("BACKGROUND_COLOR", (255, 255, 255)),

library/lcd_comm.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from enum import IntEnum
+from PIL import Image, ImageDraw, ImageFont
 
 from library import config
 
@@ -43,6 +44,10 @@ def get_height() -> int:
 
 
 class LcdComm(ABC):
+    @abstractmethod
+    def InitializeComm(self):
+        pass
+
     @abstractmethod
     def Reset(self):
         pass
@@ -64,33 +69,123 @@ def SetBrightness(self, level: int):
         pass
 
     @abstractmethod
-    def SetOrientation(self, orientation: Orientation):
+    def SetBackplateLedColor(self, led_color: tuple[int, int, int]):
         pass
 
     @abstractmethod
-    def DisplayBitmap(self, bitmap_path: str, x: int, y: int, width: int, height: int):
+    def SetOrientation(self, orientation: Orientation):
         pass
 
     @abstractmethod
-    def DisplayText(
+    def DisplayPILImage(
             self,
-            text: str,
-            x: int,
-            y: int,
-            font: str,
-            font_size: int,
-            font_color: tuple[int, int, int],
-            background_color: tuple[int, int, int],
-            background_image: str
+            image: Image,
+            x: int = 0, y: int = 0,
+            image_width: int = 0,
+            image_height: int = 0
     ):
         pass
 
-    @abstractmethod
-    def DisplayProgressBar(self, x: int, y: int, width: int, height: int, min_value: int,
-                           max_value: int,
-                           value: int,
-                           bar_color: tuple[int, int, int],
-                           bar_outline: bool,
-                           background_color: tuple[int, int, int],
-                           background_image: str):
-        pass
+    def DisplayBitmap(self, bitmap_path: str, x: int = 0, y: int = 0, width: int = 0, height: int = 0):
+        image = Image.open(bitmap_path)
+        self.DisplayPILImage(image, x, y, width, height)
+
+    def DisplayText(
+            self,
+            text: str,
+            x: int = 0,
+            y: int = 0,
+            font: str = "roboto-mono/RobotoMono-Regular.ttf",
+            font_size: int = 20,
+            font_color: tuple[int, int, int] = (0, 0, 0),
+            background_color: tuple[int, int, int] = (255, 255, 255),
+            background_image: str = None
+    ):
+        # Convert text to bitmap using PIL and display it
+        # Provide the background image path to display text with transparent background
+
+        if isinstance(font_color, str):
+            font_color = tuple(map(int, font_color.split(', ')))
+
+        if isinstance(background_color, str):
+            background_color = tuple(map(int, background_color.split(', ')))
+
+        assert x <= get_width(), 'Text X coordinate must be <= display width'
+        assert y <= get_height(), 'Text Y coordinate must be <= display height'
+        assert len(text) > 0, 'Text must not be empty'
+        assert font_size > 0, "Font size must be > 0"
+
+        if background_image is None:
+            # A text bitmap is created with max width/height by default : text with solid background
+            text_image = Image.new(
+                'RGB',
+                (get_width(), get_height()),
+                background_color
+            )
+        else:
+            # The text bitmap is created from provided background image : text with transparent background
+            text_image = Image.open(background_image)
+
+        # Draw text with specified color & font
+        font = ImageFont.truetype("./res/fonts/" + font, font_size)
+        d = ImageDraw.Draw(text_image)
+        d.text((x, y), text, font=font, fill=font_color)
+
+        # Crop text bitmap to keep only the text (also crop if text overflows display)
+        left, top, text_width, text_height = d.textbbox((0, 0), text, font=font)
+        text_image = text_image.crop(box=(
+            x, y,
+            min(x + text_width, get_width()),
+            min(y + text_height, get_height())
+        ))
+
+        self.DisplayPILImage(text_image, x, y)
+
+    def DisplayProgressBar(self, x: int, y: int, width: int, height: int, min_value: int = 0, max_value: int = 100,
+                           value: int = 50,
+                           bar_color: tuple[int, int, int] = (0, 0, 0),
+                           bar_outline: bool = True,
+                           background_color: tuple[int, int, int] = (255, 255, 255),
+                           background_image: str = None):
+        # Generate a progress bar and display it
+        # Provide the background image path to display progress bar with transparent background
+
+        if isinstance(bar_color, str):
+            bar_color = tuple(map(int, bar_color.split(', ')))
+
+        if isinstance(background_color, str):
+            background_color = tuple(map(int, background_color.split(', ')))
+
+        assert x <= get_width(), 'Progress bar X coordinate must be <= display width'
+        assert y <= get_height(), 'Progress bar Y coordinate must be <= display height'
+        assert x + width <= get_width(), 'Progress bar width exceeds display width'
+        assert y + height <= get_height(), 'Progress bar height exceeds display height'
+
+        # Don't let the set value exceed our min or max value, this is bad :)
+        if value < min_value:
+            value = min_value
+        elif max_value < value:
+            value = max_value
+
+        assert min_value <= value <= max_value, 'Progress bar value shall be between min and max'
+
+        if background_image is None:
+            # A bitmap is created with solid background
+            bar_image = Image.new('RGB', (width, height), background_color)
+        else:
+            # A bitmap is created from provided background image
+            bar_image = Image.open(background_image)
+
+            # Crop bitmap to keep only the progress bar background
+            bar_image = bar_image.crop(box=(x, y, x + width, y + height))
+
+        # Draw progress bar
+        bar_filled_width = value / (max_value - min_value) * width
+        draw = ImageDraw.Draw(bar_image)
+        draw.rectangle([0, 0, bar_filled_width - 1, height - 1], fill=bar_color, outline=bar_color)
+
+        if bar_outline:
+            # Draw outline
+            draw.rectangle([0, 0, width - 1, height - 1], fill=None, outline=bar_color)
+
+        self.DisplayPILImage(bar_image, x, y)