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()