Beispiel #1
0
    def __init__(self):
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(clk, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
        GPIO.setup(dt, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

        self.counter = 0
        self.clkLastState = GPIO.input(clk)
        i2c_bus = busio.I2C(SCL, SDA)
        trelli = [
            [
                NeoTrellis(i2c_bus, False, addr=0x2E),
                NeoTrellis(i2c_bus, False, addr=0x2F),
                NeoTrellis(i2c_bus, False, addr=0x30)
            ],
        ]
        trellis = MultiTrellis(trelli)
Beispiel #2
0
 def __init__(self, i2c_bus):
     super().__init__()
     self.led_matrix = [[BLANK for x in range(W)] for y in range(H)]
     self.old_led_matrix = [[BLANK for x in range(W)] for y in range(H)]
     self.trelli = [[] for i in range(int(H/4))]  # [[],[]]
     print("Creating Trelli")
     for x, slice in enumerate(trellis_addresses):
         for y, addr in enumerate(slice):
             t = NeoTrellis(i2c_bus, False, addr=addr)
             t.pixels.auto_write = False
             self.trelli[x].append(t)
             sleep(0.1)
             pass
     print("Linking Trelli")
     self.trellis = MultiTrellis(self.trelli)
     print("Trelli linked")
     button_cb = self.make_button_cb()
     print("Initializing Trelli inputs")
     for y in range(H):
         for x in range(W):
             pass
             sleep(0.01)
             self.trellis.activate_key(x, y, NeoTrellis.EDGE_RISING)
             sleep(0.01)
             self.trellis.activate_key(x, y, NeoTrellis.EDGE_FALLING)
             self.trellis.set_callback(x, y, button_cb)
     debug("Inputs initialized")
     self.blank_screen()
Beispiel #3
0
    def init(self):
        self.states.enterMenu(MENUSTATE_INIT)
        self.config.load()
        self.states.sleepEnabled = self.config.isSleepEnabled()
        self.config.registerFilechangedListener(self.onConfigChanged)

        self.btctl = BluetoothCtl(self.config.getBluetoothMacs())
        # create the i2c object for the trellis
        i2c_bus = busio.I2C(SCL, SDA)
        # create the trellis
        self.trellis = NeoTrellis(i2c_bus)
        for i in range(16):
            # activate rising edge events on all keys
            self.trellis.activate_key(i, NeoTrellis.EDGE_RISING)
            # activate falling edge events on all keys
            self.trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
            # set all keys to trigger the blink callback
            self.trellis.callbacks[i] = self.onKeyPressed
Beispiel #4
0
def main(trellis: NeoTrellis):
    for i in range(BUTTON_COUNT):
        trellis.activate_key(i, NeoTrellis.EDGE_RISING)
        trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
        trellis.callbacks[i] = button_callback(trellis, i)

    while True:
        for i in range(BUTTON_COUNT):
            trellis.pixels[i] = button_target_color(i)

        trellis.sync()
        time.sleep(0.02)
Beispiel #5
0
    def __init__(self, startup_color='random', debug=True):

        self.debug = debug
        self.nbuttons = 16
        self.colors = {
            'off': (0, 0, 0),
            'purple': (180, 0, 255),
            'red': (255, 0, 0),
            'orange': (255, 164, 0),
            'green': (0, 255, 0),
            'yellow': (158, 152, 17),
            'gray': (100, 100, 100),
            'blue': (0, 0, 255),
            'lightblue': (7, 34, 81),
            'blueish': (33, 211, 237),
            'darkgray': (10, 10, 10),
            'seagreen': (30, 255, 30),
            'lightseagreen': (39, 239, 120),
            'salmon': (206, 28, 41),
            'lightorange': (176, 76, 9),
            'lightpurple': (87, 20, 174),
            'lighterpurple': (70, 27, 87),
            'pink': (100, 0, 100)
        }

        # create the i2c object for the trellis
        self.i2c_bus = busio.I2C(SCL, SDA)

        # create the trellis
        self.trellis = NeoTrellis(
            self.i2c_bus)  # can set interrupt=True here...

        # for handling colors of groups of buttons
        self.startup_color = startup_color
        self.color_map = {}

        # to ensure callback set
        self.button_handler = None
Beispiel #6
0
    def __init__(self, button_bus, led_bus, i2c_bus):
        Thread.__init__(self, name='Display')
        # super(Display, self).__init__()
        self.button_bus = button_bus
        self.led_bus = led_bus
        debug("Creating i2c bus")
        lcd.flash("Creating i2c bus")
        # i2c_bus = busio.I2C(SCL, SDA)
        lcd.setup_hw(i2c_bus)
        debug("i2c bus created")
        lcd.flash("i2c bus created")
        debug("Creating Trelli")
        lcd.flash("Creating Trelli")
        trelli = [[], [], [], []]
        # addrs = trellis_addresses
        # Create trelli sequentially with a slight pause between each
        for x, slice in enumerate(trellis_addresses):
            for y, addr in enumerate(slice):
                t = NeoTrellis(i2c_bus, False, addr=addr)
                t.pixels.auto_write = False
                trelli[x].append(t)
                sleep(0.1)
        debug("Linking Trelli")
        lcd.flash("Linking Trelli")
        self.trellis = MultiTrellis(trelli)

        debug("Trelli linked")
        lcd.flash("Trelli linked")
        self.grid_h = H
        self.grid_w = W
        self.state = 'play'
        self.led_matrix = [[(0, 0, 0) for x in range(w)] for y in range(h)]
        self.old_led_matrix = [[(0, 0, 0) for x in range(w)] for y in range(h)]
        button_cb = self.make_cb()
        debug("Initializing Trelli inputs")
        lcd.flash("Initializing Trelli inputs")
        for y in range(self.grid_h):
            for x in range(self.grid_w):
                sleep(0.01)
                self.trellis.activate_key(x, y, NeoTrellis.EDGE_RISING)
                sleep(0.01)
                self.trellis.activate_key(x, y, NeoTrellis.EDGE_FALLING)
                self.trellis.set_callback(x, y, button_cb)
        self.ins_button = digitalio.DigitalInOut(D13)
        self.gbl_button = digitalio.DigitalInOut(D6)
        debug("Inputs initialized")
        lcd.flash("Inputs initialized")
        self.col_scheme = select_scheme('default')
        return
Beispiel #7
0
    def __init__(self):
        # setup trellis
        i2c_bus = busio.I2C(SCL, SDA)
        self.trellis = MultiTrellis(
            [
                [
                    NeoTrellis(i2c_bus, True, addr=0x31),
                    NeoTrellis(i2c_bus, True, addr=0x30),
                    NeoTrellis(i2c_bus, True, addr=0x2F),
                    NeoTrellis(i2c_bus, True, addr=0x2E),
                ],
                [
                    NeoTrellis(i2c_bus, True, addr=0x35),
                    NeoTrellis(i2c_bus, True, addr=0x34),
                    NeoTrellis(i2c_bus, True, addr=0x33),
                    NeoTrellis(i2c_bus, True, addr=0x32),
                ],
            ]
        )

        # interrupt pin - sync only when needed
        self.interrupt = digitalio.DigitalInOut(D5)
        self.interrupt.direction = digitalio.Direction.INPUT
Beispiel #8
0
import time
import random
import board
from board import SCL, SDA
import digitalio
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis
trellis = NeoTrellis(i2c_bus)

button_pin = board.D6

button = digitalio.DigitalInOut(button_pin)
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.UP

# some color definitions
OFF = (0, 0, 0)
RED = (25, 0, 0)
YELLOW = (25, 15, 0)
GREEN = (0, 25, 0)
CYAN = (0, 25, 25)
BLUE = (0, 0, 25)
PURPLE = (18, 0, 25)
WHITE = (127, 127, 127)

PUSH_COLOR = GREEN
Beispiel #9
0
sample_dir = 'samples'
try:
    sample_name = sys.argv[1]
except:
    sample_name = 'wurly'

soundfiles = glob.glob(os.path.join(sample_dir, sample_name, '*.wav'))
samples = [pygame.mixer.Sound(soundfile) for soundfile in soundfiles]
print('Loaded {} samples from {}'.format(len(samples), sample_name))

#create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)
print (i2c_bus)

#create the trellis
trellis = NeoTrellis(i2c_bus) # can set interrupt=True here...
print(trellis)

#some color definitions
OFF = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)

#this will be called when button events are received
def blink(event):
    #turn the LED on when a rising edge is detected
    if event.edge == NeoTrellis.EDGE_RISING:
def gradient_1d(start, stop, steps):
    gradient = list(map(col_to_rgb, start.range_to(stop, steps)))
    return gradient


# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis
trelli = [[], [], [], []]
addrs = [[0x31, 0x30, 0x2f, 0x2e], [0x35, 0x34, 0x33, 0x32],
         [0x36, 0x37, 0x38, 0x39], [0x3a, 0x3c, 0x3b, 0x3d]]
# Create trelli sequentially with a slight pause between each
for x, slice in enumerate(addrs):
    for y, addr in enumerate(slice):
        t = NeoTrellis(i2c_bus, False, addr=addr)
        t.pixels.auto_write = False
        trelli[x].append(t)
        sleep(0.2)

sizeY = len(trelli) * 4
sizeX = len(trelli[0]) * 4

trellis = MultiTrellis(trelli)

for ts in trelli:
    for t in ts:
        print(t)
        print(type(t))
        t.pixels.auto_write = False
Beispiel #11
0
from board import SDA, SCL
from adafruit_neotrellis.neotrellis import NeoTrellis

import busio

import adafruit_ble
from adafruit_ble.advertising import Advertisement
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.standard.hid import HIDService
from adafruit_ble.services.standard.device_info import DeviceInfoService
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode

i2c_bus = busio.I2C(SCL, SDA)
trellis = NeoTrellis(i2c_bus)
hid = HIDService()

KEYCOUNT = 16

OFF = (0, 0, 0)
ON = (125, 125, 125)
RED = (125, 0, 0)
GREEN = (0, 125, 0)
BLUE = (0, 0, 125)

k = Keyboard(hid.devices)
kl = KeyboardLayoutUS(k)


# define the buttons and positions
Beispiel #12
0
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

import time
import board
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

# create the i2c object for the trellis
SCL = board.GP27
SDA = board.GP26
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis
trellis = NeoTrellis(i2c_bus)

# some color definitions
OFF = (0, 0, 0)
ON = (255, 255, 255)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)

# default color-layout
defpix = [
    YELLOW, YELLOW, YELLOW, ON, YELLOW, BLUE, YELLOW, ON, YELLOW, YELLOW,
    YELLOW, ON, GREEN, BLUE, RED, ON
#Author: Becky Button
#This is a file to test the 4x4 trellis module, and
#test that the colors are being cycled correctly!

import time

from board import SCL, SDA
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

#create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

#create the trellis
trellis = NeoTrellis(i2c_bus)

#colors
OFF = (0, 0, 0)
RED = (255, 0, 0)
ORANGE = (255, 127, 0)
YELLOW = (255, 255, 255)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
INDIGO = (46, 43, 95)
VIOLET = (139, 0, 255)

#this stores all of the possible color options
COLORS = [OFF, RED, ORANGE, YELLOW, GREEN, BLUE,\
     INDIGO, VIOLET]

#the current color index the given button is at
Beispiel #14
0
button_LED = DigitalInOut(board.D13)
button_LED.direction = Direction.OUTPUT
button_LED.value = True

pixel_pin = board.D5
num_pixels = 34

pixels = neopixel.NeoPixel(pixel_pin, num_pixels, auto_write=False)
unpixel = pixels[1]
print(unpixel)

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis object
trellis = NeoTrellis(i2c_bus)
boton = 17
count = 0

# color definitions

OFF = (0, 0, 0)
RED = (255, 0, 0)
ROUGE = (210, 0, 50)
DM_RED = (20, 0, 0)
YELLOW = (235, 150, 0)
GREEN = (0, 210, 20)
CYAN = (0, 100, 240)
DM_CYAN = (0, 50, 120)
BLUE = (0, 10, 230)
PURPLE = (80, 0, 240)
Beispiel #15
0
class Nightstand:
    def __init__(self):
        self.config = NightStandConfig(CONFIGFILE)
        self.audioPlayer = None
        self.states = NightstandStates()
        self.btctl = None
        self.states.registerMenuStateChangeListener(self.onMenuChanged)
        self.states.registerResetListener(self.reset)
        self.states.registerSleepListener(self.onGoToSleep)
        self.timer = RepeatedTimer(TIMER_INTERVAL, self.onTimerTick)

    def init(self):
        self.states.enterMenu(MENUSTATE_INIT)
        self.config.load()
        self.states.sleepEnabled = self.config.isSleepEnabled()
        self.config.registerFilechangedListener(self.onConfigChanged)

        self.btctl = BluetoothCtl(self.config.getBluetoothMacs())
        # create the i2c object for the trellis
        i2c_bus = busio.I2C(SCL, SDA)
        # create the trellis
        self.trellis = NeoTrellis(i2c_bus)
        for i in range(16):
            # activate rising edge events on all keys
            self.trellis.activate_key(i, NeoTrellis.EDGE_RISING)
            # activate falling edge events on all keys
            self.trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
            # set all keys to trigger the blink callback
            self.trellis.callbacks[i] = self.onKeyPressed

    def doConnect(self):
        self.btctl.doConnectAsync(BTCONNECT_RETRIES, self.onConnectFinished,
                                  self.onConnectFailed)

    def doDisconnect(self):
        self.btctl.doDisconnect()

    def onConnectFinished(self):
        print("bt connections established")
        self.states.enterMenu(MENUSTATE_IDLE)

    def onConnectFailed(self):
        print("failed to connect to bt devices")
        self.states.enterMenu(MENUSTATE_ERROR)

    def onMenuChanged(self, oldMenuState, newMenuState):
        print("menu changed from " + str(oldMenuState) + " to " +
              str(newMenuState))
        if oldMenuState == MENUSTATE_SLEEPCONFIG:
            self.states.setSleepConfig(self.config.isSleepEnabled(),
                                       self.config.getSleepTime())
            self.states.enterMenu(
                MENUSTATE_PLAYING
                if self.audioPlayer is not None else MENUSTATE_IDLE, True)
            return

        self.initColors()

    def reset(self, startupSequence=True, stopAudio=False):
        self.states.enterMenu(MENUSTATE_INIT)
        self.states.resetCounter = RESET_COUNTER_START
        self.btctl = BluetoothCtl(self.config.getBluetoothMacs())
        if stopAudio:
            self.playAudio(None)
        if startupSequence:
            for i in range(16):
                self.trellis.pixels[i] = RED
                time.sleep(INIT_DELAY)
            for i in range(16):
                self.trellis.pixels[i] = YELLOW
                time.sleep(INIT_DELAY)
            for i in range(16):
                self.trellis.pixels[i] = GREEN
                time.sleep(INIT_DELAY)
            for i in range(16):
                self.trellis.pixels[i] = OFF
                time.sleep(INIT_DELAY)
        self.initColors()
        if self.config.doBluetoothAutoConnect():
            self.states.enterMenu(MENUSTATE_CONNECTING)
            self.doConnect()
        else:
            self.states.enterMenu(MENUSTATE_IDLE)

    def onGoToSleep(self):
        self.enterMenu(MENUSTATE_SLEEPING)
        self.playAudio(None)
        self.doDisconnect()

    def getKeyColor(self, index):
        if self.states.menuState == MENUSTATE_SLEEPCONFIG:
            time = self.config.getSleepTime()
            if index < 12:
                return YELLOW if time > index * 300 else OFF
            elif index == 12:
                return WHITE
            elif index == 13:
                return GREEN if self.config.isSleepEnabled() else RED
            elif index == 14:
                return GREEN if self.config.isSleepEnabled() else RED
            elif index == 15:
                return WHITE
        elif self.states.menuState == MENUSTATE_DIMMING or self.states.menuState == MENUSTATE_STOPPED or self.states.menuState == MENUSTATE_SLEEPING:
            return OFF
        else:
            kc = self.config.getKeyConfig(index)
            if not kc.isPlayerButton(
            ) or self.states.menuState == MENUSTATE_PLAYING:
                return kc.color
            else:
                return OFF

    def initColors(self):
        for i in range(16):
            self.trellis.pixels[i] = self.getKeyColor(i)

    def onTimerTick(self):
        self.states.onResetTimerTick()
        self.states.onSleepTimerTick()
        self.states.onDimmingTimerTick()

    def onConfigChanged(self):
        print("config changed")
        self.reset(False)

    def onKeyPressed(self, event):
        self.states.resetDimmingTimer()

        # turn the LED on when a rising edge is detected
        if event.edge == NeoTrellis.EDGE_RISING:
            self.trellis.pixels[event.number] = self.config.getKeyConfig(
                event.number).keyPressedColor
            self.states.keyStates[event.number] = KEYSTATE_PRESSED
        # turn the LED off when a rising edge is detected
        elif event.edge == NeoTrellis.EDGE_FALLING:
            if self.states.menuState == MENUSTATE_DIMMING:
                self.states.menuBack()
                return
            kc = self.config.getKeyConfig(event.number)
            if not kc.isPlayerButton(
            ) or self.states.menuState == MENUSTATE_PLAYING:
                self.trellis.pixels[event.number] = kc.color
            else:
                self.trellis.pixels[event.number] = OFF
            if self.states.menuState == MENUSTATE_SLEEPCONFIG:
                self.onSleepConfigKeyPressed(event.number)
            else:
                self.onAudioKeyPressed(event.number)
            self.states.keyStates[event.number] = KEYSTATE_NONE

    def onSleepConfigKeyPressed(self, index):
        curSleep = self.config.getSleepTime()
        incdec = 300
        if index == 12:
            self.config.setSleepTime(curSleep -
                                     incdec if curSleep > incdec else 0)
            if self.config.getSleepTime() == 0:
                self.config.enableSleep(False)
        if index == 15:
            self.config.setSleepTime(curSleep +
                                     incdec if curSleep < 11 * incdec else 12 *
                                     incdec)
            if curSleep == 0:
                self.config.enableSleep(True)
        if index == 13 or index == 14:
            self.config.enableSleep(not self.config.isSleepEnabled())
        self.states.stayinSleepConfig()
        self.initColors()

    def onAudioKeyPressed(self, index):
        if self.states.menuState == MENUSTATE_IDLE or (
                self.states.menuState == MENUSTATE_PLAYING
                and not self.config.getKeyConfig(index).isPlayerButton()):
            print("start audio")
            self.playAudio(self.config.getMedia(index))
        elif self.states.menuState == MENUSTATE_PLAYING:
            keyConfig = self.config.getKeyConfig(index)
            if keyConfig.isPlayerButton():
                self.audioPlayerButtonClick(keyConfig.playerButton)

    def audioPlayerButtonClick(self, button):
        print("exec audio button ", button)
        if not self.audioPlayer is None:
            if button == KeyConfig.AUDIOBUTTON_PLAY_PAUSE:
                if self.audioPlayer.is_playing():
                    self.audioPlayer.pause()
                else:
                    self.audioPlayer.play()
            elif button == KeyConfig.AUDIOBUTTON_STOP:
                self.playAudio(None)
            elif button == KeyConfig.AUDIOBUTTON_VOLUMEUP:
                vol = self.audioPlayer.audio_get_volume() + VOL_INCDEC
                self.audioPlayer.audio_set_volume(vol)
            elif button == KeyConfig.AUDIOBUTTON_VOLUMEDOWN:
                vol = self.audioPlayer.audio_get_volume() - VOL_INCDEC
                self.audioPlayer.audio_set_volume(vol)
            elif button == KeyConfig.AUDIOBUTTON_NEXT:
                self.audioPlayer.next_chapter()
            elif button == KeyConfig.AUDIOBUTTON_PREV:
                self.audioPlayer.previous_chapter()

    def playAudio(self, audio):
        if not self.audioPlayer is None:
            print("stopping current audio")
            self.audioPlayer.stop()
            self.states.enterMenu(MENUSTATE_IDLE)
        if audio is None:
            return
        self.states.enterMenu(MENUSTATE_PLAYING)
        print("start playing ", audio)
        self.audioPlayer = vlc.MediaPlayer(audio)
        self.audioPlayer.play()

    def startServer(self):
        print('Hello from the Nightstand Service')
        try:
            while True:
                # call the sync function call any triggered callbacks
                self.trellis.sync()
                # the trellis can only be read every 17 millisecons or so
                time.sleep(0.02)
        except:
            self.config.stop()
        self.stop()

    def startCLI(self):
        print('Hello from the Nightstand Server')
        self.reset()
        self.timer.start()
        try:
            while True:
                # call the sync function call any triggered callbacks
                self.trellis.sync()
                # the trellis can only be read every 17 millisecons or so
                time.sleep(0.02)
        except KeyboardInterrupt:
            self.config.stop()
        self.stop()

    def stop(self):
        self.config.join()
        self.timer.stop()
        self.states.enterMenu(MENUSTATE_STOPPED)
        self.doDisconnect()
        self.states.unregisterMenuStateChangeListener(self.onMenuChanged)
Beispiel #16
0
### The number of rows is also the number of NEOPIXEL
###rows = 10 ### CPB with build in 10 RGB
###rows = 12 ### CLUE with SnowPi RGB
rows = 12 ### PyPortal with SnowPi RGB
###rows = 16 ### CLUE with NeoTrellis


###strip = neopixel.NeoPixel(board.NEOPIXEL, rows, brightness=BRIGHTNESS)     ### CPB
###strip = neopixel.NeoPixel(board.P2, rows, brightness=BRIGHTNESS)           ### CLUE with SnowPi RGB
strip = neopixel.NeoPixel(board.D4, rows, brightness=BRIGHTNESS)           ### PyPortal with SnowPi RGB

# create the i2c object for the trellis
i2c_bus = busio.I2C(board.SCL, board.SDA)
# create the trellis
trellis = NeoTrellis(i2c_bus)

for i in range(16):
    trellis.pixels[i] = (0, 0, 31)
    time.sleep(0.05)

for i in range(16):
    trellis.pixels[i] = (0, 0, 0)
    time.sleep(0.05)


### Neopixel version for CPB and SnowPi
strip.fill((0, 0, 31))
time.sleep(0.5)
strip.fill((0, 0, 0))
Beispiel #17
0
import time

from board import SCL, SDA
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis
from adafruit_neotrellis.multitrellis import MultiTrellis

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)
""" None should work here but code will throw if we try to call actions on the missing quadrant.

May wanna eventually write a wrapper class to safeguard
"""
trelli = [
    [None, NeoTrellis(i2c_bus, False, addr=0x2F)],
    [
        NeoTrellis(i2c_bus, False, addr=0x30),
        NeoTrellis(i2c_bus, False, addr=0x31)
    ],
]

trellis = MultiTrellis(trelli)

# some color definitions
OFF = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
Beispiel #18
0
CYAN = (0, 25, 25)
BLUE = (0, 0, 25)
PURPLE = (18, 0, 25)
WHITE = (127, 127, 127)

# Instrument
instru = ""

# Path
path = ""

# Create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# Create the trellis
trellis = NeoTrellis(i2c_bus, False, addr=0x2F)

print("NeoTrellis created")

audio_file = None

PUSH_COLOR = GREEN
ANIM_COLOR = WHITE

COLORS = ["RED", "YELLOW", "GREEN", "CYAN", "BLUE", "PURPLE", "WHITE"]
COLOR_TUPLES = [RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE]

buttons = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
button_colors = [
    OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF, OFF,
    OFF
import time
import sys
import select

from board import SCL, SDA
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

i2c_bus = busio.I2C(SCL, SDA)
trellis = NeoTrellis(i2c_bus)


def clicked(event):
    sys.stdout.write('Clicked {0}\n'.format(event.number))
    sys.stdout.flush()


for i in range(16):
    trellis.activate_key(i, NeoTrellis.EDGE_RISING)
    trellis.pixels[i] = (0, 0, 0)
    trellis.callbacks[i] = clicked

while True:
    trellis.sync()
    if select.select([
            sys.stdin,
    ], [], [], 0.0)[0]:
        while True:
            line = sys.stdin.readline()
            if not line:
                break
Beispiel #20
0
class Trellis:
    """
    relays button presses by adding them to a queue
    buttons can be referred to by name, index, or color group name
    """
    def __init__(self, startup_color='random', debug=True):

        self.debug = debug
        self.nbuttons = 16
        self.colors = {
            'off': (0, 0, 0),
            'purple': (180, 0, 255),
            'red': (255, 0, 0),
            'orange': (255, 164, 0),
            'green': (0, 255, 0),
            'yellow': (158, 152, 17),
            'gray': (100, 100, 100),
            'blue': (0, 0, 255),
            'lightblue': (7, 34, 81),
            'blueish': (33, 211, 237),
            'darkgray': (10, 10, 10),
            'seagreen': (30, 255, 30),
            'lightseagreen': (39, 239, 120),
            'salmon': (206, 28, 41),
            'lightorange': (176, 76, 9),
            'lightpurple': (87, 20, 174),
            'lighterpurple': (70, 27, 87),
            'pink': (100, 0, 100)
        }

        # create the i2c object for the trellis
        self.i2c_bus = busio.I2C(SCL, SDA)

        # create the trellis
        self.trellis = NeoTrellis(
            self.i2c_bus)  # can set interrupt=True here...

        # for handling colors of groups of buttons
        self.startup_color = startup_color
        self.color_map = {}

        # to ensure callback set
        self.button_handler = None

    def set_color_map(self, color_map):
        self.color_map = color_map

    def set_callback(self, fcn):
        # callback for when buttons are pressed
        self.button_handler = fcn
        # set handlers for button press
        self.activate(self.startup_color, lightshow=True)

    def activate(self, startup_color=None, lightshow=False):
        if self.button_handler is None:
            print("Error: callback must be set using 'set_callback'")

        for i in range(self.nbuttons):
            # activate rising edge events on all keys
            self.trellis.activate_key(i, BUTTON_PRESSED)
            # activate falling edge events on all keys
            self.trellis.activate_key(i, BUTTON_RELEASED)
            # set all keys to trigger the blink callback
            self.trellis.callbacks[i] = self.button_handler

            if not lightshow:
                continue
            #cycle the LEDs on startup
            if startup_color is not None:
                if startup_color == 'random':
                    color = random_color()
                else:
                    color = self.colors[startup_color]
                self.trellis.pixels[i] = color
                time.sleep(.03)

        for i in range(self.nbuttons):
            self.trellis.pixels[i] = self.colors['off']
            if lightshow:
                time.sleep(.03)

    def end_lightshow(self, event=None):
        # reset callbacks and turn lights off
        if event is None or event.edge == BUTTON_PRESSED:
            self.activate()
            self.lightshow_on = False

    def lightshow(self):
        self.lightshow_on = True
        # first, set callback to interrupt the show
        for i in range(self.nbuttons):
            self.trellis.callbacks[i] = self.end_lightshow
        # now pick buttons and flash lights on/off in random order
        while True:
            button_indices = list(range(self.nbuttons))
            random.shuffle(button_indices)
            for i in button_indices:
                self.trellis.pixels[i] = random_color()
                time.sleep(.07)
                if not self.lightshow_on:
                    return
            for i in button_indices:
                self.trellis.pixels[i] = self.colors['off']
                time.sleep(.07)
                if not self.lightshow_on:
                    return
            self.sync()
            time.sleep(.02)

    def set_color_all_buttons(self, color):
        for i in range(self.nbuttons):
            self.set_color(i, color)

    def set_color(self, index, color):
        if color in self.color_map:
            color = self.color_map[color]
        self.trellis.pixels[index] = self.colors[color]

    def sync(self):
        self.trellis.sync()

    def terminate(self):
        for i in range(self.nbuttons):
            self.trellis.pixels[i] = self.colors['off']
        self.sync()
Beispiel #21
0
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis
from adafruit_neotrellis.multitrellis import MultiTrellis

#create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)
"""create the trellis. This is for a 2x2 array of NeoTrellis boards
for a 2x1 array (2 boards connected left to right) you would use:

trelli = [
    [NeoTrellis(i2c_bus, False, addr=0x2E), NeoTrellis(i2c_bus, False, addr=0x2F)]
    ]

"""
trelli = [[
    NeoTrellis(i2c_bus, False, addr=0x2E),
    NeoTrellis(i2c_bus, False, addr=0x2F)
],
          [
              NeoTrellis(i2c_bus, False, addr=0x30),
              NeoTrellis(i2c_bus, False, addr=0x31)
          ]]

trellis = MultiTrellis(trelli)

#some color definitions
OFF = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
from neotrellism4 import NeoTrellisM4

#create the i2c object for the trellis
I2C = busio.I2C(SCL, SDA)
"""create the trellis. This is for a 2x2 array of TrellisM4 (first row) with
2 Neotrellis (second row).

 [ NeoM4_left | NeoM4_right ]
  neotrellis0 | neotrellis1
"""

trellim4_left = NeoTrellisM4()
trellim4_right = NeoTrellisM4(left_part=trellim4_left)
trelli = [[trellim4_left, trellim4_right],
          [
              NeoTrellis(I2C, False, addr=0x2F),
              NeoTrellis(I2C, False, addr=0x2E)
          ]]

trellis = MultiTrellis(trelli)

#some color definitions
OFF = (0, 0, 0)
RED = (127, 0, 0)
YELLOW = (127, 75, 0)
GREEN = (0, 127, 0)
CYAN = (0, 127, 127)
BLUE = (0, 0, 127)
PURPLE = (90, 0, 127)

Beispiel #23
0
    if i in OUTER_RING:
        float_color = hsv_to_rgb(sin_time(0.25), 0.8, 0.8)
    if i in INNER_RING:
        float_color = hsv_to_rgb(cos_time(0.25), 0.8, 0.8)

    return float_to_byte_color(float_color)


def main(trellis: NeoTrellis):
    for i in range(BUTTON_COUNT):
        trellis.activate_key(i, NeoTrellis.EDGE_RISING)
        trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
        trellis.callbacks[i] = button_callback(trellis, i)

    while True:
        for i in range(BUTTON_COUNT):
            trellis.pixels[i] = button_target_color(i)

        trellis.sync()
        time.sleep(0.02)


if __name__ == "__main__":
    i2c = busio.I2C(SCL, SDA)
    trellis = NeoTrellis(i2c)
    try:
        main(trellis)
    except KeyboardInterrupt:
        for i in range(BUTTON_COUNT):
            trellis.pixels[i] = (0, 0, 0)
Beispiel #24
0

# some color definitions
OFF = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
WHITE = (255, 255, 255)

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)
trelli = [
    [NeoTrellis(i2c_bus, False, addr=0x2E), NeoTrellis(i2c_bus, False, addr=0x2F), NeoTrellis(i2c_bus, False, addr=0x30)],
]
trellis = MultiTrellis(trelli)

# this will be called when button events are received
def blink(xcoord, ycoord, edge):
    # turn the LED on when a rising edge is detected
    if edge == NeoTrellis.EDGE_RISING:
        trellis.color(xcoord, ycoord, GREEN)
    # turn the LED off when a rising edge is detected
    elif edge == NeoTrellis.EDGE_FALLING:
        trellis.color(xcoord, ycoord, OFF)

def get_next(x, y):
    if x == 3 and y == 3:
        return 4, 0
Beispiel #25
0
import boardStateDriver, tests
import time
from random import randrange
from adafruit_seesaw.neopixel import NeoPixel
import board
from board import SCL, SDA
import digitalio
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis
trellis = NeoTrellis(i2c_bus)

button_pin = board.D6

button = digitalio.DigitalInOut(button_pin)
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.UP
# ALWAYS PASS x.theBoard TO ITS SELF WHEN CHANGING STATE!!!!!!!!!!!!
x = boardStateDriver.boardState([0] * 16)

for i in range(16):
    # activate rising edge events on all keys
    trellis.activate_key(i, NeoTrellis.EDGE_RISING)
    # activate falling edge events on all keys
    #trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
    # set all keys to trigger the blink callback
    trellis.callbacks[i] = x.redrawBoard
Beispiel #26
0
import time

from board import SCL, SDA
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

#create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

#create the trellis
trellis = NeoTrellis(i2c_bus)

#some color definitions
OFF = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)

#this will be called when button events are received
def blink(event):
    #turn the LED on when a rising edge is detected
    if event.edge == NeoTrellis.EDGE_RISING:
        trellis.pixels[event.number] = CYAN
    #turn the LED off when a rising edge is detected
    elif event.edge == NeoTrellis.EDGE_FALLING:
        trellis.pixels[event.number] = OFF

for i in range(16):
Beispiel #27
0
# running CircuitPython 5 or newer

import time
from board import SCL, SDA
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis
import usb_midi
import adafruit_midi
from adafruit_midi.note_on import NoteOn
from adafruit_midi.note_off import NoteOff

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis
trellis = NeoTrellis(i2c_bus)

# color definitions
OFF = (0, 0, 0)
CYAN = (0, 16, 16)
ORANGE = (30, 20, 0)
MAGENTA = (15, 0, 30)
WHITE = (5, 5, 6)

STARTUP_COLOR = WHITE
COLOR_A = MAGENTA
COLOR_B = CYAN

midi_channel = 1  # change this if you want to send on a different MIDI channel

midi = adafruit_midi.MIDI(midi_out=usb_midi.ports[1], out_channel=midi_channel-1)
Beispiel #28
0
#Authors Hunter Hannula, Cameron Kerley

import time
from random import randrange  # possibly remove, if we use random we should write a seprate module for those functions
from adafruit_seesaw.neopixel import NeoPixel
import board
from board import SCL, SDA
import digitalio
import busio
from adafruit_neotrellis.neotrellis import NeoTrellis

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis
trellis = NeoTrellis(i2c_bus)

button_pin = board.D6

button = digitalio.DigitalInOut(button_pin)
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.UP

# some color definitions
OFF = (0, 0, 0)
RED = (25, 0, 0)
YELLOW = (25, 15, 0)
GREEN = (0, 25, 0)
CYAN = (0, 25, 25)
BLUE = (0, 0, 25)
PURPLE = (18, 0, 25)
Beispiel #29
0
from digitalio import DigitalInOut, Direction

button_LED = DigitalInOut(board.D13)
button_LED.direction = Direction.OUTPUT
button_LED.value = True

pixel_pin = board.D5
num_pixels = 136

pixels = neopixel.NeoPixel(pixel_pin, num_pixels, auto_write=False)

# create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)

# create the trellis object
trellis = NeoTrellis(i2c_bus)

# color definitions
OFF = (0, 0, 0)
RED = (255, 0, 0)
ROUGE = (210, 0, 50)
DM_RED = (100, 0, 0)
YELLOW = (235, 150, 0)
GREEN = (0, 255, 20)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (80, 0, 240)
ORANGE = (255, 50, 0)
PINK = (255, 0, 100)
WHITE = (255, 255, 255)
Beispiel #30
0
from adafruit_ble import BLERadio
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.nordic import UARTService

from toy import Toy

ble = BLERadio()
uart = UARTService()
advertisement = ProvideServicesAdvertisement(uart)

i2c = board.I2C()

trelli = [
    [
        NeoTrellis(i2c, False, addr=0x2F),
        NeoTrellis(i2c, False, addr=0x2E),
    ],
    [
        NeoTrellis(i2c, False, addr=0x31),
        NeoTrellis(i2c, False, addr=0x30),
    ],
]
trellis = MultiTrellis(trelli)


class TrellisWrapper(object):
    """Wrapper that implements the basic color iface, for use with Toy"""
    def __init__(self, trellis, brightness=1):
        self.brightness = brightness
        self.trellis = trellis
                   help='port for the websocket server')
parser.add_argument('-c','--config',required=False, default='/etc/keypad.conf.json',
                   help='keypad config file to load')

parser.add_argument('-d', required=False,
                   help='run as daemon.no cli')

args = vars(parser.parse_args())
port=args["port"]


server = SimpleWebSocketServer('', port, NeoTrellisSocket)
#create the i2c object for the trellis
i2c_bus = busio.I2C(SCL, SDA)
#create the trellis
trellis = NeoTrellis(i2c_bus)

for i in range(16):
  colors.append(KeyLedConfig())
  #activate rising edge events on all keys
  trellis.activate_key(i, NeoTrellis.EDGE_RISING)
  #activate falling edge events on all keys
  trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
  #set all keys to trigger the blink callback
  trellis.callbacks[i] = keyEvent

loadConfig(args["config"])

if runAsDaemon:
  while True:
    server.serveonce()