示例#1
0
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
示例#2
0
from gpiozero import LED
from gpiozero.pins.pigpio import PiGPIOFactory
from signal import pause

factory = PiGPIOFactory(host='raspberrypi.local')
led = LED(17, pin_factory=factory)

led.blink()

pause()
示例#3
0
class StatefulHWButton(StatefulButton):
    """Cycling mode button with an LED and button

    Args:
        StatefulHWButton ([type]): [description]
    """

    def __init__(self, path, states, led_pin=None, button_pin=None, fallback=None):
        super().__init__(path, states, fallback)
        self.button = None
        self.led = None
        self.lit_for = None
        self.last_pressed = dt.min
        self.button = None
        self.led = None
        try:
            # only works on raspi
            if button_pin:
                self.button = Button(button_pin)
                self.button.when_pressed = self.push
            if led_pin:
                self.led = LED(led_pin)

        except Exception as e:
            LOGGER.warning(f"Exception but continuing:{e}")
            LOGGER.debug(f"Exception but continuing:{e}", exc_info=True)

    def __str__(self):
        return f"StatefulHWButton: {vars(self)}"

    def __repr__(self):
        return f"StatefulHWButton: {vars(self)}"

    def illuminate(self):
        """ Don't change, just illuminate """
        self.last_pressed = dt.now()
        self.set_LED()

    def push(self):
        """
        Resets the dormancy counter.
        """
        #LOGGER.debug("button pushed!")

        moment = dt.now()

        if self.lit_for is None or moment < self.last_pressed + self.lit_for:
            # active: change state
            next(self)
        self.set_LED()
        self.last_pressed = dt.now()

    def set_LED(self):
        if not self.led:
            return
        current = self.value
        try:
            led_on_time = current.on_time
            led_off_time = current.off_time
            one_n = led_on_time + led_off_time
            # LOGGER.debug(f"set_LED; {vars(self)}")
            if self.lit_for is None:
                self.led.blink(on_time=led_on_time, off_time=led_off_time)
            else:
                led_n = int(self.lit_for.total_seconds() / one_n)
                self.led.blink(on_time=led_on_time, off_time=led_off_time, n=led_n)
        except KeyError as exc:
            raise ButtonError("check set_LED") from exc

    def configd(self, config_dict):
        if 'button' in config_dict:
            c = config_dict['button']
        else:
            c = config_dict
        LOGGER.debug(f"button config: {c}")
        self.path = Path(c['file'])
        self.button = Button(c['button'])
        self.button.when_pressed = self.push
        self.led = LED['led']
        LOGGER.debug(f"button configd: {self.path}, button: {self.button}, led: {self.led}")
        # self.value() # update from new file
        self.set_LED()
示例#4
0
file = open("/home/pi/retropicam/auths/ACCESS_KEY.txt","r")
ACCESS_KEY = file.read()
file = open("/home/pi/retropicam/auths/ACCESS_SECRET.txt","r")
ACCESS_SECRET = file.read()
api = Twython(CONSUMER_KEY,CONSUMER_SECRET,ACCESS_KEY,ACCESS_SECRET)

#setup ins and outs
btn = Button(23)
led = LED(17)
bz = Buzzer(2)

#Setect button
while True:
    if btn.is_pressed:
        #User feedback
        led.blink(0.05,0.05)
        bz.beep(on_time=0.1,off_time=0.1)
        print("Button pressed, taking photos...")
       
        #Take photos
        filename = "/home/pi/retropicam/photos/photo"
        
        #Take gif photos
        for num in range (length):
          date = time.strftime("%d-%m-%Y-%H-%M%S")
          takephoto = "fswebcam -r "+resolution+" --no-banner"+" "+filename+"-"+date+".jpg"
          os.system(takephoto)
     	#User feedback
        print("Photos Taken")
        led.off()
        bz.off()
示例#5
0
        if x == 10: break
        print "Checking pin no.", x, ": GPIO", lvlPinNoArray[x]
        lvlPin = Button(lvlPinNoArray[x], pull_up=False)
        if lvlPin.is_pressed:
            break
    result = (10.0 - x) / 10.0
    print "Detected tank level is ", result * 100, "%"
    seedVoltage.off()
    return result


print "Starting..."

pump = LED(pumpPinNo)
statusLed = LED(statusLedPin)

while True:
    level = readTankLevel()
    print "Level =", level * 100, "%"
    # TODO: Store level in Log

    # Check level and turn off pump if necessary
    if level * 100 < threshold:
        pump.off()
    else:
        pump.on()

    statusLed.blink()
    sleep(sleep_time)

print "Done."
示例#6
0
    while seeking == True:
        # Get players position
        playerPos = mc.player.getPos()
        # Has the player moved
        if lastPlayerPos != playerPos:
            distanceFromBlock = distanceBetweenPoints(randomBlockPos, playerPos)

            if distanceFromBlock < 2:
                # found it!
                seeking = False
            else:
                if distanceFromBlock < 5 and position != 4:
                    led.on()
                    position = 4
                if 4 < distanceFromBlock < 11 and position != 3:
                    led.blink(0.3, 0.3)
                    position = 3
                if 10 < distanceFromBlock < 26 and position != 2:
                    led.blink(0.6, 0.5)
                    position = 2
                if 25 < distanceFromBlock < 41 and position != 1:
                    led.blink(1, 0.5)
                    position = 1
                if distanceFromBlock > 40 and distanceFromBlock < lastDistanceFromBlock:
                    led.blink()
                if distanceFromBlock > 40 and distanceFromBlock > lastDistanceFromBlock:
                    led.off()

            lastDistanceFromBlock = distanceFromBlock

        sleep(2)
示例#7
0
import sys
import piglow
#initialize led indicator
red = LED(16)
red.off()
piglow.all(0)
piglow.show()
#function to gradually change the volume
def rampvol(speed = 0.25, start = 0, stop = 100, step = 1):
	vol = start
	while vol != stop:
		vol = vol + step
		system("amixer -q sset PCM,0 " + str(vol) + "%")
		sleep(speed)
#blink all the indicators
red.blink(0.25,0.25,5,1)
red.off()
i = 0
while i <= 5:
	piglow.red(1)
	piglow.show()
	i += 1
	sleep(0.5)
	piglow.red(0)
	piglow.show()
	sleep(0.5)
day = int(time.strftime("%j")) #get the day of the year [0,366]
playlist = ( int(day) + offset ) % 2
if playlist == 0:
	if day > 330: #kiss me baby, it's christmas time
		maxvol = 80
from gpiozero import LED

led = LED(18)

led.blink(0.5, 0.5, background=True)

print("here")
input()
print("there")
led.off()
input()
示例#9
0
photoButton.when_held = snapShot

#GPIO button assignment for send location
locationButton = Button(26, hold_time=0.5)
locationButton.when_held = sendLocation

#Sensehat joystick assignments
sense.stick.direction_up = powerOff
sense.stick.direction_down = powerOff
sense.stick.direction_left = powerOff
sense.stick.direction_right = powerOff

#Main function, will run until colission detected or user powers off device
while True:
    sense.clear()
    greenLed.blink()
    sense.show_message("ON", text_colour=green)
    time.sleep(2)
    sense.clear()
    #Counter variable controls
    while counter < 21:
        curTime = time.gmtime()
        curMin = curTime.tm_min
        curSec = curTime.tm_sec
        #print("Cursec",curSec)
        #Resets video number to zero if video count >2
        # Only video 0,1,2 are maintained on the device
        if vidNum > 2:
            vidNum = 0
            print("Reset vidNum")
        #If the device is recorsing and the current secont modulo 20 = 0
示例#10
0
class MP2_A2:
    def __init__(self):
        # Preparing
        self.audiodir = path.expanduser('~/Git/MP2_A2_audiofiles/AudioFiles')
        self.fire = Fire("Arduino")
        self.first_button = Button(pin_fig.first_button)
        self.second_button = Button(pin_fig.second_button)
        self.main_status_led = LED(pin_fig.status_led_2)
        self.recovery_staus_led = LED(pin_fig.status_led_1)

        self.get_option()

    def get_option(self):
        argparser = ArgumentParser()
        argparser.add_argument('-t', '--finishtime', action='store_true',
                               help='Measure finish time')
                                # default is False
        argparser.add_argument('-e', '--waitforenter', action='store_true',
                               help=('Wait for ENTER key '
                                     'instead of button press'))
                                # default is False
        argparser.add_argument('-nl', '--no-loop', action='store_true',
                               help='Loop this script')
                                # default is False
        self.option = argparser.parse_args()

    def move_robot(self):
        # Preparing
        self.fc = FireAndConveyor(audiofiles_dir=self.audiodir)
        self.ee = ExplodeAndEscape(audiofiles_dir=self.audiodir)
        # Move Robot
        self.main_status_led.on()

        if self.option.waitforenter:
            input("Waiting for ENTER key instead of BUTTON1 (first section): ")
        else:
            print("Waiting for BUTTON1 press (first section)")
            self.first_button.wait_for_press()

        print("move_robot start")
        self.main_status_led.blink(on_time=1, off_time=2)
        init_time = time()
        self.fire.on()
        self.fc.main(init_time)

        self.main_status_led.blink(on_time=0.5, off_time=0.5)
        if self.option.waitforenter:
            input("Waiting for ENTER key instead of BUTTON2 (second section): ")
        else:
            print("Waiting for BUTTON2 press (second section)")
            self.second_button.wait_for_press()

        self.main_status_led.blink(on_time=1, off_time=2)
        self.ee.main(init_time)
        sleep(1)
        self.fire.off()
        print("move_robot end")

        if self.option.finishtime:
            input("Press ENTER key to measure finish time: ")
            print("{:.3f} sec: ".format(time() - init_time), end="")
        self.main_status_led.off()

    def recovery_robot(self):
        # Preparing
        self.recovery = Recovery()
        # Recovery Robot
        sleep_time = 0.1

        self.recovery_staus_led.on()
        print("Waiting for BUTTON1 press (recovery section)")
        self.first_button.wait_for_press()
        press_button_time = 0
        while self.first_button.is_pressed:
            press_button_time += 1
            if press_button_time >= 2.0 / sleep_time:
                self.recovery_staus_led.off()
            sleep(sleep_time)
        if press_button_time < 2 / sleep_time:
            print("recovery_robot start")
            self.recovery_staus_led.blink(on_time=1, off_time=2)
            self.recovery.main()
            print("recovery_robot end")
            self.recovery_staus_led.off()
        else:
            print("recovery was skipped")

    def main(self):
        self.move_robot()
        self.recovery_robot()
        # Start main() again for loop
        if not self.option.no_loop:
            self.main()
示例#11
0
class FootController(object):
    def __init__(self):
        self.power_led = LED(6)
        self.green_led = LED(17)
        self.blue_led = LED(27)
        self.yellow_led = LED(22)
        self.red_led = LED(24)
        self.white_led = LED(25)

        self.moller = {
            'led': self.green_led,
            # value 100 is off
            'value': 100,
            'sig': 0x52,
        }

        self.ts = {
            'led': self.blue_led,
            # value 100 is off
            'value': 100,
            'sig': 0x50,
        }

        self.delay = {
            'led': self.yellow_led,
            # value 100 is off
            'value': 100,
            'sig': 0x51,
        }

        self.mute = {
            # value 100 is off
            'value': 100,
            'sig': 0x54,
        }

        self.bunk = {
            'value': 0,
        }

        self.amp = {
            'value': 'jcm900',
            'jcm900': {
                'led': self.red_led,
                'sig': 0x00
            },
            'twin reverb': {
                'led': self.white_led,
                'sig': 0x01
            }
        }
        self.amp['jcm900']['led'].on()

        self.right_button = Button(13)
        self.right_button.when_pressed = self.right_button_push
        self.center_button = Button(19)
        self.center_button.when_pressed = self.center_button_push
        self.left_button = Button(26)
        self.left_button.when_pressed = self.left_button_push

        self.other_button = Button(23)
        self.other_button.when_pressed = self.mute_change

        self.power_led.on()

    def ts_change(self, on_off=''):
        if on_off == '' and self.ts['value'] == 100:
            self.ts['led'].on()
            self.ts['value'] = 0
            print('TS ON')
        elif on_off == '' and self.ts['value'] == 0:
            self.ts['led'].off()
            self.ts['value'] = 100
            print('TS OFF')
        elif on_off == 'on':
            self.ts['led'].on()
            self.ts['value'] = 0
            print('TS ON')
        else:
            self.ts['led'].off()
            self.ts['value'] = 100
            print('TS OFF')
        controller_change = [
            CONTROLLER_CHANGE, self.ts['sig'], self.ts['value']
        ]
        midiout.send_message(controller_change)

    def delay_change(self, on_off=''):
        if on_off == '' and self.delay['value'] == 100:
            self.delay['led'].on()
            self.delay['value'] = 0
            print('Delay ON')
        elif on_off == '' and self.delay['value'] == 0:
            self.delay['led'].off()
            self.delay['value'] = 100
            print('Delay OFF')
        elif on_off == 'on':
            self.delay['led'].on()
            self.delay['value'] = 0
            print('Delay ON')
        else:
            self.delay['led'].off()
            self.delay['value'] = 100
            print('Delay OFF')
        controller_change = [
            CONTROLLER_CHANGE, self.delay['sig'], self.delay['value']
        ]
        midiout.send_message(controller_change)

    def moller_change(self, on_off=''):
        if on_off != 'off' and self.moller['value'] == 100:
            self.moller['led'].on()
            self.moller['value'] = 0
            print('Moller ON')
        else:
            self.moller['led'].off()
            self.moller['value'] = 100
            print('Moller OFF')
        controller_change = [
            CONTROLLER_CHANGE, self.moller['sig'], self.moller['value']
        ]
        midiout.send_message(controller_change)

    def mute_change(self):
        if self.mute['value'] == 100:
            self.mute['value'] = 0
            self.red_led.blink()
            self.moller_change('off')
            self.ts_change('off')
            self.delay_change('off')
            print('Mute ON')
            self.bunk_status()
        else:
            self.mute['value'] = 100
            print('Mute OFF')
            if self.bunk['value'] in [0, 1]:
                self.moller_change('off')
                self.ts_change('off')
                self.delay_change('off')
                # jcm900 ON
                self.red_led.on()
                if self.amp['value'] != 'jcm900':
                    self.amp['value'] = 'jcm900'
                    controller_change = [
                        CONTROLLER_CHANGE, self.amp['jcm900']['sig'], 100
                    ]
                    midiout.send_message(controller_change)

        controller_change = [
            CONTROLLER_CHANGE, self.mute['sig'], self.mute['value']
        ]
        midiout.send_message(controller_change)

    def right_button_push(self):
        if self.mute['value'] == 0:
            return
        if self.bunk['value'] == 0:
            self.moller_change()
        elif self.bunk['value'] == 1:
            self.ts_change('off')
            self.delay_change('off')

    def center_button_push(self):
        if self.mute['value'] == 0:
            self.decrement_bunk()
            return
        if self.bunk['value'] == 0:
            self.ts_change()
        elif self.bunk['value'] == 1:
            self.ts_change('on')
            self.delay_change('off')

    def left_button_push(self):
        if self.mute['value'] == 0:
            self.increment_bunk()
            return
        if self.bunk['value'] == 0:
            self.delay_change()
        elif self.bunk['value'] == 1:
            self.ts_change('on')
            self.delay_change('on')

    def increment_bunk(self):
        if self.bunk['value'] == 7:
            self.bunk['value'] = 0
        else:
            self.bunk['value'] += 1
        print('Bunk Change: Number {}'.format(self.bunk['value']))
        self.bunk_status()

    def decrement_bunk(self):
        if self.bunk['value'] == 0:
            self.bunk['value'] = 7
        else:
            self.bunk['value'] -= 1
        print('Bunk Change: Number {}'.format(self.bunk['value']))
        self.bunk_status()

    def bunk_status(self):
        if self.bunk['value'] == 0:
            self.green_led.off()
            self.blue_led.off()
            self.yellow_led.off()
        elif self.bunk['value'] == 1:
            self.green_led.on()
            self.blue_led.off()
            self.yellow_led.off()
        elif self.bunk['value'] == 2:
            self.green_led.off()
            self.blue_led.on()
            self.yellow_led.off()
        elif self.bunk['value'] == 3:
            self.green_led.on()
            self.blue_led.on()
            self.yellow_led.off()
        elif self.bunk['value'] == 4:
            self.green_led.off()
            self.blue_led.off()
            self.yellow_led.on()
        elif self.bunk['value'] == 5:
            self.green_led.on()
            self.blue_led.off()
            self.yellow_led.on()
        elif self.bunk['value'] == 6:
            self.green_led.off()
            self.blue_led.on()
            self.yellow_led.on()
        elif self.bunk['value'] == 7:
            self.green_led.on()
            self.blue_led.on()
            self.yellow_led.on()
示例#12
0
from gpiozero import LED, LightSensor, Button, DistanceSensor, PWMOutputDevice, AngularServo
from signal import pause
from gpiozero import PWMLED
import Adafruit_DHT
import RPi.GPIO as GPIO
from time import sleep
import random

blue = LED(6)
blue.blink()
pause()
示例#13
0
from gpiozero import LED
import time
import random
​
nose = LED(25)
left = LED(23)
right = LED(24)
leds = [LED(7), LED(8), LED(9), LED(22), LED(18), LED(17)]
​
left.off()
right.off()
time.sleep(1)
nose.blink()
left.on()
right.on()
​
def sparkle():
    for i in range(25):
        result = random.choice(leds)
        result.on()
        time.sleep(0.2)
        result.off()
​
while True:
    sparkle()        
    time.sleep(0.2)
示例#14
0
from gpiozero import LED
import time

# GPIO 24 ... LED ... 470 ohm resistor ... GND

led = LED(24)
try:
    led.blink()
    time.sleep(20)
except KeyboardInterrupt:
    led.off()
print "done"
        modra.on() # Zhasni zelenou LED a rozsvit vyckavaci modrou LED

# Zacatek hlavniho proudu programu
if __name__ == "__main__":

    cervena = LED(22) # Cervena LED na pinu 22
    zelena  = LED(23) # Zelena LED na pinu 23
    modra   = LED(27) # Modra LED na pinu 27

    smycka = True

    # Pokud dorazi signal preruseni/ukonceni programu, zpracuj funkci uklid_pri_vypnuti
    signal.signal(signal.SIGINT, uklid_pri_vypnuti)
    signal.signal(signal.SIGTERM, uklid_pri_vypnuti)

    modra.blink(.1, .1, None, True) # Rozblikej modrou LED v separatnim vlakne

    # Cekej, dokud neoverim, ze jsem pripojeny k Wi-Fi (dostal jsem od DHCP serveru IP adresu)
    ip = None
    while ip is None:
        ip = ziskej_ip("wlan0")
        if ip == None:
            print("Cekam na Wi-Fi...")
            time.sleep(1)
        else:
            print("Jsem pripojeny k Wi-Fi a mam IP adresu")

    modra.on() # Ukonci blikani a rozsvit vyckavaci modrou LED

    zarizeni = "/sys/bus/w1/devices/" # Adresar pripojenych 1-Wire zarizeni
    soubor = open("/boot/teplomer_konfigurace.txt") # Precti konfguraci programu jako JSON
示例#16
0
class treeWater:
        def __init__(self):
                self.GPIO_led_R1 = 14
                self.GPIO_led_Y1 = 15
                self.GPIO_led_G1 = 4
                self.GPIO_led_B1 = 17
                self.GPIO_btn_B1 = 18
                self.MTR_pump1 = 1
                
                self.GPIO_wtr_tgd = 21
                self.GPIO_wtr_t01 = 20
                self.GPIO_wtr_t02 = 19
                self.GPIO_wtr_t03 = 16
                self.GPIO_wtr_t04 = 13
                self.GPIO_wtr_t05 = 12
                self.GPIO_wtr_t06 = 6
                self.GPIO_wtr_t07 = 5
                self.GPIO_wtr_t08 = 7
                self.GPIO_wtr_t09 = 8
                self.GPIO_wtr_t10 = 11
                self.GPIO_wtr_t11 = 9
                self.GPIO_wtr_t12 = 10
                self.GPIO_wtr_t13 = 25
                
                self.GPIO_wtr_pgd = 22
                self.GPIO_wtr_p01 = 23
                
                # Setup the water level indicator
#                self.wtrLevel = LEDBarGraph(self.GPIO_led_R1, self.GPIO_led_Y1, self.GPIO_led_G1, pwm=True)
                
                # Setup the Pump Water Level Sensor
                # _pumpWtrLevelGnd should remain ON the entire time
                self._pumpWtrLevelGnd = DigitalOutputDevice(self.GPIO_wtr_pgd, True, True)
                self.pumpWtrLevel = DigitalInputDevice(self.GPIO_wtr_p01)
                
                # Setup the tree water level indicator
                # _treeWtrLevelGnd should remain ON the entire time
                self._treeWtrLevelGnd = DigitalOutputDevice(self.GPIO_wtr_tgd, True, True)

                self.treeWtrLevel01 = DigitalInputDevice(self.GPIO_wtr_t01)
                self.treeWtrLevel02 = DigitalInputDevice(self.GPIO_wtr_t02)
                self.treeWtrLevel03 = DigitalInputDevice(self.GPIO_wtr_t03)
                self.treeWtrLevel04 = DigitalInputDevice(self.GPIO_wtr_t04)
                self.treeWtrLevel05 = DigitalInputDevice(self.GPIO_wtr_t05)
                self.treeWtrLevel06 = DigitalInputDevice(self.GPIO_wtr_t06)
                self.treeWtrLevel07 = DigitalInputDevice(self.GPIO_wtr_t07)
                self.treeWtrLevel08 = DigitalInputDevice(self.GPIO_wtr_t08)
                self.treeWtrLevel09 = DigitalInputDevice(self.GPIO_wtr_t09)
                self.treeWtrLevel10 = DigitalInputDevice(self.GPIO_wtr_t10)
                self.treeWtrLevel11 = DigitalInputDevice(self.GPIO_wtr_t11)
                self.treeWtrLevel12 = DigitalInputDevice(self.GPIO_wtr_t12)
                self.treeWtrLevel13 = DigitalInputDevice(self.GPIO_wtr_t13)
                
                # Setup the pump status indicator and manual override button
                self.pumpStsLED = LED(self.GPIO_led_B1)
                self.pumpBtn = Button(self.GPIO_btn_B1, True)
                
                # create a default object, no changes to I2C address or frequency
                self.mtrHat = Adafruit_MotorHAT(addr=0x60)
                
                self.pump = self.mtrHat.getMotor(self.MTR_pump1)
                
                # We should always run at max speed
                self.pump.setSpeed(255)
                
                self.pumpSts = False

        # recommended for auto-disabling motors on shutdown!
        def Shutdown(self):
	        self.mtrHat.getMotor(1).run(Adafruit_MotorHAT.RELEASE)
	        self.mtrHat.getMotor(2).run(Adafruit_MotorHAT.RELEASE)
	        self.mtrHat.getMotor(3).run(Adafruit_MotorHAT.RELEASE)
	        self.mtrHat.getMotor(4).run(Adafruit_MotorHAT.RELEASE)

        def pumpRun(self):
                if self.pumpSts == False:
                        # Pump is off; Turn it on
                        self.log("Turning Pump On","INFO")
                        self.pump.run(Adafruit_MotorHAT.FORWARD)
                        self.pumpSts = True
                        self.pumpStsLED.on()
                #else:
                        # Pump is already running; Do nothing

        def pumpStop(self):
                if self.pumpSts == True:
                        # Pump is on; Turn it off
                        self.log("Turning Pump Off","INFO")
                        self.pump.run(Adafruit_MotorHAT.RELEASE)
                        self.pumpSts = False
                        self.pumpStsLED.off()
                #else:
                        # Pump is already off; Do nothing

        def log(self, msg, level = "INFO"):
                # Probably prefix MSG with timestamp?
                # Add logging facilities later
                ts = time.gmtime()
                ts = time.strftime("%Y-%m-%d %H:%M:%S", ts)
                print(ts," - ",level,": ",msg)

        def manualRun(self):
                self.log("Manual override process running...")
                while True:
                        if self.pumpBtn.value:
                                self.pumpRun()
                        else:
                                self.pumpStop()
                        # Cool this down a little
                        sleep(0.5)

        def autoFill(self):
                self.log("Automatic filler process running...")
                while True:
                        if self.WtrLevel.value <= 0.5 and self.pumpWtrLevel.value:
                                self.pumpRun()
                        else:
                                self.pumpStop()
                        # Cool this down a little
                        sleep(0.5)
                        
        def monitorWtrPump(self):
                self.log("Pump water level checker running...")
                lastState = not self.pumpWtrLevel.value
                stateCheck = True
                while True:
                        state = self.pumpWtrLevel.value
                        if lastState != state:
                                lastState = state
                                if state:
                                        self.log("Pump water present","INFO")
                                        if self.pumpSts:
                                                self.pumpStsLED.on()
                                        else:
                                                self.pumpStsLED.off()
                                else:
                                        self.log("Low pump water level","WARNING")
                                        self.pumpStsLED.blink(0.5,0.5,None,True)
                        # Cool this down a little
                        sleep(0.5)

        def monitorTreeWtr(self):
                self.log("Tree water level monitor running...")
                self.wtrLevel = LEDBarGraph(self.GPIO_led_R1, self.GPIO_led_Y1, self.GPIO_led_G1, pwm=True)
                level = 0
                lastLevel = -1

                while True:
                        # This is terrible, horrible, very bad code!
                        if self.treeWtrLevel13.value:
                                level = 13
                        elif self.treeWtrLevel12.value:
                                level = 12
                        elif self.treeWtrLevel11.value:
                                level = 11
                        elif self.treeWtrLevel10.value:
                                level = 10
                        elif self.treeWtrLevel09.value:
                                level = 9
                        elif self.treeWtrLevel08.value:
                                level = 8
                        elif self.treeWtrLevel07.value:
                                level = 7
                        elif self.treeWtrLevel06.value:
                                level = 6
                        elif self.treeWtrLevel05.value:
                                level = 5
                        elif self.treeWtrLevel04.value:
                                level = 4
                        elif self.treeWtrLevel03.value:
                                level = 3
                        elif self.treeWtrLevel02.value:
                                level = 2
                        elif self.treeWtrLevel01.value:
                                level = 1
                        else:
                                level = 0

                        if lastLevel != level:
                                self.log("Tree water level now at level " + str(level), "INFO")
                                lastLevel = level

                        level = level / 13
                        self.wtrLevel.value = level
                        sleep(1)
示例#17
0
def main():
    now = datetime.now()
    my_path = os.path.abspath(os.path.dirname(__file__))
    log_file_path_abs = os.path.join(
        my_path, "{}/{}_{}.log".format(log_file_path, log_file_name,
                                       now.strftime("%Y-%m-%d_%H-%M-%S")))
    csv_file_path_abs = os.path.join(
        my_path, "{}/{}_{}.csv".format(log_file_path, csv_file_name,
                                       now.strftime("%Y-%m-%d_%H-%M-%S")))
    print_and_log("Starting...", log_file_path_abs)

    csv_file = open(csv_file_path_abs, "w+")
    csv_file.write("Time;Level;Pump\n")
    csv_file.close()

    pump = LED(PUMP_PIN_NO, active_high=False)
    #pump_off(pump, log_file)
    status_led = LED(STATUS_LED_PIN_NO)

    # CFG stuff - TODO: quick and dirty for testing, needs to be replaced
    cfg_file_threshold_path_abs = os.path.join(my_path, "threshold.cfg")

    # TODO: Read Thingspeak URL and Key from config file

    # Main Loop
    while True:
        try:
            level = read_tank_level(log_file_path_abs)

            threshold = read_threshold_from_file(cfg_file_threshold_path_abs,
                                                 log_file_path_abs)
            print_and_log("Using threshold value of: {}".format(threshold),
                          log_file_path_abs)

            # Turn off pump if necessary
            pumpState = 0
            if level * 100 < threshold:
                #pump_off(pump, log_file)
                pump.off()
                pumpState = 0
            else:
                #pump_on(pump, log_file)
                pump.on()
                pumpState = 1

            print_and_log(
                "Current state: Level: {}% | Pump: {}".format(
                    level * 100, pump_state_textual(pumpState)),
                log_file_path_abs)

            csv_file = open(csv_file_path_abs, "a")
            csv_file.write("{};{};{}\n".format(
                get_timestamp(), level, pumpState))  # TODO: Store level in Log
            csv_file.close()

            print_and_log("Sending data to Thingspeak...", log_file_path_abs)
            send_data_to_thingspeak(THINGSPEAKURL, THINGSPEAKKEY, level,
                                    pumpState, log_file_path_abs)
            sys.stdout.flush()

            status_led.blink(
            )  # Heartbeat TODO: check if this works as intended
            sleep(sleep_time)  # Wait
        # except IOError as e:
        #     print_and_log("File write error occurred: {}".format(e), log_file)
        except Exception as err:
            print_and_log("Error occurred! Exiting...", log_file_path_abs)
            raise err

    # Terminate Program
    print_and_log("Terminating...", log_file_path_abs)

    try:
        csv_file.close()
        log_file.close()
    except:
        print("Unable to close file stream.")
    finally:
        print("Done.")
示例#18
0
from gpiozero import LED
from TwitterAPI import TwitterAPI
from oauth import *
import time

# set up 2 pins for LEDs
yLed = LED(20)
rLed = LED(21)

#### specify hashtags to follow
# can be separated by comma: '#jesus,#pizza,#selfie'
TRACK_TERM = '#jesus'

# set up the TwitterAPI object
api = TwitterAPI(CONSUMER_KEY,CONSUMER_SECRET,
                 ACCESS_TOKEN_KEY,ACCESS_TOKEN_SECRET)

# print a welcome message
print "Connected to Twitter. Searching for: %s"%TRACK_TERM

# this is the responseobject from twitter.
# it gets updated everytime a new tweet comes in with the TRACK_TERMs
response = api.request('statuses/filter', {'track': TRACK_TERM})

# this goes through the tweets availalble in the response object
for tweet in response:
    # prints out their text and blinks the lights
    print(tweet['text'] if 'text' in tweet else '')
    rLed.blink(on_time=1, n=1)
    yLed.blink(on_time=1, n=1)
示例#19
0
    def _forward(self):
        self.motorLeft.forward()
        self.motorRight.forward()

    def _backward(self):
        self.motorLeft.backward()
        self.motorRight.backward()

    def _left(self):
        self.motorLeft.backward()
        self.motorRight.forward()

    def _right(self):
        self.motorLeft.forward()
        self.motorRight.backward()

    def _stop(self):
        self.motorLeft.stop()
        self.motorRight.stop()


motionController = MotionController(motorLeft, motorRight)
communicator = Communicator(motionController)
while True:
    statusLed.blink(0.5, 0.5)
    communicator.connect()
    statusLed.on()
    communicator.listen()
    communicator.cleanup()
示例#20
0
from gpiozero import LED
red = LED(22)
amber = LED(27)
green = LED(17)


red.blink(0.5,0.1)
amber.blink(0.25,0.1)
green.blink(0.125,0.1)
示例#21
0
led_white = LED(17)
led_blue = LED(5)
led_white.on()
led_blue.on()

switch_to_robot_network()

try:
    response = dweepy.get_latest_dweet_for('misty')
    old_status = str(response[0]["created"])
    print("START:", old_status)
except:
    dweepy.dweet_for('misty', {'status': 'script_start'})
    time.sleep(2)

led_blue.blink(0.1)
led_white.blink(0.1)

while True:
    try:
        time.sleep(1.5)
        response = dweepy.get_latest_dweet_for('misty')
        new_status = str(response[0]["created"])
        print("NOW:  ", new_status)
        if new_status != old_status:
            old_status = new_status
            print("Trigger Alarm")
            print("Preparing Image")
            prepare_image()
            print("Connecting to printer network")
            x = switch_to_printer_network()
示例#22
0
from gpiozero import LED
led = LED(17)
led.blink(n=1)
示例#23
0
    # Seteo de los pines
    ok_led = LED(ok_led_pin)
    warn_led = LED(warn_led_pin)
    error_led = LED(error_led_pin)
    monitor_led = LED(monitor_led_pin)
# Configuramos la antena Xbee
# Comando para escanear puertos {dmesg | grep tty}
# se accede a traves de RS232 masterport
xbee = ZigBeeDevice("/dev/ttyAMA0", 9600)
remote_xbee = RemoteZigBeeDevice(
    xbee, XBee64BitAddress.from_hex_string("0013A20041513615"))

print("Empezamos")

for x in range(5):
    ok_led.blink(1, 1, 5)
    warn_led.blink(1, 1, 5)
    error_led.blink(1, 1, 5)
    monitor_led.blink(1, 1, 5)
    print(servo.value)
    servo.min()
    print(servo.value)
    sleep(5)
    servo.mid()
    sleep(5)
    servo.max()
    sleep(5)
    print(x)

print("e voila")
示例#24
0
            f.write("\n")

        line = ""
        while True:
            data = self.gp.bb_i2c_zip(27,[4,0x42,2,6,1,3,0])[1][0]

            char = chr(data)
            if data ==255:
                pass
            elif char == "$":
                self.processline(line)
                line = "$"
            else:
                line += char
                
            sleep(0.1)

if __name__ == '__main__':
    gps = GPS()
    ok = LED(26)
    while True:
        sleep(30)
        print(gps.gpsData)
        if gps.sat > 4:
           print("fix") 
           ok.blink()
        else:
           print("no fix") 

           ok.off()
示例#25
0
        os.system("/bin/bash /opt/RetroFlag/killes.sh")
        os.system("omxplayer -o hdmi /opt/RetroFlag/tone.mp3")
        print("Shutting down...")
        os.system("shutdown -h now")
        break
    else:
        led.on()  #Take control of LED instead of relying on TX pin

    #RESET Button pressed
    #When Reset button is presed restart current game
    if rebootBtn.is_pressed:
        retroPiCmd("RESET")

    #RESET Button held
    #When Reset button is held for more then 3 sec quit current game
    if rebootBtn.is_held:
        led.blink(.2, .2)
        retroPiCmd("QUIT")

    #Fan control
    #Adjust MIN and MAX TEMP as needed to keep the FAN from kicking
    #on and off with only a one second loop
    cpuTemp = int(float(getCPUtemp()))
    fanOnTemp = 55  #Turn on fan when exceeded
    fanOffTemp = 40  #Turn off fan when under
    if cpuTemp >= fanOnTemp:
        fan.on()
    if cpuTemp < fanOffTemp:
        fan.off()
    time.sleep(1.00)
示例#26
0
i7 = Button(io.I7, pull_up=False)
i8 = Button(io.I8, pull_up=False)
i9 = Button(io.I9, pull_up=False)
i10 = Button(io.I10, pull_up=False)
i11 = Button(io.I11, pull_up=False)
i12 = Button(io.I12, pull_up=False)

col = PiIO_col()
motor_timer = PiIO_TON(0, 2)  # 2s timer
run_timer = PiIO_timer()  # run timer
enable = LED(io.OE)
run = LED(io.RUN)
count = 0
servo_setp = 0
motor_enable = False
run.blink(.100, .900)  # run LED


# mqt message handler
#
def on_mqt_message(client, userdata, message):
    global servo_setp, motor_enable

    if 'motor' in message.topic:
        motor_enable = (message.payload.decode('utf-8').lower() == 'true')
        if motor_enable:
            run_timer.reset()
            print("on")

    if 'servo' in message.topic:
        servo_setp = float(message.payload.decode('utf-8'))
class PiShutdownButton:
    """PiShutdownButton."""
    def __init__(self,
                 gpio_btn,
                 gpio_led,
                 btn_hold_time=1,
                 reset_time=2,
                 shutdown_mode_time=4):
        """Initialize a PiShutdownButton object."""
        self.btn = Button(gpio_btn, hold_time=btn_hold_time, hold_repeat=True)
        self.btn.when_held = self.btn_hold
        self.btn.when_pressed = self.btn_press
        self.btn.when_released = self.btn_release

        self.led = LED(gpio_led)
        self.led.on()

        self.shutdown_mode_time = shutdown_mode_time
        self.shutdown_mode = False  # Shutdown mode is active
        self.shutdown_timer = False  # Shutdown timer is active
        self.shutdown_triggered = False  # Shutdown is in progress
        self.reset_time = reset_time
        self.reset_timer = None

    def reset(self):
        """Reset application state."""
        logging.debug('Resetting application state.')
        self.shutdown_mode = False
        self.shutdown_timer = False
        self.shutdown_triggered = False
        self.led.on()

    def btn_hold(self, button):
        """Handle button hold."""
        logging.debug('Button is being held.')
        if not self.shutdown_mode:
            pressed_time = int(button.pressed_time)
            # 4 second threshold - 1 second hold delay
            if (pressed_time >
                    self.shutdown_mode_time - 1) and not self.shutdown_mode:
                logging.debug("Entering shutdown mode.")
                self.led.blink(on_time=0.1, off_time=0.1)
                self.shutdown_mode = True

    def btn_press(self):
        """Handle button press."""
        logging.debug('Button is pressed.')
        if not self.shutdown_mode:
            self.led.blink(on_time=0.5, off_time=0.5)

    def btn_release(self):
        """Handle button release."""
        logging.debug('Button is released.')
        if not self.shutdown_mode:
            logging.debug('Turning LED on.')
            # Not in the shutdown mode, turn the LED on
            self.led.on()
        elif not self.shutdown_timer:
            # Shutdown mode is active, start the reset timer
            logging.debug('Starting shutdown timer.')
            self.shutdown_timer = True
            self.reset_timer = Timer(self.reset_time, self.reset)
            self.reset_timer.start()
        elif not self.shutdown_triggered:
            # Shutdown timer is active, initiate shutdown
            logging.debug('Shutting down system.')
            self.shutdown_triggered = True
            self.reset_timer.cancel()
            self.led.off()
            os.system('sudo poweroff')
示例#28
0
#!/usr/bin/env python
#Reaction game recipe

from gpiozero import Button, LED
from time import sleep
import random

led1 = LED(27)
led2 = LED(23)

player_1 = Button(22)
player_2 = Button(24)

led2.blink(on_time=1, off_time=1, n=10, background=True)

time = random.uniform(5, 10)
sleep(time)
led1.on()

while True:
    if player_1.is_pressed:
        print("Player 1 wins!")
        break
    if player_2.is_pressed:
        print("Player 2 wins!")
        break

led1.off()
示例#29
0
from gpiozero import LED
from time import sleep
from controller import robot_controller
import os

robot = robot_controller(os.path.dirname(os.path.realpath(__file__)))

for pin in robot.get_config()['Robot']:
    re = LED(pin)

echo = LED(robot.get_config()['distance_sensor']['echo'])
echo.off()
trigger = LED(robot.get_config()['distance_sensor']['trigger'])
trigger.off()
signal_led = LED(robot.get_config()['distance_sensor']['signal_led'])
signal_led.blink()
sleep(1)
示例#30
0
def main():
    now = datetime.now()
    my_path = os.path.abspath(os.path.dirname(__file__))
    log_file_path_abs = os.path.join(
        my_path, "{}/{}{}.log".format(log_file_path, log_file_name,
                                      now.strftime("%Y-%m-%d_%H-%M-%S")))
    csv_file_path_abs = os.path.join(
        my_path, "{}/{}{}.csv".format(log_file_path, csv_file_name,
                                      now.strftime("%Y-%m-%d_%H-%M-%S")))
    print_and_log("Starting...", log_file_path_abs)

    write_to_csv("Time;Level;Pump", csv_file_path_abs, log_file_path_abs)

    try:
        # Set stack size limit to maximum possible
        resource.setrlimit(resource.RLIMIT_STACK,
                           (resource.RLIM_INFINITY, resource.RLIM_INFINITY))
        print_and_log("Successfully increased stack size to maximum.",
                      log_file_path_abs)
    except Exception as e:
        print_and_log(
            "Unable to increase stack size. Reason: {}. Continuing...".format(
                e), log_file_path_abs)

    # Create devices using GPIOZERO library
    try:
        pump = LED(PUMP_PIN_NO, active_high=False)
        #pump_off(pump, log_file)
        status_led = LED(STATUS_LED_PIN_NO)
        seed_voltage = LED(SEED_VOLTAGE_PIN_NO)
        lvl_pin_cnt = len(list(LVL_PIN_NO_ARRAY))
        lvl_pin_array = [LED] * lvl_pin_cnt
        for x in range(lvl_pin_cnt):
            #print_and_log("Checking pin no. {}: GPIO {}".format(x, lvlPinNoArray[x]), log_file_path_abs)
            lvl_pin_array[x] = Button(LVL_PIN_NO_ARRAY[x], pull_up=False)
        print_and_log(
            "Done initializing GPIO devices. Using {} level pins.".format(
                lvl_pin_cnt), log_file_path_abs)
    except Exception as e:
        print_and_log("Unable to create devices: {}. Exiting...".format(e),
                      log_file_path_abs)
        return 1

    # CFG stuff - TODO: quick and dirty for testing, needs to be replaced
    cfg_file_threshold_path_abs = os.path.join(my_path, "threshold.cfg")

    # Manual pump ctl through file TODO: Replace
    manctl_filepath = os.path.join(my_path, "manual_pump_control.cfg")

    # Initialize pump state variable - pump is always off if not actively pulled LOW by program
    pump_running = False

    # TODO: Read Thingspeak URL and Key from config file

    # Heartbeat TODO: check if this works as intended (when program crashes...)
    status_led.blink()

    # Switch to manual mode for testing TODO: Remove
    switch_mode(ControlMode.MANUAL)

    # Main Loop
    while True:
        try:
            # Read Level
            level = read_tank_level(lvl_pin_array, seed_voltage,
                                    log_file_path_abs)

            # Read Threshold from File
            threshold = read_threshold_from_file(cfg_file_threshold_path_abs,
                                                 log_file_path_abs)
            print_and_log("Using threshold value of: {}".format(threshold),
                          log_file_path_abs)

            # Control pump
            pump_allowed = is_pump_allowed(level, pump_running, threshold)
            pump_desired = is_pump_desired(manctl_filepath, log_file_path_abs)
            if pump_allowed & pump_desired:
                pump_running = pump_turn_on(pump, log_file_path_abs)
            else:
                pump_running = pump_turn_off(pump, log_file_path_abs)

            # Log Data
            print_and_log(
                "Current state: Level: {}% | Pump: [ALLOWED: {}, DESIRED: {}, RUNNING: {}]"
                .format(level * 100, pump_allowed, pump_desired,
                        pump_state_textual(pump_running)), log_file_path_abs)

            write_to_csv(
                "{};{};{}\n".format(get_timestamp(), level, int(pump_running)),
                csv_file_path_abs, log_file_path_abs)

            # Send Data to Thingspeak
            print_and_log("Sending data to Thingspeak...", log_file_path_abs)
            send_data_to_thingspeak(THINGSPEAKURL, THINGSPEAKKEY, level * 100,
                                    int(pump_running), log_file_path_abs)
            sys.stdout.flush()

            # Wait until next check is due
            print_and_log(
                "Waiting {} seconds until next check...".format(sleep_time),
                log_file_path_abs)
            sleep(sleep_time)
        except Exception as err:
            print_and_log("An unknown error occurred! Exiting...",
                          log_file_path_abs)
            print_and_log(traceback.format_exc(), log_file_path_abs)
            raise err

    # Terminate Program
    print_and_log("Terminating...", log_file_path_abs)

    print("Done.")
    return 0
示例#31
0
# Ejecutar como root con sudo

from gpiozero import Button, LED
from subprocess import check_call
from signal import pause

# Boton de apagado; debe mantenerse pulsado 3 segundos
shutdown_btn = Button(3, hold_time=3)
# LED opcional para saber que todo va bien
led = LED(21)


# Funcion que se ejecuta cuando pulsamos el boton
def shutdown():
    # Parpadear el LED mas rapido mientras se esta apagando
    led.blink(on_time=0.1, off_time=0.1)
    check_call(['sudo', 'poweroff'])


# Parpadear el LED opcional para saber que
# todo esta funcionando bien
led.blink(on_time=0.5, off_time=0.5)
# Asignar la funcion shutdown al mantener el boton pulsado
shutdown_btn.when_held = shutdown

# Mantener el programa pausado
pause()
示例#32
0
        if tempdiff >= highdiff:
            red = True
            reason = 0
        elif tempdiff <= lowdiff:
            red = False

#LED and notification controls
    filewrite(updated.month, updated.day, updated.hour, updated.minute, inside,
              outside, attic, window, outsidehigh, red, reason)
    if red == True:
        greenled.off()
        if window == 1:
            if notified == False:
                notify(reason)
                notified = True
            redled.blink(0.75, 0.75)
        elif window == 2:
            if (reason == 0) or (reason == 3):
                if notified == False:
                    notify(reason)
                    notified = True
                redled.blink(0.75, 0.75)
            else:
                redled.on()
        else:
            redled.on()
    else:
        redled.off()
        greenled.on()
        notified = False
示例#33
0
	
	if config.post_online:
		show_image(real_path + "/finished.png")
	else:
		show_image(real_path + "/finished2.png")
	
	time.sleep(restart_delay)
	show_image(real_path + "/intro.png");
	led_pin.on() #turn on the LED

####################
### Main Program ###
####################

## clear the previously stored pics based on config settings
if config.clear_on_startup:
	clear_pics(1)

print("Photo booth app running...") 
led_pin.blink()

show_image(real_path + "/intro.png");
led_pin.on(); #turn on the light showing users they can push the button

input(pygame.event.get()) # press escape to exit pygame. Then press ctrl-c to exit python.

	#GPIO.wait_for_edge(btn_pin, GPIO.FALLING)
time.sleep(config.debounce) #debounce
btn_pin.when_pressed = start_photobooth

pause()
示例#34
0
from gpiozero import LED
from signal import pause

myLed = LED(17)

myLed.blink(.5)

pause()
示例#35
0
ledRed = LED(17)
ledGreen = LED(27)

# NFS Server Check
print('Checking for NFS Server...')
pingResponse = os.system("ping -c 1 " + nfsServer)

ledRed.on()
if pingResponse == 0:
    print('{} {}'.format(nfsServer, 'is up!'))
    mntCmd = 'mount {}:{} {}'.format(nfsServer, nfsDrive, nfsMnt)
    mntResponse = os.system(mntCmd)
    if mntResponse == 0:
        print('{} {}'.format(nfsServer, 'has been mounted!'))
        print('Transferring backups to external storage...')
        ledRed.blink()
        copy_tree(tmpDir, nfsMnt, verbose=1)
        if os.getenv('CLEANUP') == 'true':
            rmCmd = 'rm -rf {}/*'.format(tmpDir)
            os.system(rmCmd)
        print('done')
    else:
        print('{} {}'.format('Cannot mount', nfsServer))
        ledGreen.blink()
        ledRed.blink()
        time.sleep(10)
else:
    print('{} {}'.format(nfsServer, 'is not available!'))
    ledGreen.blink()
    ledRed.blink()
    time.sleep(5)
示例#36
0
from gpiozero import LED
from signal import pause

red = LED(17)

red.blink()

pause()
示例#37
0
#!/usr/bin/python

from gpiozero import LED
from signal import pause
import time

yellow = LED(26)

yellow.blink()

pause()
示例#38
0
#!/home/pi/Documents/python/blink.py
from gpiozero import LED
from signal import pause

red = LED(25)
red.blink(0.2)

pause()
示例#39
0
while True:
    config = yaml.load(
        file('/home/pi/Desktop/python3/smartfridge/config.yml', 'r'))

    frequencySecs = int(config["frequencysecs"])
    fridgeThreshold = getFridgeTempThreshold()
    tempFridge = getTemperature(temp_fridge_sensor)
    tempExternal = getTemperature(temp_external_sensor)

    led.on()
    print("Threshold: " + str(fridgeThreshold))
    print("Fridge temp: " + str(tempFridge))
    print("External temp: " + str(tempExternal))

    if tempFridge == ERROR_TEMP:
        led.blink(0.1, 0.5)
        relay.off()  #off for a NC relay = on
        print("error with fridge temp sensor fridge on")
        logData(fridgeThreshold, str(tempFridge), str(tempExternal),
                "error with fridge temp sensor fridge on")
    elif tempFridge > fridgeThreshold:
        relay.off()  #off for a NC relay = on
        print("fridge on")
        logData(fridgeThreshold, str(tempFridge), str(tempExternal), "on")
    else:
        relay.on()  #on for a NC relay = off
        print("fridge off")
        logData(fridgeThreshold, str(tempFridge), str(tempExternal), "off")

    sleep(frequencySecs)
示例#40
0
# This is an alternative for blinking an LED
# Instead of calling ON/OFF with a delay,
# this program generated the blinking on/off cycle
# with just a single function call
# Blinking interval is hard-coded to 1 second
# in the library. That is 1 sec on, 1 sec off
 
from gpiozero import LED
from signal import pause

green=LED(17)

green.blink()

pause()
示例#41
0
from gpiozero import LED
from signal import pause

red = LED(17)

red.blink()

pause()
示例#42
0
from gpiozero import LED
from signal import pause

power = LED(35) # /sys/class/leds/led1
activity = LED(47) # /sys/class/leds/led0

activity.blink()
power.blink()
pause()
示例#43
0
文件: testzero.py 项目: PiHw/Pi-Stop
#!/usr/bin/python3
# testzero.py
#
# Example using GPIOZero with GPIO.BOARD numbering
# PiStop in Location C (BOARD pins 8,10,12)
#
# Note: 1. gpiopins.py must be located in python path or same directory.
#       2. /usr/lib/python3/dist-packages/gpiozero/devices.py should be updated as shown in devices.py file.

import gpiopins as GPIO
GPIO.setmode(GPIO.BOARD)

from gpiozero import LED
from time import sleep

green=LED(8)
yellow=LED(10)
red=LED(12)

green.blink()
sleep(0.1)
yellow.blink()
sleep(0.1)
red.blink()