def config_fn(data, t):
print("Config: %s" % hexlify(data))
d = {}
d["numleds"] = (data[0] << 8) + data[1]
init_cmd = data[2:]
fout = open("settings.cfg", 'wb')
fout.write(json.dumps(d) + "\n")
fout.write(init_cmd)
fout.close()
# Pause the animator and update the strip with the new number of LEDs.
t.pause()
t.strip = neopixel.Adafruit_NeoPixel(
d["numleds"],
NEOPIXEL_PIN,
NEOPIXEL_HZ,
5,
False,
strip_type=neopixel.ws.WS2811_STRIP_GRB)
t.strip.setBrightness(MAX_BRIGHTNESS)
t.strip.begin()
# Call the new default animation fn (which will resume the animator if it wishes)
cmd = init_cmd[0]
n = (init_cmd[1] << 8) + init_cmd[2]
assert len(init_cmd[3:]
) == n, "Incorrectly sized data packet. Expected %x, got %x" % (
n, len(init_cmd[3:]))
commands[cmd](init_cmd[3:], t)
def init(cls):
# Create NeoPixel object with appropriate configuration.
cls.strip = neopixel.Adafruit_NeoPixel(cls.LED_COUNT, cls.LED_PIN,
cls.LED_FREQ_HZ, cls.LED_DMA,
cls.LED_INVERT)
# Intialize the library (must be called once before other functions).
cls.strip.begin()
def __init__(self, max_brightness=255):
self.strand_lights = sum(config.SIDES)
self.strand = neo.Adafruit_NeoPixel(self.strand_lights, config.LED_PIN,
config.LED_FREQ, config.LED_DMA,
config.LED_INVERT, max_brightness,
config.LED_CHANNEL)
self.strand.begin()
def __init__(self,
n_pixels,
pin=18,
invert_logic=False,
freq=800000,
dma=5):
"""Creates a Raspberry Pi output device
Parameters
----------
n_pixels: int
Number of LED strip pixels
pin: int, optional
GPIO pin used to drive the LED strip (must be a PWM pin).
Pin 18 can be used on the Raspberry Pi 2.
invert_logic: bool, optional
Whether or not to invert the driving logic.
Set this to True if you are using an inverting logic level
converter, otherwise set to False.
freq: int, optional
LED strip protocol frequency (Hz). For ws2812 this is 800000.
dma: int, optional
DMA (direct memory access) channel used to drive PWM signals.
If you aren't sure, try 5.
"""
try:
import neopixel
except ImportError as e:
url = 'learn.adafruit.com/neopixels-on-raspberry-pi/software'
print('Could not import the neopixel library')
print('For installation instructions, see {}'.format(url))
raise e
self.strip = neopixel.Adafruit_NeoPixel(n_pixels, pin, freq, dma,
invert_logic, 255)
self.strip.begin()
def init():
from main import LedArray
LED_COUNT = 37 * 4 # Number of LED pixels.
LED_PIN = 18 # GPIO pin connected to the pixels (18 uses PWM!).
# LED_PIN = 10 # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0).
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 11 # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 50 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
strip = neopixel.Adafruit_NeoPixel(LED_COUNT,
LED_PIN,
LED_FREQ_HZ,
LED_DMA,
LED_INVERT,
LED_BRIGHTNESS,
LED_CHANNEL,
strip_type=neopixel.ws.WS2811_STRIP_GRB)
# Intialize the library (must be called once before other functions).
strip.begin()
set_all(strip, neopixel.Color(0, 0, 0))
here = (48.224708, 16.438082) # lat long
leds = LedArray([49.0, 32.0, 16.5, 0.0], [18, 12, 6, 1], [
-np.pi / 2 + np.deg2rad(10), -np.pi / 2, -np.pi / 2 - np.deg2rad(30), 0
], [1, -1, -1, 1], 200, *here, [500, 1000, 2500])
return strip, leds
def InitStrip(): global strip # Create NeoPixel object with appropriate configuration. strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) # Intialize the library (must be called once before other functions). strip.begin()
def __init__(self):
# Create NeoPixel object with appropriate configuration.
self.strip = neopixel.Adafruit_NeoPixel(self.LED_COUNT, self.LED_PIN,
self.LED_FREQ_HZ, self.LED_DMA,
self.LED_INVERT)
# Intialize the library (must be called once before other functions).
self.strip.begin()
def led_strip_from_constants():
return neopixel.Adafruit_NeoPixel(LED_COUNT,
LED_PIN,
LED_FREQ_HZ,
LED_DMA,
LED_INVERT,
LED_BRIGHTNESS,
LED_CHANNEL,
strip_type=neopixel.ws.WS2811_STRIP_GRB)
def main():
file_name = sys.argv[1] if len(sys.argv) == 2 else 'config.json'
with open(file_name, 'rb') as config_file:
config = json.load(config_file)
tide_station = config['tide_station']
tide_time_offset_low = config['tide_time_offset']['low']
tide_time_offset_high = config['tide_time_offset']['high']
tide_level_offset_low = config['tide_level_offset']['low']
tide_level_offset_high = config['tide_level_offset']['high']
tide_request_window_back = config['tide_request_window']['back']
tide_request_window_forward = config['tide_request_window']['forward']
tide_renew_threshold = config['tide_renew_threshold']
yellow_threshold = config['water_level_thresholds']['yellow']
green_threshold = config['water_level_thresholds']['green']
water_level_minutes = datetime.timedelta(
minutes=config['water_level_minutes'])
init_logger(config['log_file_name'])
strip = neopixel.Adafruit_NeoPixel(LED_COUNT, config['led_pin'],
LED_FREQ_HZ, LED_DMA, LED_INVERT,
config['led_brightness'], LED_CHANNEL,
LED_STRIP)
strip.begin()
time_offset = predictions.AdditiveOffset(
datetime.timedelta(minutes=tide_time_offset_low),
datetime.timedelta(minutes=tide_time_offset_high))
level_offset = predictions.MultiplicativeOffset(tide_level_offset_low,
tide_level_offset_high)
tide_offset = predictions.TideOffset(time_offset, level_offset)
query_range = (datetime.timedelta(days=tide_request_window_back),
datetime.timedelta(days=tide_request_window_forward))
renew_threshold = datetime.timedelta(days=tide_renew_threshold)
tt = task.TideTask(tide_station, tide_offset, query_range, renew_threshold)
tt.start()
while True:
now = datetime.datetime.utcnow()
later = now + water_level_minutes
tide_now = tt.await_tide(now)
tide_later = tt.await_tide(later)
logger.info('tide now: {}'.format(tide_now))
logger.info('tide later: {}'.format(tide_later))
if tide_now.level >= green_threshold and tide_later.level >= green_threshold:
render(strip, False, False, True)
elif tide_now.level >= yellow_threshold and tide_later.level >= yellow_threshold:
render(strip, False, True, False)
else:
render(strip, True, False, False)
time.sleep(60)
def start():
global strip
# Create NeoPixel object with appropriate configuration.
strip = neopixel.Adafruit_NeoPixel(config.N_PIXELS, config.LED_PIN,
config.LED_FREQ_HZ, config.LED_DMA,
config.LED_INVERT,
config.LED_BRIGHTNESS,
config.LED_CHANNEL, config.LED_STRIP)
# Intialize the library (must be called once before other functions).
strip.begin()
def __init__(self, width = 16, height = 16, led_pin = 18, led_freq_hz = 800000, led_dma = 5, led_invert = False, led_brightness = 200): super(Screen, self).__init__(width, height) import neopixel self.strip = neopixel.Adafruit_NeoPixel(width * height, led_pin, led_freq_hz, led_dma, led_invert, led_brightness, strip_type=528384) self.strip.begin() self.update_brightness() global instance instance = self
def make_strip(self):
return neopixel.Adafruit_NeoPixel(
self.LED_COUNT,
self.LED_PIN,
self.LED_FREQ_HZ,
self.LED_DMA,
self.LED_INVERT,
self.LED_BRIGHTNESS,
self.LED_CHANNEL,
)
def __init__(self, num_leds, led_pin, led_data_rate, led_dma_channel,
led_pixel_order):
self.leds = neopixel.Adafruit_NeoPixel(num_leds, led_pin,
led_data_rate, led_dma_channel,
False, 255)
self.px_order = led_pixel_order
self.leds.begin()
for i in range(num_leds):
self.leds.setPixelColor(i, neopixel.Color(0, 0, 0))
self.leds.show()
def __init__(self):
# LED strip configuration:
LED_COUNT = 5 # Number of LED pixels.
#LED_PIN = 18 # GPIO pin connected to the pixels (18 uses PWM!).
#LED_PIN = 10 # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0).
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10 # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 80 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
confs = utils.getConfiguration(self.name)
if confs != None:
self.channel = confs['channel']
if self.channel != 'None':
self.channel = int(self.channel)
else:
self.channel = False
print("FrontLED initialized - configuration found")
else:
self.channel = 18
newConfs = [('channel', None)]
utils.setConfiguration(self.name, newConfs)
print("FrontLED initialized - Warning: new configuration")
if self.channel != False:
#from neopixel import *
import neopixel
# Create NeoPixel object with appropriate configuration.
self.strip = neopixel.Adafruit_NeoPixel(LED_COUNT, self.channel,
LED_FREQ_HZ, LED_DMA,
LED_INVERT, LED_BRIGHTNESS,
LED_CHANNEL)
# Intialize the library (must be called once before other functions).
self.strip.begin()
print("LED Strip initialized")
else:
self.dimmer = ExecutePWM.ExecutePWM()
confs = utils.getConfiguration(self.name)
if confs != None:
self.channel_0 = int(confs['channel_0'])
self.channel_1 = int(confs['channel_1'])
self.channel_2 = int(confs['channel_2'])
self.channel_3 = int(confs['channel_3'])
self.channel_4 = int(confs['channel_4'])
print("Old IndicatorPanel initialized - configuration found")
else:
newConfs = [('channel_0', None), ('channel_1', None),
('channel_2', None), ('channel_3', None),
('channel_4', None)]
utils.setConfiguration(self.name, newConfs)
print(
"Old IndicatorPanel initialized - Warning: new configuration"
)
def __init__(self, **cnf):
# Create NeoPixel object with appropriate configuration.
count = cnf.get("count", self.LED_COUNT)
pin = cnf.get("pin", self.LED_PIN)
freq_hz = cnf.get("freq_hz", self.LED_FREQ_HZ)
dma = cnf.get("dma", self.LED_DMA)
invert = cnf.get("invert", self.LED_INVERT)
brightness = cnf.get("brightness", self.LED_BRIGHTNESS)
channel = cnf.get("channel", self.LED_CHANNEL)
strip = cnf.get("strip", self.LED_STRIP)
self.strip = np.Adafruit_NeoPixel(count, pin, freq_hz, dma, invert,
brightness, channel, strip)
# Intialize the library (must be called once before other functions).
self.strip.begin()
def main():
strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ,
LED_DMA, LED_INVERT, LED_BRIGHTENESS)
strip.begin()
while (True):
rpm = adc.read_voltage(1)
print(rpm) # debug tensione
if rpm > 1 and rpm < 2:
for j in range(1):
strip.setPixelColorRGB(j, 0, 255, 0)
strip.setPixelColorRGB(LED_COUNT - j - 1, 0, 255, 0)
for i in range(2, 15):
strip.setPixelColorRGB(i, 0, 0, 0)
if rpm > 2 and rpm < 3:
for j in range(1, 2):
strip.setPixelColorRGB(j, 0, 255, 0)
strip.setPixelColorRGB(LED_COUNT - j - 1, 0, 255, 0)
for x in range(2, 4):
strip.setPixelColorRGB(x, 255, 0, 0)
strip.setPixelColorRGB(LED_COUNT - x - 1, 255, 0, 0)
for i in range(4, 12):
strip.setPixelColorRGB(i, 0, 0, 0)
if rpm > 3 and rpm < 4:
for i in range(1, 2):
strip.setPixelColorRGB(j, 0, 255, 0)
strip.setPixelColorRGB(LED_COUNT - j - 1, 0, 255, 0)
for x in range(2, 4):
strip.setPixelColorRGB(x, 255, 0, 0)
strip.setPixelColorRGB(LED_COUNT - x - 1, 255, 0, 0)
for j in range(5, 6):
strip.setPixelColorRGB(j, 0, 0, 255)
strip.setPixelColorRGB(LED_COUNT - j - 1, 0, 0, 255)
for i in range(7, 11):
strip.setPixelColorRGB(i, 0, 0, 0)
if rpm > 4 and rpm < 6:
for i in range(1, 2):
strip.setPixelColorRGB(i, 0, 255, 0)
strip.setPixelColorRGB(LED_COUNT - i - 1, 0, 255, 0)
for x in range(2, 4):
strip.setPixelColorRGB(x, 255, 0, 0)
strip.setPixelColorRGB(LED_COUNT - x - 1, 255, 0, 0)
for j in range(5, 6):
strip.setPixelColorRGB(j, 0, 0, 255)
strip.setPixelColorRGB(LED_COUNT - j - 1, 0, 0, 255)
for p in range(7, 8):
strip.setPixelColorRGB(p, 0, 0, 255)
strip.setPixelColorRGB(LED_COUNT - p - 1, 0, 0, 255)
strip.show()
def __init__(self, brightness=150):
# Pip install rpi_ws281x
#
# NB: Do this import inside the constructor so that only tests which
# explicitly require instantiating the class will require the import
# which is platform-dependent
import neopixel
super(KanoHatLeds, self).__init__()
self._leds = neopixel.Adafruit_NeoPixel(KanoHatLeds.LED_COUNT,
KanoHatLeds.LED_PIN,
dma=10)
self.set_brightness(brightness)
self._leds.begin()
def __init__(self):
self.current_color = None
self.transition_from_color = None
self.transition_to_color = None
self.transition_alpha = 0
self.current_animation = None
self.strip = neopixel.Adafruit_NeoPixel(
RgbLed.LED_COUNT, RgbLed.LED_PIN, RgbLed.LED_FREQ_HZ,
RgbLed.LED_DMA, RgbLed.LED_INVERT, RgbLed.LED_BRIGHTNESS)
self.strip.begin()
# set default color
self.set_color(color.red)
def init(system, config):
"""
bring the hardware online
:param system (dict): global settings and handy objects
:param config (dict): preferences in a global dictionary
"""
# update system settings
global _screenW
global _screenH
cfg = config['platform_cfg']['raspi']
system["theme_path"] = cfg['themebasepath']
_screenW = system["screen_width"] = cfg[
'screen_width'] # this is specific to this hardware anyway
_screenH = system["screen_height"] = cfg['screen_height']
global _display
_display = povserial.pov(cfg)
# setup gpios
gpio.setmode(gpio.BCM)
# pin GPIO23 is connected to the sound relay
gpio.setup(GPIO_RELAY, gpio.OUT, initial=gpio.LOW)
# Create NeoPixel object with appropriate configuration.
global _strip
_strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ,
LED_DMA, LED_INVERT, LED_BRIGHTNESS)
_strip.begin()
pygame.mixer.pre_init(frequency=41000, channels=1, buffer=4096 * 2)
pygame.init()
pygame.mixer.set_num_channels(16)
if 'forceDisplayWindow' in system: # for debugging
pygame.display.set_mode((160, 180))
displayOn(True)
_display.secondsDisplay(False)
_display.clear()
__init_lut(system)
system['canvas'] = fc.Canvas(w=_screenW, h=_screenH)
print 'sys lamp: init done.'
def start():
if neopixel:
app.strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ,
LED_DMA, LED_INVERT,
LED_BRIGHTNESS)
app.strip.begin()
clear_display(app.strip)
#app.displayThread = DisplayJAnimThread(app.strip)
app.displayThread = DisplayShowPlaylistThread(
app.strip, 'playlists/imageloop.csv')
app.displayThread.start()
else:
app.strip = None
app.wlan0_ip = ipaddr.get_ip('wlan0')
app.run(host='0.0.0.0', port=80, debug=True)
def setup_strip(self):
brightness = self.strip_conf.get("brightness")
if (0 < brightness and brightness < 1):
brightness = int(brightness * 255)
strip_type = self.strip_conf.get("strip")
if (strip_type == "ws281x"):
strip_type = neopixel.ws.WS2811_STRIP_GRB
strip = neopixel.Adafruit_NeoPixel(self.strip_conf.get("count"),
self.strip_conf.get("pin"),
self.strip_conf.get("freq"),
self.strip_conf.get("DMA"),
self.strip_conf.get("invert"),
brightness,
self.strip_conf.get("channel"),
strip_type)
strip.begin()
return strip
def __init__(self, strip_size, strip_pin, strip_brightness=255):
import neopixel
self.strip_size = strip_size
self.strip_pin = strip_pin
self.strip_brightness = strip_brightness
self.strip_type = getattr(
neopixel.ws,
'%s_STRIP_%s' % (self.strip_type_name, self.strip_type_order))
self.strip = neopixel.Adafruit_NeoPixel(
self.strip_size, self.strip_pin, self.strip_freq_hz,
self.strip_dma, self.strip_invert, self.strip_brightness,
self.strip_channel, self.strip_type)
self.strip.begin()
def __init__(self,pin,default_anim,brightness=255): Thread.__init__(self) self._strip = neopixel.Adafruit_NeoPixel(self.LED_COUNT, pin, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, brightness, self.LED_CHANNEL) self._animation = default_anim self._new_animation_event = Event() self._running = True self._pause_event = Event() self._pause_event.set() self._locker = RLock() # dunno better self._bottle_fill_level = 0 # liquid szint self._wipe_pointer = 0 # meddig lett letorolve
def setup_strip(self):
import neopixel
brightness = self.strip_conf.get("brightness")
if 0 < brightness < 1:
brightness = int(brightness * 255)
strip_type = self.strip_conf.get("strip")
if strip_type == "ws281x":
# must have installed rpi_ws281x
strip_type = neopixel.ws.WS2811_STRIP_GRB
strip = neopixel.Adafruit_NeoPixel(self.strip_conf.get("count"),
self.strip_conf.get("pin"),
self.strip_conf.get("freq"),
self.strip_conf.get("DMA"),
self.strip_conf.get("invert"),
brightness,
self.strip_conf.get("channel"),
strip_type)
strip.begin()
return strip
def __init__(self):
self.strip_handler = neopixel.Adafruit_NeoPixel(
led_data.LED_COUNT, led_data.LED_PIN, led_data.LED_FREQ_HZ,
led_data.LED_DMA, led_data.LED_INVERT, led_data.LED_BRIGHTNESS,
led_data.LED_CHANNEL, led_data.LED_STRIP)
self.strip_handler.begin()
self.strip_handler.setBrightness(50)
logging.info('LED strip started')
msg = 'Neo pixel LEDs: {}, X: {}, Y: {}, font X: {}, font Y: {}.'
logging.debug(
msg.format(led_data.LED_COUNT, led_data.LED_COUNT_X,
led_data.LED_COUNT_Y,
selected_font[font_data.FONT_TUPLE_X],
selected_font[font_data.FONT_TUPLE_Y]))
self.act_time = 0
self.old_time = 0
self.message = ''
self.i = font_data.FONT_OFFSET_X
self.red = 100
self.blue = 0
self.green = 0
self.color = neopixel.Color(50, 50, 0)
def main(args):
global sock
global strip
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.bind(("0.0.0.0",UDPport))
# initialize the strip.
print "... create ..."
strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
# Intialize the library (must be called once before other functions).
print "... done ... start ..."
strip.begin()
print "... done ..."
load_default_gammacurves()
print "start loop, listen-port %u" % UDPport
data = sock.recv(10000)
try:
while(data):
## #print "UDP data %s" % repr(data)[:55]
proc_input(data)
data = sock.recv(10000)
except socket.timeout:
sock.close()
print "exiting..."
time.sleep(0.25)
return 0
import sys
LED_COUNT = 5
LED_PIN = 18
LED_BRIGHTNESS = 255
LED_CHANNEL = 0
def SetColor(strip, num, color, milli_sec):
for i in range(milli_sec):
strip.setPixelColor(num, color)
strip.show()
time.sleep(0.001)
strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, 800000, 10, False,
LED_BRIGHTNESS, LED_CHANNEL, 1050624)
strip.begin()
def OneByOne():
for i in range(LED_COUNT):
if i % 3 == 1:
for j in range(256):
SetColor(strip, i, neopixel.Color(j, 0, 255 - j),
1) #Blue ~ Red
for j in range(256):
SetColor(strip, i, neopixel.Color(255 - j, j, 0),
1) #Red ~ Green
for j in range(256):
SetColor(strip, i, neopixel.Color(0, 255 - j, j),
1) #Green ~ Blue
sleep(1)
print("Found device {}, with IP address {}".format(config.settings["configuration"]["MAC_ADDR"], ip_addr))
config.settings["configuration"]["UDP_IP"] = ip_addr
# ESP8266 uses WiFi communication
if config.settings["configuration"]["DEVICE"] == 'esp8266':
import socket
from subprocess import check_output
from time import sleep
_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
_sock.settimeout(0.005)
# Raspberry Pi controls the LED strip directly
elif config.settings["configuration"]["DEVICE"] == 'pi':
import neopixel
strip = neopixel.Adafruit_NeoPixel(config.settings["configuration"]["N_PIXELS"], config.settings["configuration"]["LED_PIN"],
config.settings["configuration"]["LED_FREQ_HZ"], config.settings["configuration"]["LED_DMA"],
config.settings["configuration"]["LED_INVERT"], config.settings["configuration"]["BRIGHTNESS"])
strip.begin()
elif config.settings["configuration"]["DEVICE"] == 'blinkstick':
from blinkstick import blinkstick
import signal
import sys
#Will turn all leds off when invoked.
def signal_handler(signal, frame):
all_off = [0]*(config.settings["configuration"]["N_PIXELS"]*3)
stick.set_led_data(0, all_off)
sys.exit(0)
stick = blinkstick.find_first()
# Create a listener that turns the leds off when the program terminates
signal.signal(signal.SIGTERM, signal_handler)
from __future__ import print_function
from __future__ import division
import platform
import numpy as np
import config
# ESP8266 uses WiFi communication
if config.DEVICE == 'esp8266':
import socket
_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Raspberry Pi controls the LED strip directly
elif config.DEVICE == 'pi':
import neopixel
strip = neopixel.Adafruit_NeoPixel(config.N_PIXELS, config.LED_PIN,
config.LED_FREQ_HZ, config.LED_DMA,
config.LED_INVERT, config.BRIGHTNESS)
strip.begin()
elif config.DEVICE == 'blinkstick':
from blinkstick import blinkstick
import signal
import sys
#Will turn all leds off when invoked.
def signal_handler(signal, frame):
all_off = [0]*(config.N_PIXELS*3)
stick.set_led_data(0, all_off)
sys.exit(0)
stick = blinkstick.find_first()
# Create a listener that turns the leds off when the program terminates
signal.signal(signal.SIGTERM, signal_handler)
strip.setPixelColor(i + q, 0)
# Main program logic follows:
if __name__ == '__main__':
# Process arguments
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--clear',
action='store_true',
help='clear the display on exit')
args = parser.parse_args()
# Create NeoPixel object with appropriate configuration.
strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ,
LED_DMA, LED_INVERT, LED_BRIGHTNESS,
LED_CHANNEL)
# Intialize the library (must be called once before other functions).
strip.begin()
print('Press Ctrl-C to quit.')
if not args.clear:
print('Use "-c" argument to clear LEDs on exit')
try:
while True:
print('Color wipe animations.')
colorWipe(strip, neopixel.Color(255, 0, 0)) # Red wipe
colorWipe(strip, neopixel.Color(0, 255, 0)) # Blue wipe
colorWipe(strip, neopixel.Color(0, 0, 255)) # Green wipe
