def label(self, newtext):
if self._label and self.group and (self.group[-1] == self._label):
self.group.pop()
self._label = None
if not newtext or (self._label_color is None): # no new text
return # nothing to do!
if not self._label_font:
raise RuntimeError("Please provide label font")
self._label = Label(self._label_font, text=newtext)
dims = self._label.bounding_box
if dims[2] >= self.width or dims[3] >= self.height:
raise RuntimeError("Button not large enough for label")
self._label.x = self.x + (self.width - dims[2]) // 2
self._label.y = self.y + self.height // 2
self._label.color = self._label_color
self.group.append(self._label)
if (self.selected_label is None) and (self._label_color is not None):
self.selected_label = (~self._label_color) & 0xFFFFFF
def addPlayer(self, name, rssi=None):
"""Add a player to the player list.
playerListScreen must be called prior to use."""
if self.disp is None:
return
text_color = OPP_NAME_COL_FG if len(
self.disp_group) else PLAYER_NAME_COL_FG
pname_dob = Label(self.font, text=name, scale=2, color=text_color)
pname_dob.x = self.pl_x_pos
pname_dob.y = self.pl_y_cur_pos
self.disp_group.append(pname_dob)
if rssi is not None:
prssi_dob = Label(self.font,
text="{:4d}".format(round(rssi)),
scale=2,
color=text_color)
prssi_dob.x = self.plrssi_x_rpos - 4 * 2 * self.font_width
prssi_dob.y = self.pl_y_cur_pos
self.disp_group.append(prssi_dob)
self.pl_y_cur_pos += self.pl_y_off
def set_text(
self,
text: Optional[str],
color: Optional[str],
background_color: Optional[int] = None,
) -> None:
"""Display the test for a card.
:param text: the text to display
:type text: str or None
:param color: the text color
:type color: str or None
:param background_color: the background color of the text
:type background_color: int or None
"""
if self._text_group:
self._text_group.pop()
if not text or not color:
return # nothing to do!
text_wrap = 37
if self._display.height < 130:
text_wrap = 25
text = self.wrap_nicely(text, text_wrap)
text = "\n".join(text)
print("Set text to", text, "with color", hex(color))
text_x = 8
text_y = 95
if self._display.height < 130:
text_x = 3
text_y = 38
elif self._display.height > 250:
text_y = 50
if text:
self._text = Label(self._text_font, text=str(text))
self._text.x = text_x
self._text.y = text_y
self._text.color = color
if background_color:
self._text.background_color = background_color
self._text_group.append(self._text)
def info(self, value):
"""Place some text on the screen.
Multiple lines are supported with newline character.
Font will be 3x standard terminalio font or 2x if that does not fit."""
if self._displayio_info is not None:
self._displayio_graph.pop()
if value is not None and value != "":
font_scale = 3
line_spacing = 1.25
font_w, font_h = self._font.get_bounding_box()
text_lines = value.split("\n")
max_word_chars = max([len(word) for word in text_lines])
# If too large reduce the scale
if (max_word_chars * font_scale * font_w > self._screen_width
or len(text_lines) * font_scale * font_h * line_spacing >
self._screen_height):
font_scale -= 1
self._displayio_info = Label(self._font,
text=value,
line_spacing=line_spacing,
scale=font_scale,
background_color=None,
color=self.INFO_BG_COLOR)
self._displayio_info.palette[0] = self.INFO_FG_COLOR
self._displayio_info.palette.make_opaque(0)
# centre the (left justified) text
self._displayio_info.x = (
self._screen_width - font_scale * font_w * max_word_chars) // 2
self._displayio_info.y = self._screen_height // 2
self._displayio_graph.append(self._displayio_info)
else:
self._displayio_info = None
if self._mode == "scroll":
self._display_refresh()
def build(
widget: Button,
*,
radius: int,
size: float | int,
fit_to_text: bool,
) -> tuple[Native, tuple[int, int]]:
"""
Creates the native element for the std tg-gui widget based on the _fixed_style_attrs_.
Those _fixed_style_attrs_ are passed as kwargs to this function.
:param widget: the tg-gui widget instance to build the native for
:param **style_attrs: the fixed style attributes that are set at build time
:return: a tuple of the native widget and suggested size
"""
native = Group()
label = Label(font=FONT, x=0, y=0, text=widget.text, scale=size)
native.append(label)
_, _, w, h = label.bounding_box
w *= size
h = int(1.15 * h * size)
r = (
min(radius, w // 2 - 1, h // 2 - 1)
if isinstance(radius, int)
else min(w // 2, h // 2) - 1
)
padding = round(1.25 * r)
widget._impl_cache_ = dict(radius=radius, label_width=w)
return (
native,
(
w + padding + widget._margin_ * 2,
int(h * 1.2) + widget._margin_ * 2,
),
)
def label(self, newtext):
if self._label and (self.group[-1] == self._label):
self.group.pop()
self._label = None
if not newtext or (self._label_color is None): # no new text
return # nothing to do!
if not self._label_font:
raise RuntimeError("Please provide label font")
self._label = Label(self._label_font, text=newtext)
dims = self._label.bounding_box
if dims[2] >= self.width or dims[3] >= self.height:
raise RuntimeError("Button not large enough for label")
# PaddedButton
# Set an x,y location for the label
if self._label_x > -1:
x_loc = self.x + self._label_x
else:
x_loc = self.x + (self.width - dims[2]) // 2
if self._label_y > -1:
y_loc = self.y + self._label_y
else:
y_loc = self.y + self.height // 2
self._label.x = x_loc
self._label.y = y_loc
# self._label.x = self.x + (self.width - dims[2]) // 2
# self._label.y = self.y + self.height // 2
self._label.color = self._label_color
self.group.append(self._label)
if (self.selected_label is None) and (self._label_color is not None):
self.selected_label = (~self._label_color) & 0xFFFFFF
def display_weather(self, weather):
# set the icon
self.set_icon(weather["weather"][0]["icon"])
city_name = weather["name"] + ", " + weather["sys"]["country"]
print(city_name)
if not self.city_text:
self.city_text = Label(self.small_font, text=city_name)
self.city_text.color = CITY_COLOR
self._scrolling_texts.append(self.city_text)
temperature = weather["main"]["temp"]
print(temperature)
if self.celsius:
self.temp_text.text = "%d°C" % temperature
else:
self.temp_text.text = "%d°F" % temperature
description = weather["weather"][0]["description"]
description = description[0].upper() + description[1:]
print(description)
self.description_text.text = description
# "thunderstorm with heavy drizzle"
humidity = weather["main"]["humidity"]
print(humidity)
self.humidity_text.text = "%d%% humidity" % humidity
wind = weather["wind"]["speed"]
print(wind)
if self.meters_speed:
self.wind_text.text = "%d m/s" % wind
else:
self.wind_text.text = "%d mph" % wind
self.display.show(self.root_group)
def update_date(self):
date_now = time.localtime()
year = date_now[0]
mon = date_now[1]
date = date_now[2]
day = date_now[6]
today = weekday[day]
month = month_name[mon - 1]
date_format_str = " %d, %d"
shortened_date_format_str = " %d"
date_str = today+", "+month+date_format_str % (date, year)
holiday_date_str = month+shortened_date_format_str % (date)
print(date_str)
self.date_text.text = date_str
for i in holiday_checks:
h = holiday_checks.index(i)
if holiday_date_str == holiday_checks[h]:
if not self.holiday_text:
self.holiday_text = Label(self.medium_font)
self.holiday_text.x = 10
self.holiday_text.y = 45
self.holiday_text.color = 0xf2f89d
self._text_group.append(self.holiday_text)
self.holiday_text.text = holiday_greetings[h]
def update_display():
counters = [{
'font': large_font2,
'max_glyphs': 3,
'text': "%d" % HEALTH,
'pos': (30, 60),
'color': 0xFFFFFF
}, {
'font': large_font2,
'max_glyphs': 3,
'text': "%d" % PLAYER_COUNTER,
'pos': (190, 60),
'color': 0xFFFFFF
}]
for counter in counters:
texty = Label(counter['font'],
max_glyphs=counter['max_glyphs'],
x=counter['pos'][0],
y=counter['pos'][1],
color=counter['color'],
text=counter['text'])
texts.append(texty)
if len(texts) > 2:
texts.pop(0)
def st_graphics(medium_font, large_font, small_font, st):
"""Take input JSON pulled from the Shower Thoughts subreddit API, extract the title field,
and format for display. Inputs are medium, large, and small fonts and the JSON input from
the API
"""
text_group = displayio.Group(max_size=6)
st = json.loads(st)
thought = st['data']['children'][0]['data']['title']
print(thought)
# Split into multiple lines (based on pyportal's wrap_nicely method)
# Use smaller font if needed to fit
print("length: ", len(thought))
if len(thought) > 140:
max_chars = 38
font = small_font
max_glyphs = 38
print("using small font")
else:
max_chars = 28
font = medium_font
max_glyphs = 28
print("using medium font")
words = thought.split(' ')
the_lines = []
the_line = ""
for w in words:
if len(the_line + ' ' + w) <= max_chars:
the_line += ' ' + w
else:
the_lines.append(the_line)
the_line = '' + w
if the_line: # last line remaining
the_lines.append(the_line)
# remove first space from first line:
the_lines[0] = the_lines[0][1:]
for idx, line in enumerate(the_lines):
thought_text = Label(font, line_spacing=1.2, max_glyphs=max_glyphs)
thought_text.x = 15
thought_text.color = 0xFFFFFF
thought_text.y = 110 + (idx * 24)
thought_text.text = line
text_group.append(thought_text)
return (text_group)
# Create a TileGrid using the Bitmap and Palette
tile_grid = displayio.TileGrid(bitmap, pixel_shader=color)
group.append(tile_grid) # Add the TileGrid to the Group
display.show(group)
if not DEBUG:
# font = bitmap_font.load_font("fonts/IBMPlexMono-Medium-24_jep.bdf")
font = bitmap_font.load_font("fonts/Arial-14.bdf")
font2 = bitmap_font.load_font("fonts/Arial-12.bdf")
small_font = bitmap_font.load_font("fonts/helvR10.bdf")
else:
font = terminalio.FONT
font2 = terminalio.FONT
small_font = terminalio.FONT
clock_label = Label(font, max_glyphs=8)
clock_label.color_idx = 1
clock_label.color = color[clock_label.color_idx]
clock_label.text = 'Matrix'
clock_label.x = 0
clock_label.y = display.height // 4
clock_label.normal = True
event_label = Label(font2, max_glyphs=32)
event_label.color_idx = 2
event_label.color = color[event_label.color_idx]
event_label.text = 'Clock'
event_label.x = 0
event_label.y = display.height // 4 * 3
DATA_LOCATION = []
# A quick template and troubleshooting help App
# for the Adafruit Mini Color TFT with Joystick FeatherWing
# Included is the DisplayIO library to modify the screen output
# If you connected everything correctly this code should work
import time
import displayio
import terminalio
from adafruit_display_text.label import Label
from adafruit_featherwing import minitft_featherwing
minitft = minitft_featherwing.MiniTFTFeatherWing()
uiGroup = displayio.Group(max_size=20)
text_area = Label(terminalio.FONT, text=' ', max_glyphs=20)
text_area.x = 40
text_area.y = 32
uiGroup.append(text_area)
minitft.display.show(uiGroup)
while True:
buttons = minitft.buttons
if buttons.right:
text_area.text = "Button RIGHT!"
if buttons.down:
text_area.text = "Button DOWN!"
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
dims = text.bounding_box
print(dims)
textbg_bitmap = displayio.Bitmap(dims[2], dims[3], 1)
textbg_palette = displayio.Palette(1)
textbg_palette[0] = 0xFF0000
textbg_sprite = displayio.TileGrid(textbg_bitmap,
pixel_shader=textbg_palette,
x=text.x + dims[0],
y=text.y + dims[1])
splash.append(textbg_sprite)
board.DISPLAY.brightness = b / 100
time.sleep(0.01) # default (0.01)
demos = [
"CircuitPython = Code + Community", "accents - üàêùéáçãÍóí",
"others - αψ◌"
]
splash = displayio.Group(max_size=len(fonts) * len(demos))
board.DISPLAY.show(splash)
max_y = 0
y = 2
for demo_text in demos:
for font in fonts:
print("Font load {}".format(font.name))
area = Label(font, text=demo_text)
area.y = y
splash.append(area)
y += area.height
# Wait for the image to load.
board.DISPLAY.wait_for_frame()
# Wait for 10 minutes (600 seconds)
time.sleep(600)
# Fade down the backlight
for b in range(100, -1, -1):
board.DISPLAY.brightness = b / 100
time.sleep(0.01) # default (0.01)
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(max_size = 8)
min_label = Label(terminalio.FONT, max_glyphs=10, color=palette[0], x = 0, y = 110)
center_label = Label(terminalio.FONT, max_glyphs=10, color=palette[int(number_of_colors/2)], x = 48, y = 110)
max_label = Label(terminalio.FONT, max_glyphs=10, color=palette[last_color], x = 80, y = 110)
# Indicator for the minimum and maximum location
o_label = Label(terminalio.FONT, max_glyphs = 1, text = "o", color = 0xFFFFFF, x = 0, y = 0)
x_label = Label(terminalio.FONT, max_glyphs = 1, text = "x", color = 0xFFFFFF, x = 0, y = 0)
# Add all the sub-group to the SuperGroup
group.append(image_group)
group.append(scale_group)
group.append(min_label)
group.append(center_label)
group.append(max_label)
group.append(o_label)
group.append(x_label)
'background_13.bmp', 'background_14.bmp', 'background_15.bmp',
'background_16.bmp', 'background_17.bmp'
]
event_background = cwd + "/happy_halloween.bmp"
# Initialize the pyportal object and let us know what data to fetch and where
# to display it
pyportal = PyPortal(status_neopixel=board.NEOPIXEL,
default_bg=cwd + backgrounds[0],
caption_text='DAYS REMAINING',
caption_font=cwd + '/fonts/Terror-31.bdf',
caption_position=(24, 218),
caption_color=0x000000)
countdown_text = Label(big_font, max_glyphs=3)
countdown_text.x = 25
countdown_text.y = 120
countdown_text.color = 0x7942a0
pyportal.splash.append(countdown_text)
refresh_time = None
while True:
# only query the online time once per hour (and on first run)
if (not refresh_time) or (time.monotonic() - refresh_time) > 3600:
try:
print("Getting time from internet!")
pyportal.get_local_time(location=secrets['timezone'])
refresh_time = time.monotonic()
except RuntimeError as e:
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()
min_label = Label(terminalio.FONT, max_glyphs=10, color=palette[0], x=0, y=110)
max_label = Label(terminalio.FONT,
max_glyphs=10,
color=palette[last_color],
x=80,
y=110)
# Add all the sub-group to the SuperGroup
group.append(image_group)
group.append(scale_group)
group.append(min_label)
group.append(max_label)
# Add the SuperGroup to the Display
board.DISPLAY.show(group)
# the current working directory (where this file is)
cwd = ("/" + __file__).rsplit('/', 1)[0]
large_font = cwd + "/fonts/Helvetica-Bold-36.bdf"
small_font = cwd + "/fonts/Helvetica-Bold-16.bdf"
root_group = displayio.Group()
print('loading fonts...')
weight_font = bitmap_font.load_font(large_font)
weight_font.load_glyphs(b'0123456789.goz-SCALEROIO ')
text_font = bitmap_font.load_font(small_font)
text_font.load_glyphs(b'sendig!t.')
print('making labels...')
weight_label = Label(weight_font)
weight_label.x = 75
weight_label.y = 120
root_group.append(weight_label)
weight_label.text = "---"
title_label = Label(weight_font)
title_label.x = 65
title_label.y = 20
root_group.append(title_label)
title_label.text = "IO SCALE"
text_label = Label(text_font)
text_label.x = 100
text_label.y = 200
text_label.color = 0xFFFFFF
def __init__(self,
min_val,
max_val,
width,
height,
base_size=8,
colour=0x0000FF,
outline_colour=0x0000FF,
outline=True,
bg_colour=0000000,
display_value=True,
value_label="",
arc_colour=0xFF0000,
colour_fade=False):
super().__init__(max_size=20)
self.pivot1 = [(width // 2) - (base_size // 2), 0]
self.pivot2 = [(width // 2) + (base_size // 2), 0]
self.mid = width // 2
self.min_val = min_val
self.max_val = max_val
self.colour = colour
self.height = height
self.value_label = value_label
self.outline_colour = outline_colour
self.outline = outline
self.length = int(1.4 * (width / 2))
if outline:
self.arrow = Triangle(self.pivot1[0],
self.length,
self.pivot2[0],
self.length,
self.mid,
0,
fill=self.colour,
outline=self.outline_colour)
else:
self.arrow = Triangle(self.pivot1[0],
self.length,
self.pivot2[0],
self.length,
self.mid,
0,
fill=self.colour)
self.data = Label(terminalio.FONT,
text="0.0",
color=0xFFFFFF,
max_glyphs=10)
self.data.x = width // 2
self.data.y = (height - self.length) // 2
if display_value: super().append(self.data)
arc = draw_arc(width // 2,
self.height,
self.length,
0,
width,
10,
arc_colour,
height,
colour_fade=colour_fade)
for tri in arc:
super().append(tri)
super().append(self.arrow)
width=BUTTON_WIDTH,
height=BUTTON_HEIGHT,
label="Button 2",
label_font=font,
style=Button.SHADOWROUNDRECT,
label_color=0x505050,
fill_color=0x9E9E9E,
outline_color=0x464646,
)
buttons.append(button_2)
for b in buttons:
splash.append(b.group)
# Text Label Objects
temperature_label = Label(font, text="temperature", color=0xE300D2)
temperature_label.x = 130
temperature_label.y = 20
splash.append(temperature_label)
light_label = Label(font, text="lux", color=0xE300D2)
light_label.x = 130
light_label.y = 40
splash.append(light_label)
motion_label = Label(font, text="motion", color=0xE300D2)
motion_label.x = 130
motion_label.y = 60
splash.append(motion_label)
feed1_label = Label(font, text="MQTT feed1", color=0xE39300)
# to display it
pyportal = PyPortal(status_neopixel=board.NEOPIXEL,
default_bg=cwd + "/countup_background.bmp")
big_font = bitmap_font.load_font(cwd + "/fonts/Helvetica-Bold-24.bdf")
big_font.load_glyphs(b'0123456789') # pre-load glyphs for fast printing
years_position = (126, 15)
days_position = (13, 41)
hours_position = (118, 41)
minutes_position = (25, 68)
text_color = 0xFF0000
text_areas = []
for pos in (years_position, days_position, hours_position, minutes_position):
textarea = Label(big_font, text=' ')
textarea.x = pos[0]
textarea.y = pos[1]
textarea.color = text_color
pyportal.splash.append(textarea)
text_areas.append(textarea)
refresh_time = None
while True:
# only query the online time once per hour (and on first run)
if (not refresh_time) or (time.monotonic() - refresh_time) > 3600:
try:
print("Getting time from internet!")
pyportal.get_local_time()
refresh_time = time.monotonic()
except RuntimeError as e:
pyportal = PyPortal(status_neopixel=board.NEOPIXEL,
default_bg=cwd + "/countdown_background.bmp")
big_font = bitmap_font.load_font(cwd + "/fonts/Helvetica-Bold-36.bdf")
big_font.load_glyphs(b'0123456789') # pre-load glyphs for fast printing
on_air_background = cwd + "/on_air_background.bmp"
its_over_background = cwd + "/its_over_background.bmp"
days_position = (8, 115)
hours_position = (100, 115)
minutes_position = (210, 115)
text_color = 0xFFFFFF
text_areas = []
for pos in (days_position, hours_position, minutes_position):
textarea = Label(big_font, max_glyphs=3)
textarea.x = pos[0]
textarea.y = pos[1]
textarea.color = text_color
pyportal.splash.append(textarea)
text_areas.append(textarea)
refresh_time = None
while True:
# only query the online time once per hour (and on first run)
if (not refresh_time) or (time.monotonic() - refresh_time) > 3600:
try:
print("Getting time from internet!")
pyportal.get_local_time()
refresh_time = time.monotonic()
except RuntimeError as e:
# splash.append(view2)
# splash.append(view3)
text = "hello hello"
color = 0x0000FF
font = terminalio.FONT
color = 0x03AD31
# Set the font and preload letters
font = bitmap_font.load_font("/fonts/Junction-regular-24.bdf")
# font = bitmap_font.load_font("/fonts/Arial-ItalicMT-17.bdf")
# font = bitmap_font.load_font("/fonts/LeagueSpartan-Bold-16.bdf")
font.load_glyphs(
b'abcdefghjiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890- ()')
# Used to calculate vertical text height for Top Alignment
text_hight = Label(font, text="M", color=0x03AD31, max_glyphs=10)
# Create the text label
text_area = Label(font, text=text, color=color, max_glyphs=200)
# Set the location
text_area.x = 100
text_area.y = 180
# Show it
cntr = 0
while True:
# text = str(cntr)
cntr = cntr + 1
received_data = io.receive_data(temperature_feed["key"])
"others - αψ◌"
]
splash = displayio.Group()
board.DISPLAY.show(splash)
max_y = 0
y = 0
for demo_text in demos:
for font in fonts:
if y >= board.DISPLAY.height:
y = 0
while len(splash):
splash.pop()
print("Font load {}".format(font.name))
area = Label(font,
text=demo_text,
anchor_point=(0, 0),
anchored_position=(0, y))
splash.append(area)
y += area.height
# Wait for the image to load.
try:
board.DISPLAY.refresh(target_frames_per_second=60)
except AttributeError:
board.DISPLAY.wait_for_frame()
# Wait for 1 minute (60 seconds)
time.sleep(60)
# Fade down the backlight
print('loading fonts...')
# Fonts within /fonts/ folder
font = cwd+"/fonts/GothamBlack-50.bdf"
font_small = cwd+"/fonts/GothamBlack-25.bdf"
# pylint: disable=syntax-error
data_glyphs = b'0123456789FC-* '
font = bitmap_font.load_font(font)
font.load_glyphs(data_glyphs)
font_small = bitmap_font.load_font(font_small)
full_glyphs = b'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-,.: '
font_small.load_glyphs(full_glyphs)
# Label to display Adafruit IO status
label_status = Label(font_small, max_glyphs=20)
label_status.x = 305
label_status.y = 10
splash.append(label_status)
# Create a label to display the temperature
label_temp = Label(font, max_glyphs=4)
label_temp.x = 35
label_temp.y = 300
splash.append(label_temp)
# Create a label to display the water level
label_level = Label(font, max_glyphs=4)
label_level.x = display.width - 130
label_level.y = 300
splash.append(label_level)
FONT_WIDTH, FONT_HEIGHT = terminalio.FONT.get_bounding_box()
screen_group = Group(max_size=len(choices) * 2 + 1 + 1)
### The position of the two players RPS Label objects inside screen_group
rps_dob_idx = []
### Create the simple arrow cursors
left_col = 20
right_col = display.width // 2 + left_col
for x_pos in (left_col, right_col):
y_pos = top_y_pos
rps_dob_idx.append(len(screen_group))
for label_text in choices:
rps_dob = Label(terminalio.FONT,
text=label_text,
scale=2,
color=DEFAULT_TXT_COL_FG,
background_color=DEFAULT_TXT_COL_BG)
rps_dob.x = x_pos
rps_dob.y = y_pos
y_pos += 60
screen_group.append(rps_dob)
cursor_dob = Label(terminalio.FONT, text=">", scale=3, color=CURSOR_COL_FG)
cursor_dob.x = left_col - 20
setCursor(my_choice_idx, "mine")
cursor_dob.y = top_y_pos
screen_group.append(cursor_dob)
### Initially set to a space to not show it
opp_cursor_dob = Label(terminalio.FONT,
submit = touchio.TouchIn(board.CAP8)
# Check for secrets.py. Note: for this project, your secrets.py needs an adafruit io api key as
# well as the wifi information
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
# Make the rgb group for setting rgb hex values for NeoPixels
rgb_group = displayio.Group()
R_label = Label(
terminalio.FONT,
text=" +\nR:\n -",
color=0xFFFFFF,
anchor_point=(0, 0.5),
anchored_position=(5, 120),
scale=2,
)
G_label = Label(
terminalio.FONT,
text=" +\nG:\n -",
color=0xFFFFFF,
anchor_point=(0, 0.5),
anchored_position=(90, 120),
scale=2,
)
B_label = Label(
terminalio.FONT,
text=" +\nB:\n -",
color=0xFFFFFF,
def __init__(self, is_celsius):
"""Creates an Azure_GFX object.
:param bool is_celsius: Temperature displayed in Celsius.
"""
# root displayio group
root_group = displayio.Group()
board.DISPLAY.show(root_group)
super().__init__()
# temperature display option
self._is_celsius = is_celsius
# create background icon group
self._icon_group = displayio.Group()
board.DISPLAY.show(self._icon_group)
# create text object group
self._text_group = displayio.Group()
self._icon_sprite = None
self._icon_file = None
self._cwd = cwd
self.set_icon(self._cwd + "/images/azure_splash.bmp")
print("loading fonts...")
glyphs = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-,.: "
data_glyphs = b"012345678-,.:/FC"
self.main_font = bitmap_font.load_font(main_font)
self.main_font.load_glyphs(glyphs)
self.data_font = bitmap_font.load_font(data_font)
self.data_font.load_glyphs(data_glyphs)
self.data_font.load_glyphs(("°", )) # extra glyph for temperature font
print("setting up labels...")
self.title_text = Label(self.main_font, text="Azure Plant Monitor")
self.title_text.x = 35
self.title_text.y = 25
self._text_group.append(self.title_text)
self.temp_label = Label(self.main_font, text="Temperature")
self.temp_label.x = 0
self.temp_label.y = 65
self._text_group.append(self.temp_label)
self.temp_text = Label(self.data_font)
self.temp_text.x = 200
self.temp_text.y = 85
self._text_group.append(self.temp_text)
self.moisture_label = Label(self.main_font, text="Moisture Level")
self.moisture_label.x = 0
self.moisture_label.y = 135
self._text_group.append(self.moisture_label)
self.moisture_text = Label(self.data_font)
self.moisture_text.x = 200
self.moisture_text.y = 175
self._text_group.append(self.moisture_text)
self.azure_status_text = Label(self.main_font)
self.azure_status_text.x = 65
self.azure_status_text.y = 225
self._text_group.append(self.azure_status_text)
# Initialize a requests object with a socket and esp32spi interface
socket.set_interface(esp)
requests.set_socket(socket, esp)
# DisplayIO Setup
# Set up fonts
font_small = bitmap_font.load_font("/fonts/Arial-12.pcf")
font_large = bitmap_font.load_font("/fonts/Arial-14.pcf")
# preload fonts
glyphs = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-,.: "
font_small.load_glyphs(glyphs)
font_large.load_glyphs(glyphs)
group_verification = displayio.Group(max_size=25)
label_overview_text = Label(font_large,
x=0,
y=45,
text="To authorize this device with Google:")
group_verification.append(label_overview_text)
label_verification_url = Label(font_small,
x=0,
y=100,
line_spacing=1,
max_glyphs=90)
group_verification.append(label_verification_url)
label_user_code = Label(font_small, x=0, y=150, max_glyphs=50)
group_verification.append(label_user_code)
label_qr_code = Label(font_small, x=0, y=190, text="Or scan the QR code:")
group_verification.append(label_qr_code)
def sample_sum(pin, num):
"""Sample the analogue value from pin num times and return the sum
of the values."""
global samples ### Not strictly needed - indicative of r/w use
samples[:] = [pin.value for _ in range(num)]
return sum(samples)
### Initialise detector display
### The units are created as separate text objects as they are static
### and this reduces the amount of redrawing for the dynamic numbers
FONT_SCALE = 3
if magnetometer is not None:
magnet_value_dob = Label(font=terminalio.FONT,
text="----.-",
scale=FONT_SCALE,
color=0xc0c000)
magnet_value_dob.y = 90
magnet_units_dob = Label(font=terminalio.FONT,
text="uT",
scale=FONT_SCALE,
color=0xc0c000)
magnet_units_dob.x = len(magnet_value_dob.text) * FONT_WIDTH * FONT_SCALE
magnet_units_dob.y = magnet_value_dob.y
voltage_value_dob = Label(font=terminalio.FONT,
text="----.-",
scale=FONT_SCALE,
color=0x00c0c0)
voltage_value_dob.y = 30
