from gpiozero import LEDBoard from time import sleep from signal import pause leds = LEDBoard(5, 6, 13, 19, 26) leds.on() sleep(1) leds.off() sleep(1) leds.value = (1, 0, 1, 0, 1) sleep(1) leds.blink() pause()
def launch_sequence():
"""
Test that all the leds are operating.
"""
# Manually configure the leds as PWM compatible
# Each number is a GPIO pin number
with LEDBoard(17, 22, 9, 5, 13, pwm=True) as green_leds:
# Ensure everything is off to start
green_leds.off()
with LEDBoard(4, 27, 10, 11, 6, pwm=True) as red_leds:
# Ensure everything is off to start
red_leds.off()
# Pulse red LEDs on
pulse_leds(red_leds)
sleep(3)
# Swoosh up down
fade_in = 0
fade_out = 0.7
pause = 0.25
for repeat in range(5):
pulse_leds(red_leds, fade_in, fade_out, pause)
pulse_leds(reversed(red_leds), fade_in, fade_out, pause)
def __init__(self, pwm=False, initial_value=False, pin_factory=None):
super(Snowman, self).__init__(
face=LEDBoard(leftEye=23,
rightEye=24,
nose=25,
pwm=pwm,
initial_value=initial_value,
_order=('leftEye', 'rightEye', 'nose'),
pin_factory=pin_factory),
body=LEDBoard(left=LEDBoard(top=7,
middle=8,
bottom=9,
pwm=pwm,
initial_value=initial_value,
_order=('top', 'middle', 'bottom'),
pin_factory=pin_factory),
right=LEDBoard(top=17,
middle=18,
bottom=22,
pwm=pwm,
initial_value=initial_value,
_order=('top', 'middle', 'bottom'),
pin_factory=pin_factory),
pwm=pwm,
initial_value=initial_value,
_order=('left', 'right'),
pin_factory=pin_factory),
pwm=pwm,
initial_value=initial_value,
_order=('face', 'body'),
pin_factory=pin_factory)
def active_seismometer(callback, callback_interval):
buzzer = Buzzer(3)
status_led = LED(26)
scale_led = LEDBoard(a=18, b=23, c=12, d=19, e=6, f=22, g=17, xdp=16)
seismometer = Seismometer()
seismometer.start_calculation(callback, callback_interval)
while True:
try:
seismic_scale = seismometer.seismic_scale
scale_led.value = SCALE_LED_CHARSETS[
seismometer.get_user_friendly_formatted_seismic_scale()]
if seismometer.ready:
if not status_led.is_lit:
status_led.on()
if seismic_scale >= 3.5:
if not buzzer.is_active:
buzzer.on()
else:
buzzer.off()
except KeyboardInterrupt:
break
seismometer.stop_calculation()
scale_led.off()
status_led.off()
buzzer.off()
def __init__(self, pwm=False, initial_value=False, pin_factory=None):
super(ChristmasTree, self).__init__(
baubles=LEDBoard(
bottom=LEDBoard(
left=11, midleft=16, midright=17, right=18,
pwm=pwm, initial_value=initial_value,
_order=('left', 'midleft', 'midright', 'right'),
pin_factory=pin_factory),
middle=LEDBoard(
left=19, midleft=20, midright=21, right=22,
pwm=pwm, initial_value=initial_value,
_order=('left', 'midleft', 'midright', 'right'),
pin_factory=pin_factory),
top=LEDBoard(
left=23, right=24,
pwm=pwm, initial_value=initial_value,
_order=('left', 'right'),
pin_factory=pin_factory),
),
star=12,
pwm=pwm, initial_value=initial_value,
_order=('baubles', 'star'),
pin_factory=pin_factory
)
def __init__(self, hostIP):
''' initialize the hostIP and leds GPIO pins'''
self.hostIP = hostIP # host is the one that controls the lights
self.factory = PiGPIOFactory(host=hostIP)
# 18, 19, 20, 21, 22, 23, 24, 25 are the connected GPIO pins
self.leds = LEDBoard(18, 19, 20, 21, 22, 23, 24, 25,
pwm=True, pin_factory=self.factory)
def __init__(self):
''' initialize the hostIP and leds GPIO pins'''
# 18, 19, 20, 21, 22, 23, 24, 25 are the connected GPIO pins
self.leds = LEDBoard(18, 19, 20, 21, 22, 23, 24, 25, pwm=False)
self.sensor = tsl2591.Tsl2591()
self.lux_dictionary = self.calibrate_light()
def sevensegment(ch,d,pinout):
#ch is the character to display
#d is the duration in seconds
#pinout is the pinout for the display
from gpiozero import LEDBoard
from time import sleep
import traceback
num = {
'1': (3,6),
'2': (2,3,0,4,5),
'3': (2,3,0,6,5),
'4': (1,0,3,6),
'5': (2,1,0,6,5),
'6': (2,1,4,5,6,0),
'7': (2,3,6),
'8': (0,1,2,3,4,5,6),
'9': (2,3,1,0,6),
'0': (2,1,4,5,6,3),
'A': (4,1,2,3,0,6),
'C': (2,1,4,5),
'E': (2,1,0,4,5),
'F': (2,1,0,4),
'H': (1,4,0,3,6),
'J': (3,6,5,4),
'L': (1,4,5),
'P': (2,3,0,1,4),
'U': (1,4,5,6,3)
}
# Validate the inputs - ch needs to be in the num dictionary, and d needs to be an integer
try:
if ch not in num:
raise ValueError ("Can't display that value on seven segment display)")
if not type(d) is int:
raise TypeError ("Expecting an integer for duration")
if not type(pinout) is tuple:
raise TypeError ("Need a tuple for pinouts")
if len(pinout) != 8:
raise IndexError ("Need list of 8 pinouts")
for a in range(0,len(pinout)):
if not (1<=pinout[a]<=26):
raise ValueError ("GPIO pinouts must be from 1 to 26")
except ValueError as error:
traceback.print_exc()
except TypeError as error:
traceback.print_exc()
except IndexError as error:
traceback.print_exc()
else:
leds = LEDBoard(*pinout)
for a in range(0,len(num[ch])):
leds[num[ch][a]].on()
sleep(d)
leds.off()
def __init__(self, panel):
self._panel = panel
if self._panel.width not in range(
Graphic.WIDTH +
1) and self._panel.height not in range(Graphic.HEIGHT + 1):
raise SystemError('Panel size is illegal!')
self._running = True
self._coms = LEDBoard(2, 3, 4, 17, 27, 22, 10, 9, 11)
self._segs = LEDBoard(14, 15, 18, 23, 24, 25, 8, 7, 12, 16, 20, 21)
self._canvas = Canvas(self._panel.width, self._panel.height)
self._render_thread = Thread(target=self.render)
self._update_thread = Thread(target=self.update)
def assign_leds(self, led_pins):
self._close_leds()
try:
self._leds = LEDBoard(
fine=led_pins.get('fine'),
cloud=led_pins.get('cloud'),
rain=led_pins.get('rain'),
snow=led_pins.get('snow'),
pwm=True,
)
except PinInvalidPin:
pass
def __init__(self, parent=None):
super().__init__(parent) # 父类的构造函数
self.setupUi(self) # 初始化程序界面
# factory = PiGPIOFactory(host='169.254.163.132') # 填写树莓派的IP地址
self.timer_camera_tongkong = QtCore.QTimer()
self.timer_camera_hateman = QtCore.QTimer() # 定义定时器，用于控制显示视频的帧率
self.cap_tongkong = cv2.VideoCapture()
self.cap_hateman = cv2.VideoCapture() # 视频流
self.CAM_TONGKONG = 0 # 为0时表示视频流来自笔记本内置摄像头
self.CAM_HATEMAN = 2
####验光仪光路硬件部分定义
self.laser = PWMLED(17)
self.wuxiang = PWMLED(6)
self.yuanhuan_in = PWMLED(13)
self.yuanhuan_out = PWMLED(16)
self.buttun = Button(18)
self.yuanhuan_in.value = 0.2
self.laser.value = 0.25
self.graph = LEDBoard(20, 21, 22, 23)
#####圆环中心坐标
self.yuanhuan_x = self.spinBox_up.value()
self.yuanhuan_y = self.spinBox_right.value()
self.slot_init() # 初始化槽函数t自带的，会关闭程序
def pibooth_startup(app, cfg):
"""Create the LED instances.
.. note:: gpiozero is configured as BCM, use a string with "BOARD" to
use BOARD pin numbering.
"""
app.led_startup = LEDBoard(*("BOARD{}".format(pin)
for pin in cfg.gettuple('CONTROLS', 'startup_led_pin', int)))
app.led_sequence = LEDBoard(*("BOARD{}".format(pin)
for pin in cfg.gettuple('CONTROLS', 'preview_led_pin', int)))
app.led_flash = LEDBoard(*("BOARD{}".format(pin)
for pin in cfg.gettuple('CONTROLS', 'flash_led_pin', int)))
app.led_startup.on()
class ChristmasTreeListener(StreamListener):
"""Stream Listener and Tree LED controller"""
tree = LEDBoard(*range(2, 28), pwm=True)
# Need 26 keywords for the LEDs, the first is the star
keywords = [
"star", "snow", "christmas", "santa", "merry", "xmas", "present",
"gift", "card", "mince", "turkey", "joy", "tree", "light",
"decoration", "carol", "cake", "wrap", "elves", "jingle", "reindeer",
"festive", "holiday", "sleigh", "nativity", "peace"
]
# Associate each word with an LED via a dictionary for lookups
lookup = {word: led for word, led in zip(keywords, tree.leds)}
# Keep track of how many times a word has been found via a counter dictionary
word_counter = {word: 0 for word in keywords}
def on_data(self, data):
"""When new data is received from the Twitter stream"""
# Parse from JSON string
parsed_data = json.loads(data)
# May not contain text, may be limit if the result is < 1% of tweets batch.
if "text" in parsed_data: # checks parsed_data's keys for "text"
# Search for the words, if found, flip the led
for word, led in self.lookup.items():
if word in parsed_data["text"]:
self.word_counter[word] += 1
led.toggle() # if on, turn off, else turn on.
return True
def on_error(self, status):
print(status)
def __init__(self):
self.leds = LEDBoard(4,
15,
13,
21,
22,
6,
12,
25,
16,
17,
27,
26,
9,
23,
11,
5,
20,
19,
14,
18,
7,
8,
10,
24,
2,
pwm=True)
async def light_up_xmas():
tree = LEDBoard(*range(2, 28), pwm=True)
for led in tree:
led.source_delay = 0.1
led.source = random_values()
await asyncio.sleep(1)
def setLights(self):
tree = LEDBoard(*range(2,28),pwm=True)
for led in tree:
led.source_delay = 0.1
led.source = random_values()
if(self.on == False):
break
pause()
def twinkle():
print("Twinkle twinkle")
twinkle_time = time.time() + uniform(period_min, period_max)
tree = LEDBoard(*range(3,28), pwm=True)
for led in tree:
led.source_delay = 0.1
led.source = random_values()
while twinkle_time > time.time():
time.sleep(delay)
class Lights():
def __init__(self, hostIP):
''' initialize the hostIP and leds GPIO pins'''
self.hostIP = hostIP # host is the one that controls the lights
self.factory = PiGPIOFactory(host=hostIP)
# 18, 19, 20, 21, 22, 23, 24, 25 are the connected GPIO pins
self.leds = LEDBoard(18, 19, 20, 21, 22, 23, 24, 25,
pwm=True, pin_factory=self.factory)
def adjustableLED(self, brightness):
''' adjust LED intensity according to brightness assigned'''
leds = self.processBrightness(brightness)
self.leds.value = (leds[0], leds[1], leds[2], leds[3],
leds[4], leds[5], leds[6], leds[7])
def hardOnOffLED(self, onTime, offTime, brightness):
''' turn LEDS light on for onTime and off for offTime,
with assigned brightness'''
while True:
leds = self.processBrightness(brightness)
self.leds.value = (leds[0], leds[1], leds[2], leds[3],
leds[4], leds[5], leds[6], leds[7])
sleep(onTime)
self.leds.off()
sleep(offTime)
def processBrightness(self, brightness):
''' Return leds switch value as a list
1 for on, 0 for off '''
if brightness > 255 or brightness < 0:
print("invalid light brightness level")
sys.exit(0)
leds = [0, 0, 0, 0, 0, 0, 0, 0] # initially turn everything off
binLevel = bin(brightness) # string of form '0b101010'
binLevel = binLevel[2:]
binList = list(binLevel)
binList.reverse() # because the pins are in reversed order
for i in range(0, len(binList)):
if binList[i] == '1':
leds[i] = 1
print("active led")
print(leds)
return leds
def run(self):
tree = LEDBoard(*range(2,28),pwm=True)
while not self._stop_event.is_set():
for led in tree:
if not self._stop_event.is_set():
led.on()
sleep(0.1)
led.off()
sleep(0.1)
class Graphic:
WIDTH = 12
HEIGHT = 9
RENDER_DELAY = .001
FPS = 60
TPF = float(1) / FPS
def __init__(self, panel):
self._panel = panel
if self._panel.width not in range(
Graphic.WIDTH +
1) and self._panel.height not in range(Graphic.HEIGHT + 1):
raise SystemError('Panel size is illegal!')
self._running = True
self._coms = LEDBoard(2, 3, 4, 17, 27, 22, 10, 9, 11)
self._segs = LEDBoard(14, 15, 18, 23, 24, 25, 8, 7, 12, 16, 20, 21)
self._canvas = Canvas(self._panel.width, self._panel.height)
self._render_thread = Thread(target=self.render)
self._update_thread = Thread(target=self.update)
def render(self):
while self._running:
for i in range(self._panel.height):
self._segs.value = self._canvas.matrix[i]
com = self._coms.leds[i]
com.on()
sleep(Graphic.RENDER_DELAY)
com.off()
def update(self):
last = time()
while self._running:
start = time()
current = time()
self._panel.render(self._canvas, current - last)
last = current
try:
sleep(start + Graphic.TPF - time())
except IOError:
pass
def start(self):
self._coms.off()
self._segs.on()
self._render_thread.start()
self._update_thread.start()
def stop(self):
self._running = False
self._render_thread.join()
self._update_thread.join()
self._segs.close()
self._coms.close()
class Tree(object):
Lower = 2
Upper = 28
Period = 20
def __init__(self):
self.tree = LEDBoard(*range(Tree.Lower, Tree.Upper), pwm=True)
def reset(self):
for led in self.tree:
led.source_delay = 0
led.source = [0]
def off(self):
self.tree.off()
def on(self):
self.tree.on()
def pulse(self):
self.tree.pulse(fade_in_time=4, fade_out_time=4)
def flicker(self):
for led in self.tree:
led.source_delay = 0.2
led.source = random_values()
def sequence(self):
delay = Tree.Period * 1.0 / (Tree.Upper - Tree.Lower)
values = []
for index in range(Tree.Lower, Tree.Upper):
values.append(0)
index = 0
for led in self.tree:
#delay += 0.1
led.source_delay = delay
values[index] = 1
led.source = list(values)
values[index] = 0
index += 1
#print( led.source )
#led.on()
#sleep( 0.1 )
#led.off()
def wait(self):
sleep(Tree.Period)
def go(self):
while True:
self.sequence()
self.wait()
self.pulse()
self.wait()
self.flicker()
self.wait()
self.reset()
def random_led():
# function that turns off and on random leds
print("Random LED")
tree = LEDBoard(*range(4,28))
random_time = time.time() + uniform(period_min, period_max)
while random_time > time.time():
# Turn on a random led
on_lamp = randint(0, 23)
tree[on_lamp].on()
time.sleep(on_delay)
# Turn off a random led
off_lamp = randint(0, 23)
tree[off_lamp].off()
def __init__(self, pwm=False, initial_value=False, pin_factory=None):
super(PumpkinPi, self).__init__(
sides=LEDBoard(left=LEDBoard(bottom=18,
midbottom=17,
middle=16,
midtop=13,
top=24,
pwm=pwm,
initial_value=initial_value,
_order=('bottom', 'midbottom',
'middle', 'midtop', 'top'),
pin_factory=pin_factory),
right=LEDBoard(bottom=19,
midbottom=20,
middle=21,
midtop=22,
top=23,
pwm=pwm,
initial_value=initial_value,
_order=('bottom', 'midbottom',
'middle', 'midtop', 'top'),
pin_factory=pin_factory),
pwm=pwm,
initial_value=initial_value,
_order=('left', 'right'),
pin_factory=pin_factory),
eyes=LEDBoard(left=12,
right=6,
pwm=pwm,
initial_value=initial_value,
_order=('left', 'right'),
pin_factory=pin_factory),
pwm=pwm,
initial_value=initial_value,
_order=('eyes', 'sides'),
pin_factory=pin_factory)
class TailLights:
led_lights = LEDBoard(red=21, green=20)
def __init__(self):
self.led_lights.on()
sleep(0.25)
self.led_lights.off()
sleep(0.25)
def blink_red(self, num, duration):
for x in range(num):
self.led_lights.red.on()
sleep(duration)
self.led_lights.red.off()
sleep(duration)
def blink_green(self, num, duration):
for x in range(num):
self.led_lights.green.on()
sleep(duration)
self.led_lights.green.off()
sleep(duration)
def blink_alternating(self, num, duration):
for x in range(num):
self.led_lights.red.off()
self.led_lights.green.on()
sleep(duration)
self.led_lights.red.on()
self.led_lights.green.off()
sleep(duration)
self.led_lights.red.off()
def blink_together(self, num, duration):
for x in range(num):
self.led_lights.on()
sleep(duration)
self.led_lights.off()
sleep(duration)
def alarm(self, num):
for x in range(num):
self.blink_alternating(2, 0.25)
self.blink_together(2, 0.5)
def __init__(self, pwm=False, initial_value=False, pin_factory=None):
super(Star, self).__init__(outer=LEDBoard(
A=8,
B=7,
C=12,
D=21,
E=20,
F=16,
G=26,
H=19,
I=13,
J=6,
K=5,
L=11,
M=9,
N=10,
O=22,
P=27,
Q=17,
R=4,
S=3,
T=14,
U=23,
V=18,
W=15,
X=24,
Y=25,
pwm=pwm,
initial_value=initial_value,
_order=('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y'),
pin_factory=pin_factory),
inner=2,
pwm=pwm,
initial_value=initial_value,
_order=('inner', 'outer'),
pin_factory=pin_factory)
# modification: 2021/17/01
########################################################################
from gpiozero import LEDBoard
from time import sleep
from signal import pause
print('Program is starting ... ')
numberToConvert = 512
ledPins = [
"J8:11", "J8:12", "J8:13", "J8:15", "J8:16", "J8:18", "J8:22", "J8:3",
"J8:5", "J8:24"
]
leds = LEDBoard(*ledPins, active_high=False)
#define array of 10 bit : 0000000000
binary = []
for i in range(10):
binary.append(0)
print("Init bit array:" + str(binary))
#convert number in binary string
number = numberToConvert
i = len(binary) - 1
while number > 0:
bit = number % 2
binary[i] = bit
from gpiozero import LEDBoard from gpiozero.tools import random_values from signal import pause tree = LEDBoard(*range(2,28),pwm=True) for led in tree: led.source_delay = 0.1 led.source = random_values() pause()
from flask import Flask, render_template, Response, send_from_directory, url_for
# import numpy as np
# import cv2
# Raspberry Pi camera module (requires picamera package, developed by Miguel Grinberg)
from camera_pi import Camera
from gpiozero import LEDBoard
# cap = cv2.VideoCapture(-1)
leds = LEDBoard(0,
1,
2,
3,
4,
pwm=False,
active_high=False,
initial_value=False,
pin_factory=None) # LEDBoard(17, 18, 15, 27)
#my_message = "Started";
app = Flask(__name__, static_url_path='/static')
# def get_frame():
# while(cap.isOpened()):
# ret, frame = cap.read()
# if ret==True:
# #frame = cv2.flip(frame,0)
# return frame
@app.route('/')
from gpiozero import LEDBoard
from time import sleep
t = 0.2
setting = 3
if (setting == 0):
ledRow = LEDBoard(18, 23, 17, 22, 12, 16, 5, 13)
while True:
for i in range(8):
if (i != 0):
ledRow[i].on()
sleep(t)
ledRow[i].off()
sleep(t)
for i in range(8):
if (i != 0):
ledRow[7 - i].on()
sleep(t)
ledRow[7 - i].off()
sleep(t)
elif (setting == 1):
ledHalfs = LEDBoard(18, 13, 23, 5, 17, 16, 22, 12)
while True:
for i in range(8):
ledHalfs[i].on()
sleep(.2)
sleep(1)
for i in range(8):
ledHalfs[7 - i].off()
sleep(.2)
sleep(1)
# by Carl Monk (@ForToffee) # github.com/fortoffee from time import sleep from datetime import datetime from gpiozero import LED, LEDBoard, Button, Buzzer import random board = LEDBoard(9, 22, 8, 18, 7, 17, 23, 24, 25) button = Button(21) buzzer = Buzzer(20) def game(): random.seed() board.on() sleep(0.25) board.leds[7].off() board.leds[6].off() sleep(0.25) board.leds[8].off() sleep(0.25) for i in range(5, -1, -2): board.leds[i].off() board.leds[i-1].off() sleep(0.25) gameState = 0 #1 = win, -1 = lose led = 0 while gameState == 0 :
from gpiozero import LEDBoard from time import sleep leds = LEDBoard(red=LEDBoard(top=2, bottom=3), green=LEDBoard(top=4, bottom=5)) leds.red.on() ## both reds on sleep(1) leds.green.on() # both greens on sleep(1) leds.off() # all off sleep(1) leds.red.top.on() # top red on sleep(1) leds.green.bottom.on() # bottom green on sleep(1)
def __init__(self, config):
self._config = config
# Clean directory where pictures are saved
savedir = config.getpath('GENERAL', 'directory')
if not osp.isdir(savedir):
os.makedirs(savedir)
elif osp.isdir(savedir) and config.getboolean('GENERAL', 'debug'):
shutil.rmtree(savedir)
os.makedirs(savedir)
# Prepare the pygame module for use
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
# Dont catch mouse motion to avoid filling the queue during long actions
pygame.event.set_blocked(pygame.MOUSEMOTION)
# Create window of (width, height)
init_size = self._config.gettyped('WINDOW', 'size')
init_debug = self._config.getboolean('GENERAL', 'debug')
init_color = self._config.gettyped('WINDOW', 'background')
init_text_color = self._config.gettyped('WINDOW', 'text_color')
if not isinstance(init_color, (tuple, list)):
init_color = self._config.getpath('WINDOW', 'background')
title = 'Pibooth v{}'.format(pibooth.__version__)
if not isinstance(init_size, str):
self._window = PtbWindow(title,
init_size,
color=init_color,
text_color=init_text_color,
debug=init_debug)
else:
self._window = PtbWindow(title,
color=init_color,
text_color=init_text_color,
debug=init_debug)
# Create plugin manager and defined hooks specification
self._plugin_manager = pluggy.PluginManager(
hookspecs.hookspec.project_name)
self._plugin_manager.add_hookspecs(hookspecs)
self._plugin_manager.load_setuptools_entrypoints(
hookspecs.hookspec.project_name)
# Register plugins
custom_paths = [
p for p in self._config.gettuple('GENERAL', 'plugins', 'path') if p
]
load_plugins(self._plugin_manager, *custom_paths)
# Define states of the application
self._machine = StateMachine(self._plugin_manager, self._config, self,
self._window)
self._machine.add_state('wait')
self._machine.add_state('choose')
self._machine.add_state('chosen')
self._machine.add_state('preview')
self._machine.add_state('capture')
self._machine.add_state('processing')
self._machine.add_state('print')
self._machine.add_state('finish')
# ---------------------------------------------------------------------
# Variables shared with plugins
# Change them may break plugins compatibility
self.dirname = None
self.capture_nbr = None
self.capture_choices = (4, 1)
self.nbr_duplicates = 0
self.previous_picture = None
self.previous_animated = None
self.previous_picture_file = None
self.camera = camera.get_camera(
config.getint('CAMERA', 'iso'),
config.gettyped('CAMERA', 'resolution'),
config.getint('CAMERA', 'rotation'),
config.getboolean('CAMERA', 'flip'),
config.getboolean('CAMERA', 'delete_internal_memory'))
self.button_capture = Button(
"BOARD" + config.get('CONTROLS', 'picture_btn_pin'),
bounce_time=config.getfloat('CONTROLS', 'debounce_delay'),
pull_up=True,
hold_time=1)
self.button_print = Button(
"BOARD" + config.get('CONTROLS', 'print_btn_pin'),
bounce_time=config.getfloat('CONTROLS', 'debounce_delay'),
pull_up=True,
hold_time=1)
self.leds = LEDBoard(
capture="BOARD" + config.get('CONTROLS', 'picture_led_pin'),
printer="BOARD" + config.get('CONTROLS', 'print_led_pin'),
preview="BOARD" + config.get('CONTROLS', 'preview_led_pin'),
start="BOARD" + config.get('CONTROLS', 'startup_led_pin'))
self.printer = PtbPrinter(config.get('PRINTER', 'printer_name'))
from gpiozero import LEDBoard
from time import sleep
leds = LEDBoard(2, 3, 4, 5, 6, 7, 8, 9)
for led in leds[3:]: # leds 3 and onward
led.on()
sleep(1)
leds.off()
for led in leds[:2]: # leds 0 and 1
led.on()
sleep(1)
leds.off()
for led in leds[::2]: # even leds (0, 2, 4...)
led.on()
sleep(1)
leds.off()
for led in leds[1::2]: # odd leds (1, 3, 5...)
led.on()
sleep(1)
leds.off()
##
# Press enter to light up the tree
##
from time import sleep
from gpiozero import LEDBoard
tree = LEDBoard(*range(2, 28), pwm=True)
tree.off() # Turn all LED's off
print("Press Enter to Light Up Tree")
while True:
raw_input()
print("button pressed")
tree.on()
sleep(.2)
tree.off()
from gpiozero import LEDBoard leds = LEDBoard(5, 6, 13, 19, 26, pwm=True) leds.value = (0.2, 0.4, 0.6, 0.8, 1.0)
