DasK / Launchpad_Keyboard_Panel - Files

code.py
from time import sleep
import board
import busio
import neopixel
from keypad import KeyMatrix
from digitalio import DigitalInOut, Direction, Pull
import rotaryio
from analogio import AnalogIn
import random
# import storage 
import displayio
import terminalio
from adafruit_display_text import label
import adafruit_displayio_ssd1306


class CustomDisplay:
    def __init__(self):
        displayio.release_displays()
        i2c = busio.I2C(board.GP5, board.GP4)
        display_bus = displayio.I2CDisplay(i2c, device_address=0x3c)
        self._display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)
        self._splash = displayio.Group()
        self._text = ""
        self._text_changed = True

        # Make the display context
        self._display.show(self._splash)
        color_bitmap = displayio.Bitmap(128, 32, 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)
        self._splash.append(bg_sprite)
        # Draw a smaller inner rectangle as text background
        inner_bitmap = displayio.Bitmap(118, 24, 1)
        inner_palette = displayio.Palette(1)
        inner_palette[0] = 0x000000  # Black
        inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=5, y=4)
        self._splash.append(inner_sprite)    
        # Draw a label
        self._text_area = label.Label(terminalio.FONT, text=self._text, color=0xFFFFFF, x=28, y=15)
        self._splash.append(self._text_area)

    def text(self, text):
        self._text = text
        self._text_changed = True

    def update(self):
        if not self._text_changed:
            return
        self._text_changed = False
        self._text_area.text = self._text
        self._display.show(self._splash)

    def close(self):
        displayio.release_displays()

display = CustomDisplay()



pixels = neopixel.NeoPixel(board.GP0, 13, brightness=0.3, auto_write=True)  # does not need pixels.show() each time
l2b = (0, 1, 2, 3, 4, 8, 7, 6, 5, 9, 10, 11, 12)  # led index map with button index


# CUSTOM FUNCTIONS FOR POTENTIOMETERS ===============================

def change_brightness(val):
    # val 0.0 to 1.0
    pixels.brightness = round(val, 3)
    print(f"brightness {pixels.brightness}")

last_volume = 0
def change_volume(val):
    # val 0.0 to 1.0
    global last_volume
    volume = round(val*10)
    if volume == last_volume:
        return
    last_volume = volume
    m = f"vol {volume}"
    print(m)
    display.text(m)

last_example = 0
def change_example(val):
    # val 0.0 to 1.0
    global last_example
    disc_value = round(val*50)
    if disc_value == last_example:
        return
    last_example = disc_value
    m = f"exam {disc_value}"
    print(m)
    display.text(m)

pots = []
pots.append({
    "id": 1,
    'apin': AnalogIn(board.GP27_A1),
    'min': 3872,  # TODO get from configuration file
    'max': 62272,
    'threshold': 1200,
    'divisions': 10,
    'inverted': True,
    'trigger_at_start': False,
    'callback': change_volume,
})
pots.append({
    "id": 2,
    'apin': AnalogIn(board.GP28_A2),
    'min': 4256 + 450, # measured 4256
    'max': 62704 - 600, # measured 62704
    'threshold': 1200,
    'divisions': 20,
    'inverted': True,
    'trigger_at_start': True,
    'callback': change_brightness,    
})
pots.append({
    "id": 3,
    'apin': AnalogIn(board.GP26_A0),
    'min': 144 + 450,  # measured 144
    'max': 65520 - 450, # measured 65520
    'threshold': 900,
    'divisions': 10,
    'inverted': True,
    'trigger_at_start': False,
    'callback': change_example,
})

# configure pots
for pot in pots:
    sleep(0.01)
    if pot['trigger_at_start']:
        pot['last_value'] = 99999
    else:
        pot['last_value'] = pot['apin'].value


encoders = []
encoders.append({
    "id": 1,
    'obj': rotaryio.IncrementalEncoder(board.GP12, board.GP11),
    'last_position': 0
})

# configure and fill last_position
for encoder in encoders:
    encoder['obj'].divisor = 2
    encoder['last_position'] = encoder['obj'].position


km = KeyMatrix(
    row_pins=(board.GP20, board.GP19, board.GP18),
    column_pins=(board.GP16, board.GP17, board.GP21, board.GP22),
    # interval=0.050,  # debounce
)


def check_pots():
    for pot in pots:
        value = pot['apin'].value
        if abs(value - pot['last_value']) > pot['threshold']:
            # v = value * 3.3 / 65536
            pot['last_value'] = value
            d = (value - pot['min'])/(pot['max'] - pot['min'])
            if d<0:
                d=0.0
            elif d>1:
                d=1.0
            if pot['inverted']:
                d=1.0-d
            print(f"pot id {pot['id']}: raw {value} norm {d:.3f}")
            # display.text(f"p{pot['id']}: {d:.2f}")
            pot['callback'](d)


def check_encoders():
    for encoder in encoders:
        position = encoder['obj'].position
        if position != encoder['last_position']:
            encoder['last_position'] = position
            print(f"encoder id{encoder['id']}: {position}")
            display.text(f"e{encoder['id']}: {position}")


def check_keyboard():
    while 1:
        event = km.events.get()
        if not event:
            break
        # print(event)
        print(f"{event.key_number} {event.pressed} {event.released} {event.timestamp} ")
        display.text(f"key {event.key_number+1} {event.pressed}")
        if event.pressed:
            r = random.randrange(0,256)
            g = random.randrange(0,256)
            b = random.randrange(0,256)
            i = l2b[event.key_number+1]
            pixels[i] = (r,g,b)


def calibrate_pots_limits():
    for pot in pots:
        pot['min'] = 65536
        pot['max'] = 0
    print_resoult = True
    while True:
        for pot in pots:
            sleep(0.05)
            value = pot['apin'].value
            if value < pot['min']:
                pot['min'] = value
                print_resoult=True
            elif value > pot['max']:
                pot['max'] = value
                print_resoult=True
        if print_resoult:
            s = ""
            for pot in pots:
                s+=f"id{pot['id']} min {pot['min']} max {pot['max']}, "
            print(s)
            print_resoult=False

def calibrate_pots_threshold():
    for pot in pots:
        pot['m'] = 0

    while True:
        s = ""
        for pot in pots:
            r = pot['apin'].value
            for i in range(50):
                sleep(0.005)
                v = pot['apin'].value
                if abs(v-r) > pot['m']:
                    pot['m']=abs(v-r)
            s+=f"{pot['id']}: {pot['m']}, "
        print(s)
        sleep(5)


pixels[0] = (0, 128, 0)  # status LED

# calibrate_pots_limits()
# calibrate_pots_threshold()
counter = 0
# try:
while True:
    check_pots()
    check_encoders()
    check_keyboard()
    if counter%5 == 0:
        display.update()
    counter+=1
    sleep(0.01)
    # except MemoryError:  # because of the display
# except:
#     pixels[0] = (128, 0, 0)
#     pixels.brightness = 0.25
# displayio.release_displays()