displayio/_displaycore.py

   1 # SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
   2 # SPDX-FileCopyrightText: 2021 James Carr
   3 #
   4 # SPDX-License-Identifier: MIT
   5
   6 """
   7 `displayio._displaycore`
   8 ================================================================================
   9
  10 Super class of the display classes
  11
  12 **Software and Dependencies:**
  13
  14 * Adafruit Blinka:
  15   https://github.com/adafruit/Adafruit_Blinka/releases
  16
  17 * Author(s): James Carr, Melissa LeBlanc-Williams
  18
  19 """
  20
  21 __version__ = "0.0.0+auto.0"
  22 __repo__ = "https://github.com/adafruit/Adafruit_Blinka_Displayio.git"
  23
  24
  25 import time
  26 import struct
  27 from circuitpython_typing import WriteableBuffer, ReadableBuffer
  28 from paralleldisplay import ParallelBus
  29 from ._fourwire import FourWire
  30 from ._group import Group
  31 from ._i2cdisplay import I2CDisplay
  32 from ._structs import ColorspaceStruct, TransformStruct
  33 from ._area import Area
  34 from ._displaybus import _DisplayBus
  35 from ._helpers import bswap16
  36 from ._constants import (
  37     CHIP_SELECT_UNTOUCHED,
  38     CHIP_SELECT_TOGGLE_EVERY_BYTE,
  39     DISPLAY_COMMAND,
  40     DISPLAY_DATA,
  41     NO_COMMAND,
  42 )
  43
  44
  45 class _DisplayCore:
  46     # pylint: disable=too-many-arguments, too-many-instance-attributes, too-many-locals, too-many-branches, too-many-statements
  47
  48     def __init__(
  49         self,
  50         bus,
  51         width: int,
  52         height: int,
  53         ram_width: int,
  54         ram_height: int,
  55         colstart: int,
  56         rowstart: int,
  57         rotation: int,
  58         color_depth: int,
  59         grayscale: bool,
  60         pixels_in_byte_share_row: bool,
  61         bytes_per_cell: int,
  62         reverse_pixels_in_byte: bool,
  63         reverse_bytes_in_word: bool,
  64         column_command: int,
  65         row_command: int,
  66         set_current_column_command: int,
  67         set_current_row_command: int,
  68         data_as_commands: bool,
  69         always_toggle_chip_select: bool,
  70         sh1107_addressing: bool,
  71         address_little_endian: bool,
  72     ):
  73         self.colorspace = ColorspaceStruct(
  74             depth=color_depth,
  75             grayscale=grayscale,
  76             grayscale_bit=8 - color_depth,
  77             pixels_in_byte_share_row=pixels_in_byte_share_row,
  78             bytes_per_cell=bytes_per_cell,
  79             reverse_pixels_in_byte=reverse_pixels_in_byte,
  80             reverse_bytes_in_word=reverse_bytes_in_word,
  81             dither=False,
  82         )
  83         self.current_group = None
  84         self.colstart = colstart
  85         self.rowstart = rowstart
  86         self.last_refresh = 0
  87
  88         self.column_command = column_command
  89         self.row_command = row_command
  90         self.set_current_column_command = set_current_column_command
  91         self.set_current_row_command = set_current_row_command
  92         self.data_as_commands = data_as_commands
  93         self.always_toggle_chip_select = always_toggle_chip_select
  94         self.sh1107_addressing = sh1107_addressing
  95         self.address_little_endian = address_little_endian
  96
  97         self.refresh_in_progress = False
  98         self.full_refresh = False
  99         self.last_refresh = 0
 100
 101         if bus:
 102             if isinstance(bus, (FourWire, I2CDisplay, ParallelBus)):
 103                 self._bus_reset = bus.reset
 104                 self._begin_transaction = bus._begin_transaction
 105                 self._send = bus._send
 106                 self._end_transaction = bus._end_transaction
 107             else:
 108                 raise ValueError("Unsupported display bus type")
 109
 110         self._bus = bus
 111         self.area = Area(0, 0, width, height)
 112
 113         self.width = width
 114         self.height = height
 115         self.ram_width = ram_width
 116         self.ram_height = ram_height
 117         self.rotation = rotation
 118         self.transform = TransformStruct()
 119
 120     def set_rotation(self, rotation: int) -> None:
 121         """
 122         Sets the rotation of the display as an int in degrees.
 123         """
 124         # pylint: disable=protected-access, too-many-branches
 125         transposed = self.rotation in (90, 270)
 126         will_be_transposed = rotation in (90, 270)
 127         if transposed != will_be_transposed:
 128             self.width, self.height = self.height, self.width
 129
 130         height = self.height
 131         width = self.width
 132
 133         rotation %= 360
 134         self.rotation = rotation
 135         self.transform.x = 0
 136         self.transform.y = 0
 137         self.transform.scale = 1
 138         self.transform.mirror_x = False
 139         self.transform.mirror_y = False
 140         self.transform.transpose_xy = False
 141
 142         if rotation in (0, 180):
 143             if rotation == 180:
 144                 self.transform.mirror_x = True
 145                 self.transform.mirror_y = True
 146         else:
 147             self.transform.transpose_xy = True
 148             if rotation == 270:
 149                 self.transform.mirror_y = True
 150             else:
 151                 self.transform.mirror_x = True
 152
 153         self.area.x1 = 0
 154         self.area.y1 = 0
 155         self.area.next = None
 156
 157         self.transform.dx = 1
 158         self.transform.dy = 1
 159         if self.transform.transpose_xy:
 160             self.area.x2 = height
 161             self.area.y2 = width
 162             if self.transform.mirror_x:
 163                 self.transform.x = height
 164                 self.transform.dx = -1
 165             if self.transform.mirror_y:
 166                 self.transform.y = width
 167                 self.transform.dy = -1
 168         else:
 169             self.area.x2 = width
 170             self.area.y2 = height
 171             if self.transform.mirror_x:
 172                 self.transform.x = width
 173                 self.transform.dx = -1
 174             if self.transform.mirror_y:
 175                 self.transform.y = height
 176                 self.transform.dy = -1
 177
 178         if self.current_group is not None:
 179             self.current_group._update_transform(self.transform)
 180
 181     def set_root_group(self, root_group: Group) -> bool:
 182         """
 183         Switches to displaying the given group of layers. When group is `None`, the
 184         default CircuitPython terminal will be shown.
 185
 186         :param Optional[displayio.Group] root_group: The group to show.
 187         """
 188         # pylint: disable=protected-access
 189
 190         if root_group == self.current_group:
 191             return True
 192
 193         if root_group is not None and root_group._in_group:
 194             return False
 195
 196         if self.current_group is not None:
 197             self.current_group._in_group = False
 198
 199         if root_group is not None:
 200             root_group._update_transform(self.transform)
 201             root_group._in_group = True
 202
 203         self.current_group = root_group
 204         self.full_refresh = True
 205
 206         return True
 207
 208     def start_refresh(self) -> bool:
 209         # pylint: disable=protected-access
 210         """Mark the display core as currently being refreshed"""
 211
 212         if self.refresh_in_progress:
 213             return False
 214
 215         self.refresh_in_progress = True
 216         self.last_refresh = time.monotonic() * 1000
 217         return True
 218
 219     def finish_refresh(self) -> None:
 220         # pylint: disable=protected-access
 221         """Unmark the display core as currently being refreshed"""
 222
 223         if self.current_group is not None:
 224             self.current_group._finish_refresh()
 225
 226         self.full_refresh = False
 227         self.refresh_in_progress = False
 228         self.last_refresh = time.monotonic() * 1000
 229
 230     def release_display_core(self) -> None:
 231         """Release the display from the current group"""
 232         # pylint: disable=protected-access
 233
 234         if self.current_group is not None:
 235             self.current_group._in_group = False
 236
 237     def fill_area(
 238         self,
 239         area: Area,
 240         mask: WriteableBuffer,
 241         buffer: WriteableBuffer,
 242     ) -> bool:
 243         """Call the current group's fill area function"""
 244         if self.current_group is not None:
 245             return self.current_group._fill_area(  # pylint: disable=protected-access
 246                 self.colorspace, area, mask, buffer
 247             )
 248         return False
 249
 250     def clip_area(self, area: Area, clipped: Area) -> bool:
 251         """Shrink the area to the region shared by the two areas"""
 252
 253         overlaps = self.area.compute_overlap(area, clipped)
 254         if not overlaps:
 255             return False
 256
 257         # Expand the area if we have multiple pixels per byte and we need to byte
 258         # align the bounds
 259         if self.colorspace.depth < 8:
 260             pixels_per_byte = (
 261                 8 // self.colorspace.depth * self.colorspace.bytes_per_cell
 262             )
 263             if self.colorspace.pixels_in_byte_share_row:
 264                 if clipped.x1 % pixels_per_byte != 0:
 265                     clipped.x1 -= clipped.x1 % pixels_per_byte
 266                 if clipped.x2 % pixels_per_byte != 0:
 267                     clipped.x2 += pixels_per_byte - clipped.x2 % pixels_per_byte
 268             else:
 269                 if clipped.y1 % pixels_per_byte != 0:
 270                     clipped.y1 -= clipped.y1 % pixels_per_byte
 271                 if clipped.y2 % pixels_per_byte != 0:
 272                     clipped.y2 += pixels_per_byte - clipped.y2 % pixels_per_byte
 273
 274         return True
 275
 276     def set_region_to_update(self, area: Area) -> None:
 277         """Set the region to update"""
 278         region_x1 = area.x1 + self.colstart
 279         region_x2 = area.x2 + self.colstart
 280         region_y1 = area.y1 + self.rowstart
 281         region_y2 = area.y2 + self.rowstart
 282
 283         if self.colorspace.depth < 8:
 284             pixels_per_byte = 8 // self.colorspace.depth
 285             if self.colorspace.pixels_in_byte_share_row:
 286                 region_x1 //= pixels_per_byte * self.colorspace.bytes_per_cell
 287                 region_x2 //= pixels_per_byte * self.colorspace.bytes_per_cell
 288             else:
 289                 region_y1 //= pixels_per_byte * self.colorspace.bytes_per_cell
 290                 region_y2 //= pixels_per_byte * self.colorspace.bytes_per_cell
 291
 292         region_x2 -= 1
 293         region_y2 -= 1
 294
 295         chip_select = CHIP_SELECT_UNTOUCHED
 296         if self.always_toggle_chip_select or self.data_as_commands:
 297             chip_select = CHIP_SELECT_TOGGLE_EVERY_BYTE
 298
 299         # Set column
 300         self.begin_transaction()
 301         data_type = DISPLAY_DATA
 302         if not self.data_as_commands:
 303             self.send(
 304                 DISPLAY_COMMAND, CHIP_SELECT_UNTOUCHED, bytes([self.column_command])
 305             )
 306         else:
 307             data_type = DISPLAY_COMMAND
 308
 309         if self.ram_width < 0x100:  # Single Byte Bounds
 310             data = struct.pack(">BB", region_x1, region_x2)
 311         else:
 312             if self.address_little_endian:
 313                 region_x1 = bswap16(region_x1)
 314                 region_x2 = bswap16(region_x2)
 315             data = struct.pack(">HH", region_x1, region_x2)
 316
 317         # Quirk for SH1107 "SH1107_addressing"
 318         #     Column lower command = 0x00, Column upper command = 0x10
 319         if self.sh1107_addressing:
 320             data = struct.pack(
 321                 ">BB",
 322                 ((region_x1 >> 4) & 0xF0) | 0x10,  # 0x10 to 0x17
 323                 region_x1 & 0x0F,  # 0x00 to 0x0F
 324             )
 325
 326         self.send(data_type, chip_select, data)
 327         self.end_transaction()
 328
 329         if self.set_current_column_command != NO_COMMAND:
 330             self.begin_transaction()
 331             self.send(
 332                 DISPLAY_COMMAND, chip_select, bytes([self.set_current_column_command])
 333             )
 334             # Only send the first half of data because it is the first coordinate.
 335             self.send(DISPLAY_DATA, chip_select, data[: len(data) // 2])
 336             self.end_transaction()
 337
 338         # Set row
 339         self.begin_transaction()
 340
 341         if not self.data_as_commands:
 342             self.send(DISPLAY_COMMAND, CHIP_SELECT_UNTOUCHED, bytes([self.row_command]))
 343
 344         if self.ram_width < 0x100:  # Single Byte Bounds
 345             data = struct.pack(">BB", region_y1, region_y2)
 346         else:
 347             if self.address_little_endian:
 348                 region_y1 = bswap16(region_y1)
 349                 region_y2 = bswap16(region_y2)
 350             data = struct.pack(">HH", region_y1, region_y2)
 351
 352         # Quirk for SH1107 "SH1107_addressing"
 353         #     Page address command = 0xB0
 354         if self.sh1107_addressing:
 355             data = struct.pack(">B", 0xB0 | region_y1)
 356
 357         self.send(data_type, chip_select, data)
 358         self.end_transaction()
 359
 360         if self.set_current_row_command != NO_COMMAND:
 361             self.begin_transaction()
 362             self.send(
 363                 DISPLAY_COMMAND, chip_select, bytes([self.set_current_row_command])
 364             )
 365             # Only send the first half of data because it is the first coordinate.
 366             self.send(DISPLAY_DATA, chip_select, data[: len(data) // 2])
 367             self.end_transaction()
 368
 369         """
 370         img = self._buffer.convert("RGB").crop(astuple(area))
 371         img = img.rotate(360 - self._core.rotation, expand=True)
 372
 373         display_area = self._apply_rotation(area)
 374
 375         img = img.crop(astuple(display_area))
 376
 377         data = numpy.array(img).astype("uint16")
 378         color = (
 379             ((data[:, :, 0] & 0xF8) << 8)
 380             | ((data[:, :, 1] & 0xFC) << 3)
 381             | (data[:, :, 2] >> 3)
 382         )
 383
 384         pixels = bytes(
 385             numpy.dstack(((color >> 8) & 0xFF, color & 0xFF)).flatten().tolist()
 386         )
 387         """
 388
 389     def send(
 390         self,
 391         data_type: int,
 392         chip_select: int,
 393         data: ReadableBuffer,
 394     ) -> None:
 395         """
 396         Send the data to the current bus
 397         """
 398         self._send(data_type, chip_select, data)
 399
 400     def begin_transaction(self) -> bool:
 401         """
 402         Begin Bus Transaction
 403         """
 404         return self._begin_transaction()
 405
 406     def end_transaction(self) -> None:
 407         """
 408         End Bus Transaction
 409         """
 410         self._end_transaction()
 411
 412     def get_width(self) -> int:
 413         """
 414         Gets the width of the display in pixels.
 415         """
 416         return self.width
 417
 418     def get_height(self) -> int:
 419         """
 420         Gets the height of the display in pixels.
 421         """
 422         return self.height
 423
 424     def get_rotation(self) -> int:
 425         """
 426         Gets the rotation of the display as an int in degrees.
 427         """
 428         return self.rotation
 429
 430     def get_bus(self) -> _DisplayBus:
 431         """
 432         The bus being used by the display. [readonly]
 433         """
 434         return self._bus