Badger examples

counter.py

# A very simple Badger script which displays a counter and allows you to increment/decrement it with the up/down buttons
import badger2040

badger = badger2040.Badger2040()
display = badger.display
display.set_update_speed(badger2040.UPDATE_FAST)

number = 0

def clear():
  display.set_pen(15)
  display.clear()
  display.update()

def print_number(num):
  clear()
  display.set_font("sans")
  display.set_pen(0)
  display.set_thickness(3)
  display.text(str(num), (badger2040.WIDTH // 2) - 25, badger2040.HEIGHT // 2, 50)
  display.update()

clear()
print_number(number)

while True:
  if badger.pressed(badger2040.BUTTON_UP):
    number += 1
    print_number(number)
  elif badger.pressed(badger2040.BUTTON_DOWN):
    number += 1
    print_number(number)

slide1.txt

text
# Jamie
Welcome to Montreal

slide2.txt

qr
https://docs.google.com/document/d/1w18C82QkS2uirt9sP1PVHFTVPFVeW9SWlGI2LJcvo4I/edit
Docs

slide3.txt

image
/podia-logo-black.jpg

slides.py

import time
import qrcode
import badger2040
import badger_os
from picographics import PicoGraphics, DISPLAY_INKY_PACK
import jpegdec
import os
import re

# Global Constants
WIDTH = badger2040.WIDTH
HEIGHT = badger2040.HEIGHT

IMAGE_WIDTH = 104

HEADING_HEIGHT = 50
TEXT_HEIGHT = 15

TEXT_WIDTH = WIDTH
QR_TITLE_WIDTH = WIDTH - 140

HEADING_SIZE = 2
TEXT_SIZE = 1

LEFT_PADDING = 5
NAME_PADDING = 20
DETAIL_SPACING = 10

def max_slides():
    num_slides = 0
    
    regex = re.compile("slide(\d).txt")
    
    for filename in os.ilistdir():
        match = regex.match(filename[0])
        if match != None:
          slide_num = int(match.group(1))
          if slide_num > num_slides:
              num_slides = slide_num
              
    return num_slides
    
MAX_SLIDES = max_slides()

# ------------------------------
#      Utility functions
# ------------------------------

# Reduce the size of a string until it fits within a given width
def truncatestring(text, text_size, width):
    while True:
        length = display.measure_text(text, text_size)
        if length > 0 and length > width:
            text = text[:-1]
        else:
            text += ""
            return text


# ------------------------------
#      Drawing functions
# ------------------------------
def blank_canvas():
    badger.set_pen(0)
    display.clear()
    badger.set_pen(15)
    display.rectangle(0, 0, WIDTH, HEIGHT)

def render_slide():
    if slide_number() <= MAX_SLIDES:
        # Open the badge file
        try:
          slide = open("slide" + str(slide_number())+".txt", "r")
        except:
            message = "No file found for slide number "+str(slide_number())
            update_slide_number(1)
            badger_os.warning(display, message)
            
        slide_template = slide.readline()[:-1] # "image" or "text" (removing \n)
        
        if slide_template == "image":
            render_image(slide)
        elif slide_template == "text":
            render_text(slide)
        elif slide_template == "qr":
            render_qr(slide)
        else:
            error_and_reset("No slide template for" + slide_template)
    else:
       error_and_reset("No slide found for " + str(slide_number()))
       
def error_and_reset(message):
    badger_os.warning(display, message)
    time.sleep(4)
    update_slide_number(1)
    render_slide()

def measure_qr_code(size, code):
    w, h = code.get_size()
    module_size = int(size / w)
    return module_size * w, module_size

def draw_qr_code(ox, oy, size, code):
    size, module_size = measure_qr_code(size, code)
    badger.set_pen(15)
    display.rectangle(ox, oy, size, size)
    display.set_pen(0)
    for x in range(size):
        for y in range(size):
            if code.get_module(x, y):
                display.rectangle(ox + x * module_size, oy + y * module_size, module_size, module_size)

def render_qr(slide):
    url = slide.readline()
    code = qrcode.QRCode()
    
    blank_canvas()

    badger.set_pen(0)
    code.set_text(url)
    size, _ = measure_qr_code(128, code)
    left = top = int((badger2040.HEIGHT / 2) - (size / 2))
    draw_qr_code(WIDTH-128, 0, 128, code)
    
    title = slide.readline()
    display.set_pen(15)
    display.rectangle(0, 0, QR_TITLE_WIDTH, HEADING_HEIGHT)
    display.set_pen(0)  # Change this to 0 if a white background is used
    display.set_font("sans")
    display.set_thickness(3)
    line = truncatestring(title, TEXT_SIZE, QR_TITLE_WIDTH)
    display.text(line, LEFT_PADDING, (HEADING_HEIGHT // 2) + 1, HEADING_SIZE)

    detail = slide.readline()
    display.set_pen(0)
    display.set_font("sans")
    display.set_thickness(2)
    line = truncatestring(detail, TEXT_SIZE, QR_TITLE_WIDTH)
    display.text(line, LEFT_PADDING, HEADING_HEIGHT + (HEADING_HEIGHT // 2) + 1, HEADING_SIZE)

def render_image(slide):
    image_filename = slide.readline()

    blank_canvas()

    jpeg = jpegdec.JPEG(display)
    jpeg.open_file("/podia-logo-black.jpg")
    jpeg.decode(0, 0, jpegdec.JPEG_SCALE_FULL, dither=True)

def render_text(slide):
    blank_canvas()
    
    line_number = 0
    line = slide.readline()
    line_y = 0
    
    while len(line) > 1:
        line_number += 1
        
        if line[0:2] == "# ":
            mode = "heading"
            line = line[2:]
        elif line[0:2] == "- ":
            mode = "list"
            line = line[2:]
        else:
            mode = "text"
            
        if mode == "heading":
            badger.set_pen(0)
            display.rectangle(0, line_y, TEXT_WIDTH, HEADING_HEIGHT)
            badger.set_pen(15)  # Change this to 0 if a white background is used
            display.set_font("sans")
            display.set_thickness(3)

            line = truncatestring(line, TEXT_SIZE, WIDTH)
            display.text(line, LEFT_PADDING, line_y + (HEADING_HEIGHT // 2) + 1, scale=2)
            line_y += HEADING_HEIGHT

        elif mode == "text":
            badger.set_pen(15)
            display.rectangle(0, line_y, TEXT_WIDTH, TEXT_HEIGHT)
            badger.set_pen(0)  # Change this to 0 if a white background is used
            display.set_font("bitmap8")
    
            display.text(line, LEFT_PADDING, line_y + (TEXT_HEIGHT // 2) + 1, wordwrap=200, scale=2)
            line_y += TEXT_HEIGHT
        
        line = slide.readline() 

# ------------------------------
#        Program setup
# ------------------------------

# Create a new Badger and set it to update NORMAL
badger = badger2040.Badger2040()
display = badger.display
badger.led(50)
badger.set_update_speed(badger2040.UPDATE_MEDIUM)

state = {"slide_number": 1}
badger_os.state_load("slide_state", state)

badger_os.warning(display, str(MAX_SLIDES) + " slides found")

def update_slide_number(num):
    if num > MAX_SLIDES:
        num = 1

    if num < 1:
        num = MAX_SLIDES
        
    state["slide_number"] = num
    badger_os.state_modify("slide_state", state)

def slide_number():
    return state["slide_number"]

# ------------------------------
#       Main program
# ------------------------------

while True:
    if badger2040.pressed_to_wake(badger2040.BUTTON_A) or badger.pressed(badger2040.BUTTON_A):
        # Reset to the start
        update_slide_number(1)
    elif badger2040.pressed_to_wake(badger2040.BUTTON_B) or badger.pressed(badger2040.BUTTON_B):
        update_slide_number(2)
    elif badger2040.pressed_to_wake(badger2040.BUTTON_C) or badger.pressed(badger2040.BUTTON_C):
        update_slide_number(3)
    elif badger2040.pressed_to_wake(badger2040.BUTTON_UP) or badger.pressed(badger2040.BUTTON_UP):
        # Scroll up
        update_slide_number(slide_number()-1)
    elif badger2040.pressed_to_wake(badger2040.BUTTON_DOWN) or badger.pressed(badger2040.BUTTON_DOWN):
        # Scroll down
        update_slide_number(slide_number()+1)
    elif badger2040.woken_by_rtc():
        # If we're woken by the clock and no other button, increment the slide
        update_slide_number(slide_number()+1)
        
    badger2040.reset_pressed_to_wake()
    
    render_slide()
    display.update()

    # sleep the Badger for 1 minute, it will wake up if any of the front buttons are pressed
    badger2040.sleep_for(1)