コード例 #1
0
ファイル: consumers.py プロジェクト: Bicskow/rpiGateOpener
 def triggerGate(self, command):
     try:
         if command == "pedestrian_access":
             led = LED(2, active_high=False)
             led.on()
             sleep(0.2)
             led.off()
             led.close()
             self.send(text_data=json.dumps({'result': 'gate_triggered'}))
             MailSender.sendMail("Pedestrian access triggered")
             return
         elif command == "vehicle_access":
             led = LED(3, active_high=False)
             led.on()
             sleep(0.2)
             led.off()
             led.close()
             self.send(text_data=json.dumps({'result': 'gate_triggered'}))
             MailSender.sendMail("Vehicle access triggered")
             return
         self.send(text_data=json.dumps({'result': 'bad_command'}))
         MailSender.sendMail("Gate trigger failed with bad command")
     except Exception as e:            
         self.send(text_data=json.dumps({'result': 'internal_server_error'}))
         MailSender.sendMail(f"Gate trigger failed with exception: {e}")
コード例 #2
0
class StatusLed:

    def __init__(self):
        self._led = LED(PIN)
        self._led.off()
        _logger.debug('{} initialized'.format(self.__class__.__name__))

    def set(self, status):
        self._led.off()
        blinking_time_s = _blinking_time_s.get(status)
        if blinking_time_s is None:
            raise ValueError('Unknown status: {}'.format(status))

        if blinking_time_s < 0:
            # Constant on.
            self._led.on()

        else:
            self._led.blink(on_time=blinking_time_s,
                            off_time=blinking_time_s)

    def close(self):
        self._led.off()
        self._led.close()
        _logger.debug('{} stopped'.format(self.__class__.__name__))
コード例 #3
0
    def test_construction(self):
        """ 生成テスト """
        # 接続ピン
        PIN_LD = 23
        PIN_PR = 10

        # 周辺設定
        led = LED(PIN_LD)

        # 期待値
        valueLDExpctd = False # black

        # ターゲット生成
        photoref  = Button(PIN_PR,active_state=True,pull_up=None)

        # 接続
        led.source = photoref

        # 実際値
        valueLDActual = led.value

        # 評価
        try:
            self.assertEqual(valueLDActual,valueLDExpctd)
            sleep(0.1)
        finally:
            led.close()
            photoref.close()
コード例 #4
0
ファイル: manager.py プロジェクト: nstoik/farm_device
class HardwareController(object):

    def __init__(self):

        self.button = Button(pin=BUTTON_PIN, hold_time=1, hold_repeat=True)
        self.status_led = LED(STATUS_LED_PIN)
        self.button_led = LED(BUTTON_LED_PIN)

        self.button.when_pressed = self.button_pressed
        self.button.when_released = self.button_released
        self.button.when_held = self.button_held
        self.hold_time = 0

        self.status_led.blink(on_time=0.1, off_time=0.1, n=5, background=False)
        self.status_led.on()

        return

    def close(self):

        self.button.close()
        self.button_led.close()
        self.status_led.close()

        return

    def button_held(self):

        logger.debug("button held")
        self.hold_time = self.button.active_time
        self.button_led.blink(on_time=0.25, off_time=0.1, n=1)

        return

    def button_pressed(self):

        logger.debug("button pressed")
        self.hold_time = 0

        return

    def button_released(self):

        increments = int(self.hold_time / BUTTON_HOLD_INCREMENTS)
        logger.debug("button released. Held for {0} increments".format(increments))

        if increments > 0:
            time.sleep(2)
            self.button_led.blink(on_time=0.5, off_time=0.5, n=increments, background=False)
            time.sleep(1)

            if increments == 1:
                logger.info("Shutdown called via button press")
                check_call(['sudo', 'poweroff'])
            elif increments == 2:
                logger.info("Reboot called via button press")
                check_call(['sudo', 'reboot'])

        return
コード例 #5
0
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()
コード例 #6
0
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()
コード例 #7
0
class 
Me(tornado.web.RequestHandler):
    def prepare(self):
        logging.log(logging.INFO, "Preparing LED 26 ...")
        self.relay = LED(26)

    def get(self):
        self.relay.on()
        sleep(1)
        self.relay.off()
        self.relay.close()

        self.write("{\"time\": " + str(time.time()) + "}")
コード例 #8
0
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()
コード例 #9
0
def blink():
    led = LED(PIN_NO_LED)
    led.off()
    sleep(SLEEP_TIME)
    led.on()
    sleep(SLEEP_TIME)
    led.off()
    sleep(SLEEP_TIME)
    led.close()
    # Use brute force method because gpiozero turns off output on exit
    os.system('echo "' + str(PIN_NO_LED) +
              '" | tee /sys/class/gpio/export >/dev/null')
    os.system('echo "out" | tee /sys/class/gpio/gpio' + str(PIN_NO_LED) +
              '/direction >/dev/null')
    os.system('echo "1" | tee /sys/class/gpio/gpio' + str(PIN_NO_LED) +
              '/value >/dev/null')
コード例 #10
0
class Explode:
    def __init__(self, audiofiles_dir):
        self.led_explode = LED(pin_fig.explode_led)
        self.mixer_explode = mixer
        self.audiofiles_dir = audiofiles_dir

    def on(self):
        siren_mp3_path = path.join(self.audiofiles_dir, "bomb1.mp3")
        self.mixer_explode.init()
        self.mixer_explode.music.load(siren_mp3_path)
        self.mixer_explode.music.play(1)
        self.led_explode.blink(on_time=0.05, off_time=0.05)
        print("explode on")

    def off(self):
        self.mixer_explode.music.stop()
        self.led_explode.off()
        self.led_explode.close()
        print("explode off")
コード例 #11
0
ファイル: Device.py プロジェクト: mirco5/mOrto
class Nozzle(Device):
    @property
    def obit(self):
        return self.__obit
    @threaded
    def init(self):
        self.__obit = LED(int(self.pins[0]))
        print("Init Finished:" + self.name)
    @threaded
    def run(self):
        self.__obit.on()
    @threaded
    def stop(self):
        self.__obit.off()
        print("Stop Finished:" + self.name)
    @threaded
    def exit(self):
        self.__obit.close()
        print("Exit Finished:" + self.name)
コード例 #12
0
def tcpCallback():
    while True:
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            s.bind((HOST, PORT))
            s.listen(1)
            print("TCP socket awaiting connection...")
            (conn, addr) = s.accept()

            conn.send(("OKENDOFMSG").encode())
            print("Socket connected")

            while True:
                string_recv = (conn.recv(1024)).decode()
                print("Recv: " + string_recv)
                if string_recv == "PINGENDOFMSG":
                    conn.send(("PONGENDOFMSG").encode())
                elif string_recv == "NEXTENDOFMSG":
                    printer = LED(26)
                    printer.on()
                    printer.close()
                elif string_recv == "SCANENDOFMSG":
                    print_paper()
                    with open('/home/pi/Desktop/Checker/image_in.jpg',
                              'rb') as file:
                        data = file.read()
                    message = data + ("ENDOFMSG").encode()
                    print('Sending data to:', addr)
                    conn.sendall(message)
                elif string_recv == "EXENDOFMSG":
                    conn.close()
                    break
                elif string_recv == "SHUTENDOFMSG":
                    conn.close()
                    quit()
                print("Done")

        except Exception as e:
            print(e)

        sleep(2)
コード例 #13
0
class Siren:
    def __init__(self, audiofiles_dir):
        self.led_siren = LED(pin_fig.siren_led)
        self.mixer_siren = mixer
        self.audiofiles_dir = audiofiles_dir

    def on(self):
        siren_mp3_path = path.join(self.audiofiles_dir, "ambulance-siren2.mp3")
        self.mixer_siren.init()
        self.mixer_siren.music.load(siren_mp3_path)  # 12sec
        self.mixer_siren.music.play(-1)
        self.mixer_siren.music.set_volume(0.7)
        self.led_siren.blink(on_time=1, off_time=1)
        print("siren on")

    def off(self):
        self.mixer_siren.music.stop()
        self.led_siren.off()
        self.led_siren.close()
        print("siren off")
コード例 #14
0
    def test_callback(self):
        """ コールバックテスト """
        # 接続ピン
        PIN_LD = 23
        PIN_PR = 10

        # 周辺設定
        led = LED(PIN_LD)

        # 期待値
        highLDExpctd = True # white
        lowLDExpctd = False # black

        # ターゲット生成
        photoref  = Button(PIN_PR,active_state=True,pull_up=None)
        photoref_pin = Device.pin_factory.pin(PIN_PR)

        # コールバック関数設定
        photoref.when_pressed = led.on
        photoref.when_released = led.off

        # Highでフォトリフレクタを駆動(白)
        photoref_pin.drive_high()
        sleep(0.1)
        highLDActual = led.value

        # Low でフォトリフレクタを駆動(黒)
        photoref_pin.drive_low()
        sleep(0.1)
        lowLDActual = led.value

        # 評価
        try:
            self.assertEqual(highLDActual,highLDExpctd)
            self.assertEqual(lowLDActual,lowLDExpctd)
            sleep(0.1)
        finally:
            led.close()
            photoref.close()
コード例 #15
0
class Blender(object):
    def __init__(self, timeout):
        # https://gpiozero.readthedocs.io/en/stable/recipes.html#pin-numbering
        # Connect the GPIO-18 pin and a ground pin (Ground 6 for example)
        self.pin = LED(18)
        self.timeout = timeout
        self.timeout_thread = None
        self.state = 0
        self.off()

    def handle_timeout(self):
        print("Timeout")
        self.off()

    def ensure_blender_turns_off(self):
        self.timeout_thread = threading.Timer(self.timeout,
                                              self.handle_timeout, [])
        self.timeout_thread.start()

    def on(self):
        print('Setting blender to ON')
        self.pin.on()
        self.ensure_blender_turns_off()

        self.state = ON

    def off(self):
        print('Setting blender to OFF')
        self.pin.off()
        self.state = OFF

    def toggle(self):
        if self.state == ON:
            self.off()
        else:
            self.on()

    def cleanup(self):
        self.pin.close()
コード例 #16
0
def main():
    global led_state, led_pin
    try:
        led = LED(led_pin)
        led.on()
        while True:
            txt = input("Type [Enter]: ")
            led_state = not led_state
            if led_state:
                led.on()
            else:
                led.off()
            log.info("LED state: %s" % led_state)

    except KeyboardInterrupt:
        log.info("...^C pressed...")
    except:
        log.error(str(sys.exc_info()[1]))
        log.error(traceback.format_tb(sys.exc_info()[2]))
    finally:
        log.info("Cleaning up/closing.")
        led.close()  # this ensures a clean exit
コード例 #17
0
GPIO_PIN = 14

LED = LED(GPIO_PIN)

class WakewordGadget(AlexaGadget):
    """
    An Alexa Gadget that turns an LED on and off in sync with the detection
    of the wake word
    """

    def __init__(self):
        super().__init__()

    def on_alexa_gadget_statelistener_stateupdate(self, directive):
        for state in directive.payload.states:
            if state.name == 'wakeword':
                if state.value == 'active':
                    logger.info('Wake word active - turn on LED')
                    LED.on()
                elif state.value == 'cleared':
                    logger.info('Wake word cleared - turn off LED')
                    LED.off()


if __name__ == '__main__':
    try:
        WakewordGadget().main()
    finally:
        logger.debug('Cleaning up GPIO')
        LED.close()
コード例 #18
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("-rpc", help="Start rpc server",
                        action="store_true", default=False)
    parser.add_argument("-v", "--verbose", help="Log verbosity",
                        action="store_true", default=False)
    parser.add_argument("-stop", help="Cleanup on stop service",
                        action="store_true", default=False)
    parser.add_argument(
        "-off_first", help="Check OFF condition first, then ON condition", action="store_true", default=False)
    parser.add_argument("--lcd", help="Use I2C LCD 16x2 to show status", choices=[
                        "sainsmart_charlcd_led", "adafruit_charlcd_rgb", "adafruit_charlcd_mono"], default=None)
    parser.add_argument("--pin", help="GPIO Pin", type=int,
                        action='append', default=[])
    parser.add_argument(
        "--off", help="Pin Off condition, format: <temp|hum>:<eq|lt|lte|gt|gte>:<value>:[or|and|xor|nand|nor|xnor]", action="append", default=[])
    parser.add_argument(
        "--on", help="Pin On condition, format: <temp|hum>:<eq|lt|lte|gt|gte>:<value>:[or|and|xor|nand|nor|xnor]", action="append", default=[])
    parser.add_argument(
        "--rpc_listen", help="Listen address, default all 0.0.0.0", type=str, default="0.0.0.0")
    parser.add_argument(
        "--rpc_port", help="Listen port, default 15555", type=int, default=15555)

    args = parser.parse_args()

    logging.basicConfig(
        level=logging.DEBUG if args.verbose else logging.INFO,
        format="%(asctime)s %(levelname)-8s %(name)-30s %(message)s"
    )
    logger = logging.getLogger("rpioalert.main")

    if args.stop is True:
        logger.info("Reset LED")
        for pin in args.pin:
            led = LED(pin)
            led.off()
            led.close()
        sys.exit()

    try:
        leds = [LED(pin) for pin in args.pin]
    except:
        logger.info("Unable to connect to GPIO Pin {}".format(args.pin))
        logger.debug(sys.exc_info())

    loop = asyncio.get_event_loop()
    executor = ThreadPoolExecutor(max_workers=1)

    lcd = Lcd(lcd_type=args.lcd)
    stats = Status(lcd=lcd)

    lock = asyncio.Lock()

    tasks = [
        asyncio.ensure_future(rpio_alert(**{
            "leds": leds,
            "off_condition": args.off,
            "on_condition": args.on,
            "off_first": args.off_first,
            "stats": stats,
            "lock": lock,
            "executor": executor,
            "loop": loop
        }))
    ]

    if args.rpc:
        tasks.append(
            asyncio.ensure_future(rpc_server(**{
                "leds": leds,
                "listen": args.rpc_listen,
                "port": args.rpc_port,
                "off_condition": args.off,
                "on_condition": args.on,
                "off_first": args.off_first,
                "stats": stats,
                "lock": lock,
                "executor": executor,
                "loop": loop
            }))
        )

    try:
        logger.info("Start rpioalert")
        loop.run_forever()
    except asyncio.CancelledError:
        pass
    except KeyboardInterrupt:
        pass
    except:
        logger.debug(sys.exc_info())

    logger.info("Stop rpioalert")
    loop.run_until_complete(asyncio.wait([shutdown(t) for t in tasks]))
    executor.shutdown(wait=True)
    loop.close()

    lcd.clear_lcd()

    for led in leds:
        if not led.closed:
            led.off()
            led.close()
コード例 #19
0
        '--shutdown_after_seconds',
        required=False,
        default=5 * 60,
        help=
        "In seconds, how long to wait after no motion is detected to shut down the LED. (default: 5 * 60)"
    )
    parser.add_argument(
        '--rescan_after_seconds',
        required=False,
        default=1,
        help="In seconds, how long to wait between motion checks. (default: 1)"
    )
    args = parser.parse_args()
    sensor = MotionSensor(args.sensor_pin)
    led = LED(args.led_pin)
    detection_led = LED(args.detection_led_pin)
    while True:
        try:
            turn_on_and_wait(
                sensor=sensor,
                led=led,
                detection_led=detection_led,
                shutdown_after_seconds=int(args.shutdown_after_seconds),
                rescan_after_seconds=int(args.rescan_after_seconds))
        except KeyboardInterrupt:
            print("Ending the program.")
            sensor.close()
            led.close()
            detection_led.close()
            break
コード例 #20
0
def main():
    altunitraw = os.getenv('ALTUNIT', 'False')
    altunit = ast.literal_eval(altunitraw)

    reverse_pin = int(os.getenv('REV_GPIO', 17))
    servo_gpio = int(os.getenv('SERVO_GPIO', 27))
    backup_in = int(os.getenv('BACKUP_GPIO', 22))

    obd_port = os.getenv('OBD_PORT', '/dev/elm_obd')
    arduino_port = os.getenv('ARDUINO_PORT', None)

    logging.warning('Reverse activate pin {0}'.format(reverse_pin))
    logging.warning('Video Switch Servio pin {0}'.format(servo_gpio))
    logging.warning('Backup activate pin {0}'.format(backup_in))
    logging.warning('ELM327 OBD Serial port {0}'.format(obd_port))
    logging.warning('Arduino (Physical Interface Unit) Serial port {0}'.format(
        arduino_port))
    logging.warning('Use Alt Units - (Imperial) {0}'.format(altunit))

    if arduino_port:
        arduino = Arduino(arduino_port)
        arduino.start()

    lock = Lock()

    #Set screen on pin
    screen_reverse_pin = LED(reverse_pin)
    screen_reverse_pin.blink(on_time=10, off_time=1, background=True)

    #Could not make this work in a function.. Or a thread..
    if servo_gpio and backup_in:
        logging.warning(
            'Setting up 2 way video switch on GPIO {0} triggered by {1}.'.
            format(servo_gpio, backup_in))
        backup = Button(backup_in)

        init_servo = 1 if backup.value else -1
        servo = Servo(servo_gpio, initial_value=init_servo)

        backup.when_pressed = servo.max
        backup.when_released = servo.min

    mirror = Carmirror(gps=True, obd_port=obd_port, altunit=altunit)
    mirror.infoscreen("starting OBD", "Please wait")
    mirror.configobd()

    mirror.infoscreen("starting GPS", "Please wait")
    mirror.configgps()

    if mirror.connection:
        mirror.codes()

    currentscreen = 1
    buttonpressed = False

    totalscreens = 4 + len(gauges)

    try:
        while True:
            currentscreen = currentscreen % totalscreens

            keypress = None

            if currentscreen == 0:
                if arduino_port:
                    lock.acquire()
                    ax = arduino.get_value('AY') / 9.81
                    ay = arduino.get_value('AX') / 9.81
                    maxx = arduino.get_value('MAY') / 9.81
                    maxy = arduino.get_value('MAX') / 9.81
                    lock.release()
                    keypress = mirror.accelerometer(ax, ay, maxx, maxy)
                else:
                    currentscreen = currentscreen + 1

            if currentscreen == 1:
                keypress = mirror.gpsscreen()
            if currentscreen == 2:
                keypress = mirror.obd_main()
            if currentscreen == 3:
                keypress = mirror.obd_airfuel()
            if currentscreen > 3:
                keypress = mirror.obd_gauge(**gauges[currentscreen - 4])

            #handle user inputs.
            if arduino_port:
                buttons = arduino.get_value('BTNS')

                if buttons and not buttonpressed:
                    buttonpressed = True
                    if int(buttons) == 1:
                        currentscreen += 1
                    elif int(buttons) == 2:
                        currentscreen -= 1
                    elif int(buttons) == 3:  # Set fav for now..
                        currentscreen = 4
                elif not buttons:
                    buttonpressed = False

            if keypress == 'K_LEFT':
                currentscreen -= 1
            if keypress == 'K_RIGHT':
                currentscreen += 1

    except KeyboardInterrupt:
        logging.warning('interrupted!')

    screen_reverse_pin.close()
コード例 #21
0
# using random to generate blinking interval

from gpiozero import LED
import random
from time import sleep

led = LED(17)

try:
    while True:
        interval = random.uniform(0.1, 3)
        print("interval is " + str(interval))
        print("on!")
        led.on()
        sleep(interval)
        print("off!")
        print()
        led.off()
        sleep(interval)
except KeyboardInterrupt:
    print('interrupted!')
    led.close()  # cleans up pin
コード例 #22
0
#!/usr/bin/python3
from gpiozero import LED
from time import sleep

red = LED(21)
sleep_speed = 0.5

print("Press Crtl-C to stop the program.")
while True:
    try:
        red.on()
        sleep(sleep_speed)
        red.off()
        sleep(sleep_speed)
    except KeyboardInterrupt:
        print("Stopping program.\n")
        red.close()
        exit()
コード例 #23
0
ファイル: smart.py プロジェクト: YasinEnigma/SmartHome
def smart(bot):
    global led1
    global led2
    global led3
    global update_id
    back = 20

    # led status
    if led1.closed:
        led1 = LED(12)

    if led2.closed:
        led2 = LED(21)

    if led3.closed:
        led3 = LED(16)

    for update in bot.get_updates(offset=update_id, timeout=10):
        update_id = update.update_id + 1
        action_list = [["روشن", "بازگشت"], [""]]
        sleep(1)
        update.message.reply_text(
            "لطفا یکی از گزینه‌های زیر را انتخاب نمائید : ",
            reply_markup=telegram.ReplyKeyboardMarkup(action_list,
                                                      one_time_keyboard=True))
        led1.off()
        led2.off()
        led3.off()

        if update.message:
            if update.message.text == "روشن":
                while back:

                    lightLevel = readLight()
                    update.message.reply_text(
                        "شدت نور برابر است با : {}".format(lightLevel))
                    if 100 < lightLevel < 150:
                        led1.on()
                        led2.off()
                        led3.off()
                        update.message.reply_text("چراغ یک روشن")
                    elif 50 < lightLevel < 100:
                        led1.on()
                        led2.on()
                        led3.off()
                        update.message.reply_text("چراغ یک و دو روشن")
                    elif lightLevel < 50:
                        led1.on()
                        led2.on()
                        led3.on()
                        update.message.reply_text("همه چراغ‌ها روشن شوند")
                    else:
                        led1.off()
                        led2.off()
                        led3.off()
                        update.message.reply_text(
                            "نیازی به چراغ روشن وجود ندارد.")

                    sleep(2.5)
                    back -= True
                    if not back:
                        update.message.reply_text("تست به پایان رسید!")
            elif update.message.text == "بازگشت":
                import run

                led1.close()
                led2.close()
                led3.close()

                run.main()
                sleep(1)
コード例 #24
0
def greenLED():
    greenled = LED(24)
    greenled.on()
    sleep(1)
    greenled.off()
    greenled.close()
コード例 #25
0
ファイル: garage_door.py プロジェクト: Romanmc72/RPiGPIO
import argparse
from logs import get_logger

from gpiozero import LED

if __name__ == "__main__":
    logger = get_logger()
    logger.info("Beginning garage door app.")
    parser = argparse.ArgumentParser("Open/close the garage door.")
    parser.add_argument('--pin',
                        default=os.getenv('GARAGE_DOOR_PIN', 14),
                        required=False,
                        type=int,
                        help="The GPIO pin for the garage door on the Pi.")
    args = parser.parse_args()
    logger.info(
        "Connecting garage door opener to pin ({pin})".format(pin=args.pin))
    try:
        garage_door = LED(args.pin)
        logger.info("Triggering garage door.")
        garage_door.toggle()
        sleep(0.5)
        garage_door.toggle()
        logger.info("Garage door has changed its state.")
    finally:
        # This closes the pin connection to the program so that the pin can be
        # readily used again by the next caller even if the above fails for
        # whatever reason.
        garage_door.close()
    logger.info("Ending garage door app.")
コード例 #26
0
ファイル: LogTemp.py プロジェクト: fdelia/raspberry-backup
# print sensor data for log
try:
  sensor = BME280(mode=BME280_OSAMPLE_8)

  degrees = sensor.read_temperature()
  pascals = sensor.read_pressure()
  hectopascals = pascals / 100
  humidity = sensor.read_humidity()

  print strftime("%Y.%m.%d %H:%M:%S") + '  {0:0.3f} , {1:0.3f} deg C , {2:0.2f} hPa , {3:0.2f} %'.format(sensor.t_fine, degrees, hectopascals, humidity)

#print 'Timestamp = {0:0.3f}'.format(sensor.t_fine)
#print 'Temp      = {0:0.3f} deg C'.format(degrees)
#print 'Pressure  = {0:0.2f} hPa'.format(hectopascals)
#print 'Humidity  = {0:0.2f} %'.format(humidity)
#print ' '
	
except (RuntimeError, TypeError, NameError):
  counter = 0
  while counter < 50:
    led.on()
    sleep(0.3)
    led.off()
    sleep(0.3)
    counter += 1



led.close()
#led2.close()
コード例 #27
0
        print('led3 on')
    elif event == 'led4':
        led4.on()
        print('led4 on')
    elif event == 'led5':
        led5.on()
        print('led5 on')
    elif event == 'led6':
        led6.on()
        print('led6 on')
    elif event == 'led7':
        led7.on()
        print('led7 on')
    elif event == 'led8':
        print('led8 on')
        led8.on()

    elif event is None:
        break

led1.close()
led2.close()
led3.close()
led4.close()
led5.close()
led6.close()
led7.close()
led8.close()
window.Close()
print('done')
コード例 #28
0
#!/usr/bin/env python3
from gpiozero import Button
from gpiozero import LED
from time import sleep

btn = Button(22)
btn2 = Button(24)
led = LED(16)

print("""
From left-to-right,
press button 1 for led 4,
button 2 to exit.
""")

while True:
  if btn.is_pressed:
    led.on()
    sleep(0.1)
    led.off()
  elif btn2.is_pressed:
    btn.close()
    led.close()
    print("done")
    exit(0)
コード例 #29
0
# blink_gpiozero.py
# BlinkPython
#
# Description:
# Python program to blink an LED on a Raspberry Pi with the GPIO Zero library.
#
# Created by John Woolsey on 06/07/2018.
# Copyright c 2018 Woolsey Workshop.  All rights reserved.

# Imports
from gpiozero import LED
from time import sleep

# Pin Definitions
redLED = LED(21)  # BCM pin 21, physical pin 40

# Blink LED
print "Press CTRL-C to exit."
try:
    while True:  # runs forever
        redLED.on()  # turn on LED
        sleep(0.5)  # wait half a second
        redLED.off()  # turn off LED
        sleep(0.5)  # wait half a second

# Cleanup
finally:  # exit cleanly when CTRL+C is pressed
    redLED.close()  # release redLED resource
    print "\nCompleted cleanup of GPIO resources."
コード例 #30
0
ファイル: 2LogTemp.py プロジェクト: fdelia/raspberry-backup
# print sensor data for log
try:
  sensor = BME280(mode=BME280_OSAMPLE_8)

  degrees = sensor.read_temperature()
  pascals = sensor.read_pressure()
  hectopascals = pascals / 100
  humidity = sensor.read_humidity()

  print strftime("%Y.%m.%d %H:%M:%S") + '  {0:0.3f} , {1:0.3f} deg C , {2:0.2f} hPa , {3:0.2f} %'.format(sensor.t_fine, degrees, hectopascals, humidity)

#print 'Timestamp = {0:0.3f}'.format(sensor.t_fine)
#print 'Temp      = {0:0.3f} deg C'.format(degrees)
#print 'Pressure  = {0:0.2f} hPa'.format(hectopascals)
#print 'Humidity  = {0:0.2f} %'.format(humidity)
#print ' '
	
except:
  counter = 0
  while counter < 50:
    led.on()
    sleep(0.3)
    led.off()
    sleep(0.3)
    counter += 1



led.close()
led2.close()
コード例 #31
0
class Zoltar(object):
    def __init__(self, comm_client):
        print('Finally, a Zoltar!')
        self.is_moving = False
        self.left_eye = LED(LED1_GPIO)
        self.right_eye = LED(LED2_GPIO)
        self.button = Button(BUTTON_GPIO)
        self.button.when_pressed = self.stop_moving
        self.communications = comm_client

    def begin_moving(self):
        self.left_eye.on()
        self.right_eye.on()
        self.servo = AngularServo(SERVO_GPIO,
                                  min_angle=SERVO_MIN_ANGLE,
                                  max_angle=SERVO_MAX_ANGLE,
                                  initial_angle=SERVO_INITIAL_ANGLE)
        while self.is_moving:
            if self.communications.available():
                (origin, message) = self.communications.recv()
                if message == 'COIN':
                    break
            for x in reversed(range(0, 179)):
                self.servo.angle = x
                sleep(0.01)
            for x in range(0, 179):
                self.servo.angle = x
                if self.servo.angle == 0:
                    sleep(0.5)
                else:
                    sleep(0.01)
        self.finale()

    def eyes_off(self):
        self.right_eye.off()
        self.left_eye.off()

    def eyes_on(self):
        self.left_eye.on()
        self.right_eye.on()

    def finale(self):
        self.flashing_eyes()
        self.print_fortune()
        self.cleanup_gpio()

    def print_fortune(self):
        zoltar_dir = os.getenv('ZOLTAR_DIR')
        subprocess.Popen(['python', 'zoltar_print_fortune.py'], cwd=zoltar_dir)

    def flashing_eyes(self):
        self.eyes_off()
        sleep(1)
        self.eyes_on()
        sleep(1)
        self.eyes_off()
        sleep(1)
        self.eyes_on()
        sleep(1)
        self.eyes_off()

    def stop_moving(self):
        print('Button detected')
        self.is_moving = False

    def cleanup_gpio(self):
        self.left_eye.close()
        self.right_eye.close()
        self.servo.close()
        self.button.close()
コード例 #32
0
ファイル: password.py プロジェクト: joshualeejunyi/IOTCA1
            lcd.text('Passcode', 1)
            lcd.text('Correct!', 2)
            buzz.on()
            greenled.on()
            sleep(2)
            greenled.off()
            buzz.off()
            lcd.text('Initializing', 1)
            lcd.text('Face Scan...', 2)
            break
        else:
            lcd.text('Passcode', 1)
            lcd.text('Incorrect!', 2)
            buzz.on()
            redled.on()
            sleep(2)
            redled.off()
            buzz.off()
            userpass = []
    elif len(userpass) > len(password):
        lcd.clear()
        lcd.text('Please Try Again', 1)
        sleep(1)
        userpass = []

redled.close()
greenled.close()
buzz.close()
btn1.close()
btn2.close()
import faceunlock
コード例 #33
0
#!/usr/bin/env python

# requires to install python3-gpiozero
# flashes A few leds

print("Loading gpiozero..")

from gpiozero import LED
from time import sleep

led1 = LED(4)
led2 = LED(18)

x = 1
print("Flashing two leds like an alarm..")
while (x < 5):
    print(x, "/ 4", "flashing..")
    led1.on()
    sleep(0.5)
    led1.off()

    led2.on()
    sleep(0.5)
    led2.off()
    x = x + 1

print("Exiting..")
led1.close()
led2.close()
exit()