color_bits_inverted: bool = False,
highlight_color: int = 0x000000,
refresh_display_command: Union[int, ReadableBuffer],
- refresh_time: float = 40.0,
+ refresh_time: float = 40,
busy_pin: Optional[microcontroller.Pin] = None,
busy_state: bool = True,
seconds_per_frame: float = 180,
self._start_sequence = start_sequence
self._start_up_time = start_up_time
self._stop_sequence = stop_sequence
- self._refesh_sequence = refresh_sequence
+ self._refresh_sequence = refresh_sequence
self._busy = None
self._two_byte_sequence_length = two_byte_sequence_length
if busy_pin is not None:
self._busy = DigitalInOut(busy_pin)
self._busy.switch_to_input()
+ self._ticks_disabled = False
+
# Clear the color memory if it isn't in use
if highlight_color == 0x00 and write_color_ram_command != NO_COMMAND:
"""TODO: Clear"""
)
display_instance = super().__new__(cls)
- display_instance._refreshing = False
allocate_display(display_instance)
return display_instance
def show(self, group: Group) -> None:
# pylint: disable=unnecessary-pass
- """Switches to displaying the given group of layers. When group is None, the default
+ """
+ .. 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 (eventually).
"""
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 update_refresh_mode(
self, start_sequence: ReadableBuffer, seconds_per_frame: float
) -> None:
def _refresh(self) -> bool:
if self._refreshing and self._busy is not None:
if self._busy.value != self._busy_state:
+ self._ticks_disabled = True
self._refreshing = False
self._send_command_sequence(False, self._stop_sequence)
else:
self._finish_refresh()
while self._refreshing:
# TODO: Add something here that can change self._refreshing
+ # or add something in _background()
pass
self._start_refresh()
for area in areas_to_refresh:
self._refresh_area(area)
- self._core.finish_refresh()
+ self._finish_refresh()
return True
"""Release the display and free its resources"""
if self._refreshing:
self._wait_for_busy()
+ self._ticks_disabled = True
self._refreshing = False
# Run stop sequence but don't wait for busy because busy is set when sleeping
self._send_command_sequence(False, self._stop_sequence)
def _background(self) -> None:
"""Run background refresh tasks."""
+
+ # Wait until initialized
+ if not hasattr(self, "_core"):
+ return
+
+ if self._ticks_disabled:
+ return
+
if self._refreshing:
refresh_done = False
if self._busy is not None:
time.monotonic() * 1000 - self._core.last_refresh
> self._refresh_time
)
+
if refresh_done:
+ self._ticks_disabled = True
self._refreshing = False
- self._finish_refresh()
# Run stop sequence but don't wait for busy because busy is set when sleeping
self._send_command_sequence(False, self._stop_sequence)
def _refresh_area(self, area: Area) -> bool:
"""Redraw the area."""
# 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
-
subrectangles = 1
rows_per_buffer = clipped.height()
pixels_per_word = 32 // self._core.colorspace.depth
if pixels_per_buffer % pixels_per_word:
buffer_size += 1
- mask_length = (pixels_per_buffer // 8) + 1 # 1 bit per pixel + 1
+ mask_length = (pixels_per_buffer // 32) + 1 # 1 bit per pixel + 1
passes = 1
if self._write_color_ram_command != NO_COMMAND:
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
8 // self._core.colorspace.depth
)
- buffer = memoryview(bytearray([0] * (buffer_size * 4)))
- mask = memoryview(bytearray([0] * mask_length))
+ buffer = memoryview(bytearray([0] * (buffer_size * 4))).cast("I")
+ mask = memoryview(bytearray([0] * (mask_length * 4))).cast("I")
if not self._acep:
self._core.colorspace.grayscale = True
if (pass_index == 1 and self._color_bits_inverted) or (
pass_index == 0 and self._black_bits_inverted
):
- for i, _ in enumerate(buffer):
+ for i in range(buffer_size):
buffer[i] = ~buffer[i]
if not self._core.begin_transaction():
# Can't acquire display bus; skip the rest of the data. Try next display.
return False
self._core.send(
- DISPLAY_DATA, self._chip_select, buffer[:subrectangle_size_bytes]
+ DISPLAY_DATA,
+ self._chip_select,
+ buffer.tobytes()[:subrectangle_size_bytes],
)
self._core.end_transaction()
return True
self._core.send(
DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, bytes([command])
)
- self._core.send(
- DISPLAY_DATA,
- CHIP_SELECT_UNTOUCHED,
- data,
- )
+ if data_size > 0:
+ self._core.send(
+ DISPLAY_DATA,
+ CHIP_SELECT_UNTOUCHED,
+ bytes(data),
+ )
self._core.end_transaction()
delay_time_ms = 0
if delay:
def _finish_refresh(self) -> None:
# Actually refresh the display now that all pixel RAM has been updated
- self._send_command_sequence(False, self._refesh_sequence)
+ self._send_command_sequence(False, self._refresh_sequence)
+ self._ticks_disabled = False
self._refreshing = True
self._core.finish_refresh()
def _wait_for_busy(self) -> None:
if self._busy is not None:
- while self._busy.value != self._busy_state:
+ while self._busy.value == self._busy_state:
time.sleep(0.001)
def _clean_area(self) -> bool:
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 time_to_refresh(self) -> float:
"""The root group on the epaper display.
If the root group is set to ``None``, no output will be shown.
"""
- return self._core.root_group
+ return self._core.current_group
@root_group.setter
def root_group(self, new_group: Group) -> None:
- self._core.root_group = new_group
+ self._set_root_group(new_group)
projects / hackapet / Adafruit_Blinka_Displayio.git / blobdiff