class LEDatGPIO():
def __init__(self, pinnumber):
self.led = LED(pinnumber)
self.__loop = True
self.__threading = threading.Thread(target=self.__blink)
def on(self, ):
self.__loop = False
self.maybejoin()
self.led.on()
def off(self, ):
self.__loop = False
self.maybejoin()
self.led.off()
def maybejoin(self, ):
if self.__threading.isAlive():
self.__threading.join()
def blink(self, pitch):
self.__threading = threading.Thread(target=self.__blink,
args=(pitch, ))
self.__threading.start()
def __blink(self, pitch=.25):
self.__loop = True
while self.__loop:
self.led.toggle()
time.sleep(pitch / 2)
self.led.off()
def main():
from gpiozero import LED, Button
SOCKET = config.set_socket()
FLOOR = 'f1'
ROOM = 'bathroom'
led1 = LED(21)
led2 = LED(22)
button1 = Button(11)
button1.when_pressed = led1.toggle
button2 = Button(12)
button2.when_pressed = led2.toggle
while True:
command = SOCKET.recv(10240).decode(config.CODE).split(config.SPLIT)
print(command)
if command[0] == FLOOR or command[0] == config.ANY:
if command[1] == ROOM or command[1] == config.ANY:
if command[2] == config.LAMP or command[2] == config.ANY:
if command[3] == config.ONE or command[3] == config.ANY:
if command[4] == config.ON:
led1.on()
elif command[4] == config.OFF:
led1.off()
elif command[4] == config.CHANGE:
led1.toggle()
if command[3] == config.TWO or command[3] == config.ANY:
if command[4] == config.ON:
led2.on()
elif command[4] == config.OFF:
led2.off()
elif command[4] == config.CHANGE:
led2.toggle()
def blink(LED, secs_between_blinks, num_blinks):
count = 0
while count < num_blinks * 2:
LED.toggle()
time.sleep(secs_between_blinks / 2)
count += 1
return
def main():
from gpiozero import LED, Button
SOCKET = config.set_socket()
FLOOR = 'f1'
ROOM = 'kitchen'
COMMAND = 'f1;living_room;lamp;1;change'
def button2_pressed():
SOCKET.sendto(COMMAND.encode(config.CODE),
(config.MCAST_GRP, config.MCAST_PORT))
led = LED(21)
button1 = Button(11)
button1.when_pressed = led.toggle
button2 = Button(12)
button2.when_pressed = button2_pressed
while True:
command = SOCKET.recv(10240).decode(config.CODE).split(config.SPLIT)
print(command)
if command[0] == FLOOR or command[0] == config.ANY:
if command[1] == ROOM or command[1] == config.ANY:
if command[2] == config.LAMP or command[2] == config.ANY:
if command[3] == config.ONE or command[3] == config.ANY:
if command[4] == config.ON:
led.on()
elif command[4] == config.OFF:
led.off()
elif command[4] == config.CHANGE:
led.toggle()
def main():
# LEDピン設定
factory = PiGPIOFactory()
led = LED(PIN_LED1, pin_factory=factory)
# LEDをチカチカ
for _ in range(5):
print("LED ON")
led.on()
sleep(0.5)
print("LED OFF")
led.off()
sleep(0.5)
# blinkを使用することも可能
print("blink")
led.blink()
sleep(3)
led.off()
# toggleを使用することも可能
print("toggle")
for _ in range(20):
led.toggle()
sleep(0.1)
class GPIO:
callback_function = None
def __init__(self):
self._button_state: bool = False
self.__button = Button(5)
self.__green_led = LED(19)
self.__red_led = LED(17)
@property
def button_state(self):
return self._button_state
@button_state.setter
def button_state(self, value):
print(self.callback_function)
self._button_state = value
self.callback_function(self.button_state)
def bind_to(self, callback):
self.callback_function = callback
def green_led_toggle(self):
self.__green_led.toggle()
def red_led_toggle(self):
self.__red_led.toggle()
def run(self):
while True:
if self.__button.is_pressed:
self.button_state = True
break
def run(self):
# LED expected to be on GPIO 18.
led = LED(18)
# Button expected to be on GPIO 4 and to be active low (e.g. connected to GND)
button = Button(4)
button.when_pressed = self.__startPress
button.when_released = self.__endPress
log.debug("Panel thread startup complete")
# TODO: this state machine fuckery is turning into a pain. Should probably reimplement
# LED control in a more event-based (e.g. sane) way.
while self.live:
if self.ledmode == 'blink':
led.toggle()
if self.ledmode == 'on':
led.on()
if self.ledmode == 'off':
led.off()
if self.ledmode == 'once':
led.on()
self.ledmode = "oncedone"
if self.ledmode == 'oncedone':
led.off()
self.ledmode = "off"
time.sleep(1)
def button_led2():
led = LED(2)
button = Button(3)
while True:
button.wait_for_press()
sleep(.1)
led.toggle()
sleep(.1)
class LEDplus():
def __init__(self, pinnumber):
self.led = LED(pinnumber)
self.__loop = True
self.operation = 'off'
self.__threading = threading.Thread(target=self.__blink)
def on(self, ):
self.operation = 'on'
self.__loop = False
self.maybejoin()
self.led.on()
def off(self, ):
self.operation = 'off'
self.__loop = False
self.maybejoin()
self.led.off()
def close(self, ):
self.operation = 'off'
self.__loop = False
self.maybejoin()
self.led.off()
self.led.close()
def close(self, ):
self.operation = 'off'
self.__loop = False
self.maybejoin()
self.led.off()
self.led.close()
def maybejoin(self, ):
if self.__threading.isAlive():
self.__threading.join()
def blink(self, pitch):
if self.operation != 'blink-%s' % pitch:
self.__loop = False
if self.operation != 'on' and self.operation != 'off':
last_pitch = self.operation.split('-')[1]
time.sleep(float(last_pitch) + 0.1)
self.operation = 'blink-%s' % pitch
self.__loop = False
self.maybejoin()
self.__threading = threading.Thread(target=self.__blink,
args=(pitch, ))
self.__threading.start()
def __blink(self, pitch=2):
self.__loop = True
while self.__loop:
self.led.toggle()
time.sleep(pitch)
self.led.off()
class Led:
def __init__(self,
pin: Union[int, str],
active_high=True,
initial_value=False) -> None:
try:
self._led = LED(pin,
active_high=active_high,
initial_value=initial_value)
except BadPinFactory:
logger.warning("no gpio found")
self._led = None
@property
def pin(self) -> Any:
if self._led:
return self._led.pin
@property
def is_lit(self) -> bool:
if self._led:
return self._led.is_lit
return False
@property
def value(self) -> int:
if self._led:
return self._led.value
return 0
@value.setter
def value(self, value) -> None:
if self._led:
self._led.value = value
def close(self) -> None:
if self._led:
self._led.close()
def on(self) -> None:
if self._led:
self._led.on()
def off(self) -> None:
if self._led:
self._led.off()
def toggle(self) -> None:
if self._led:
self._led.toggle()
def blink(self) -> None:
if self._led:
self._led.blink()
class Relay:
def __init__(self, pin):
self.pin = LED(pin)
def on(self):
self.pin.off()
def off(self):
self.pin.on()
def toggle(self):
self.pin.toggle()
def led_toggle():
#deletes plot files from previous run - beware!
#if file exists
#os.remove('public/plots/interim.png')
#os.remove('public/plots/final_plot.png')
#toggles LED state
if not dev:
whitelight = LED(21)
whitelight.toggle()
else:
print('LED on!')
class GoogleAIYVoicehat(MycroftSkill):
def __init__(self):
MycroftSkill.__init__(self)
def initialize(self):
self.time_held = 100
self.short_press = 2
self.button = Button(23, hold_time = 7)
self.led = LED(25)
self.schedule_repeating_event(self.handle_button, None, 0.01, 'buttonpress')
def handle_button(self):
self.button.when_pressed = self.start_timer
self.button.when_held = self.graceful_exit
self.button.when_released = self.stop_timer
self.add_event('recognizer_loop:record_begin', self.handle_listener_started)
self.add_event('recognizer_loop:record_end', self.handle_listener_ended)
def start_timer(self):
self.time_held = time.time()
def stop_timer(self):
self.time_held = time.time() - self.time_held
if self.time_held < self.short_press:
self.bus.emit(Message('mycroft.mic.listen'))
elif self.time_held < self.button.hold_time:
self.bus.emit(Message('mycroft.stop'))
def handle_listener_started(self):
self.led.on()
def handle_listener_ended(self):
self.led.off()
# In truth, this is a not-so-graceful power down.
# Emitting message 'system.shutdown' doesn't work on Picroft.
def graceful_exit(self):
self.blink()
self.log.info('Forcing a linux shutdown ...')
subprocess.call(['sudo', 'shutdown', '-h', 'now'])
def blink(self):
for i in range(6):
self.led.toggle()
time.sleep(0.5)
def shutdown(self):
self.cancel_scheduled_event('buttonpress')
self.button.close()
self.led.close()
class PiController:
'''Describes the controller methods which are usually used while connected
to a raspberry pi controller using the module `gpiozero`.
'''
def __init__(self):
self.led12 = LED(12)
self.led24 = LED(24)
def toggleLight(self):
self.led12.toggle()
print("Light toggled on pin 12")
def lightBlinker(self, times=10):
self.led24.blink(n=times)
print("Light blinks", times, "times on pin 24")
class SmartBoxLight: def __init__(self): self.light = LED(19) def turn_on(self): self.light.on() def turn_off(self): self.light.off() def toggle(self): self.light.toggle() def is_light_on(self): return self.light.value
class RelayLED(object):
def __init__(self, pin):
self._delay = 1
self._on = False
self._led = LED(pin=pin, initial_value=None)
def set_delay(self, delay_in):
self._delay = delay_in
def toggle(self):
self._led.toggle()
timer = threading.Timer(self._delay, self.reset)
timer.start()
def reset(self):
self._led.toggle()
class Clk:
from gpiozero import LED
import time
def __init__(self, args: Namespace) -> None:
self.__pin = LED(args.clockpin)
self.__period = us_to_s(args.period)
self.__propagation = us_to_s(args.propagation)
def tick(self) -> None:
time.sleep(self.__period)
self.__pin.toggle()
time.sleep(self.__propagation)
def high(self) -> None:
self.__pin.on()
def main():
# now just write the code you would use on a real Raspberry Pi
from gpiozero import LED, Button
import socket
import struct
MCAST_GRP = '236.0.0.0'
MCAST_PORT = 3456
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('', MCAST_PORT))
mreq = struct.pack("4sl", socket.inet_aton(MCAST_GRP), socket.INADDR_ANY)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
floor = 'f1'
room = 'bathroom'
led1 = LED(21)
led2 = LED(22)
button1 = Button(11)
button1.when_pressed = led1.toggle
button2 = Button(12)
button2.when_pressed = led2.toggle
while True:
command = sock.recv(10240).decode("utf-8").split(';')
print(command)
if command[0] == floor or command[0] == '*':
if command[1] == room or command[1] == '*':
if command[2] == 'lamp' or command[2] == '*':
if command[3] == '1' or command[3] == '*':
if command[4] == 'on':
led1.on()
elif command[4] == 'off':
led1.off()
elif command[4] == 'change':
led1.toggle()
if command[3] == '2' or command[3] == '*':
if command[4] == 'on':
led2.on()
elif command[4] == 'off':
led2.off()
elif command[4] == 'change':
led2.toggle()
def get_settings_defaults(self):
#return dict(url="https://en.wikipedia.org/wiki/Hello_world")
led = LED(17)
led.toggle()
def get_template_configs(self):
return [
dict(type="navbar", custom_bindings=False),
dict(type="settings", custom_bindings=False)
]
def get_assets(self):
return dict(
js=["js/helloworld.js"],
css=["css/helloworld.css"],
less=["less/helloworld.less"]
)
class Light:
def __init__(self, name: str, pin: Pin):
self.name = name
self.pin = pin
self.__led = LED(pin.value, active_high=False)
print('INFO: Light:', pin.name, '-', pin.value)
def on(self):
self.__led.on()
def off(self):
self.__led.off()
def toggle(self):
self.__led.toggle()
def is_on(self):
return self.__led.is_active
class LEDResource(resource.Resource):
def get_link_description(self):
# Publish additional data in .well-known/core
return dict(**super().get_link_description(),
title=f"LED Resource - pin: {self.pin}")
def __init__(self, pin):
super().__init__()
self.pin = pin
self.resource = LED(pin)
async def render_get(self, request):
payload = f"{self.resource.value}"
print(f'LED {self.pin}: GET')
return Message(payload=payload.encode(), code=Code.CONTENT)
async def render_post(self, request):
payload = request.payload.decode()
print(f'LED {self.pin}: POST {payload}')
if payload in ['0', 'off']:
self.resource.off()
elif payload in ['1', 'on']:
self.resource.on()
elif payload in ['-1', 'toggle']:
self.resource.toggle()
elif 'blink' in payload:
p = payload.split(" ")
if p[0] != 'blink':
return Message(code=Code.BAD_REQUEST)
on_time, off_time, n = 1, 1, None
if len(p) > 1 and p[1].isdigit():
on_time = int(p[1])
if len(p) > 2 and p[2].isdigit():
off_time = int(p[2])
if len(p) > 3 and p[3].isdigit():
n = int(p[3])
self.resource.blink(on_time, off_time, n)
else:
return Message(code=Code.BAD_REQUEST)
return Message(code=Code.CHANGED)
class ArmSwitch:
def __init__(self, led_pin: int, button_pin: int,
callback: Callable[[bool], None]):
self.led = LED(led_pin)
self.button = Button(button_pin, bounce_time=0.1)
def handle_change():
self.led.toggle()
callback(self.led.is_active)
self.button.when_released = handle_change
@property
def armed(self) -> bool:
return self.led.is_active
@armed.setter
def armed(self, value: bool):
self.led.value = value
class EffectComponent(object):
def __init__(self, pin_button, pin_led, pull_up=False):
self.button = Button(pin_button, pull_up=pull_up)
self.led = LED(pin_led)
self._effect = None
@property
def action(self):
return self.button.when_pressed
@action.setter
def action(self, data):
self.button.when_pressed = lambda: [self._update_led(), data()]
def _update_led(self):
if self.effect is not None:
self.led.toggle()
else:
self.led.off()
@property
def effect(self):
return self._effect
@effect.setter
def effect(self, effect):
"""
Update this component status by :param effect
"""
self._effect = effect
if effect is not None:
self.led.value = effect.status
else:
self.led.off()
def active(self):
self.led.off()
def disable(self):
self.led.on()
class Light:
def __init__(self, pin):
"""Inicializacion de un led
Parameters
----------
pin : int
gpio, not board
"""
self.pin = pin
self.light = DO(self.pin)
logging.debug("Led was set at pin# " + str(self.pin))
async def TurnOn(self):
self.light.on()
logging.debug("Led_{} turned on".format(self.pin))
async def TurnOff(self):
self.light.off()
logging.debug("Led_{} turned off".format(self.pin))
async def CheckStatus(self):
return self.light.is_active
def TurnOnSync(self):
self.light.on()
logging.debug("Led_{} turned on".format(self.pin))
def TurnOffSync(self):
self.light.off()
logging.debug("Led_{} turned off".format(self.pin))
def ToggleSync(self):
self.light.toggle()
return self.light.is_active
def CheckStatusSync(self):
return self.light.is_active
class LEDplus():
def __init__(self, pinnumber):
self.led = LED(pinnumber)
self.__loop = True
self.__threading = threading.Thread(target=self.__blink)
self._startTime = time.time()
self._blinkPeriod = 1
def on(self, ):
self.__loop = False
self.maybejoin()
self.led.on()
logging.debug("All goal buttons switched on")
def off(self, ):
self.__loop = False
self.maybejoin()
self.led.off()
def maybejoin(self, ):
if self.__threading.isAlive():
self.__threading.join()
def blink(self):
self.__threading = threading.Thread(target=self.__blink)
self.__threading.start()
def __blink(self):
self.__loop = True
while self.__loop:
self.led.toggle()
time.sleep(self._blinkPeriod / 2)
time.time() - self._startTime
#logging.debug(self.led)
#logging.info("Blink-"+str(self.__threading.ident)+' '+ str(time.localtime().tm_sec))
self.led.off()
from gpiozero.pins.mock import MockFactory
from gpiozero import Device, LED, Button
from time import sleep
from sys import argv
args = argv
ENVIRONMENT = ''
running = True
if (len(args) > 1):
ENVIRONMENT = args[1]
if (ENVIRONMENT == 'development'):
Device.pin_factory = MockFactory()
redLed = LED(2)
blueLed = LED(3)
greenLed = LED(4)
while (running):
greenLed.toggle()
from gpiozero import Button, LED
tlacitko = Button(21)
cervena = LED(13)
i = 0
while True:
tlacitko.wait_for_active()
i += 1
if i == 11:
cervena.toggle()
i = 0
tlacitko.wait_for_inactive()
def sw1Pressed():
global sw1Press
sw1Press = True
sw1.when_pressed = sw1Pressed
sw1Press = False
print("Reading QR code using Raspberry Pi camera")
print("Press SW1 to scan.")
while True:
if sw1Press == True:
led.toggle()
_, img = cap.read()
data, bbox, _ = detector.detectAndDecode(img)
if bbox is not None:
for i in range(len(bbox)):
cv2.line(img,
tuple(bbox[i][0]),
tuple(bbox[(i + 1) % len(bbox)][0]),
color=(255, 0, 0),
thickness=2)
cv2.putText(img, data,
(int(bbox[0][0][0]), int(bbox[0][0][1]), 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
from gpiozero import LED
led1 = LED(13)
led2 = LED(12)
userin = ''
while userin != 'q':
print("Type 'q' to quit")
userin = input("Type LED nr to toggle it: ")
if userin == 'q':
break
elif userin == '1':
led1.toggle()
elif userin == '2':
led2.toggle()
else:
print("Incorrect command try again")
#!/usr/bin/env python
#jetzt verbinde eine LED mit deinem Pi, ein Jumper zu GPIO17 und einer zu GND
from gpiozero import LED
from gpiozero import Button
from time import sleep
button = Button(24)
led = LED(17)
while True: # das ist eine Endlosschleife, die mit CTRL+C stoppen kannst
if button.is_active: #wenn Button nicht nicht gedrueckt wird
print "Button gedrueckt" #schreibe Button gedrueckt
led.toggle() #aendere den Status der LED #probiere mal led.on() oder led.off() oder led.blink()
else:
print "Button nicht gedrueckt" #wenn Button nicht gedrueckt, wenn du willst kannst due jetzt auch das ganze Else wegloeschen
sleep(0.1)
eyeLeft = LED(23)
eyeRight = LED(24)
nose = LED(25)
buttonTopLeft.off()
buttonMiddleLeft.off()
buttonBottomLeft.off()
buttonTopRight.off()
buttonMiddleRight.off()
buttonBottomRight.off()
eyeLeft.off()
eyeRight.off()
nose.off()
while True:
buttonTopLeft.toggle()
time.sleep(1)
buttonMiddleLeft.toggle()
time.sleep(1)
buttonBottomLeft.toggle()
time.sleep(1)
buttonTopRight.toggle()
time.sleep(1)
buttonMiddleRight.toggle()
time.sleep(1)
buttonBottomRight.toggle()
time.sleep(1)
eyeLeft.toggle()
time.sleep(1)
eyeRight.toggle()
time.sleep(1)
from gpiozero import LED from time import sleep red_led = LED(17) red_led.toggle() sleep(1) print(red_led.is_lit) red_led.toggle() sleep(1) print(red_led.is_lit)
from gpiozero import Button, LED from time import sleep led=LED(3) button = Button(4) while True: button.wait_for_press() led.toggle()
