"""
import time
-import struct
-from array import array
from typing import Optional
import digitalio
import microcontroller
from ._displaycore import _DisplayCore
from ._displaybus import _DisplayBus
from ._colorconverter import ColorConverter
-from ._group import Group
+from ._group import Group, circuitpython_splash
from ._area import Area
from ._constants import (
CHIP_SELECT_TOGGLE_EVERY_BYTE,
BACKLIGHT_IN_OUT,
BACKLIGHT_PWM,
NO_COMMAND,
+ DELAY,
)
__version__ = "0.0.0+auto.0"
class Display:
- # pylint: disable=too-many-instance-attributes
+ # pylint: disable=too-many-instance-attributes, too-many-statements
"""This initializes a display and connects it into CircuitPython. Unlike other objects
in CircuitPython, Display objects live until ``displayio.release_displays()`` is called.
This is done so that CircuitPython can use the display itself.
backlight_on_high: bool = True,
SH1107_addressing: bool = False,
):
- # pylint: disable=too-many-locals,invalid-name
+ # pylint: disable=too-many-locals,invalid-name, too-many-branches
"""Create a Display object on the given display bus (`displayio.FourWire` or
`paralleldisplay.ParallelBus`).
The initialization sequence should always leave the display memory access inline with
the scan of the display to minimize tearing artifacts.
"""
+
+ if rotation % 90 != 0:
+ raise ValueError("Display rotation must be in 90 degree increments")
+
+ if SH1107_addressing and color_depth != 1:
+ raise ValueError("color_depth must be 1 when SH1107_addressing is True")
+
# Turn off auto-refresh as we init
self._auto_refresh = False
ram_width = 0x100
self._brightness = brightness
self._auto_refresh = auto_refresh
- self._initialize(init_sequence)
+ i = 0
+ while i < len(init_sequence):
+ command = init_sequence[i]
+ data_size = init_sequence[i + 1]
+ delay = (data_size & DELAY) != 0
+ data_size &= ~DELAY
+ while self._core.begin_transaction():
+ pass
+
+ if self._core.data_as_commands:
+ full_command = bytearray(data_size + 1)
+ full_command[0] = command
+ full_command[1:] = init_sequence[i + 2 : i + 2 + data_size]
+ self._core.send(
+ DISPLAY_COMMAND,
+ CHIP_SELECT_TOGGLE_EVERY_BYTE,
+ full_command,
+ )
+ else:
+ self._core.send(
+ DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, bytes([command])
+ )
+ self._core.send(
+ DISPLAY_DATA,
+ CHIP_SELECT_UNTOUCHED,
+ init_sequence[i + 2 : i + 2 + data_size],
+ )
+ self._core.end_transaction()
+ delay_time_ms = 10
+ if delay:
+ data_size += 1
+ delay_time_ms = init_sequence[i + 1 + data_size]
+ if delay_time_ms == 255:
+ delay_time_ms = 500
+ time.sleep(delay_time_ms / 1000)
+ i += 2 + data_size
+
self._current_group = None
self._last_refresh_call = 0
self._refresh_thread = None
- if self._auto_refresh:
- self.auto_refresh = True
self._colorconverter = ColorConverter()
self._backlight_type = None
self._backlight_type = BACKLIGHT_IN_OUT
self._backlight = digitalio.DigitalInOut(backlight_pin)
self._backlight.switch_to_output()
- self.brightness = brightness
+ self.brightness = brightness
+ if not circuitpython_splash._in_group:
+ self._set_root_group(circuitpython_splash)
+ self.auto_refresh = auto_refresh
def __new__(cls, *args, **kwargs):
from . import ( # pylint: disable=import-outside-toplevel, cyclic-import
allocate_display(display_instance)
return display_instance
- def _initialize(self, init_sequence):
- i = 0
- while i < len(init_sequence):
- command = init_sequence[i]
- data_size = init_sequence[i + 1]
- delay = (data_size & 0x80) > 0
- data_size &= ~0x80
-
- if self._core.data_as_commands:
- self._core.send(
- DISPLAY_COMMAND,
- CHIP_SELECT_TOGGLE_EVERY_BYTE,
- bytes([command]) + init_sequence[i + 2 : i + 2 + data_size],
- )
- else:
- self._core.send(
- DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, bytes([command])
- )
- self._core.send(
- DISPLAY_DATA,
- CHIP_SELECT_UNTOUCHED,
- init_sequence[i + 2 : i + 2 + data_size],
- )
- delay_time_ms = 10
- if delay:
- data_size += 1
- delay_time_ms = init_sequence[i + 1 + data_size]
- if delay_time_ms == 255:
- delay_time_ms = 500
- time.sleep(delay_time_ms / 1000)
- i += 2 + data_size
-
def _send_pixels(self, pixels):
if not self._core.data_as_commands:
self._core.send(
self._core.send(DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, pixels)
def show(self, group: Group) -> None:
- """Switches to displaying the given group of layers. When group is None, the
+ """
+ .. note:: `show()` is deprecated and will be removed when CircuitPython 9.0.0
+ is released. Use ``.root_group = group`` instead.
+
+ Switches to displaying the given group of layers. When group is None, the
default CircuitPython terminal will be shown.
+
+ :param Group group: The group to show.
"""
- self._core.show(group)
+ if group is None:
+ group = circuitpython_splash
+ self._core.set_root_group(group)
+
+ def _set_root_group(self, root_group: Group) -> None:
+ ok = self._core.set_root_group(root_group)
+ if not ok:
+ raise ValueError("Group already used")
def refresh(
self,
)
return areas
- def background(self):
+ def _background(self):
"""Run background refresh tasks. Do not call directly"""
if (
self._auto_refresh
def _refresh_area(self, area) -> bool:
"""Loop through dirty areas and redraw that area."""
- # pylint: disable=too-many-locals
- buffer_size = 128
+ # pylint: disable=too-many-locals, too-many-branches
clipped = Area()
+ # Clip the area to the display by overlapping the areas.
+ # If there is no overlap then we're done.
if not self._core.clip_area(area, clipped):
return True
rows_per_buffer = clipped.height()
- pixels_per_word = (struct.calcsize("I") * 8) // self._core.colorspace.depth
+ pixels_per_word = 32 // self._core.colorspace.depth
pixels_per_buffer = clipped.size()
- subrectangles = 1
+ # We should have lots of memory
+ buffer_size = clipped.size() // pixels_per_word
+ subrectangles = 1
+ # for SH1107 and other boundary constrained controllers
+ # write one single row at a time
if self._core.sh1107_addressing:
subrectangles = rows_per_buffer // 8
rows_per_buffer = 8
rows_per_buffer = buffer_size * pixels_per_word // clipped.width()
if rows_per_buffer == 0:
rows_per_buffer = 1
+ # If pixels are packed by column then ensure rows_per_buffer is on a byte boundary
if (
self._core.colorspace.depth < 8
and self._core.colorspace.pixels_in_byte_share_row
buffer_size = pixels_per_buffer // pixels_per_word
if pixels_per_buffer % pixels_per_word:
buffer_size += 1
-
- buffer = bytearray([0] * (buffer_size * struct.calcsize("I")))
- mask_length = (pixels_per_buffer // 32) + 1
- mask = array("L", [0] * mask_length)
+ mask_length = (pixels_per_buffer // 32) + 1 # 1 bit per pixel + 1
remaining_rows = clipped.height()
for subrect_index in range(subrectangles):
subrectangle = Area(
- clipped.x1,
- clipped.y1 + rows_per_buffer * subrect_index,
- clipped.x2,
- clipped.y1 + rows_per_buffer * (subrect_index + 1),
+ x1=clipped.x1,
+ y1=clipped.y1 + rows_per_buffer * subrect_index,
+ x2=clipped.x2,
+ y2=clipped.y1 + rows_per_buffer * (subrect_index + 1),
)
if remaining_rows < rows_per_buffer:
subrectangle.y2 = subrectangle.y1 + remaining_rows
+ remaining_rows -= rows_per_buffer
self._core.set_region_to_update(subrectangle)
if self._core.colorspace.depth >= 8:
subrectangle_size_bytes = subrectangle.size() * (
8 // self._core.colorspace.depth
)
+ buffer = memoryview(bytearray([0] * (buffer_size * 4))).cast("I")
+ mask = memoryview(bytearray([0] * (mask_length * 4))).cast("I")
self._core.fill_area(subrectangle, mask, buffer)
+ # Can't acquire display bus; skip the rest of the data.
+ if not self._core.bus_free():
+ return False
+
self._core.begin_transaction()
- self._send_pixels(buffer[:subrectangle_size_bytes])
+ self._send_pixels(buffer.tobytes()[:subrectangle_size_bytes])
self._core.end_transaction()
return True
raise ValueError("Display must have a 16 bit colorspace.")
area = Area(0, y, self._core.width, y + 1)
- pixels_per_word = (struct.calcsize("I") * 8) // self._core.colorspace.depth
+ pixels_per_word = 32 // self._core.colorspace.depth
buffer_size = self._core.width // pixels_per_word
pixels_per_buffer = area.size()
if pixels_per_buffer % pixels_per_word:
buffer_size += 1
- buffer = bytearray([0] * (buffer_size * struct.calcsize("I")))
+ buffer = memoryview(bytearray([0] * (buffer_size * 4))).cast("I")
mask_length = (pixels_per_buffer // 32) + 1
- mask = array("L", [0x00000000] * mask_length)
+ mask = memoryview(bytearray([0] * (mask_length * 4))).cast("I")
self._core.fill_area(area, mask, buffer)
return buffer
- def release(self) -> None:
+ def _release(self) -> None:
"""Release the display and free its resources"""
self.auto_refresh = False
self._core.release_display_core()
- def reset(self) -> None:
+ def _reset(self) -> None:
"""Reset the display"""
self.auto_refresh = True
+ circuitpython_splash.x = 0
+ circuitpython_splash.y = 0
+ if not circuitpython_splash._in_group: # pylint: disable=protected-access
+ self._set_root_group(circuitpython_splash)
@property
def auto_refresh(self) -> bool:
elif self._backlight_type == BACKLIGHT_IN_OUT:
self._backlight.value = value > 0.99
elif self._brightness_command is not None:
- self._core.begin_transaction()
- if self._core.data_as_commands:
- self._core.send(
- DISPLAY_COMMAND,
- CHIP_SELECT_TOGGLE_EVERY_BYTE,
- bytes([self._brightness_command, 0xFF * value]),
- )
- else:
- self._core.send(
- DISPLAY_COMMAND,
- CHIP_SELECT_TOGGLE_EVERY_BYTE,
- bytes([self._brightness_command]),
- )
- self._core.send(
- DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, round(value * 255)
- )
- self._core.end_transaction()
+ okay = self._core.begin_transaction()
+ if okay:
+ if self._core.data_as_commands:
+ self._core.send(
+ DISPLAY_COMMAND,
+ CHIP_SELECT_TOGGLE_EVERY_BYTE,
+ bytes([self._brightness_command, round(0xFF * value)]),
+ )
+ else:
+ self._core.send(
+ DISPLAY_COMMAND,
+ CHIP_SELECT_TOGGLE_EVERY_BYTE,
+ bytes([self._brightness_command]),
+ )
+ self._core.send(
+ DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, round(value * 255)
+ )
+ self._core.end_transaction()
self._brightness = value
else:
raise ValueError("Brightness must be between 0.0 and 1.0")
@rotation.setter
def rotation(self, value: int):
+ if value % 90 != 0:
+ raise ValueError("Display rotation must be in 90 degree increments")
+ transposed = self._core.rotation in (90, 270)
+ will_transposed = value in (90, 270)
+ if transposed != will_transposed:
+ self._core.width, self._core.height = self._core.height, self._core.width
self._core.set_rotation(value)
+ if self._core.current_group is not None:
+ self._core.current_group._update_transform( # pylint: disable=protected-access
+ self._core.transform
+ )
@property
def bus(self) -> _DisplayBus:
"""Current Display Bus"""
return self._core.get_bus()
+
+ @property
+ def root_group(self) -> Group:
+ """The root group on the display.
+ If the root group is set to `displayio.CIRCUITPYTHON_TERMINAL`, the default
+ CircuitPython terminal will be shown.
+ If the root group is set to ``None``, no output will be shown."""
+ return self._core.current_group
+
+ @root_group.setter
+ def root_group(self, new_group: Group) -> None:
+ self._set_root_group(new_group)
projects / hackapet / Adafruit_Blinka_Displayio.git / blobdiff