def main(): # Make the display context splash = displayio.Group(max_size=20) 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, x=0, y=0, pixel_shader=color_palette) splash.append(bg_sprite) ########################################################################## splash.append(Line(220, 130, 270, 210, 0xFF0000)) splash.append(Line(270, 210, 220, 210, 0xFF0000)) splash.append(Line(220, 210, 270, 130, 0xFF0000)) splash.append(Line(270, 130, 220, 130, 0xFF0000)) #Draw a blue star polygon = Polygon([(255, 40), (262, 62), (285, 62), (265, 76), (275, 100), (255, 84), (235, 100), (245, 76), (225, 62), (248, 62)], outline=0x0000FF) splash.append(polygon) triangle = Triangle(170, 50, 120, 140, 210, 160, fill=0x00FF00, outline=0xFF00FF) splash.append(triangle) rect = Rect(80, 20, 41, 41, fill=0x0) splash.append(rect) circle = Circle(100, 100, 20, fill=0x00FF00, outline=0xFF00FF) splash.append(circle) rect2 = Rect(50, 100, 61, 81, outline=0x0, stroke=3) splash.append(rect2) roundrect = RoundRect(10, 10, 61, 81, 10, fill=0x0, outline=0xFF00FF, stroke=6) splash.append(roundrect) sleep(4) running = False
def test_shapes(self): expected_images = [] for i in range(5): img = Image.open( os.path.join( self.abs_path, CONSTANTS.IMG_DIR_NAME, f"test_image_shapes_{i+1}.bmp", )) img.putalpha(255) expected_images.append(img.load()) # TAKEN FROM ADAFRUIT'S DISPLAY SHAPES LIBRARY # https://github.com/ladyada/Adafruit_CircuitPython_Display_Shapes/blob/master/examples/display_shapes_simpletest.py splash = displayio.Group(max_size=10) splash._Group__show = self.__send_helper board.DISPLAY.show(splash) color_bitmap = displayio.Bitmap(320, 240, 1) color_palette = displayio.Palette(1) color_palette[0] = 0xFFFFFF bg_sprite = displayio.TileGrid(color_bitmap, x=0, y=0, pixel_shader=color_palette) splash.append(bg_sprite) helper._Helper__test_image_equality(self.main_img.load(), expected_images[0]) rect = Rect(80, 20, 41, 41, fill=0x00FF00) splash.append(rect) helper._Helper__test_image_equality(self.main_img.load(), expected_images[1]) circle = Circle(100, 100, 20, fill=0x00FF00, outline=0xFF00FF) splash.append(circle) helper._Helper__test_image_equality(self.main_img.load(), expected_images[2]) rect2 = Rect(50, 100, 61, 81, outline=0x0, stroke=3) splash.append(rect2) helper._Helper__test_image_equality(self.main_img.load(), expected_images[3]) roundrect = RoundRect(10, 10, 61, 81, 10, fill=0x0, outline=0xFF00FF, stroke=6) splash.append(roundrect) helper._Helper__test_image_equality(self.main_img.load(), expected_images[4])
def _create_body(self): if (self.outline_color is not None) or (self.fill_color is not None): if self.style == Button.RECT: self.body = Rect( 0, 0, self.width, self.height, fill=self._fill_color, outline=self._outline_color, ) elif self.style == Button.ROUNDRECT: self.body = RoundRect( 0, 0, self.width, self.height, r=10, fill=self._fill_color, outline=self._outline_color, ) elif self.style == Button.SHADOWRECT: self.shadow = Rect(2, 2, self.width - 2, self.height - 2, fill=self.outline_color) self.body = Rect( 0, 0, self.width - 2, self.height - 2, fill=self._fill_color, outline=self._outline_color, ) elif self.style == Button.SHADOWROUNDRECT: self.shadow = RoundRect( 2, 2, self.width - 2, self.height - 2, r=10, fill=self._outline_color, ) self.body = RoundRect( 0, 0, self.width - 2, self.height - 2, r=10, fill=self._fill_color, outline=self._outline_color, ) if self.shadow: self.append(self.shadow)
def __init__(self, *, x, y, width, height, name=None, style=RECT, fill_color=0xFFFFFF, outline_color=0x0, label=None, label_font=None, label_color=0x0, selected_fill=None, selected_outline=None, selected_label=None, icon=None): self.x = x self.y = y self.width = width self.height = height self._font = label_font self._selected = False self.group = displayio.Group() self.name = name self._label = label self._icon = icon self.body = self.fill = self.shadow = None self.fill_color = _check_color(fill_color) self.outline_color = _check_color(outline_color) self._label_color = label_color self._label_font = label_font # Selecting inverts the button colors! self.selected_fill = _check_color(selected_fill) self.selected_outline = _check_color(selected_outline) self.selected_label = _check_color(selected_label) if self.selected_fill is None and fill_color is not None: self.selected_fill = (~self.fill_color) & 0xFFFFFF if self.selected_outline is None and outline_color is not None: self.selected_outline = (~self.outline_color) & 0xFFFFFF if outline_color or fill_color: if style == Button.RECT: self.body = Rect(x, y, width, height, fill=self.fill_color, outline=self.outline_color) elif style == Button.ROUNDRECT: self.body = RoundRect(x, y, width, height, r=10, fill=self.fill_color, outline=self.outline_color) elif style == Button.SHADOWRECT: self.shadow = Rect(x + 2, y + 2, width - 2, height - 2, fill=outline_color) self.body = Rect(x, y, width - 2, height - 2, fill=self.fill_color, outline=self.outline_color) elif style == Button.SHADOWROUNDRECT: self.shadow = RoundRect(x + 2, y + 2, width - 2, height - 2, r=10, fill=self.outline_color) self.body = RoundRect(x, y, width - 2, height - 2, r=10, fill=self.fill_color, outline=self.outline_color) if self.shadow: self.group.append(self.shadow) self.group.append(self.body) self.icon = icon self.label = label
def cc_init(cc_state): fontL = cc_state['fonts']['helvB12'] fontS = cc_state['fonts']['helvR10'] # grp_clock = displayio.Group(max_size=6) # grp_clock.append(Rect(0,0, 32,32, fill=0x000020, outline=0x202020)) grp_clock.append(Rect(1,10, 30,11, fill=0x080030)) # lbl_time = label.Label(fontL, color=0x808080, text='00:00', x=4, y=16) grp_clock.append(lbl_time) # lbl_month = label.Label(fontS, color=0x804000, text='Jan', x=1, y=25) grp_clock.append(lbl_month) # lbl_day_num = label.Label(fontS, color=0x804000, text='33', x=17, y=26) grp_clock.append(lbl_day_num) # lbl_day_wk = label.Label(fontS, color=0x804000, text='Fri', x=8, y=6) grp_clock.append(lbl_day_wk) # # LATITUDE, LONGITUDE, TIMEZONE are set up once, constant over app lifetime # Fetch latitude/longitude from secrets.py. If not present, use # IP geolocation. This only needs to be done once, at startup! lat = None ; lon = None ; tz = None net = cc_state['network'] try: lat = cc_state['secrets']['latitude'] lon = cc_state['secrets']['longitude'] print('Using stored geolocation: ', lat, lon) CC_blockData['lat'] = lat ; CC_blockData['lon'] = lon except KeyError: pass # # Load time zone string from secrets.py, else IP geolocation for this too # (http://worldtimeapi.org/api/timezone for list). try: tz = cc_state['secrets']['timezone'] # e.g. 'America/New_York' CC_blockData['tz'] = tz except KeyError: pass # try: utc_offset = cc_state['secrets']['utc_offset'] CC_blockData['utc_offset'] = utc_offset except KeyError: CC_blockData['utc_offset'] = 0 # # # Set initial last_sync time to update time right away in cc_update CC_blockData['last_sync'] = time.time() - SYNC_TIME # return grp_clock
def render(self): display = badge.display screen = displayio.Group() screen.append( Rect(0, 32, display.width, display.height - 32, fill=0xffffff)) app_label = bitmap_label.Label(terminalio.FONT, text="Keyboard Test", color=0xffffff, save_text=True) app_label_group = displayio.Group(scale=2, x=40, y=14) app_label_group.append(app_label) screen.append(app_label_group) if self.keyboard: key_label = bitmap_label.Label(terminalio.FONT, text=self.text, color=0x0, scale=3, anchor_point=(0.5, 0.5), anchored_position=(display.width // 2, 70)) else: key_label = bitmap_label.Label( terminalio.FONT, text="Keyboard not connected\n :-(", color=0x0, scale=2, anchor_point=(0.5, 0.5), anchored_position=(display.width // 2, 70)) screen.append(key_label) display.show(screen) self.update_screen = False
def __init__(self, width, height, start_x, start_y, badger, up_btn_str, down_btn_str, debug=False): self.badger = badger # Store local variables in our object to access later in other functions self.height = height self.width = width self.x = start_x self.y = start_y # will store previous update y position to determine if paddle is in motion self.prev_y = self.y # will store the int values of the buttons we are interested in for this update frame self.up_btn = 0 self.down_btn = 0 # stores the string representation of the buttons we care about self.up_btn_str = up_btn_str self.down_btn_str = down_btn_str # create a rect object self.rect = Rect(self.x, self.y, self.width, self.height, fill=0x0) # screen height needed so it knows when to stop moving self.SCREEN_HEIGHT = 128
def show_splash(self): """ Shows the loading screen """ if self.debug: return blinka_bitmap = "blinka-pyloton.bmp" # Compatible with CircuitPython 6 & 7 with open(blinka_bitmap, 'rb') as bitmap_file: bitmap1 = displayio.OnDiskBitmap(bitmap_file) tile_grid = displayio.TileGrid(bitmap1, pixel_shader=getattr( bitmap1, 'pixel_shader', displayio.ColorConverter())) self.loading_group.append(tile_grid) self.display.show(self.loading_group) status_heading = label.Label(font=self.arial16, x=80, y=175, text="Status", color=self.YELLOW) rect = Rect(0, 165, 240, 75, fill=self.PURPLE) self.loading_group.append(rect) self.loading_group.append(status_heading)
def background(self): # PLEASE NOTE # This needs to be run before calling render # Define the group for the thermal display self.image_group = displayio.Group(max_size=77) # Create a black background color fill layer; image_group[0] color_bitmap = displayio.Bitmap(self.WIDTH, self.HEIGHT, 1) color_palette = displayio.Palette(1) color_palette[0] = self.colours.BLACK background = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) self.image_group.append(background) # Define the foundational thermal image element layers; image_group[1:64] # image_group[#]=(row * 8) + column for row in range(0, 8): for col in range(0, 8): pos_x, pos_y = self.element_grid(col, row) # outline is normally None and stroke is 0 element = Rect(x=pos_x, y=pos_y, width=self.ELEMENT_SIZE, height=self.ELEMENT_SIZE, fill=None, outline=None, stroke=0 ) self.image_group.append(element) self.display.show(self.image_group)
def make_ui_group(self, main_config, config_label, rect_val=None): """ Generates and displays a displayio group containing several elements that all config screens have in common (or nearly in common). Arguments: main_config (boolean) : If true, function generates the main config screen elements, else makes elements for other config screens. config_label (string) : Text to appear at center(ish) of screen. rect_val (float) : If specified, a Rect object is created whose width represents the value. 0.0 = min, 1.0 = full display width. Returns: displayio group """ group = displayio.Group() group.append(centered_label('TAP L/R to', 3, 2)) group.append(centered_label('select item' if main_config else 'select image' if self.config_mode is 0 else 'change', 16, 2)) group.append(centered_label('HOLD L: item config' if main_config else 'HOLD L: back', 100, 2)) group.append(centered_label('HOLD R: paint', 113, 2)) if rect_val: self.rect = Rect(int(board.DISPLAY.width * (rect_val - 1.0)), 120, board.DISPLAY.width, 40, fill=0x00B000) group.append(self.rect) # Config label always appears as last item in group # so calling func can pop() and replace it if need be. group.append(centered_label(config_label, 30 if rect_val else 40, 3)) board.DISPLAY.show(group) return group
def __init__(self, parent_group, index): y = (int)(config['character_height'] + config['text_padding']) * (index + 1) self.line_rect = Rect(0, y, config['train_line_width'], config['train_line_height'], fill=config['loading_line_color']) self.destination_label = Label( config['font'], max_glyphs=config['destination_max_characters'], anchor_point=(0, 0)) self.destination_label.x = config['train_line_width'] + 2 self.destination_label.y = y self.destination_label.color = config['text_color'] self.destination_label.text = config[ 'loading_destination_text'][:config['destination_max_characters']] self.min_label = Label(config['font'], max_glyphs=config['min_label_characters'], anchor_point=(0, 0)) self.min_label.x = config['matrix_width'] - ( config['min_label_characters'] * config['character_width']) + 1 self.min_label.y = y self.min_label.color = config['text_color'] self.min_label.text = config['loading_min_text'] self.group = displayio.Group(max_size=3) self.group.append(self.line_rect) self.group.append(self.destination_label) self.group.append(self.min_label) parent_group.append(self.group)
def _badge_background( self, background_color=(255, 0, 0), rectangle_color=(255, 255, 255), rectangle_drop=0.4, rectangle_height=0.5, ): """Populate the background color with a rectangle color block over it as the background for a name badge.""" background_group = displayio.Group(max_size=30) 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 ) background_group.append(bg_sprite) rectangle = Rect( 0, (int(self.display.height * rectangle_drop)), self.display.width, (int(self.display.height * rectangle_height)), fill=rectangle_color, ) background_group.append(rectangle) return background_group
def _badge_background( self, background_color: Tuple[int, int, int] = RED, rectangle_color: Tuple[int, int, int] = WHITE, rectangle_drop: float = 0.4, rectangle_height: float = 0.5, ) -> displayio.Group: """Populate the background color with a rectangle color block over it as the background for a name badge.""" background_group = displayio.Group() 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 ) background_group.append(bg_sprite) rectangle = Rect( 0, (int(self.display.height * rectangle_drop)), self.display.width, (int(self.display.height * rectangle_height)), fill=rectangle_color, ) background_group.append(rectangle) return background_group
def voltage_bar_set(volt_diff): """Draw a bar based on positive or negative values. Width of 60 is performance compromise as more pixels take longer.""" global voltage_sep_dob, voltage_barpos_dob, voltage_barneg_dob global last_negbar_len, last_posbar_len if voltage_sep_dob is None: voltage_sep_dob = Rect(160, VOLTAGE_BAR_HEIGHT, VOLTAGE_BAR_WIDTH, VOLTAGE_BAR_SEP_HEIGHT, fill=WHITE75) screen_group.append(voltage_sep_dob) if volt_diff < 0: negbar_len = max(min(-round(volt_diff * 5e3), VOLTAGE_BAR_HEIGHT), 1) posbar_len = 1 else: negbar_len = 1 posbar_len = max(min(round(volt_diff * 5e3), VOLTAGE_BAR_HEIGHT), 1) if posbar_len == last_posbar_len and negbar_len == last_negbar_len: return if voltage_barpos_dob is not None: screen_group.remove(voltage_barpos_dob) if posbar_len > 0: voltage_barpos_dob = Rect(160, VOLTAGE_BAR_HEIGHT - posbar_len, VOLTAGE_BAR_WIDTH, posbar_len, fill=GREEN75) screen_group.append(voltage_barpos_dob) last_posbar_len = posbar_len if voltage_barneg_dob is not None: screen_group.remove(voltage_barneg_dob) if negbar_len > 0: voltage_barneg_dob = Rect(160, VOLTAGE_BAR_HEIGHT + VOLTAGE_BAR_SEP_HEIGHT, VOLTAGE_BAR_WIDTH, negbar_len, fill=RED) screen_group.append(voltage_barneg_dob) last_negbar_len = negbar_len
def new_frame(self): self._frame = displayio.Group(max_size=10) rect = Rect(0, 0, self.DISPLAY_WIDTH, self.DISPLAY_HEIGHT, fill=self.BACKGROUND_COLOR) self._frame.append(rect) return self._frame
def render(self): display = badge.display font = terminalio.FONT apps_per_screen = 3 screen = displayio.Group(max_size=3 + apps_per_screen) screen.append(Rect(0, 0, display.width, display.height, fill=0xffffff)) banner_image = displayio.OnDiskBitmap(open("/assets/banner.bmp", "rb")) banner = displayio.TileGrid(banner_image, pixel_shader=displayio.ColorConverter()) screen.append(banner) first_app = (self.selection // apps_per_screen) * apps_per_screen # List of apps for index, app in enumerate(self.apps[first_app:first_app + apps_per_screen]): title = app['menu_item'] y = 5 + (index % apps_per_screen) * 40 app_group = displayio.Group(x=38, y=y) fill = 0 palette = displayio.Palette(1) if first_app + index == self.selection: app_group.append(Rect(-5, -4, display.width - 32, 40, fill=0)) fill = 0xffffff palette[0] = 0xffffff try: app_icon_file = app.get('icon', "{}/icon.bmp".format(app.get('path', ''))) app_icon = displayio.OnDiskBitmap(open(app_icon_file, "rb")) app_group.append(displayio.TileGrid(app_icon, pixel_shader=palette)) except: pass app_label = label.Label(font, text=title, color=fill) app_label_group = displayio.Group(scale=2, x=38, y=13) app_label_group.append(app_label) app_group.append(app_label_group) screen.append(app_group) if first_app + apps_per_screen < len(self.apps): # we have more app, display a down arrow more_icon = displayio.OnDiskBitmap(open("{}/arrow_down.bmp".format(MENU_ROOT), "rb")) screen.append(displayio.TileGrid(more_icon, pixel_shader=displayio.ColorConverter(), x=display.width - 16, y=display.height - 7)) # Show it display.show(screen)
def render(self): display = badge.display screen = displayio.Group() screen.append( Rect(0, 32, display.width, display.height - 32, fill=0xffffff)) banner_image = displayio.OnDiskBitmap( open("{}/icon.bmp".format(APP_ROOT), "rb")) palette = displayio.Palette(1) palette[0] = 0xffffff banner = displayio.TileGrid(banner_image, pixel_shader=palette, x=4, y=0) screen.append(banner) app_label = bitmap_label.Label(terminalio.FONT, text="Conference Agenda", color=0xffffff, save_text=True) app_label_group = displayio.Group(scale=2, x=40, y=14) app_label_group.append(app_label) screen.append(app_label_group) lines_group = displayio.Group(x=8, y=48) lines = self.agenda[self.current_agenda][self.screen * SCREEN_SIZE:(self.screen + 1) * SCREEN_SIZE] for (index, line) in enumerate(lines): lines_group.append( bitmap_label.Label(terminalio.FONT, text=line[0:40], color=0x0, y=index * 12, save_text=True)) screen.append(lines_group) # Display up/down arrows as needed if self.screen > 0: more_icon = displayio.OnDiskBitmap( open("{}/arrow_up.bmp".format(APP_ROOT), "rb")) screen.append( displayio.TileGrid(more_icon, pixel_shader=displayio.ColorConverter(), x=display.width - 20, y=40)) if self.screen + 1 < self.screen_count[self.current_agenda]: more_icon = displayio.OnDiskBitmap( open("{}/arrow_down.bmp".format(APP_ROOT), "rb")) screen.append( displayio.TileGrid(more_icon, pixel_shader=displayio.ColorConverter(), x=display.width - 20, y=display.height - 16)) display.show(screen)
def _status_bar(self, fill_color, outline_color): # Shapes frame = RoundRect(3, 96, 154, 28, 5, fill=fill_color, outline=outline_color, stroke=1) self.main_group.append(frame) line = Rect(8, 110, 144, 1, fill=0x0) self.main_group.append(line) # Free resources self.sys_stat_label = label.Label(self.font_mini, text='Wait for status ...', color=outline_color) self.sys_stat_label.x = 92 self.sys_stat_label.y = 116 self.main_group.append(self.sys_stat_label) # Coordinates self.lat_label = label.Label(self.font_mini, text='LAT: wait ', color=outline_color) self.lat_label.x = 7 self.lat_label.y = 103 self.main_group.append(self.lat_label) self.lon_label = label.Label(self.font_mini, text='LON: wait ', color=outline_color) self.lon_label.x = 7 self.lon_label.y = 115 self.main_group.append(self.lon_label) # Satellites self.sat_label = label.Label(self.font_mini, text='SAT:0', color=fill_color) self.sat_label.x = 122 self.sat_label.y = 25 self.main_group.append(self.sat_label) # Fix Quality self.fq_label = label.Label(self.font_mini, text='FQU:0', color=fill_color) self.fq_label.x = 122 self.fq_label.y = 35 self.main_group.append(self.fq_label) # Altitude self.alt_label = label.Label(self.font_mini, text='ALT:0 ', color=outline_color) self.alt_label.x = 92 self.alt_label.y = 103 self.main_group.append(self.alt_label)
def rect(self, x, y, w, h, fill=None, outline=None, stroke=1, index=None): """ Draw a rectangle """ fl = self._pal[fill] if fill else None ol = self._pal[outline] if outline else None r = Rect(x, y, w, h, fill=fl, outline=ol, stroke=stroke) if index: self._group.insert(index, r) print(len(self._group), index) else: self._group.append(r) return r
def cc_init(cc_state): grp_meminfo = displayio.Group(max_size=3) rect = Rect(0, 0, 32, 32, fill=0x000020, outline=0x444444) grp_meminfo.append(rect) # grp_mem = cc_util.layout_group(MEM) grp_meminfo.append(grp_mem) # grp_free = cc_util.layout_group(FREE, -1, 14) grp_meminfo.append(grp_free) # return grp_meminfo
def cc_init(cc_state): conf = cc_state['config']['blocks'][CC_blockID] # grp_msg = displayio.Group(max_size=len(conf['lines']) + 1) rect = Rect(0, 0, 64, 32, fill=conf['bg'], outline=conf['ol']) grp_msg.append(rect) # for li in conf['lines']: font = cc_state['fonts'][li[3]] lbl = label.Label(font, text=li[0], x=li[1], y=li[2], color=li[4]) grp_msg.append(lbl) # return grp_msg
def run(self): display = badge.display self.running = True while self.running: group = displayio.Group() group.append( Rect(0, 0, display.width, display.height, fill=0xffffff)) group.append(self.draw_time(self.rtc.datetime, 48, 40)) display.show(group) while display.time_to_refresh > 0: pass if not self.process_input(): display.refresh()
def cc_init(cc_state): grp_ccmp = displayio.Group(max_size=4) rect = Rect(0,0,32,32,fill=0x000020, outline=0x444444) grp_ccmp.append(rect) # grp_compu = cc_util.layout_group(COMPU) grp_ccmp.append(grp_compu) # grp_canvas = cc_util.layout_group(CANVAS, 0, 10) grp_ccmp.append(grp_canvas) # grp_mp = cc_util.layout_group(MP, 0, 20, 6, 0) grp_ccmp.append(grp_mp) # return grp_ccmp
def __init__(self, width, height, start_x, start_y, debug=False): # Store local variables in our object to access later in other functions self.height = height self.width = width self.x = start_x self.y = start_y # create a rect object self.rect = Rect(self.x, self.y, self.width, self.height, fill=0x0) # default to moving up self.going_up = True # screen height needed so it knows when to change direction self.SCREEN_HEIGHT = 128
def init(cc_state): CCMP_model = cc_state['config']['CCMP_model'] width = 32 height = 32 if CCMP_model == '64x': width = 64 height = 64 cc_state['width'] = 64 cc_state['height'] = 64 elif CCMP_model == '64h': width = 64 height = 32 cc_state['width'] = 64 cc_state['height'] = 32 elif CCMP_model == '64v': width = 64 height = 32 cc_state['width'] = 32 cc_state['height'] = 64 else: cc_state['width'] = 32 cc_state['height'] = 32 # matrix = Matrix(width=width, height=height, bit_depth=6) cc_state['matrix'] = matrix matrix.display.rotation = cc_state['config']['rotation'] # root_group = displayio.Group(max_size=12) root_group.append( Rect(0, 0, cc_state['width'], cc_state['height'], fill=0x001020, outline=0x444444)) cc_state['groups']['ROOT'] = root_group # cc_state['fonts']['terminal'] = terminalio.FONT cc_state['fonts']['helvB12'] = bitmap_font.load_font('/fonts/helvB12.bdf') cc_state['fonts']['helvR10'] = bitmap_font.load_font('/fonts/helvR10.bdf') # cc_state['buttons']['up'] = digitalio.DigitalInOut(board.BUTTON_UP) cc_state['buttons']['up'].switch_to_input(digitalio.Pull.UP) cc_state['buttons']['down'] = digitalio.DigitalInOut(board.BUTTON_DOWN) cc_state['buttons']['down'].switch_to_input(digitalio.Pull.UP) cc_state['buttons']['counter'] = 0 # matrix.display.show(root_group)
def cc_init(cc_state): grp_wifi = displayio.Group(max_size=2) rect = Rect(0, 0, 32, 32, fill=0x000020, outline=0x444444) grp_wifi.append(rect) # font = cc_state['fonts']['helvB12'] lbl = label.Label(font, max_glyphs=4, color=0x800000) lbl.text = "WiFi" lbl.x = 4 lbl.y = 14 grp_wifi.append(lbl) # net = Network(status_neopixel=board.NEOPIXEL, debug=True) cc_state['network'] = net net.connect() # return grp_wifi
def PointRect(p1, p2, fill=WHITE, outline=YELLOW, stroke=2): ''' A wrapper function to create a rectangle from two points ''' width = p2.x - p1.x height = p2.y - p1.y # Set minimum height and width to stroke thickness to avoid error if width < stroke: width = stroke if height < stroke: height = stroke return Rect(p1.x, p1.y, width, height, fill=fill, outline=outline, stroke=stroke)
def cc_init(cc_state): net = Network(status_neopixel=board.NEOPIXEL, debug=True) cc_state['network'] = net cc_state['network_IP'] = "0.0.0.0" net.connect() # grp_ipaddr = displayio.Group(max_size=3) rect = Rect(0, 0, 32, 32, fill=0x000020, outline=0x444444) grp_ipaddr.append(rect) # grp_addr = cc_util.layout_group(IP_ADDR) grp_ipaddr.append(grp_addr) # grp_trip = cc_util.layout_group(IP_TRIPLETS, 0, 10, 15, 3) grp_ipaddr.append(grp_trip) # del IP_ADDR[:] del IP_TRIPLETS[:] # return grp_ipaddr
def render(self): screen = displayio.Group() screen.append(Rect(0, 0, badge.display.width, 32, fill=0xffffff)) banner_image = displayio.OnDiskBitmap( open("/apps/radio/icon.bmp", "rb")) banner = displayio.TileGrid(banner_image, pixel_shader=displayio.ColorConverter(), x=4, y=-2) screen.append(banner) app_label = label.Label(terminalio.FONT, text="Radio", color=0x0) app_label_group = displayio.Group(scale=2, x=40, y=14) app_label_group.append(app_label) screen.append(app_label_group) controls_group = displayio.Group(scale=2, x=8, y=48) if self.fm is not None: volume_label = label.Label(terminalio.FONT, text="Volume: {}".format( self.fm.volume), color=0xffffff) channel_label = label.Label(terminalio.FONT, text="Station: {} FM".format( self.fm.channel), color=0xffffff, y=16) controls_group.append(volume_label) controls_group.append(channel_label) else: missing_module_label = label.Label( terminalio.FONT, text="FM module missing\n or not working", color=0xffffff) controls_group.append(missing_module_label) screen.append(controls_group) badge.display.show(screen)
def draw_time(self, dt, x, y): timestr = '%02d:%02d' % (dt.tm_hour, dt.tm_min) group = displayio.Group(max_size=len(timestr) + 1, x=x, y=y) xpos = 0 digit = self.selected_digit if digit >= 2: # Skip the colon digit += 1 for index, ch in enumerate(timestr): shader = displayio.ColorConverter() if index == digit: rect = Rect(xpos - 4, -8, 48, 64, fill=0x0) group.append(rect) shader = displayio.Palette(2) shader[0] = 0xffffff sprite = displayio.TileGrid(self.assets[ch], x=xpos, pixel_shader=shader) group.append(sprite) xpos += self.assets[ch].width + 8 return group