],
addr_pins=[
board.MTX_ADDRA, board.MTX_ADDRB,
board.MTX_ADDRC, board.MTX_ADDRD
],
clock_pin=board.MTX_CLK,
latch_pin=board.MTX_LAT,
output_enable_pin=board.MTX_OE)
display = framebufferio.FramebufferDisplay(matrix, auto_refresh=False)
SCALE = 1
palette = displayio.Palette(8)
b1 = displayio.Bitmap(display.width // SCALE, display.height // SCALE,
len(palette))
b2 = displayio.Bitmap(display.width // SCALE, display.height // SCALE,
len(palette))
tg1 = displayio.TileGrid(b1, pixel_shader=palette)
tg2 = displayio.TileGrid(b2, pixel_shader=palette)
g1 = displayio.Group(max_size=3, scale=SCALE)
g1.append(tg1)
display.show(g1)
g2 = displayio.Group(max_size=3, scale=SCALE)
g2.append(tg2)
board1 = [b1, []]
board2 = [b2, []]
for idx in range(b1.width * b1.height):
board1[1].append(False)
board2[1].append(False)
# First time, show the Conway tribute
for idx in range(1, len(palette)):
audio = AudioOut(board.A0)
# setup for matrix display
matrix = Matrix(width=32, height=32)
display = matrix.display
group = displayio.Group()
# import dreidel bitmap
dreidel_bit, dreidel_pal = adafruit_imageload.load("/dreidel.bmp",
bitmap=displayio.Bitmap,
palette=displayio.Palette)
dreidel_grid = displayio.TileGrid(dreidel_bit, pixel_shader=dreidel_pal,
width=1, height=1,
tile_height=32, tile_width=32,
default_tile=0,
x=0, y=0)
group.append(dreidel_grid)
# show dreidel bitmap
display.show(group)
timer = 0 # time.monotonic() holder
spin = 0 # index for tilegrid
speed = 0.1 # rate that bitmap updates
clock = 0 # initial time.monotonic() holder to act as time keeper
gimel = 3 # bitmap index for gimel, the winning character
countdown = 5 # countdown for length of game. default is 5 seconds
beam_state = False # state machine for break beam
epd_cs = board.D10
epd_dc = board.D9
display_bus = displayio.FourWire(spi,
command=epd_dc,
chip_select=epd_cs,
baudrate=1000000)
time.sleep(1)
display = adafruit_il91874.IL91874(display_bus,
width=264,
height=176,
highlight_color=0xff0000,
rotation=90)
g = displayio.Group()
f = open("/display-ruler.bmp", "rb")
pic = displayio.OnDiskBitmap(f)
t = displayio.TileGrid(pic, pixel_shader=displayio.ColorConverter())
g.append(t)
display.show(g)
display.refresh()
print("refreshed")
time.sleep(120)
display_bus = displayio.FourWire(spi,
command=epd_dc,
chip_select=epd_cs,
reset=epd_reset,
baudrate=1000000)
time.sleep(1)
display = adafruit_il0398.IL0398(display_bus,
width=400,
height=300,
seconds_per_frame=20,
busy_pin=epd_busy)
g = displayio.Group()
with open("/display-ruler.bmp", "rb") as f:
pic = displayio.OnDiskBitmap(f)
# CircuitPython 6 & 7 compatible
t = displayio.TileGrid(pic,
pixel_shader=getattr(pic, "pixel_shader",
displayio.ColorConverter()))
# CircuitPython 7 compatible only
# t = displayio.TileGrid(pic, pixel_shader=pic.pixel_shader)
g.append(t)
display.show(g)
display.refresh()
time.sleep(120)
##########################################################################
THE_FONT = fonts[0]
DISPLAY_STRING = "A multi-line-\nexample of\n font bounding!"
WRAP_CHARS = 40
##########################################################################
# Make the display context
splash = displayio.Group()
board.DISPLAY.show(splash)
# Make a background color fill
color_bitmap = displayio.Bitmap(320, 240, 1)
color_palette = displayio.Palette(1)
color_palette[0] = 0xFFFFFF
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0,
y=0)
splash.append(bg_sprite)
# Load the font
font = bitmap_font.load_font(THE_FONT)
font.load_glyphs(DISPLAY_STRING.encode('utf-8'))
print(DISPLAY_STRING)
text = Label(font, text=DISPLAY_STRING)
text.x = 20
text.y = 100
text.color = 0x0
# Make a background color fill
def menu_choice(seq, button_ok, button_cancel=0, *, sel_idx=0, text_font=font):
"""Display a menu and allow a choice from it"""
gc.collect()
board.DISPLAY.auto_refresh = True
scroll_idx = 0
glyph_width, glyph_height = text_font.get_bounding_box()[:2]
num_rows = min(len(seq), board.DISPLAY.height // glyph_height)
max_glyphs = board.DISPLAY.width // glyph_width
palette = displayio.Palette(2)
palette[0] = 0
palette[1] = 0xffffff
labels = [displayio.TileGrid(text_font.bitmap, pixel_shader=palette,
width=max_glyphs+1, height=1,
tile_width=glyph_width,
tile_height=glyph_height)
for i in range(num_rows)]
terminals = [terminalio.Terminal(li, text_font) for li in labels]
cursor = adafruit_display_text.label.Label(text_font, max_glyphs=1, color=0xddddff)
base_y = 0
caret_offset = glyph_height//2-1
scene = displayio.Group(max_size=len(labels) + 1)
for i, label in enumerate(labels):
label.x = round(glyph_width * 1.5)
label.y = base_y + glyph_height * i
scene.append(label)
cursor.x = 0
cursor.y = caret_offset
cursor.text = ">"
scene.append(cursor)
last_scroll_idx = max(0, len(seq) - num_rows)
board.DISPLAY.show(scene)
buttons.get_pressed() # Clear out anything from before now
i = 0
old_scroll_idx = None
while True:
enable.value = speaker.playing
pressed = buttons.get_pressed()
if button_cancel and (pressed & button_cancel):
return -1
if pressed & button_ok:
return sel_idx
joystick.poll()
if up_key.value:
sel_idx -= 1
if down_key.value:
sel_idx += 1
sel_idx = min(len(seq)-1, max(0, sel_idx))
if scroll_idx > sel_idx or scroll_idx + num_rows <= sel_idx:
scroll_idx = sel_idx - num_rows // 2
scroll_idx = min(last_scroll_idx, max(0, scroll_idx))
board.DISPLAY.auto_refresh = False
if old_scroll_idx != scroll_idx:
for i in range(scroll_idx, scroll_idx + num_rows):
j = i - scroll_idx
new_text = ''
if i < len(seq):
new_text = seq[i][:max_glyphs]
terminals[j].write('\r\033[K')
terminals[j].write(new_text)
cursor.y = caret_offset + base_y + glyph_height * (sel_idx - scroll_idx)
board.DISPLAY.auto_refresh = True
old_scroll_idx = scroll_idx
time.sleep(1/20)
def load_map(mapname, x=0, y=0):
f = open("/maps/" + mapname + "/" + mapname + ".bmp", "rb")
odb = displayio.OnDiskBitmap(f)
tg=displayio.TileGrid(odb, pixel_shader=displayio.ColorConverter(), position=(0,0))
tg.position=(x,y)
return tg
clock_pin=board.D13,
latch_pin=board.D0,
output_enable_pin=board.D1,
)
display = framebufferio.FramebufferDisplay(matrix)
matrix.brightness = 0.05
group = displayio.Group(max_size=20)
parrot, parrot_pal = adafruit_imageload.load("/partyParrotsMatrix.bmp",
bitmap=displayio.Bitmap,
palette=displayio.Palette)
parrot0_grid = displayio.TileGrid(parrot, pixel_shader=parrot_pal,
width=1, height=1,
tile_height=32, tile_width=32,
default_tile=0,
x=0, y=0)
group.append(parrot0_grid)
display.show(group)
party0 = 0
p = 0
while True:
if (party0 + 0.1) < time.monotonic():
parrot0_grid[0] = p
def _update_text(self, new_text): # pylint: disable=too-many-locals
x = 0
y = 0
i = 1
old_c = 0
y_offset = int(
(self._font.get_glyph(ord("M")).height -
new_text.count("\n") * self.height * self.line_spacing) / 2)
left = right = top = bottom = 0
lines = 1
for character in new_text:
if character == "\n":
y += int(self.height * self._line_spacing)
x = 0
lines += 1
continue
glyph = self._font.get_glyph(ord(character))
if not glyph:
continue
right = max(right, x + glyph.shift_x)
if y == 0: # first line, find the Ascender height
top = min(top, -glyph.height - glyph.dy + y_offset)
bottom = max(bottom, y - glyph.dy + y_offset)
position_y = y - glyph.height - glyph.dy + y_offset
position_x = x + glyph.dx
if (not self._text or old_c >= len(self._text)
or character != self._text[old_c]):
try:
face = displayio.TileGrid(
glyph.bitmap,
pixel_shader=self.palette,
default_tile=glyph.tile_index,
tile_width=glyph.width,
tile_height=glyph.height,
position=(position_x, position_y),
)
except TypeError:
face = displayio.TileGrid(
glyph.bitmap,
pixel_shader=self.palette,
default_tile=glyph.tile_index,
tile_width=glyph.width,
tile_height=glyph.height,
x=position_x,
y=position_y,
)
if i < len(self):
self[i] = face
else:
self.append(face)
elif self._text and character == self._text[old_c]:
try:
self[i].position = (position_x, position_y)
except AttributeError:
self[i].x = position_x
self[i].y = position_y
x += glyph.shift_x
# TODO skip this for control sequences or non-printables.
i += 1
old_c += 1
# skip all non-printables in the old string
while (self._text and old_c < len(self._text)
and (self._text[old_c] == "\n"
or not self._font.get_glyph(ord(self._text[old_c])))):
old_c += 1
# Remove the rest
while len(self) > i:
self.pop()
self._text = new_text
self._boundingbox = (left, top, left + right, bottom - top)
self[0] = self._create_background_box(lines, y_offset)
)
green = int(
round((color[idx2][1] - color[idx1][1]) * fractBetween + color[idx1][1])
)
blue = int(
round((color[idx2][2] - color[idx1][2]) * fractBetween + color[idx1][2])
)
palette[c] = (0x010000 * red) + (0x000100 * green) + (0x000001 * blue)
MakeHeatMapColor()
# Bitmap for colour coded thermal value
image_bitmap = displayio.Bitmap(32, 24, number_of_colors)
# Create a TileGrid using the Bitmap and Palette
image_tile = displayio.TileGrid(image_bitmap, pixel_shader=palette)
# Create a Group that scale 32*24 to 128*96
image_group = displayio.Group(scale=4)
image_group.append(image_tile)
scale_bitmap = displayio.Bitmap(number_of_colors, 1, number_of_colors)
# Create a Group Scale must be 128 divided by number_of_colors
scale_group = displayio.Group(scale=2)
scale_tile = displayio.TileGrid(scale_bitmap, pixel_shader=palette, x=0, y=60)
scale_group.append(scale_tile)
for i in range(number_of_colors):
scale_bitmap[i, 0] = i # Fill the scale with the palette gradian
# Create the super Group
group = displayio.Group()
tft_dc = board.D25
display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs)
display = ST7789(
display_bus, rotation=90, width=240, height=135, rowstart=40, colstart=53
)
# Make the display context
splash = displayio.Group(max_size=10)
display.show(splash)
color_bitmap = displayio.Bitmap(display.width, display.height, 1)
color_palette = displayio.Palette(1)
color_palette[0] = BACKGROUND_COLOR
bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
splash.append(bg_sprite)
# Draw a smaller inner rectangle
inner_bitmap = displayio.Bitmap(
display.width - BORDER * 2, display.height - BORDER * 2, 1
)
inner_palette = displayio.Palette(1)
inner_palette[0] = FOREGROUND_COLOR
inner_sprite = displayio.TileGrid(
inner_bitmap, pixel_shader=inner_palette, x=BORDER, y=BORDER
)
splash.append(inner_sprite)
# Draw a label
text = "Hello World!"
def aws_announcements(self,
*,
background_color=0xFF9900,
foreground_color=0xFFFFFF,
background_text_color=0x000000,
foreground_text_color=0x000000,
hello_font=terminalio.FONT,
hello_scale=1,
my_name_is_font=terminalio.FONT,
my_name_is_scale=1,
my_name_is_string="MY NAME IS",
name_font=terminalio.FONT,
name_scale=1,
name_string="Blinka"):
splash = displayio.Group(max_size=20)
color_bitmap = displayio.Bitmap(self.display.width,
self.display.height, 1)
color_palette = displayio.Palette(1)
color_palette[0] = background_color
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0,
y=0)
splash.append(bg_sprite)
rect = Rect(0, (int(self.display.height * 0.5)),
self.display.width, (int(self.display.height * 0.5)),
fill=foreground_color)
splash.append(rect)
# Header
header_string = "re:Invent"
hello_font_name = "/fonts/Verdana-Bold-18.bdf"
hello_font = bitmap_font.load_font(hello_font_name)
hello_font.load_glyphs(header_string.encode('utf-8'))
hello_scale = hello_scale
hello_group = displayio.Group(scale=hello_scale)
hello_label = Label(font=hello_font, text=header_string)
(_, _, width, height) = hello_label.bounding_box
hello_label.x = ((self.display.width // (2 * hello_scale)) -
width // 2)
hello_label.y = int(height // (1.2 * hello_scale))
hello_label.color = background_text_color
hello_group.append(hello_label)
# Subheader
my_name_is_string = "Announcements"
my_name_is_string2 = "this week"
my_name_is_font_name = "/fonts/Arial-12.bdf"
my_name_is_font = bitmap_font.load_font(my_name_is_font_name)
my_name_is_font.load_glyphs(my_name_is_string.encode('utf-8'))
my_name_is_font.load_glyphs(my_name_is_string2.encode('utf-8'))
my_name_is_scale = my_name_is_scale
my_name_is_group = displayio.Group(scale=my_name_is_scale)
my_name_is_label = Label(font=my_name_is_font, text=my_name_is_string)
(_, _, width, height) = my_name_is_label.bounding_box
my_name_is_label.x = ((self.display.width // (2 * my_name_is_scale)) -
width // 2)
my_name_is_label.y = int(height // (0.32 * my_name_is_scale))
my_name_is_label.color = background_text_color
my_name_is_group.append(my_name_is_label)
my_name_is_group2 = displayio.Group(scale=my_name_is_scale)
my_name_is_label2 = Label(font=my_name_is_font,
text=my_name_is_string2)
(_, _, width, height) = my_name_is_label2.bounding_box
my_name_is_label2.x = ((self.display.width // (2 * my_name_is_scale)) -
width // 2)
my_name_is_label2.y = int(height // (0.32 * my_name_is_scale)) + 16
my_name_is_label2.color = background_text_color
my_name_is_group2.append(my_name_is_label2)
# Main Body
name_font_name = "/fonts/IdealSans-Semibold-48.bdf"
name_font = bitmap_font.load_font(name_font_name)
name_font.load_glyphs(name_string.encode('utf-8'))
name_scale = name_scale
name_group = displayio.Group(scale=name_scale)
name_label = Label(font=name_font, text=name_string, line_spacing=0.75)
(_, _, width, height) = name_label.bounding_box
name_label.x = ((self.display.width // (2 * name_scale)) - width // 2)
# name_label.y = int(height // (0.5 * name_scale))
name_label.y = int((self.display.height // 2) + 25)
name_label.color = foreground_text_color
name_group.append(name_label)
group = displayio.Group(max_size=5)
group.append(splash)
group.append(hello_group)
group.append(my_name_is_group)
group.append(my_name_is_group2)
group.append(name_group)
self.display.show(group)
def show_badge(self,
*,
background_color=0xFF0000,
foreground_color=0xFFFFFF,
background_text_color=0xFFFFFF,
foreground_text_color=0x000000,
hello_font=terminalio.FONT,
hello_scale=1,
hello_string="HELLO",
my_name_is_font=terminalio.FONT,
my_name_is_scale=1,
my_name_is_string="MY NAME IS",
name_font=terminalio.FONT,
name_scale=1,
name_string="Blinka"):
"""Create a "Hello My Name is"-style badge.
:param background_color: The color of the background. Defaults to 0xFF0000.
:param foreground_color: The color of the foreground rectangle. Defaults to 0xFFFFFF.
:param background_text_color: The color of the "HELLO MY NAME IS" text. Defaults to
0xFFFFFF.
:param foreground_text_color: The color of the name text. Defaults to 0x000000.
:param hello_font: The font for the "HELLO" string. Defaults to ``terminalio.FONT``.
:param hello_scale: The size scale of the "HELLO" string. Defaults to 1.
:param hello_string: The first string of the badge. Defaults to "HELLO".
:param my_name_is_font: The font for the "MY NAME IS" string. Defaults to
``terminalio.FONT``.
:param my_name_is_scale: The size scale of the "MY NAME IS" string. Defaults to 1.
:param my_name_is_string: The second string of the badge. Defaults to "MY NAME IS".
:param name_font: The font for the name string. Defaults to ``terminalio.FONT``.
:param name_scale: The size scale of the name string. Defaults to 1.
:param name_string: The third string of the badge - change to be your name. Defaults to
"Blinka".
"""
splash = displayio.Group(max_size=20)
color_bitmap = displayio.Bitmap(self.display.width,
self.display.height, 1)
color_palette = displayio.Palette(1)
color_palette[0] = background_color
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0,
y=0)
splash.append(bg_sprite)
rect = Rect(0, (int(self.display.height * 0.4)),
self.display.width, (int(self.display.height * 0.5)),
fill=foreground_color)
splash.append(rect)
hello_font_name = "/fonts/Verdana-Bold-18.bdf"
hello_font = bitmap_font.load_font(hello_font_name)
hello_font.load_glyphs(hello_string.encode('utf-8'))
hello_scale = hello_scale
hello_group = displayio.Group(scale=hello_scale)
hello_label = Label(font=hello_font, text=hello_string)
(_, _, width, height) = hello_label.bounding_box
hello_label.x = ((self.display.width // (2 * hello_scale)) -
width // 2)
hello_label.y = int(height // (1.2 * hello_scale))
hello_label.color = background_text_color
hello_group.append(hello_label)
my_name_is_font_name = "/fonts/Arial-12.bdf"
my_name_is_font = bitmap_font.load_font(my_name_is_font_name)
my_name_is_font.load_glyphs(my_name_is_string.encode('utf-8'))
my_name_is_scale = my_name_is_scale
my_name_is_group = displayio.Group(scale=my_name_is_scale)
my_name_is_label = Label(font=my_name_is_font, text=my_name_is_string)
(_, _, width, height) = my_name_is_label.bounding_box
my_name_is_label.x = ((self.display.width // (2 * my_name_is_scale)) -
width // 2)
my_name_is_label.y = int(height // (0.32 * my_name_is_scale))
my_name_is_label.color = background_text_color
my_name_is_group.append(my_name_is_label)
name_font_name = "/fonts/IdealSans-Semibold-48.bdf"
name_font = bitmap_font.load_font(name_font_name)
name_font.load_glyphs(name_string.encode('utf-8'))
name_scale = name_scale
name_group = displayio.Group(scale=name_scale)
name_label = Label(font=name_font, text=name_string, line_spacing=0.75)
(_, _, width, height) = name_label.bounding_box
name_label.x = ((self.display.width // (2 * name_scale)) - width // 2)
name_label.y = int(height // (0.45 * name_scale))
name_label.color = foreground_text_color
name_group.append(name_label)
group = displayio.Group()
group.append(splash)
group.append(hello_group)
group.append(my_name_is_group)
group.append(name_group)
self.display.show(group)
def show_business_card(self,
*,
image_name=None,
name_string=None,
name_scale=1,
name_font=terminalio.FONT,
email_string_one=None,
email_scale_one=1,
email_font_one=terminalio.FONT,
email_string_two=None,
email_scale_two=1,
email_font_two=terminalio.FONT):
"""Display a bitmap image and a text string, such as a personal image and email address.
:param str image_name: REQUIRED. The name of the bitmap image including .bmp, e.g.
``"Blinka.bmp"``.
:param str name_string: A name string to display along the bottom of the display, e.g.
``"Blinka"``.
:param int name_scale: The scale of ``name_string``. Defaults to 1.
:param name_font: The font for the name string. Defaults to ``terminalio.FONT``.
:param str email_string_one: A string to display along the bottom of the display, e.g.
``"*****@*****.**"``.
:param int email_scale_one: The scale of ``email_string_one``. Defaults to 1.
:param email_font_one: The font for the first email string. Defaults to ``terminalio.FONT``.
:param str email_string_two: A second string to display along the bottom of the display.
Use if your email address is longer than one line or to add
more space between the name and email address,
e.g. (blinka@) ``"adafruit.com"``.
:param int email_scale_two: The scale of ``email_string_two``. Defaults to 1.
:param email_font_two: The font for the second email string. Defaults to
``terminalio.FONT``.
"""
business_card_splash = displayio.Group(max_size=30)
self.display.show(business_card_splash)
with open(image_name, "rb") as file_name:
on_disk_bitmap = displayio.OnDiskBitmap(file_name)
face_image = displayio.TileGrid(
on_disk_bitmap, pixel_shader=displayio.ColorConverter())
business_card_splash.append(face_image)
# self.display.wait_for_frame() #CP 4
self.display.refresh() #CP 5
if name_string:
name_group = displayio.Group(scale=name_scale)
name_label = Label(name_font, text=name_string)
(_, _, width, height) = name_label.bounding_box
name_label.x = ((self.display.width // (2 * name_scale)) -
width // 2)
name_label.y = int(height // (0.15 * name_scale))
name_label.color = 0xFFFFFF
name_group.append(name_label)
business_card_splash.append(name_group)
if email_string_one:
email_group_one = displayio.Group(scale=email_scale_one)
email_label_one = Label(email_font_one, text=email_string_one)
(_, _, width, height) = email_label_one.bounding_box
email_label_one.width = self.display.width
email_label_one.x = ((self.display.width //
(2 * email_scale_one)) - width // 2)
email_label_one.y = int(height // (0.13 * email_scale_one))
email_label_one.color = 0xFFFFFF
email_group_one.append(email_label_one)
business_card_splash.append(email_group_one)
if email_string_two:
email_group_two = displayio.Group(scale=email_scale_two)
email_label_two = Label(email_font_two, text=email_string_two)
(_, _, width, height) = email_label_two.bounding_box
email_label_two.width = self.display.width
email_label_two.x = ((self.display.width //
(2 * email_scale_two)) - width // 2)
email_label_two.y = int(height // (0.12 * email_scale_two))
email_label_two.color = 0xFFFFFF
email_group_two.append(email_label_two)
business_card_splash.append(email_group_two)
default_bg="/tides_bg_graph.bmp")
# Connect to the internet and get local time
pyportal.get_local_time()
# Setup palette used for plot
palette = displayio.Palette(3)
palette[0] = 0x0
palette[1] = PLOT_COLOR
palette[2] = MARK_COLOR
palette.make_transparent(0)
# Setup tide plot bitmap
tide_plot = displayio.Bitmap(WIDTH, HEIGHT, 3)
pyportal.graphics.splash.append(
displayio.TileGrid(tide_plot, pixel_shader=palette))
# Setup font used for date and time
date_font = bitmap_font.load_font("/fonts/mono-bold-8.bdf")
date_font.load_glyphs(b"1234567890-")
# Setup date label
date_label = Label(date_font, text="0000-00-00", color=DATE_COLOR, x=7, y=14)
pyportal.graphics.splash.append(date_label)
# Setup time label
time_label = Label(date_font, text="00:00:00", color=TIME_COLOR, x=234, y=14)
pyportal.graphics.splash.append(time_label)
# Setup current time marker
time_marker_bitmap = displayio.Bitmap(MARK_SIZE, MARK_SIZE, 3)
def show_business_card(self,
*,
image_name=None,
name_string=None,
name_scale=1,
name_font=terminalio.FONT,
font_color=0xFFFFFF,
font_background_color=None,
email_string_one=None,
email_scale_one=1,
email_font_one=terminalio.FONT,
email_string_two=None,
email_scale_two=1,
email_font_two=terminalio.FONT):
"""Display a bitmap image and a text string, such as a personal image and email address.
:param str image_name: REQUIRED. The name of the bitmap image including .bmp, e.g.
``"Blinka.bmp"``.
:param str name_string: A name string to display along the bottom of the display, e.g.
``"Blinka"``.
:param int name_scale: The scale of ``name_string``. Defaults to 1.
:param name_font: The font for the name string. Defaults to ``terminalio.FONT``.
:param str email_string_one: A string to display along the bottom of the display, e.g.
``"*****@*****.**"``.
:param int email_scale_one: The scale of ``email_string_one``. Defaults to 1.
:param email_font_one: The font for the first email string. Defaults to ``terminalio.FONT``.
:param str email_string_two: A second string to display along the bottom of the display.
Use if your email address is longer than one line or to add
more space between the name and email address,
e.g. (blinka@) ``"adafruit.com"``.
:param int email_scale_two: The scale of ``email_string_two``. Defaults to 1.
:param email_font_two: The font for the second email string. Defaults to
``terminalio.FONT``.
.. code-block:: python
from adafruit_pybadger import pybadger
while True:
pybadger.show_business_card(image_name="Blinka.bmp", name_string="Blinka",
name_scale=2, email_string_one="blinka@",
email_string_two="adafruit.com")
"""
business_card_label_groups = []
if name_string:
name_group = self._create_label_group(
text=name_string,
font=name_font,
color=font_color,
scale=name_scale,
height_adjustment=0.73,
background_color=font_background_color,
)
business_card_label_groups.append(name_group)
if email_string_one:
email_one_group = self._create_label_group(
text=email_string_one,
font=email_font_one,
color=font_color,
scale=email_scale_one,
height_adjustment=0.84,
background_color=font_background_color,
)
business_card_label_groups.append(email_one_group)
if email_string_two:
email_two_group = self._create_label_group(
text=email_string_two,
font=email_font_two,
color=font_color,
scale=email_scale_two,
height_adjustment=0.91,
background_color=font_background_color,
)
business_card_label_groups.append(email_two_group)
business_card_splash = displayio.Group()
self.display.show(business_card_splash)
with open(image_name, "rb") as file_name:
on_disk_bitmap = displayio.OnDiskBitmap(file_name)
face_image = displayio.TileGrid(
on_disk_bitmap,
pixel_shader=getattr(on_disk_bitmap, "pixel_shader",
displayio.ColorConverter()),
# TODO: Once CP6 is no longer supported, replace the above line with below
# pixel_shader=on_disk_bitmap.pixel_shader,
)
business_card_splash.append(face_image)
for group in business_card_label_groups:
business_card_splash.append(group)
self.display.refresh()
font=FONT,
text="Scan QR Code...",
color=0xFFFFFF,
background_color=0x0,
padding_top=2,
padding_left=2,
padding_right=2,
padding_bottom=2,
anchor_point=(0.5, 1.0),
anchored_position=(160, 230),
)
# Show the camera image at 2x size
g1 = displayio.Group(scale=2)
view = np.frombuffer(bitmap, dtype=np.uint8)
tg = displayio.TileGrid(
bitmap,
pixel_shader=pal,
)
tg.flip_y = True
g1.append(tg)
g = displayio.Group()
g.append(g1)
g.append(label)
display.show(g)
display.auto_refresh = False
old_payload = None
while True:
cam.capture(bitmap)
for row in qrdecoder.decode(bitmap, qrio.PixelPolicy.EVEN_BYTES):
payload = row.payload
label.Label(terminalio.FONT,
text="PM10: {:d}",
color=blue,
x=80,
y=5,
max_glyphs=15))
# pms5003_splotter.group.append(label.Label(terminalio.FONT, text="PM1.0: {:d}", color=red, x=0, y=20, max_glyphs=15)) # uncomment to enable PM1.0 measuring
# red line for the WHO guideline (https://en.wikipedia.org/wiki/Air_quality_guideline)
# made in a new bitmap so it doesn't get overwritten
pms5003_splotter.redline_bm = displayio.Bitmap(160, 1, 1)
pms5003_splotter.redline_pl = displayio.Palette(1)
pms5003_splotter.redline_pl[0] = red
pms5003_splotter.redline_tg = displayio.TileGrid(
pms5003_splotter.redline_bm,
pixel_shader=pms5003_splotter.redline_pl,
x=0,
y=44)
pms5003_splotter.group.append(pms5003_splotter.redline_tg)
# Set up the gas screen plotter
# the max value is set to 3.3 as its the max voltage the feather can read
gas_splotter = plotter.ScreenPlotter([red, green, blue],
max_value=3.3,
min_value=0.5,
top_space=10,
display=screen)
# add a colour coded text label for each reading
gas_splotter.group.append(
label.Label(terminalio.FONT,
rowstart=80,
backlight_pin=tft_backlight,
rotation=180)
# Load background image
try:
bg_bitmap, bg_palette = adafruit_imageload.load(BACKGROUND,
bitmap=displayio.Bitmap,
palette=displayio.Palette)
# Or just use solid color
except (OSError, TypeError):
BACKGROUND = BACKGROUND if isinstance(BACKGROUND, int) else 0x000000
bg_bitmap = displayio.Bitmap(WIDTH, HEIGHT, 1)
bg_palette = displayio.Palette(1)
bg_palette[0] = BACKGROUND
background = displayio.TileGrid(bg_bitmap, pixel_shader=bg_palette)
# Shared palette for snow bitmaps
palette = displayio.Palette(2)
palette[0] = 0xADAF00 # transparent color
palette[1] = SNOW_COLOR # snow color
palette.make_transparent(0)
# Snowflake setup
FLAKES = (
0,
0,
0,
0,
0,
0,
BORDER = 2
display = adafruit_displayio_sh1107.SH1107(display_bus,
width=WIDTH,
height=HEIGHT)
# Make the display context
splash = displayio.Group()
display.show(splash)
color_bitmap = displayio.Bitmap(WIDTH, HEIGHT, 1)
color_palette = displayio.Palette(1)
color_palette[0] = 0xFFFFFF # White
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0,
y=0)
splash.append(bg_sprite)
# Draw a smaller inner rectangle in black
inner_bitmap = displayio.Bitmap(WIDTH - BORDER * 2, HEIGHT - BORDER * 2, 1)
inner_palette = displayio.Palette(1)
inner_palette[0] = 0x000000 # Black
inner_sprite = displayio.TileGrid(inner_bitmap,
pixel_shader=inner_palette,
x=BORDER,
y=BORDER)
splash.append(inner_sprite)
# Draw some white squares
sm_bitmap = displayio.Bitmap(8, 8, 1)
def update_display():
# pylint: disable=too-many-locals
# clear out existing icons
while len(storm_icons):
_ = storm_icons.pop()
# get latest storm data
try:
resp = pyportal.network.fetch(URL)
storm_data = pyportal.network.process_json(resp.json(),
(JSON_PATH, ))[0]
except RuntimeError:
return
print("Number of storms:", len(storm_data))
# parse the storm data
for storm in storm_data:
# don't exceed max
if len(storm_icons) >= MAX_STORMS:
continue
# get lat/lon
lat = storm["latitudeNumeric"]
lon = storm["longitudeNumeric"]
# check if on map
if (not LAT_RANGE[0] >= lat >= LAT_RANGE[1]
or not LON_RANGE[0] <= lon <= LON_RANGE[1]):
continue
# OK, let's make a group for all the graphics
storm_gfx = displayio.Group()
# convert to sreen coords
x = int(
map_range(lon, LON_RANGE[0], LON_RANGE[1], 0,
board.DISPLAY.width - 1))
y = math.radians(lat)
y = math.tan(math.pi / 4 + y / 2)
y = math.log(y)
y = (VIRTUAL_WIDTH * y) / (2 * math.pi)
y = VIRTUAL_HEIGHT / 2 - y
y = int(y - Y_OFFSET)
# icon type
if storm["classification"] in STORM_CLASS:
storm_type = STORM_CLASS.index(storm["classification"])
else:
storm_type = 0
# create storm icon
icon = displayio.TileGrid(
icons_bmp,
pixel_shader=icons_pal,
width=1,
height=1,
tile_width=16,
tile_height=16,
default_tile=storm_type,
x=x - 8,
y=y - 8,
)
# add storm icon
storm_gfx.append(icon)
# add a label
name = Label(
terminalio.FONT,
text=storm["name"],
color=NAME_COLOR,
background_color=NAME_BG_COLOR,
)
name.anchor_point = (0.0, 1.0)
name.anchored_position = (x + 8, y - 8)
storm_gfx.append(name)
# add direction arrow
angle = math.radians(storm["movementDir"])
xd = x + int(ARROW_LENGTH * math.sin(angle))
yd = y - int(ARROW_LENGTH * math.cos(angle))
arrow = Line(x, y, xd, yd, color=ARROW_COLOR)
storm_gfx.append(arrow)
# add the storm graphics
storm_icons.append(storm_gfx)
# update time
info_update.text = storm["lastUpdate"]
# debug
print("{} @ {},{}".format(storm["name"], storm["latitudeNumeric"],
storm["longitudeNumeric"]))
# no storms? at least say something
if not len(storm_icons):
print("No storms in map area.")
storm_icons.append(
Label(
terminalio.FONT,
scale=4,
x=50,
y=110,
text="NO STORMS\n IN AREA",
color=NAME_COLOR,
background_color=NAME_BG_COLOR,
))
palette=displayio.Palette)
display = board.DISPLAY
group = displayio.Group(scale=1, max_size=5)
touchscreen = adafruit_touchscreen.Touchscreen(board.TOUCH_XL,
board.TOUCH_XR,
board.TOUCH_YD,
board.TOUCH_YU,
calibration=((9000, 59000),
(8000, 57000)),
size=(display.width,
display.height))
tilegrid = displayio.TileGrid(sprite_sheet,
pixel_shader=palette,
width=20,
height=15,
tile_height=16,
tile_width=16,
default_tile=BLANK)
group.append(tilegrid)
display.show(group)
board_data = bytearray(b'\x00' * 300)
#pylint:disable=redefined-outer-name
def get_data(x, y):
return board_data[y * 20 + x]
import board
import displayio
display = board.DISPLAY
# Create a bitmap with two colors
bitmap = displayio.Bitmap(display.width, display.height, 2)
# Create a two color palette
palette = displayio.Palette(2)
palette[0] = 0x000000
palette[1] = 0xffffff
# Create a TileGrid using the Bitmap and Palette
tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette)
# Create a Group
group = displayio.Group()
# Add the TileGrid to the Group
group.append(tile_grid)
# Add the Group to the Display
display.show(group)
# Draw a pixel
bitmap[80, 50] = 1
# Draw even more pixels
for x in range(150, 170):
for y in range(100, 110):
0xFF96FF, # pink
)
MESSAGE_COLORS = (
0xFF0000, # red
)
#---| User Config |--------------------------------------------------
# Create the display
display = board.DISPLAY
# Load the candy heart BMP
bitmap, palette = adafruit_imageload.load("/heart_bw.bmp",
bitmap=displayio.Bitmap,
palette=displayio.Palette)
heart = displayio.TileGrid(bitmap, pixel_shader=palette)
# Set up message text
font = bitmap_font.load_font("/Multicolore_36.bdf")
line1 = label.Label(font, text="?" * 9)
line2 = label.Label(font, text="?" * 5)
line1.anchor_point = (0.5, 0) # middle top
line2.anchor_point = (0.5, 1.0) # middle bottom
# Set up group and add to display
group = displayio.Group()
group.append(heart)
group.append(line1)
group.append(line2)
display.show(group)
board.TOUCH_YD,
board.TOUCH_YU,
calibration=((5200, 59000), (5800,
57000)),
size=(SCREEN_WIDTH, SCREEN_HEIGHT))
# Make the display context
calc_group = displayio.Group(max_size=25)
board.DISPLAY.show(calc_group)
# Make a background color fill
color_bitmap = displayio.Bitmap(SCREEN_WIDTH, SCREEN_HEIGHT, 1)
color_palette = displayio.Palette(1)
color_palette[0] = GRAY
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0,
y=0)
calc_group.append(bg_sprite)
# Load the font
if SCREEN_WIDTH < 480:
font = bitmap_font.load_font("/fonts/Arial-12.bdf")
else:
font = bitmap_font.load_font("/fonts/Arial-Bold-24.bdf")
buttons = []
# Some button functions
def button_grid(row, col):
return Coords(BUTTON_MARGIN * (row + 1) + BUTTON_WIDTH * row + 20,
WIDTH = board.DISPLAY.width
HEIGHT = board.DISPLAY.height
pyportal = PyPortal()
palette = displayio.Palette(5)
palette[0] = 0x0
palette[1] = PROFILE_COLOR
palette[2] = GRID_COLOR
palette[3] = TEMP_COLOR
palette[4] = AXIS_COLOR
palette.make_transparent(0)
plot = displayio.Bitmap(WIDTH, HEIGHT, 8)
pyportal.splash.append(displayio.TileGrid(plot, pixel_shader=palette))
ts = adafruit_touchscreen.Touchscreen(board.TOUCH_XL,
board.TOUCH_XR,
board.TOUCH_YD,
board.TOUCH_YU,
calibration=((5200, 59000), (5800,
57000)),
size=(WIDTH, HEIGHT))
class Beep(object):
def __init__(self):
self.duration = 0
self.start = 0
tone_volume = 1 # volume is from 0.0 to 1.0
import time
import displayio
from adafruit_gizmo import eink_gizmo
display = eink_gizmo.EInk_Gizmo()
# Create a display group for our screen objects
display_group = displayio.Group()
# Display a ruler graphic from the root directory of the CIRCUITPY drive
file = open("/display-ruler.bmp", "rb")
picture = displayio.OnDiskBitmap(file)
# Create a Tilegrid with the bitmap and put in the displayio group
sprite = displayio.TileGrid(picture, pixel_shader=displayio.ColorConverter())
display_group.append(sprite)
# Place the display group on the screen
display.show(display_group)
# Refresh the display to have it actually show the image
# NOTE: Do not refresh eInk displays sooner than 180 seconds
display.refresh()
print("refreshed")
time.sleep(180)
left_group.y = (SCREEN_SIZE - IMAGE_SIZE) // 2
right_group.x = (SCREEN_SIZE - IMAGE_SIZE) // 2
right_group.y = (SCREEN_SIZE - IMAGE_SIZE) // 2
# load in party parrot bitmap
star_bitmap, star_palette = adafruit_imageload.load("/rainbow_star.bmp",
bitmap=displayio.Bitmap,
palette=displayio.Palette)
right_star_grid = displayio.TileGrid(
star_bitmap,
pixel_shader=star_palette,
width=1,
height=1,
tile_height=64,
tile_width=64,
default_tile=0,
x=0,
y=0,
)
left_star_grid = displayio.TileGrid(
star_bitmap,
pixel_shader=star_palette,
width=1,
height=1,
tile_height=64,
tile_width=64,
default_tile=0,
x=0,
spi = busio.SPI(clock=spi_clk, MOSI=spi_mosi, MISO=spi_miso)
display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs)
display = adafruit_ili9341.ILI9341(display_bus, width=WIDTH, height=HEIGHT)
# Initially, just show a bright green background to prove the display is working
splash = displayio.Group(max_size=10)
display.show(splash)
color_bitmap = displayio.Bitmap(320, 240, 1)
color_palette = displayio.Palette(1)
color_palette[0] = 0x00FF00 # Bright Green
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0,
y=0)
splash.append(bg_sprite)
# Draw a smaller inner rectangle
inner_bitmap = displayio.Bitmap(280, 200, 1)
inner_palette = displayio.Palette(1)
inner_palette[0] = 0xAA0088 # Purple
inner_sprite = displayio.TileGrid(inner_bitmap,
pixel_shader=inner_palette,
x=20,
y=20)
splash.append(inner_sprite)
# Wait so it doesn't immediately get overwritten
display = board.DISPLAY
# the alarm sound file locations
alarm_sound_trash = "/sounds/trash.wav"
alarm_sound_bed = "/sounds/sleep.wav"
alarm_sound_eat = "/sounds/eat.wav"
# the alarm sounds in an array that matches the order of the gfx & alarm check-ins
alarm_sounds = [alarm_sound_trash, alarm_sound_bed,
alarm_sound_eat, alarm_sound_eat, alarm_sound_eat]
# setting up the bitmaps for the alarms
# sleep alarm
sleep_bitmap = displayio.OnDiskBitmap(open("/sleepBMP.bmp", "rb"))
sleep_tilegrid = displayio.TileGrid(sleep_bitmap, pixel_shader=getattr(sleep_bitmap, 'pixel_shader', displayio.ColorConverter()))
group_bed = displayio.Group()
group_bed.append(sleep_tilegrid)
# trash alarm
trash_bitmap = displayio.OnDiskBitmap(open("/trashBMP.bmp", "rb"))
trash_tilegrid = displayio.TileGrid(trash_bitmap, pixel_shader=getattr(trash_bitmap, 'pixel_shader', displayio.ColorConverter()))
group_trash = displayio.Group()
group_trash.append(trash_tilegrid)
# meal alarm
eat_bitmap = displayio.OnDiskBitmap(open("/eatBMP.bmp", "rb"))
eat_tilegrid = displayio.TileGrid(eat_bitmap, pixel_shader=getattr(eat_bitmap, 'pixel_shader', displayio.ColorConverter()))
group_eat = displayio.Group()
group_eat.append(eat_tilegrid)
