-# The MIT License (MIT)
+# SPDX-FileCopyrightText: 2020 Melissa LeBlanc-Williams for Adafruit Industries
#
-# Copyright (c) 2020 Melissa LeBlanc-Williams for Adafruit Industries
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# SPDX-License-Identifier: MIT
"""
`displayio.display`
import time
import struct
import threading
+import digitalio
from PIL import Image
import numpy
from recordclass import recordclass
+from displayio.colorconverter import ColorConverter
__version__ = "0.0.0-auto.0"
__repo__ = "https://github.com/adafruit/Adafruit_Blinka_displayio.git"
Rectangle = recordclass("Rectangle", "x1 y1 x2 y2")
displays = []
-# pylint: disable=unnecessary-pass, unused-argument
+BACKLIGHT_IN_OUT = 1
+BACKLIGHT_PWM = 2
+
-# pylint: disable=too-many-instance-attributes
class Display:
+ # pylint: disable=too-many-instance-attributes
"""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.
Most people should not use this class directly. Use a specific display driver instead
that will contain the initialization sequence at minimum.
-
- .. class::
- Display(display_bus, init_sequence, *, width, height, colstart=0, rowstart=0, rotation=0,
- color_depth=16, grayscale=False, pixels_in_byte_share_row=True, bytes_per_cell=1,
- reverse_pixels_in_byte=False, set_column_command=0x2a, set_row_command=0x2b,
- write_ram_command=0x2c, set_vertical_scroll=0, backlight_pin=None, brightness_command=None,
- brightness=1.0, auto_brightness=False, single_byte_bounds=False, data_as_commands=False,
- auto_refresh=True, native_frames_per_second=60)
"""
- # pylint: disable=too-many-locals
def __init__(
self,
display_bus,
auto_refresh=True,
native_frames_per_second=60
):
+ # pylint: disable=unused-argument,too-many-locals
"""Create a Display object on the given display bus (`displayio.FourWire` or
`displayio.ParallelBus`).
excluding any delay byte. The third through final bytes are the remaining command
parameters. The next byte will begin a new command definition. Here is a portion of
ILI9341 init code:
+
.. code-block:: python
init_sequence = (
- b"\xe1\x0f\x00\x0E\x14\x03\x11\x07\x31\xC1\x48\x08\x0F\x0C\x31\x36\x0F"
- b"\x11\x80\x78"# Exit Sleep then delay 0x78 (120ms)
- b"\x29\x80\x78"# Display on then delay 0x78 (120ms)
+ b"\\xE1\\x0F\\x00\\x0E\\x14\\x03\\x11\\x07\\x31\
+\\xC1\\x48\\x08\\x0F\\x0C\\x31\\x36\\x0F"
+ b"\\x11\\x80\\x78" # Exit Sleep then delay 0x78 (120ms)
+ b"\\x29\\x80\\x78" # Display on then delay 0x78 (120ms)
)
display = displayio.Display(display_bus, init_sequence, width=320, height=240)
- The first command is 0xe1 with 15 (0xf) parameters following. The second and third
+ The first command is 0xE1 with 15 (0x0F) parameters following. The second and third
are 0x11 and 0x29 respectively with delays (0x80) of 120ms (0x78) and no parameters.
Multiple byte literals (b”“) are merged together on load. The parens are needed to
allow byte literals on subsequent lines.
self._rowstart = rowstart
self._rotation = rotation
self._auto_brightness = auto_brightness
- self._brightness = brightness
+ self._brightness = 1.0
self._auto_refresh = auto_refresh
self._initialize(init_sequence)
self._buffer = Image.new("RGB", (width, height))
self._refresh_thread = None
if self._auto_refresh:
self.auto_refresh = True
-
- # pylint: enable=too-many-locals
+ self._colorconverter = ColorConverter()
+
+ self._backlight_type = None
+ if backlight_pin is not None:
+ try:
+ from pulseio import PWMOut # pylint: disable=import-outside-toplevel
+
+ # 100Hz looks decent and doesn't keep the CPU too busy
+ self._backlight = PWMOut(backlight_pin, frequency=100, duty_cycle=0)
+ self._backlight_type = BACKLIGHT_PWM
+ except ImportError:
+ # PWMOut not implemented on this platform
+ pass
+ if self._backlight_type is None:
+ self._backlight_type = BACKLIGHT_IN_OUT
+ self._backlight = digitalio.DigitalInOut(backlight_pin)
+ self._backlight.switch_to_output()
+ self.brightness = brightness
def _initialize(self, init_sequence):
i = 0
data_size = init_sequence[i + 1]
delay = (data_size & 0x80) > 0
data_size &= ~0x80
+
self._write(command, init_sequence[i + 2 : i + 2 + data_size])
delay_time_ms = 10
if delay:
i += 2 + data_size
def _write(self, command, data):
- if self._single_byte_bounds:
- self._bus.send(True, bytes([command]) + data, toggle_every_byte=True)
+ self._bus.begin_transaction()
+ if self._data_as_commands:
+ if command is not None:
+ self._bus.send(True, bytes([command]), toggle_every_byte=True)
+ self._bus.send(command is not None, data)
else:
self._bus.send(True, bytes([command]), toggle_every_byte=True)
self._bus.send(False, data)
+ self._bus.end_transaction()
def _release(self):
- self._bus.release()
+ self._bus._release() # pylint: disable=protected-access
self._bus = None
def show(self, group):
self._current_group = group
def refresh(self, *, target_frames_per_second=60, minimum_frames_per_second=1):
+ # pylint: disable=unused-argument
"""When auto refresh is off, waits for the target frame rate and then refreshes the
display, returning True. If the call has taken too long since the last refresh call
for the given target frame rate, then the refresh returns False immediately without
When auto refresh is on, updates the display immediately. (The display will also
update without calls to this.)
"""
+ self._subrectangles = []
+
# Go through groups and and add each to buffer
if self._current_group is not None:
buffer = Image.new("RGBA", (self._width, self._height))
# save image to buffer (or probably refresh buffer so we can compare)
self._buffer.paste(buffer)
- # Eventually calculate dirty rectangles here
- self._subrectangles.append(Rectangle(0, 0, self._width, self._height))
+ if self._current_group is not None:
+ # Eventually calculate dirty rectangles here
+ self._subrectangles.append(Rectangle(0, 0, self._width, self._height))
for area in self._subrectangles:
self._refresh_display_area(area)
def _refresh_display_area(self, rectangle):
"""Loop through dirty rectangles and redraw that area."""
- img = self._buffer.crop(rectangle).convert("RGB")
- img = img.rotate(self._rotation)
+ img = self._buffer.convert("RGB").crop(rectangle)
+ img = img.rotate(self._rotation, expand=True)
+
+ display_rectangle = self._apply_rotation(rectangle)
+ img = img.crop(self._clip(display_rectangle))
data = numpy.array(img).astype("uint16")
color = (
| (data[:, :, 2] >> 3)
)
- pixels = list(
+ pixels = bytes(
numpy.dstack(((color >> 8) & 0xFF, color & 0xFF)).flatten().tolist()
)
- display_rectangle = self._apply_rotation(rectangle)
-
self._write(
self._set_column_command,
self._encode_pos(
),
)
- self._write(self._write_ram_command, pixels)
+ if self._data_as_commands:
+ self._write(None, pixels)
+ else:
+ self._write(self._write_ram_command, pixels)
+
+ def _clip(self, rectangle):
+ if self._rotation in (90, 270):
+ width, height = self._height, self._width
+ else:
+ width, height = self._width, self._height
+
+ if rectangle.x1 < 0:
+ rectangle.x1 = 0
+ if rectangle.y1 < 0:
+ rectangle.y1 = 0
+ if rectangle.x2 > width:
+ rectangle.x2 = width
+ if rectangle.y2 > height:
+ rectangle.y2 = height
+
+ return rectangle
def _apply_rotation(self, rectangle):
"""Adjust the rectangle coordinates based on rotation"""
if self._rotation == 90:
return Rectangle(
- self._width - rectangle.y2,
+ self._height - rectangle.y2,
rectangle.x1,
- self._width - rectangle.y1,
+ self._height - rectangle.y1,
rectangle.x2,
)
if self._rotation == 180:
if self._rotation == 270:
return Rectangle(
rectangle.y1,
- self._height - rectangle.x2,
+ self._width - rectangle.x2,
rectangle.y2,
- self._height - rectangle.x1,
+ self._width - rectangle.x1,
)
return rectangle
def fill_row(self, y, buffer):
"""Extract the pixels from a single row"""
- pass
+ for x in range(0, self._width):
+ _rgb_565 = self._colorconverter.convert(self._buffer.getpixel((x, y)))
+ buffer[x * 2] = (_rgb_565 >> 8) & 0xFF
+ buffer[x * 2 + 1] = _rgb_565 & 0xFF
+ return buffer
@property
def auto_refresh(self):
@brightness.setter
def brightness(self, value):
- self._brightness = value
+ if 0 <= float(value) <= 1.0:
+ self._brightness = value
+ if self._backlight_type == BACKLIGHT_IN_OUT:
+ self._backlight.value = round(self._brightness)
+ elif self._backlight_type == BACKLIGHT_PWM:
+ self._backlight.duty_cycle = self._brightness * 65535
+ elif self._brightness_command is not None:
+ self._write(self._brightness_command, round(value * 255))
+ else:
+ raise ValueError("Brightness must be between 0.0 and 1.0")
@property
def auto_brightness(self):
def bus(self):
"""Current Display Bus"""
return self._bus
-
-
-# pylint: enable=too-many-instance-attributes
projects / hackapet / Adafruit_Blinka_Displayio.git / blobdiff