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 top_down(forward):
# function that lights the leds from top down.
# Or from bottom up if forward is not True.
branch1_leds = LEDBoard(27, 17, 4, 18, 15, 14)
branch2_leds = LEDBoard(11, 5, 8, 12, 6, 7)
branch3_leds = LEDBoard(19, 16, 26, 13, 20, 21)
branch4_leds = LEDBoard(25, 9, 22, 24, 23, 10)
top_down_time = time.time() + uniform(period_min, period_max)
while top_down_time > time.time():
branch1_leds.off()
branch2_leds.off()
branch3_leds.off()
branch4_leds.off()
time.sleep(top_down_delay2)
if forward:
for point in range(6):
branch1_leds[point].on()
branch2_leds[point].on()
branch3_leds[point].on()
branch4_leds[point].on()
time.sleep(top_down_delay)
else:
for point in range(5, -1, -1):
branch1_leds[point].on()
branch2_leds[point].on()
branch3_leds[point].on()
branch4_leds[point].on()
time.sleep(top_down_delay)
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, 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 __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 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()
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 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()
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)
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)
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 __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 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)
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 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)
def spiral():
# function to create a spiral pattern that repeats for a while
print("Spiral")
branch1_leds = LEDBoard(27,17,4,18,15,14)
branch2_leds = LEDBoard(11,5,8,12,6,7)
branch3_leds = LEDBoard(19,16,26,13,20,21)
branch4_leds = LEDBoard(25,9,22,24,23,10)
branch1_leds.off()
branch2_leds.off()
branch3_leds.off()
branch4_leds.off()
time.sleep(delay)
spiral_time = time.time() + uniform(period_min, period_max)
while spiral_time > time.time():
# spiral down
for point in range(6):
branch1_leds[point].on()
time.sleep(delay2)
branch2_leds[point].on()
time.sleep(delay2)
branch3_leds[point].on()
time.sleep(delay2)
branch4_leds[point].on()
time.sleep(delay2)
time.sleep(delay)
# spiral up
for point in range(5, -1, -1):
branch1_leds[point].off()
time.sleep(delay2)
branch2_leds[point].off()
time.sleep(delay2)
branch3_leds[point].off()
time.sleep(delay2)
branch4_leds[point].off()
time.sleep(delay2)
time.sleep(delay)
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 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)
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)
##
# 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()
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'))
# 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 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('/')
def shutdown(b):
# find how long the button has been held
p = b.pressed_time
# blink rate will increase the longer we hold
# the button down. E.g., at 2 seconds, use 1/4 second rate.
leds.blink(on_time=0.5 / p, off_time=0.5 / p)
if p > offtime:
os.system("sudo poweroff")
def when_pressed():
# start blinking with 1/2 second rate
leds.blink(on_time=0.5, off_time=0.5)
def when_released():
# be sure to turn the LEDs off if we release early
leds.off()
with warnings.catch_warnings():
warnings.simplefilter("ignore")
leds = LEDBoard(actledGPIO, powerledGPIO)
btn = Button(offGPIO, hold_time=mintime, hold_repeat=True)
btn.when_held = shutdown
btn.when_pressed = when_pressed
btn.when_released = when_released
pause()
from time import sleep
from signal import pause
from subprocess import Popen, check_call
import glob
# SHUTDOWN BUTTON
def shutdown():
check_call(['sudo', 'poweroff'])
shutdown_btn = Button(21, hold_time=2)
shutdown_btn.when_held = shutdown
# DEFINE LEDS
allLEDS = LEDBoard(27, 22, 23, 24, 9, 25, 11, 8, 5, 12)
def whiteLEDS():
allLEDS.value = (1, 0, 0, 0, 0, 0, 0, 0, 0, 1)
def greenLEDS():
allLEDS.value = (0, 1, 1, 0, 0, 0, 0, 0, 0, 0)
def blueLEDS():
allLEDS.value = (0, 0, 0, 1, 1, 1, 0, 0, 0, 0)
def purpleLEDS():
