class NeoPixels(object):
LED_COUNT = 256 # Number of LED pixels.
LED_PIN = 21 # GPIO pin connected to the pixels (must support PWM!). 18=PWM, 21=PCM, 10=SPI-MOSI
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 5 # DMA channel to use for generating signal (try 5)
LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
def __init__(self):
from neopixel import Adafruit_NeoPixel as NeoPixel
self._pixels = NeoPixel(num=self.LED_COUNT,
pin=self.LED_PIN,
freq_hz=self.LED_FREQ_HZ,
dma=self.LED_DMA,
invert=self.LED_INVERT,
brightness=self.LED_BRIGHTNESS)
try:
self._pixels.begin()
_logger.info("Initialized NeoPixel OK")
except RuntimeError:
_logger.error("Failed to initialize NeoPixels")
raise
self.write_pixels(np.zeros((16, 16, 3)))
def write_pixels(self, data):
for y, row in enumerate((data * 255).astype(np.uint8)):
for x, color in enumerate(row):
self._pixels.setPixelColorRGB(y * 16 + x, *color)
self._pixels.show()
class NeoPixelRenderer(Renderer):
def __init__(self, led_dma=10, led_strip=ws.WS2811_STRIP_GRB):
super(NeoPixelRenderer, self).__init__()
self.led_dma = 10
self.led_strip = led_strip
self.strip = None
def setup(self, pixel_count, world):
super(NeoPixelRenderer, self).setup(pixel_count, world)
self.strip = Adafruit_NeoPixel( pixel_count,
LED_PIN,
LED_FREQ_HZ,
self.led_dma,
LED_INVERT,
LED_BRIGHTNESS,
LED_CHANNEL,
self.led_strip)
self.strip.begin()
self.log.debug("LED strip initialized")
for idx in range(0, pixel_count):
self.strip.setPixelColorRGB(idx, 0, 0, 0, 0)
self.strip.show()
self.log.debug("LED strip cleared")
def render_buffer(self, pixel_buffer):
super(NeoPixelRenderer, self).render_buffer(pixel_buffer)
if self._is_buffer_changed(pixel_buffer):
for idx, pixel in enumerate(pixel_buffer):
self.strip.setPixelColorRGB(idx, int(pixel.r), int(pixel.g), int(pixel.b)) # , int(pixel.w))
self.strip.show()
def exc():
import os
import json
import math
import time
from copy import deepcopy
from neopixel import Adafruit_NeoPixel
basedir = os.path.dirname(os.path.realpath(__file__))
steps = 120
neopixel = Adafruit_NeoPixel(1, 18)
neopixel.begin()
setting = {'threat': 0, 'cautioning': 0, 'optimum': 1}
changelog = [0, 0, 0]
if setting['threat'] > 0:
changelog[0] = 255
elif setting['cautioning'] > 0:
changelog[0] = 255
changelog[1] = 255
elif setting['optimum'] > 0:
changelog[1] = 255
if os.path.isfile(basedir + '/ledstate.json'):
with open(basedir + '/ledstate.json', 'r') as out:
current = json.loads(out.read())
else:
raw = neopixel.getPixelColor(0)
current = []
for _ in range(3):
calc = divmod(raw, 256)
raw = calc[0]
current.append(calc[1])
current = current[::-1]
print(current)
bcurrent = []
bchange = []
for pointer in range(len(current)):
bcurrent.append(
True if current[pointer] > changelog[pointer] else False)
bchange.append(
True if current[pointer] != changelog[pointer] else False)
old = deepcopy(current)
for i in range(0, steps + 1):
color = []
for pointer in range(len(bchange)):
if bchange[pointer]:
if not bcurrent[pointer]:
x = i
offset = current[pointer]
else:
x = steps - i
offset = changelog[pointer]
color.append(offset + int(
abs(current[pointer] - changelog[pointer]) / steps * x))
# color.append(offset + int(math.cos((1 / steps) * math.pi * x) * (abs(current[pointer] - changelog[pointer]) / 2) + (abs(current[pointer] - changelog[pointer]) / 2)))
else:
color.append(old[pointer])
print(color)
neopixel.setPixelColorRGB(0, color[0], color[1], color[2])
neopixel.show()
old = deepcopy(color)
# time.sleep(1 / 30)
print(color)
with open(basedir + '/ledstate.json', 'w') as out:
out.write(json.dumps(old))
def run(steps=120):
result = VariousTools.offline_check('generalleds', hardware=False)
changelog = [0, 0, 0]
if result:
setting = {'threat': 0, 'cautioning': 0, 'optimum': 0}
plant = Plant.get(localhost=True)
all_status = SensorStatus.select().where(SensorStatus.plant == plant)
for status in all_status:
setting[status.level.label] += 1
if setting['threat'] > 0:
changelog[0] = 255
elif setting['cautioning'] > 0:
changelog[0] = 255
changelog[1] = 255
elif setting['optimum'] > 0:
changelog[1] = 255
basedir = os.path.dirname(os.path.realpath(__file__))
neopixel = Adafruit_NeoPixel(1, 18)
neopixel.begin()
if os.path.isfile(basedir + '/ledstate.json'):
with open(basedir + '/ledstate.json', 'r') as out:
current = json.loads(out.read())
else:
raw = neopixel.getPixelColor(0)
current = []
for _ in range(3):
calc = divmod(raw, 256)
raw = calc[0]
current.append(calc[1])
current = current[::-1]
if changelog == current:
return True
bcurrent = []
bchange = []
for pointer in range(len(current)):
bcurrent.append(True if current[pointer] >= changelog[pointer] else False)
bchange.append(True if current[pointer] != changelog[pointer] else False)
old = deepcopy(current)
for i in range(0, steps + 1):
color = []
for pointer in range(len(bchange)):
if bchange[pointer]:
if not bcurrent[pointer]:
x = i
offset = current[pointer]
else:
x = steps - i
offset = changelog[pointer]
color.append(offset + int(abs(current[pointer] - changelog[pointer]) / steps * x))
else:
color.append(old[pointer])
print(color)
neopixel.setPixelColorRGB(0, color[0], color[1], color[2])
neopixel.show()
old = deepcopy(color)
time.sleep(1 / 15)
with open(basedir + '/ledstate.json', 'w') as out:
out.write(json.dumps(color))
time.sleep(1)
neopixel.setPixelColorRGB(0, changelog[0], changelog[1], changelog[2])
neopixel.show()
return True
class LedController:
global debug
def __init__(self, display_mode:str, number_of_led_strips:int, number_of_leds_per_strip:int):
self.current_beat_index = 0
self.note_led_rows = []
self.number_of_led_strips = number_of_led_strips
self.number_of_leds_per_strip = number_of_leds_per_strip
# holds the rgb values of each led
self.all_colors_as_str = []
self.all_led_rgb_value_lists = []
# colors as [R, G, B]
self.color_dict = {
'off': [0, 0, 0],
'white': [255, 255, 255],
'red': [255, 0, 0],
'blue': [0, 0, 255],
'green': [0, 255, 0]
}
# choose whether or not to highlight the current beat and dim the rest = 'highlight'
# or only show the colors of the current beat = 'only_current'
self.display_mode = display_mode
# self.display_mode = 'only_current'
# self.display_mode = 'highlight'
# the other leds will be divided by this factor
self.display_mode_highlight_factor = 10
self.led_strip = None
# led strip settings
self.number_of_leds_total = self.number_of_led_strips * self.number_of_leds_per_strip
self.led_pin = 21 # uses PCM
self.frequency_hz = 800000
self.dma = 10
self.led_brightness = 100
self.led_inverted = False
self.led_pin_channel = 0
if debug:
print('Settings for LedController(): ')
print('Mode: ', self.display_mode)
print('Brightness: ', self.led_brightness)
print('Number of led strips: ', self.number_of_led_strips)
print('Number of leds per strip: ', self.number_of_leds_per_strip)
print('Total number of leds: ', self.number_of_leds_total)
def initialize_led_strip(self):
self.led_strip = Adafruit_NeoPixel(num=self.number_of_leds_total,
pin=self.led_pin,
freq_hz=self.frequency_hz,
dma=self.dma,
invert=self.led_inverted,
brightness=self.led_brightness,
channel=self.led_pin_channel
)
self.led_strip.begin()
if debug:
print('\nInitialized Led strip... Obj: ', self.led_strip)
print()
def remove_strip_obj(self):
self.led_strip = None
def set_current_beat(self, beat:int):
self.current_beat_index = beat - 1
# will set leds to be the colors from the led obj, depending on the display mode
def set_led_colors(self):
# choose whether to only show the current beat leds, or to highlight it
if debug:
print('Setting led colors... using display mode: ', self.display_mode)
if self.display_mode == 'only_current':
if debug:
print('Mode is ', self.display_mode)
self.only_show_colors_from_current_beat()
self.convert_color_str_to_rgb()
elif self.display_mode == 'highlight':
if debug:
print('Mode is ', self.display_mode)
self.highlight_current_beat_leds()
def only_show_colors_from_current_beat(self):
index = 0
for note_led_row in self.note_led_rows:
if index == self.current_beat_index:
for note_led_container in note_led_row.row:
led = note_led_container.led
if led.is_displayed():
self.all_colors_as_str.append(led.get_color())
else:
self.all_colors_as_str.append('off')
else:
for note_led_container in note_led_row.row:
self.all_colors_as_str.append('off')
index += 1
# convert color str to lists of three rgb values
def convert_color_str_to_rgb(self):
for color_str in self.all_colors_as_str:
rgb_list = self.color_dict[color_str]
self.all_led_rgb_value_lists.append(rgb_list)
# the leds of the current beat will be displayed at full brightness, the other beats at half
def highlight_current_beat_leds(self):
index = 0
for note_led_row in self.note_led_rows:
if index == self.current_beat_index:
for note_led_container in note_led_row.row:
led = note_led_container.led
if led.is_displayed():
color_str = led.get_color()
self.all_colors_as_str.append(color_str)
self.add_color_to_rgb_list(color=color_str)
else:
color_str = 'off'
self.all_colors_as_str.append(color_str)
self.add_color_to_rgb_list(color=color_str)
else:
for note_led_container in note_led_row.row:
led = note_led_container.led
if led.is_displayed():
color_str = led.get_color()
self.all_colors_as_str.append(color_str)
self.add_color_to_rgb_list(color=color_str, reduced_brightness=True)
else:
color_str = 'off'
self.all_colors_as_str.append(color_str)
self.add_color_to_rgb_list(color=color_str)
index += 1
def add_color_to_rgb_list(self, color:str, reduced_brightness=False):
rgb_list = self.color_dict[color]
output_list = []
# if reduced brightness we divide by a factor
if reduced_brightness:
index = 0
for rgb_val in rgb_list:
if not (rgb_val == 0):
rgb_val = int(float(rgb_val) / float(self.display_mode_highlight_factor))
output_list.append(rgb_val)
index += 1
else:
output_list = rgb_list
self.all_led_rgb_value_lists.append(output_list)
# set the values for each led in the strip obj
def update_led_strip_colors(self):
led_index = 0
for rgb_list in self.all_led_rgb_value_lists:
r = rgb_list[0]
g = rgb_list[1]
b = rgb_list[2]
self.led_strip.setPixelColorRGB(n=led_index, red=r, green=g, blue=b)
led_index += 1
# actually output the color values to the strip
def display_updated_leds(self):
if debug:
print('Updating the output of the leds')
self.led_strip.show()
def clear_led_strip(self):
for i in range(self.number_of_leds_total):
self.led_strip.setPixelColorRGB(n=i, red=0, green=0, blue=0)
time.sleep(0.01)
self.led_strip.show()
# main function to control the led hardware
def update_led_strips(self, led_note_rows:list):
if debug:
print('Will now update the colors of the ledstrips')
# reset the lists
self.note_led_rows = led_note_rows
self.all_colors_as_str = []
self.all_led_rgb_value_lists = []
self.set_led_colors()
self.update_led_strip_colors()
if debug:
# print('note_led_rows: ', self.note_led_rows)
# print('all_colors_as_str: ', self.all_colors_as_str)
print('all_led_rgb_value_list: ', self.all_led_rgb_value_lists)
self.display_updated_leds()
class WPad(ApplicationSession):
"""
Connects the Pi's GPIOs to WAMP.
"""
PINMODES = {'bcm': GPIO.BCM, 'board': GPIO.BOARD}
def _select_row(self, row=None):
i = 0
for pin in self._row_pins:
if row is None or row != i:
GPIO.output(pin, GPIO.HIGH)
else:
GPIO.output(pin, GPIO.LOW)
i += 1
def set_color(self, red, green, blue, k=None):
if k is None:
for i in range(self._ledstrip.numPixels()):
self._ledstrip.setPixelColorRGB(i, green, red, blue)
else:
self._ledstrip.setPixelColorRGB(k, green, red, blue)
self._ledstrip.show()
@inlineCallbacks
def flash(self, r=255, g=255, b=255, delay=25, repeat=10):
delay = float(delay) / 1000.
for i in range(repeat):
self.set_color(r, g, b)
yield sleep(2 * delay)
self.set_color(0, 0, 0)
yield sleep(delay)
@inlineCallbacks
def _tick(self):
self._tick_no += 1
now = time.time()
self._tick_sent[self._tick_no] = now
try:
pub = yield self.publish(u'{}.on_alive'.format(self._prefix),
self._tick_no,
options=PublishOptions(acknowledge=True,
exclude_me=False))
except:
self.log.failure()
else:
self.log.info('TICK sent [tick {}, pub {}]'.format(
self._tick_no, pub.id))
def show_load(self):
cpu_load = int(round(psutil.cpu_percent(interval=None)))
mem_load = int(round(psutil.virtual_memory().percent))
if cpu_load > 99:
cpu_load = 99
if mem_load > 99:
mem_load = 99
self._cpu_load.popleft()
self._cpu_load.append(cpu_load)
if not self._is_scrolling:
text = "{:0>2d}{:0>2d}".format(mem_load, cpu_load)
self._disp.setMessage(text)
@inlineCallbacks
def scroll_text(self, disp, text):
if self._is_scrolling:
return
self._is_scrolling = True
s = text + " "
for i in range(len(s)):
disp.setMessage(s[i:i + 4])
yield sleep(.2)
self._is_scrolling = False
@inlineCallbacks
def onJoin(self, details):
self._tick_sent = {}
self._is_scrolling = False
extra = self.config.extra
self._serial = get_serial()
self._my_ip = get_ip_address()
self._joined_at = time.strftime("%H:%M")
self._app_prefix = u'io.crossbar.demo.wpad'
self._prefix = u'{}.wpad.{}'.format(self._app_prefix, self._serial)
self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}",
serial=self._serial)
self.log.info("WPad connected: {details}", details=details)
# setup Neopixel LED strip
self._ledstrip = Adafruit_NeoPixel(
extra['led_count'], extra['led_pin'], extra['led_freq_hz'],
extra['led_dma'], extra['led_invert'], extra['led_brightness'])
self._ledstrip.begin()
# setup GPIO
GPIO.setwarnings(False)
pinmode = extra.get("pin_mode", "bcm")
if pinmode in WPad.PINMODES:
GPIO.setmode(WPad.PINMODES[pinmode])
else:
GPIO.setmode(GPIO.BCM)
GPIO.cleanup()
self._row_pins = extra.get("row_pins", [])
for pin in self._row_pins:
GPIO.setup(pin, GPIO.OUT)
self._select_row(0)
# setup ADC
self._adc = Adafruit_ADS1x15.ADS1015()
def log_adc():
# read values from ADC
values = []
for i in range(4):
values.append(self._adc.read_adc(i, gain=8))
# normalize values
nvalues = [
round(100. * ((2048. - float(x)) / 2048.), 3) for x in values
]
nvalues = [nvalues[2], nvalues[3], nvalues[1], nvalues[0]]
# illuminate neopixel strip
for i in range(4):
col = int(round(255. * float(nvalues[i]) / 100.))
self._ledstrip.setPixelColorRGB(i * 2, col, col, col)
self._ledstrip.setPixelColorRGB(i * 2 + 1, col, col, col)
self._ledstrip.show()
# publish WAMP event
self.publish(u'{}.on_wpad'.format(self._prefix), nvalues)
scan_rate = float(extra.get(u'scan_rate', 50))
self.log.info('Scanning sensors with {} Hz ..'.format(scan_rate))
LoopingCall(log_adc).start(1. / scan_rate)
self._cpu_load = deque()
for i in range(self._ledstrip.numPixels()):
self._cpu_load.append(0)
# our quad, alphanumeric display: https://www.adafruit.com/products/2157
self._disp = QuadAlphanum(extra[u'i2c_address'])
self._disp.clear()
self._disp.setBrightness(int(round(extra[u'brightness'] * 15)))
@inlineCallbacks
def displayNotice():
yield self.scroll_text(
self._disp, "IP {} ({}) ".format(self._my_ip,
self._joined_at).upper())
# every couple of secs, display a notice
LoopingCall(displayNotice).start(53)
def on_tick(tick_no):
if tick_no in self._tick_sent:
rtt = 1000. * (time.time() - self._tick_sent[tick_no])
del self._tick_sent[tick_no]
else:
rtt = None
self.log.info('TICK received [tick {}, rtt {}]'.format(
tick_no, rtt))
self.flash(r=0, g=255, b=0, repeat=1)
yield self.subscribe(on_tick, u'{}.on_alive'.format(self._prefix))
self._tick_no = 0
self._tick_loop = LoopingCall(self._tick)
self._tick_loop.start(7)
LoopingCall(self.show_load).start(1)
# signal we are done with initializing our component
self.publish(u'{}.on_ready'.format(self._prefix))
self.log.info("WPad ready.")
self.flash()
def onLeave(self, details):
self.log.info("Session closed: {details}", details=details)
self.disconnect()
def onDisconnect(self):
self.log.info("Connection closed")
try:
reactor.stop()
except ReactorNotRunning:
pass
class ColoramaDisplay(ApplicationSession):
@inlineCallbacks
def onJoin(self, details):
self._serial = get_serial()
self._prefix = 'io.crossbar.demo.iotstarterkit.{}.pixelstrip'.format(
self._serial)
self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}",
serial=self._serial)
self.log.info("ColoramaDisplay connected: {details}", details=details)
# get custom configuration
cfg = self.config.extra
self._leds = Adafruit_NeoPixel(cfg['led_count'], cfg['led_pin'],
cfg['led_freq_hz'], cfg['led_dma'],
cfg['led_invert'],
cfg['led_brightness'])
self._leds.begin()
for proc in [
(self.set_color, 'set_color'),
(self.get_color, 'get_color'),
(self.flash, 'flash'),
(self.lightshow, 'lightshow'),
(self.color_wipe, 'color_wipe'),
(self.theater_chase, 'theater_chase'),
(self.rainbow, 'rainbow'),
(self.rainbow_cycle, 'rainbow_cycle'),
(self.theater_chaserainbow, 'theater_chaserainbow'),
]:
yield self.register(proc[0], '{}.{}'.format(self._prefix, proc[1]))
self.flash()
self.log.info("ColoramaDisplay ready!")
@inlineCallbacks
def flash(self, delay=50, repeat=5):
delay = float(delay) / 1000.
for i in range(repeat):
self.set_color(0xe1, 0xda, 0x05)
yield sleep(2 * delay)
self.set_color(0x52, 0x42, 0x00)
yield sleep(delay)
@inlineCallbacks
def lightshow(self):
# Color wipe animations.
yield self.color_wipe(255, 0, 0) # Red wipe
yield self.color_wipe(0, 255, 0) # Blue wipe
yield self.color_wipe(0, 0, 255) # Green wipe
# Theater chase animations.
yield self.theater_chase(127, 127, 127) # White theater chase
yield self.theater_chase(127, 0, 0) # Red theater chase
yield self.theater_chase(0, 0, 127) # Blue theater chase
# Rainbow animations.
yield self.rainbow()
yield self.rainbow_cycle()
#yield self.theater_chase_rainbow()
yield self.flash()
# Define functions which animate LEDs in various ways.
@inlineCallbacks
def color_wipe(self, r, g, b, wait_ms=50):
"""Wipe color across display a pixel at a time."""
for i in range(self._leds.numPixels()):
self.set_color(r, g, b, i)
yield sleep(wait_ms / 1000.0)
@inlineCallbacks
def theater_chase(self, r, g, b, wait_ms=50, iterations=10):
"""Movie theater light style chaser animation."""
for j in range(iterations):
for q in range(3):
for i in range(0, self._leds.numPixels(), 3):
self.set_color(r, g, b, i + q)
yield sleep(wait_ms / 1000.0)
for i in range(0, self._leds.numPixels(), 3):
self.set_color(0, 0, 0, i + q)
def wheel(self, pos):
"""Generate rainbow colors across 0-255 positions."""
if pos < 85:
return (pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return (255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return (0, pos * 3, 255 - pos * 3)
@inlineCallbacks
def rainbow(self, wait_ms=20, iterations=1):
"""Draw rainbow that fades across all pixels at once."""
for j in range(256 * iterations):
for i in range(self._leds.numPixels()):
r, g, b = self.wheel((i + j) & 255)
self.set_color(r, g, b, i)
yield sleep(wait_ms / 1000.0)
@inlineCallbacks
def rainbow_cycle(self, wait_ms=20, iterations=5):
"""Draw rainbow that uniformly distributes itself across all pixels."""
for j in range(256 * iterations):
for i in range(self._leds.numPixels()):
r, g, b = self.wheel(((i * 256 / self._leds.numPixels()) + j)
& 255)
self.set_color(r, g, b, i)
yield sleep(wait_ms / 1000.0)
@inlineCallbacks
def theater_chaserainbow(self, wait_ms=50):
"""Rainbow movie theater light style chaser animation."""
for j in range(256):
for q in range(3):
for i in range(0, self._leds.numPixels(), 3):
r, g, b = self.wheel((i + j) % 255)
self.set_color(r, g, b, i + q)
yield sleep(wait_ms / 1000.0)
for i in range(0, self._leds.numPixels(), 3):
self.set_color(0, 0, 0, i)
def set_color(self, red, green, blue, k=None):
if k is None:
for i in range(self._leds.numPixels()):
# FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels?
self._leds.setPixelColorRGB(i, green, red, blue)
color_change = {'led': i, 'r': red, 'g': green, 'b': blue}
self.publish('{}.on_color_set'.format(self._prefix),
color_change)
else:
# FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels?
self._leds.setPixelColorRGB(k, green, red, blue)
color_change = {'led': k, 'r': red, 'g': green, 'b': blue}
self.publish('{}.on_color_set'.format(self._prefix), color_change)
self._leds.show()
def get_color(self, k):
c = self._leds.getPixelColor(k)
color = {
'g': c >> 16,
'r': (c >> 8) & 0xff,
'b': c & 0xff,
}
return color
def onLeave(self, details):
self.log.info("Session closed: {details}", details=details)
self.disconnect()
def onDisconnect(self):
self.log.info("Connection closed")
for i in range(self._leds.numPixels()):
self._leds.setPixelColorRGB(i, 0, 0, 0)
self._leds.show()
try:
reactor.stop()
except ReactorNotRunning:
pass
class RPiMaze(MazeGame):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Set up NeoPixel
self.np = Adafruit_NeoPixel(NUM_PIXELS, GPIO_PIN, brightness=INTENSITY)
self.np.begin()
self.led_grid = led_grid.LEDGrid(self.np, grid.SerpentinePattern.TOP_RIGHT,
width=MATRIX_WIDTH, height=MATRIX_HEIGHT)
@staticmethod
def hexcolor_to_rgb(colorstr):
# https://stackoverflow.com/a/29643643 TODO: abstract this out some more
color = tuple(int(colorstr.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
print("%s: %s" % (colorstr, str(color)))
return color
def draw_point_at(self, x, y, color):
try:
self.led_grid.set(x, y, color, allowOverwrite=True)
except IndexError:
pass
def _draw_walls(self, wall_points_to_draw):
for point in wall_points_to_draw:
#print("Drawing LED point %s, %s as a wall" % (point[0], point[1]))
self.draw_point_at(point[0], point[1], (255, 255, 255))
def draw_maze_leds(self):
"""
Draws the maze on an LED strip.
"""
for pixel in range(NUM_PIXELS):
self.np.setPixelColorRGB(pixel, 0, 0, 0)
for ypos, row in enumerate(self.maze.by_rows()):
for xpos, point in enumerate(row):
if point.is_finish:
color = self.hexcolor_to_rgb(self.FINISH_COLOR)
elif point.is_start:
color = self.hexcolor_to_rgb(self.START_COLOR)
else:
# Empty tile
color = (0, 0, 0)
for sprite in self.sprites:
if sprite.x == xpos and sprite.y == ypos:
color = self.hexcolor_to_rgb(sprite.color)
print("Setting color to %s for sprite %s at %s, %s" % (color, sprite, xpos, ypos))
if point.is_selected:
color = self.hexcolor_to_rgb(self.SELECTED_COLOR)
led_xpos = xpos * 2
led_ypos = ypos * 2
#print("Translating player position (%s, %s) into LED position (%s, %s)" % (xpos, ypos, led_xpos, led_ypos))
wall_points_to_draw = {
(led_xpos-1, led_ypos-1),
(led_xpos-1, led_ypos+1),
(led_xpos+1, led_ypos-1),
(led_xpos+1, led_ypos+1)
}
paths = point.paths
if 'north' not in paths:
wall_points_to_draw.add((led_xpos, led_ypos-1))
if 'south' not in paths:
wall_points_to_draw.add((led_xpos, led_ypos+1))
if 'east' not in paths:
wall_points_to_draw.add((led_xpos+1, led_ypos))
if 'west' not in paths:
wall_points_to_draw.add((led_xpos-1, led_ypos))
self._draw_walls(wall_points_to_draw)
self.draw_point_at(led_xpos, led_ypos, color)
self.np.show()
self.led_grid.show()
def draw_maze(self, *args, **kwargs):
super().draw_maze(*args, **kwargs)
self.draw_maze_leds()
return True
class ColoramaDisplay(ApplicationSession):
@inlineCallbacks
def onJoin(self, details):
self._serial = get_serial()
self._prefix = u'io.crossbar.demo.iotstarterkit.{}.pixelstrip'.format(self._serial)
self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}", serial=self._serial)
self.log.info("ColoramaDisplay connected: {details}", details=details)
# get custom configuration
cfg = self.config.extra
self._leds = Adafruit_NeoPixel(
cfg['led_count'],
cfg['led_pin'],
cfg['led_freq_hz'],
cfg['led_dma'],
cfg['led_invert'],
cfg['led_brightness'])
self._leds.begin()
for proc in [
(self.set_color, 'set_color'),
(self.get_color, 'get_color'),
(self.flash, 'flash'),
(self.lightshow, 'lightshow'),
(self.color_wipe, 'color_wipe'),
(self.theater_chase, 'theater_chase'),
(self.rainbow, 'rainbow'),
(self.rainbow_cycle, 'rainbow_cycle'),
(self.theater_chaserainbow, 'theater_chaserainbow'),
]:
yield self.register(proc[0], u'{}.{}'.format(self._prefix, proc[1]))
self.flash()
self.log.info("ColoramaDisplay ready!")
@inlineCallbacks
def flash(self, delay=50, repeat=5):
delay = float(delay) / 1000.
for i in range(repeat):
self.set_color(0xe1, 0xda, 0x05)
yield sleep(2 * delay)
self.set_color(0x52, 0x42, 0x00)
yield sleep(delay)
@inlineCallbacks
def lightshow(self):
# Color wipe animations.
yield self.color_wipe(255, 0, 0) # Red wipe
yield self.color_wipe(0, 255, 0) # Blue wipe
yield self.color_wipe(0, 0, 255) # Green wipe
# Theater chase animations.
yield self.theater_chase(127, 127, 127) # White theater chase
yield self.theater_chase(127, 0, 0) # Red theater chase
yield self.theater_chase(0, 0, 127) # Blue theater chase
# Rainbow animations.
yield self.rainbow()
yield self.rainbow_cycle()
#yield self.theater_chase_rainbow()
yield self.flash()
# Define functions which animate LEDs in various ways.
@inlineCallbacks
def color_wipe(self, r, g, b, wait_ms=50):
"""Wipe color across display a pixel at a time."""
for i in range(self._leds.numPixels()):
self.set_color(r, g, b, i)
yield sleep(wait_ms / 1000.0)
@inlineCallbacks
def theater_chase(self, r, g, b, wait_ms=50, iterations=10):
"""Movie theater light style chaser animation."""
for j in range(iterations):
for q in range(3):
for i in range(0, self._leds.numPixels(), 3):
self.set_color(r, g, b, i + q)
yield sleep(wait_ms / 1000.0)
for i in range(0, self._leds.numPixels(), 3):
self.set_color(0, 0, 0, i + q)
def wheel(self, pos):
"""Generate rainbow colors across 0-255 positions."""
if pos < 85:
return (pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return (255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return (0, pos * 3, 255 - pos * 3)
@inlineCallbacks
def rainbow(self, wait_ms=20, iterations=1):
"""Draw rainbow that fades across all pixels at once."""
for j in range(256 * iterations):
for i in range(self._leds.numPixels()):
r, g, b = self.wheel((i + j) & 255)
self.set_color(r, g, b, i)
yield sleep(wait_ms / 1000.0)
@inlineCallbacks
def rainbow_cycle(self, wait_ms=20, iterations=5):
"""Draw rainbow that uniformly distributes itself across all pixels."""
for j in range(256 * iterations):
for i in range(self._leds.numPixels()):
r, g, b = self.wheel(((i * 256 / self._leds.numPixels()) + j) & 255)
self.set_color(r, g, b, i)
yield sleep(wait_ms / 1000.0)
@inlineCallbacks
def theater_chaserainbow(self, wait_ms=50):
"""Rainbow movie theater light style chaser animation."""
for j in range(256):
for q in range(3):
for i in range(0, self._leds.numPixels(), 3):
r, g, b = self.wheel((i+j) % 255)
self.set_color(r, g, b, i + q)
yield sleep(wait_ms / 1000.0)
for i in range(0, self._leds.numPixels(), 3):
self.set_color(0, 0, 0, i)
def set_color(self, red, green, blue, k=None):
if k is None:
for i in range(self._leds.numPixels()):
# FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels?
self._leds.setPixelColorRGB(i, green, red, blue)
color_change = {
u'led': i,
u'r': red,
u'g': green,
u'b': blue
}
self.publish(u'{}.on_color_set'.format(self._prefix), color_change)
else:
# FIXME: not sure, but we need to swap this here. maybe it is the specific neopixels?
self._leds.setPixelColorRGB(k, green, red, blue)
color_change = {
u'led': k,
u'r': red,
u'g': green,
u'b': blue
}
self.publish(u'{}.on_color_set'.format(self._prefix), color_change)
self._leds.show()
def get_color(self, k):
c = self._leds.getPixelColor(k)
color = {
u'g': c >> 16,
u'r': (c >> 8) & 0xff,
u'b': c & 0xff,
}
return color
def onLeave(self, details):
self.log.info("Session closed: {details}", details=details)
self.disconnect()
def onDisconnect(self):
self.log.info("Connection closed")
for i in range(self._leds.numPixels()):
self._leds.setPixelColorRGB(i, 0, 0, 0)
self._leds.show()
try:
reactor.stop()
except ReactorNotRunning:
pass
from gpiozero import MCP3008
from time import sleep
from neopixel import Adafruit_NeoPixel
r = MCP3008(channel=0)
g = MCP3008(channel=1)
b = MCP3008(channel=2)
LEDS = 12
PIN = 18
strip = Adafruit_NeoPixel(LEDS, PIN)
strip.begin()
while True:
red = round(r.value * 255)
green = round(g.value * 255)
blue = round(b.value * 255)
print(red, green, blue)
for i in range(LEDS):
strip.setPixelColorRGB(i, red, green, blue)
strip.show()
sleep(0.1)
