smartscreen-driver 0.2.0__py3-none-any.whl

smartscreen_driver/lcd_comm_rev_d.py

@@ -0,0 +1,194 @@
+# turing-smart-screen-python - a Python system monitor and library for USB-C displays like Turing Smart Screen or XuanFang
+# https://github.com/mathoudebine/turing-smart-screen-python/
+
+# Copyright (C) 2021-2023  Matthieu Houdebine (mathoudebine)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from enum import Enum
+import logging
+from typing import Optional, Tuple
+import queue
+
+from serial.tools.list_ports import comports
+from PIL import Image
+
+from .lcd_comm import LcdComm, Orientation
+from .serialize import image_to_rgb565, chunked
+
+logger = logging.getLogger(__name__)
+
+
+class Command(Enum):
+    GETINFO = bytearray((71, 00, 00, 00))
+    SETORG = bytearray((67, 72, 00, 00))  # Set portrait orientation
+    SET180 = bytearray((67, 71, 00, 00))  # Set reverse portrait orientation
+    SETHF = bytearray(
+        (67, 68, 00, 00)
+    )  # Set portrait orientation with horizontal mirroring
+    SETVF = bytearray(
+        (67, 70, 00, 00)
+    )  # Set reverse portrait orientation with horizontal mirroring
+    SETBL = bytearray((67, 67))  # Brightness setting
+    DISPCOLOR = bytearray((67, 66))  # Display RGB565 color on whole screen
+    BLOCKWRITE = bytearray((67, 65))  # Send bitmap size
+    INTOPICMODE = bytearray((68, 00, 00, 00))  # Start bitmap transmission
+    OUTPICMODE = bytearray((65, 00, 00, 00))  # End bitmap transmission
+
+
+# This class is for Kipye Qiye Smart Display 3.5"
+class LcdCommRevD(LcdComm):
+    def __init__(
+        self,
+        com_port: str = "AUTO",
+        display_width: int = 320,
+        display_height: int = 480,
+        update_queue: Optional[queue.Queue] = None,
+    ):
+        logger.debug("HW revision: D")
+        LcdComm.__init__(self, com_port, display_width, display_height, update_queue)
+        self.open_serial()
+
+    def __del__(self):
+        self.close_serial()
+
+    @staticmethod
+    def auto_detect_com_port() -> Optional[str]:
+        com_ports = comports()
+        auto_com_port = None
+
+        for com_port in com_ports:
+            if com_port.vid == 0x454D and com_port.pid == 0x4E41:
+                auto_com_port = com_port.device
+                break
+
+        return auto_com_port
+
+    def write_data(self, data: bytearray):
+        LcdComm.write_data(self, data)
+
+        # Empty the input buffer after each write: we don't process acknowledgements the screen sends back
+        self.serial_flush_input()
+
+    def send_command(
+        self,
+        cmd: Command,
+        payload: Optional[bytearray] = None,
+        bypass_queue: bool = False,
+    ):
+        message = bytearray(cmd.value)
+
+        if payload:
+            message.extend(payload)
+
+        # If no queue for async requests, or if asked explicitly to do the request sequentially: do request now
+        if not self.update_queue or bypass_queue:
+            self.write_data(message)
+        else:
+            # Lock queue mutex then queue the request
+            with self.update_queue_mutex:
+                self.update_queue.put((self.write_data, [message]))
+
+    def initialize_comm(self):
+        pass
+
+    def reset(self):
+        # HW revision D does not implement a command to reset it: clear display instead
+        self.clear()
+
+    def clear(self):
+        # HW revision D does not implement a Clear command: display a blank image on the whole screen
+        color = 0xFFFF  # RGB565 White color
+        color_bytes = bytearray(color.to_bytes(2, "big"))
+        self.send_command(cmd=Command.DISPCOLOR, payload=color_bytes)
+
+    def screen_off(self):
+        # HW revision D does not implement a "ScreenOff" native command: using SetBrightness(0) instead
+        self.set_brightness(0)
+
+    def screen_on(self):
+        # HW revision D does not implement a "ScreenOn" native command: using SetBrightness() instead
+        self.set_brightness()
+
+    def set_brightness(self, level: int = 25):
+        assert 0 <= level <= 100, "Brightness level must be [0-100]"
+
+        # Brightness scales from 0 to 500, with 500 being the brightest and 0 being the darkest.
+        # Convert our brightness % to an absolute value.
+        converted_level = level * 5
+
+        level_bytes = bytearray(converted_level.to_bytes(2, "big"))
+
+        # Send the command twice because sometimes it is not applied...
+        self.send_command(cmd=Command.SETBL, payload=level_bytes)
+        self.send_command(cmd=Command.SETBL, payload=level_bytes)
+
+    def set_orientation(self, orientation: Orientation = Orientation.PORTRAIT):
+        # In revision D, reverse orientations (reverse portrait / reverse landscape) are managed by the display
+        # Basic orientations (portrait / landscape) are software-managed because screen commands only support portrait
+        self.orientation = orientation
+
+        if (
+            self.orientation == Orientation.REVERSE_LANDSCAPE
+            or self.orientation == Orientation.REVERSE_PORTRAIT
+        ):
+            self.send_command(cmd=Command.SET180)
+        else:
+            self.send_command(cmd=Command.SETORG)
+
+    def paint(
+        self,
+        image: Image.Image,
+        pos: Tuple[int, int] = (0, 0),
+    ):
+        image = self._crop_to_display_bounds(image, pos)
+        image_width, image_height = image.size[0], image.size[1]
+
+        if image_height == 0 or image_width == 0:
+            return
+
+        x, y = pos
+        if (
+            self.orientation == Orientation.PORTRAIT
+            or self.orientation == Orientation.REVERSE_PORTRAIT
+        ):
+            (x0, y0) = (x, y)
+            (x1, y1) = (x + image_width - 1, y + image_height - 1)
+        else:
+            # Landscape / reverse landscape orientations are software managed: rotate image -90° and get new coordinates
+            image = image.rotate(270, expand=True)
+            (x0, y0) = (self.display_width - y - image_height, x)
+            (x1, y1) = (self.display_width - y - 1, x + image_width - 1)
+            image_width, image_height = image_height, image_width
+
+        # Send bitmap size
+        image_data = bytearray()
+        image_data += x0.to_bytes(2, "big")
+        image_data += x1.to_bytes(2, "big")
+        image_data += y0.to_bytes(2, "big")
+        image_data += y1.to_bytes(2, "big")
+        self.send_command(cmd=Command.BLOCKWRITE, payload=image_data)
+
+        # Prepare bitmap data transmission
+        self.send_command(Command.INTOPICMODE)
+
+        rgb565be = image_to_rgb565(image, "big")
+
+        # Lock queue mutex then queue all the requests for the image data
+        with self.update_queue_mutex:
+            for chunk in chunked(rgb565be, 63):
+                self.send_line(b"\x50" + chunk)
+
+        # Indicate the complete bitmap has been transmitted
+        self.send_command(Command.OUTPICMODE)

smartscreen_driver/lcd_simulated.py

@@ -0,0 +1,168 @@
+# turing-smart-screen-python - a Python system monitor and library for USB-C displays like Turing Smart Screen or XuanFang
+# https://github.com/mathoudebine/turing-smart-screen-python/
+
+# Copyright (C) 2021-2023  Matthieu Houdebine (mathoudebine)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import mimetypes
+import shutil
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Optional, Tuple
+import queue
+import threading
+import logging
+
+from PIL import Image
+
+from .lcd_comm import LcdComm, Orientation
+
+logger = logging.getLogger(__name__)
+
+SCREENSHOT_FILE = "screencap.png"
+WEBSERVER_PORT = 5678
+
+
+# This webserver offer a blank page displaying simulated screen with auto-refresh
+class SimulatedLcdWebServer(BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        return
+
+    def do_GET(self):  # noqa: N802
+        if self.path == "/":
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(
+                bytes('<img src="' + SCREENSHOT_FILE + '" id="myImage" />', "utf-8")
+            )
+            self.wfile.write(bytes("<script>", "utf-8"))
+            self.wfile.write(bytes("setInterval(function() {", "utf-8"))
+            self.wfile.write(
+                bytes(
+                    "    var myImageElement = document.getElementById('myImage');",
+                    "utf-8",
+                )
+            )
+            self.wfile.write(
+                bytes(
+                    "    myImageElement.src = '"
+                    + SCREENSHOT_FILE
+                    + "?rand=' + Math.random();",
+                    "utf-8",
+                )
+            )
+            self.wfile.write(bytes("}, 250);", "utf-8"))
+            self.wfile.write(bytes("</script>", "utf-8"))
+        elif self.path.startswith("/" + SCREENSHOT_FILE):
+            imgfile = open(SCREENSHOT_FILE, "rb").read()
+            mimetype = mimetypes.MimeTypes().guess_type(SCREENSHOT_FILE)[0]
+            self.send_response(200)
+            if mimetype is not None:
+                self.send_header("Content-type", mimetype)
+            self.end_headers()
+            self.wfile.write(imgfile)
+
+
+# Simulated display: write on a file instead of serial port
+class LcdSimulated(LcdComm):
+    def __init__(
+        self,
+        com_port: str = "AUTO",
+        display_width: int = 320,
+        display_height: int = 480,
+        update_queue: Optional[queue.Queue] = None,
+    ):
+        LcdComm.__init__(self, com_port, display_width, display_height, update_queue)
+        self.screen_image = Image.new(
+            "RGB", (self.width(), self.height()), (255, 255, 255)
+        )
+        self.screen_image.save("tmp", "PNG")
+        shutil.copyfile("tmp", SCREENSHOT_FILE)
+        self.orientation = Orientation.PORTRAIT
+
+        try:
+            self.webServer = HTTPServer(
+                ("localhost", WEBSERVER_PORT), SimulatedLcdWebServer
+            )
+            logger.debug(
+                "To see your simulated screen, open http://%s:%d in a browser"
+                % ("localhost", WEBSERVER_PORT)
+            )
+            threading.Thread(target=self.webServer.serve_forever).start()
+        except OSError:
+            logger.error(
+                "Error starting webserver! An instance might already be running on port %d."
+                % WEBSERVER_PORT
+            )
+
+    def __del__(self):
+        self.close_serial()
+
+    @staticmethod
+    def auto_detect_com_port() -> Optional[str]:
+        return None
+
+    def close_serial(self):
+        logger.debug("Shutting down web server")
+        self.webServer.shutdown()
+
+    def initialize_comm(self):
+        pass
+
+    def reset(self):
+        pass
+
+    def clear(self):
+        self.set_orientation(self.orientation)
+
+    def screen_off(self):
+        pass
+
+    def screen_on(self):
+        pass
+
+    def set_brightness(self, level: int = 25):
+        pass
+
+    def set_backplate_led_color(
+        self, led_color: Tuple[int, int, int] = (255, 255, 255)
+    ):
+        pass
+
+    def set_orientation(self, orientation: Orientation = Orientation.PORTRAIT):
+        self.orientation = orientation
+        # Just draw the screen again with the new width/height based on orientation
+        with self.update_queue_mutex:
+            self.screen_image = Image.new(
+                "RGB", (self.width(), self.height()), (255, 255, 255)
+            )
+            self.screen_image.save("tmp", "PNG")
+            shutil.copyfile("tmp", SCREENSHOT_FILE)
+
+    def paint(
+        self,
+        image: Image.Image,
+        pos: Tuple[int, int] = (0, 0),
+    ):
+        image = self._crop_to_display_bounds(image, pos)
+        image_width, image_height = image.size[0], image.size[1]
+
+        if image_height == 0 or image_width == 0:
+            return
+
+        with self.update_queue_mutex:
+            self.screen_image.paste(image, pos)
+            self.screen_image.save("tmp", "PNG")
+            shutil.copyfile("tmp", SCREENSHOT_FILE)

smartscreen_driver/serialize.py

@@ -0,0 +1,58 @@
+from typing import Iterator, Literal
+
+import numpy as np
+from PIL import Image
+
+
+def chunked(data: bytes, chunk_size: int) -> Iterator[bytes]:
+    for i in range(0, len(data), chunk_size):
+        yield data[i : i + chunk_size]
+
+
+def image_to_rgb565(image: Image.Image, endianness: Literal["big", "little"]) -> bytes:
+    if image.mode not in ["RGB", "RGBA"]:
+        # we need the first 3 channels to be R, G and B
+        image = image.convert("RGB")
+
+    rgb = np.asarray(image)
+
+    # flatten the first 2 dimensions (width and height) into a single stream
+    # of RGB pixels
+    rgb = rgb.reshape((image.size[1] * image.size[0], -1))
+
+    # extract R, G, B channels and promote them to 16 bits
+    r = rgb[:, 0].astype(np.uint16)
+    g = rgb[:, 1].astype(np.uint16)
+    b = rgb[:, 2].astype(np.uint16)
+
+    # construct RGB565
+    r = r >> 3
+    g = g >> 2
+    b = b >> 3
+    rgb565 = (r << 11) | (g << 5) | b
+
+    # serialize to the correct endianness
+    if endianness == "big":
+        typ = ">u2"
+    else:
+        typ = "<u2"
+    return rgb565.astype(typ).tobytes()
+
+
+def image_to_bgr(image: Image.Image) -> bytes:
+    if image.mode not in ["RGB", "RGBA"]:
+        # we need the first 3 channels to be R, G and B
+        image = image.convert("RGB")
+    rgb = np.asarray(image)
+    # same as rgb[:, :, [2, 1, 0]] but faster
+    bgr = np.take(rgb, (2, 1, 0), axis=-1)
+    return bgr.tobytes()
+
+
+def image_to_bgra(image: Image.Image) -> bytes:
+    if image.mode != "RGBA":
+        image = image.convert("RGBA")
+    rgba = np.asarray(image)
+    # same as rgba[:, :, [2, 1, 0, 3]] but faster
+    bgra = np.take(rgba, (2, 1, 0, 3), axis=-1)
+    return bgra.tobytes()

smartscreen_driver-0.2.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: smartscreen-driver
+Version: 0.2.0
+Summary: Driver for serial-over-USB displays; library extracted from turing-smart-screen-python
+Author: Mathieu Houdebine
+Author-email: Hugo Chargois <hugo.chargois@free.fr>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pillow>=11.1.0
+Requires-Dist: pyserial>=3.5
+Description-Content-Type: text/markdown
+
+# smartscreen-driver
+
+This package contains drivers for low-cost serial-over-USB displays such as
+the Turing Smart Screen.
+
+This library is simply an extract of the driver code from the
+[turing-smart-screen-python](https://github.com/mathoudebine/turing-smart-screen-python)
+project, removing all the sensors and UI code and dependencies, fixing coding
+conventions violations (PEP8 et al) and adding proper Python packaging.
+
+The usage is straightforward:
+
+- you open the connection with the correct `LcdCommRevX` depending on your display
+- you `paint()` (PIL) images to the display
+
+See `hello_world.py` for an example.

smartscreen_driver-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+smartscreen_driver/lcd_comm.py,sha256=AIkdLZfHFHE8I5TV1OocVvf4j8TBFlm_OBITOG4IQZ8,7608
+smartscreen_driver/lcd_comm_rev_a.py,sha256=vnhd4UaWSVLhxXNBwsKi3f5jcIASBnj2gqQUnePgP7c,8271
+smartscreen_driver/lcd_comm_rev_b.py,sha256=HJaDXKILtdHpuWiKGA5wa_u6q-zvuWhYrr1zcN4T43s,10896
+smartscreen_driver/lcd_comm_rev_c.py,sha256=gxaAcX8IdTIq3V_kd_Bb3C10vSYxyguX0FyROsC6M_Q,13795
+smartscreen_driver/lcd_comm_rev_d.py,sha256=16H_rNbYP66nebAePvZ897FIHjVjIeinLGm7-P2TP_w,7290
+smartscreen_driver/lcd_simulated.py,sha256=ZI6-fUuFeps7_-0AyrQe2Ygo3dF3qfm8ougw0nNRFhE,5624
+smartscreen_driver/serialize.py,sha256=xG_CBRutI8q3D3kTsG7dhLA0QYmQ_5LCZr9bfC4pey8,1671
+smartscreen_driver-0.2.0.dist-info/METADATA,sha256=jlEFh2iP7lE2FXC_KJWOsqL5N2EUWEdOTZ6Sw5d-_HU,1203
+smartscreen_driver-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smartscreen_driver-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+smartscreen_driver-0.2.0.dist-info/RECORD,,

smartscreen_driver-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any