diff --git a/library/lcd/lcd_comm_rev_a.py b/library/lcd/lcd_comm_rev_a.py
index 9b2b9c6f..619311d2 100644
--- a/library/lcd/lcd_comm_rev_a.py
+++ b/library/lcd/lcd_comm_rev_a.py
@@ -21,9 +21,9 @@
from typing import Optional
from serial.tools.list_ports import comports
-import numpy as np
from library.lcd.lcd_comm import *
+from library.lcd.serialize import image_to_RGB565, chunked
from library.log import logger
@@ -173,32 +173,6 @@ def SetOrientation(self, orientation: Orientation = Orientation.PORTRAIT):
byteBuffer[10] = (height & 255)
self.serial_write(bytes(byteBuffer))
- @staticmethod
- def imageToRGB565LE(image: Image.Image):
- 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 little-endian
- return rgb565.astype('.
-import struct
-
from serial.tools.list_ports import comports
from library.lcd.lcd_comm import *
+from library.lcd.serialize import image_to_RGB565, chunked
from library.log import logger
@@ -194,6 +193,13 @@ def SetOrientation(self, orientation: Orientation = Orientation.PORTRAIT):
else:
self.SendCommand(Command.SET_ORIENTATION, payload=[OrientationValueRevB.ORIENTATION_LANDSCAPE])
+ def serialize_image(self, image: Image.Image, height: int, width: int) -> bytes:
+ if image.width != width or image.height != height:
+ image = image.crop((0, 0, width, height))
+ if self.orientation == Orientation.REVERSE_PORTRAIT or self.orientation == Orientation.REVERSE_LANDSCAPE:
+ image = image.rotate(180)
+ return image_to_RGB565(image, "big")
+
def DisplayPILImage(
self,
image: Image.Image,
@@ -231,34 +237,11 @@ def DisplayPILImage(
(y0 >> 8) & 255, y0 & 255,
(x1 >> 8) & 255, x1 & 255,
(y1 >> 8) & 255, y1 & 255])
- pix = image.load()
- line = bytes()
+
+ rgb565be = self.serialize_image(image, image_height, image_width)
# Lock queue mutex then queue all the requests for the image data
with self.update_queue_mutex:
- for h in range(image_height):
- for w in range(image_width):
- if self.orientation == Orientation.PORTRAIT or self.orientation == Orientation.LANDSCAPE:
- R = pix[w, h][0] >> 3
- G = pix[w, h][1] >> 2
- B = pix[w, h][2] >> 3
- else:
- # Manage reverse orientations from software, because display does not manage it
- R = pix[image_width - w - 1, image_height - h - 1][0] >> 3
- G = pix[image_width - w - 1, image_height - h - 1][1] >> 2
- B = pix[image_width - w - 1, image_height - h - 1][2] >> 3
-
- # Color information is 0bRRRRRGGGGGGBBBBB
- # Revision A: Encode in Little-Endian (native x86/ARM encoding)
- # Revition B: Encode in Big-Endian
- rgb = (R << 11) | (G << 5) | B
- line += struct.pack('>H', rgb)
-
- # Send image data by multiple of "display width" bytes
- if len(line) >= self.get_width() * 8:
- self.SendLine(line)
- line = bytes()
-
- # Write last line if needed
- if len(line) > 0:
- self.SendLine(line)
+ # Send image data by multiple of "display width" bytes
+ for chunk in chunked(rgb565be, self.get_width() * 8):
+ self.SendLine(chunk)
diff --git a/library/lcd/lcd_comm_rev_c.py b/library/lcd/lcd_comm_rev_c.py
index 6d4dd2ba..7e41fff2 100644
--- a/library/lcd/lcd_comm_rev_c.py
+++ b/library/lcd/lcd_comm_rev_c.py
@@ -22,13 +22,14 @@
import time
from enum import Enum
from math import ceil
-from typing import Optional
+from typing import Optional, Tuple
import serial
from PIL import Image
from serial.tools.list_ports import comports
from library.lcd.lcd_comm import Orientation, LcdComm
+from library.lcd.serialize import image_to_BGRA, image_to_BGR, chunked
from library.log import logger
@@ -282,6 +283,9 @@ def DisplayPILImage(
if image.size[0] > self.get_width():
image_width = self.get_width()
+ if image_width != image.size[0] or image_height != image.size[1]:
+ image = image.crop((0, 0, image_width, image_height))
+
assert x <= self.get_width(), 'Image X coordinate must be <= display width'
assert y <= self.get_height(), 'Image Y coordinate must be <= display height'
assert image_height > 0, 'Image height must be > 0'
@@ -293,76 +297,67 @@ def DisplayPILImage(
self._send_command(Command.START_DISPLAY_BITMAP, padding=Padding.START_DISPLAY_BITMAP)
self._send_command(Command.DISPLAY_BITMAP)
self._send_command(Command.SEND_PAYLOAD,
- payload=bytearray(self._generate_full_image(image, self.orientation)),
+ payload=bytearray(self._generate_full_image(image)),
readsize=1024)
self._send_command(Command.QUERY_STATUS, readsize=1024)
else:
with self.update_queue_mutex:
- img, pyd = self._generate_update_image(image, x, y, Count.Start, Command.UPDATE_BITMAP,
- self.orientation)
+ img, pyd = self._generate_update_image(image, x, y, Count.Start, Command.UPDATE_BITMAP)
self._send_command(Command.SEND_PAYLOAD, payload=pyd)
self._send_command(Command.SEND_PAYLOAD, payload=img)
self._send_command(Command.QUERY_STATUS, readsize=1024)
Count.Start += 1
- @staticmethod
- def _generate_full_image(image: Image.Image, orientation: Orientation = Orientation.PORTRAIT):
- if orientation == Orientation.PORTRAIT:
+ def _generate_full_image(self, image: Image.Image) -> bytes:
+ if self.orientation == Orientation.PORTRAIT:
image = image.rotate(90, expand=True)
- elif orientation == Orientation.REVERSE_PORTRAIT:
+ elif self.orientation == Orientation.REVERSE_PORTRAIT:
image = image.rotate(270, expand=True)
- elif orientation == Orientation.REVERSE_LANDSCAPE:
+ elif self.orientation == Orientation.REVERSE_LANDSCAPE:
image = image.rotate(180)
- image_data = image.convert("RGBA").load()
- image_ret = ''
- for y in range(image.height):
- for x in range(image.width):
- pixel = image_data[x, y]
- image_ret += f'{pixel[2]:02x}{pixel[1]:02x}{pixel[0]:02x}{pixel[3]:02x}'
+ bgra_data = image_to_BGRA(image)
- hex_data = bytearray.fromhex(image_ret)
- return b'\x00'.join(hex_data[i:i + 249] for i in range(0, len(hex_data), 249))
+ return b'\x00'.join(chunked(bgra_data, 249))
- def _generate_update_image(self, image, x, y, count, cmd: Optional[Command] = None,
- orientation: Orientation = Orientation.PORTRAIT):
+ def _generate_update_image(
+ self, image: Image.Image, x: int, y: int, count: int, cmd: Optional[Command] = None
+ ) -> Tuple[bytearray, bytearray]:
x0, y0 = x, y
- if orientation == Orientation.PORTRAIT:
+ if self.orientation == Orientation.PORTRAIT:
image = image.rotate(90, expand=True)
x0 = self.get_width() - x - image.height
- elif orientation == Orientation.REVERSE_PORTRAIT:
+ elif self.orientation == Orientation.REVERSE_PORTRAIT:
image = image.rotate(270, expand=True)
y0 = self.get_height() - y - image.width
- elif orientation == Orientation.REVERSE_LANDSCAPE:
+ elif self.orientation == Orientation.REVERSE_LANDSCAPE:
image = image.rotate(180, expand=True)
y0 = self.get_width() - x - image.width
x0 = self.get_height() - y - image.height
- elif orientation == Orientation.LANDSCAPE:
+ elif self.orientation == Orientation.LANDSCAPE:
x0, y0 = y, x
- img_raw_data = []
- image_data = image.convert("RGBA").load()
- for h in range(image.height):
- img_raw_data.append(f'{((x0 + h) * self.display_height) + y0:06x}{image.width:04x}')
- for w in range(image.width):
- current_pixel = image_data[w, h]
- img_raw_data.append(f'{current_pixel[2]:02x}{current_pixel[1]:02x}{current_pixel[0]:02x}')
+ img_raw_data = bytearray()
+ bgr_data = image_to_BGR(image)
+ for h, line in enumerate(chunked(bgr_data, image.width * 3)):
+ img_raw_data += int(((x0 + h) * self.display_height) + y0).to_bytes(3, "big")
+ img_raw_data += int(image.width).to_bytes(2, "big")
+ img_raw_data += line
- image_msg = ''.join(img_raw_data)
- image_size = f'{int((len(image_msg) / 2) + 2):06x}' # The +2 is for the "ef69" that will be added later.
+ image_size = int(len(img_raw_data) + 2).to_bytes(3, "big") # The +2 is for the "ef69" that will be added later.
# logger.debug("Render Count: {}".format(count))
payload = bytearray()
if cmd:
payload.extend(cmd.value)
- payload.extend(bytearray.fromhex(image_size))
+ payload.extend(image_size)
payload.extend(Padding.NULL.value * 3)
payload.extend(count.to_bytes(4, 'big'))
- if len(image_msg) > 500:
- image_msg = '00'.join(image_msg[i:i + 498] for i in range(0, len(image_msg), 498))
- image_msg += 'ef69'
+ if len(img_raw_data) > 250:
+ img_raw_data = bytearray(b'\x00').join(chunked(bytes(img_raw_data), 249))
+ img_raw_data += b'\xef\x69'
- return bytearray.fromhex(image_msg), payload
+ return img_raw_data, payload
diff --git a/library/lcd/lcd_comm_rev_d.py b/library/lcd/lcd_comm_rev_d.py
index fcc7e100..65458a69 100644
--- a/library/lcd/lcd_comm_rev_d.py
+++ b/library/lcd/lcd_comm_rev_d.py
@@ -16,12 +16,12 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
-import struct
from enum import Enum
from serial.tools.list_ports import comports
from library.lcd.lcd_comm import *
+from library.lcd.serialize import image_to_RGB565, chunked
from library.log import logger
@@ -109,7 +109,7 @@ def SetBrightness(self, level: int = 25):
# Convert our brightness % to an absolute value.
converted_level = level * 5
- level_bytes = bytearray(converted_level.to_bytes(2))
+ level_bytes = bytearray(converted_level.to_bytes(2, "big"))
# Send the command twice because sometimes it is not applied...
self.SendCommand(cmd=Command.SETBL, payload=level_bytes)
@@ -166,40 +166,22 @@ def DisplayPILImage(
image_width, image_height = image_height, image_width
# Send bitmap size
- image_data = bytearray(x0.to_bytes(2))
- image_data += bytearray(x1.to_bytes(2))
- image_data += bytearray(y0.to_bytes(2))
- image_data += bytearray(y1.to_bytes(2))
+ 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.SendCommand(cmd=Command.BLOCKWRITE, payload=image_data)
# Prepare bitmap data transmission
self.SendCommand(Command.INTOPICMODE)
- pix = image.load()
- line = bytes([80])
+ rgb565be = image_to_RGB565(image, "big")
# Lock queue mutex then queue all the requests for the image data
with self.update_queue_mutex:
- for h in range(image_height):
- for w in range(image_width):
- R = pix[w, h][0] >> 3
- G = pix[w, h][1] >> 2
- B = pix[w, h][2] >> 3
-
- # Color information is 0bRRRRRGGGGGGBBBBB
- # Revision A: Encode in Little-Endian (native x86/ARM encoding)
- # Revition B: Encode in Big-Endian
- rgb = (R << 11) | (G << 5) | B
- line += struct.pack('>H', rgb)
-
- # Send image data by multiple of 64 bytes + 1 command byte
- if len(line) >= 65:
- self.SendLine(line[0:64])
- line = bytes([80]) + line[64:]
-
- # Write last line if needed
- if len(line) > 0:
- self.SendLine(line)
+ for chunk in chunked(rgb565be, 63):
+ self.SendLine(b"\x50" + chunk)
# Indicate the complete bitmap has been transmitted
self.SendCommand(Command.OUTPICMODE)
diff --git a/library/lcd/serialize.py b/library/lcd/serialize.py
new file mode 100644
index 00000000..7f6f63d0
--- /dev/null
+++ b/library/lcd/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 = "