def main():
firstRun = True
lastRunTimestamp = time.time()
players = []
numOnline = 0
redLed = PWMLED(redPin)
while True:
if (lastRunTimestamp + 300) < time.time() or firstRun == True:
firstRun = False
lastRunTimestamp = time.time()
try:
f = open(confFile, 'r')
serverInfo = json.loads(f.read())
f.close()
#print("checking server status. " + str(time.time()))
r = requests.get("https://api.mcsrvstat.us/2/" + serverInfo['ipAddress'], timeout=10).json()
numOnline = r['players']['online']
if numOnline > 0:
players = r['players']['list']
redLed.pulse()
#print(players)
else:
players = []
redLed.off()
#print("didn't find any players")
except Exception as e:
redLed.blink(0.5,0.5,0,0,15,True)
scrollText("Something went wrong")
if numOnline > 0:
scrollText(listToString(players))
else:
scrollText("no one online")
class Laser(object):
"""
Class that uses PWM to control the laser.
"""
def __init__(self) -> None:
"""
Initialization
"""
if gpio_found:
self.laser = PWMLED(GPIO_PIN)
self._current_power = 0
self.power = 100
def state(self) -> bool:
"""
Query the laser state
"""
if gpio_found:
return self.laser.is_lit
else:
return False
def on(self) -> None:
"""
Turn the laser on.
"""
if gpio_found:
self.laser.on()
def off(self) -> None:
"""
Turn the laser on.
"""
if gpio_found:
self.laser.off()
@property
def power(self) -> int:
"""
Query the laser power %
"""
return int(self._current_power * 100)
@power.setter
def power(self, percent_power: int) -> None:
"""
Set the power as a percentage. Raises a value error is the power
is outside the expected range of 0-100%
"""
if percent_power > 100:
raise ValueError("Laser Power cannot be greater than 100%")
if percent_power < 0:
raise ValueError("Laser Power cannot be less than 0%")
self._current_power = percent_power / 100
if gpio_found:
self.laser.value = self._current_power
def main():
fan = PWMLED(18)
while True:
vcgm = Vcgencmd()
temp = vcgm.measure_temp()
if temp >= 40:
fan.on()
elif temp <= 35:
fan.off()
time.sleep(1)
def main():
# setup
# See https://www.raspberrypi.org/documentation/usage/gpio/
# Pins are on the edge of the connector, right next to each-other
# Indicator should connect the positive side (anode, yellow wire) to GPIO pin 23
# and negative side (cathode, orange wire) to ground
# Button should connect 3V3 (blue wire) to GPIO pin 24 (green wire)
away_indicator = PWMLED(pin=18, active_high=False, initial_value=False)
home_indicator = LED(pin=23, active_high=False, initial_value=False)
button = Button(pin=17, pull_up=False)
button.when_held = handle_button
button.hold_time = 0.5
# Setup logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
handler.setLevel(logging.INFO)
handler.setFormatter(
logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logger.addHandler(handler)
# This is used to communicate the state relatively "thread-safely"
# to the Sopel bot
presence_file = Path(PRESENCE_FILE)
# Prime the state from file, defaults to False if file does not exist
last_state = state = read_state(presence_file)
logger.info('Starting main loop')
while True:
# Update the state from file
state = read_state(presence_file)
# Check if state changed
if state != last_state:
# Set LED based on the state
if state:
home_indicator.on()
away_indicator.off()
else:
home_indicator.off()
away_indicator.pulse(fade_in_time=1, fade_out_time=3)
logger.info('Toggling LED state: %s', 'on' if state else 'off')
last_state = state
# Sleep before next round
sleep(0.5)
class ButtonPressRelease:
def __init__(self):
self.button = Button(2)
self.led = PWMLED(17)
def continuously_listen(self):
while True:
if self.button.is_pressed:
self.print_message_pressed()
else:
self.print_message_released()
def wait_for_being_pressed(self):
self.button.wait_for_press()
self.print_message_pressed(False)
def when_pressed_or_released_print_something(self):
self.button.when_pressed = self.print_message_pressed
self.button.when_released = self.print_message_released
pause()
def turn_on_off_led(self):
self.button.when_released = self.turn_off_led
self.button.when_pressed = self.led_pulse
pause()
def print_message_pressed(self, is_continous=True):
if is_continous:
tense = "is"
else:
tense = "was"
print("Button " + tense + " pressed.")
def print_message_released(self):
print("Button is released.")
def led_pulse(self):
self.print_message_pressed(True)
self.led.pulse()
def turn_off_led(self):
self.print_message_released()
self.led.off()
class LED(object):
def __init__(self,pin_gpio, name="GPIO"):
self.GPIO = PWMLED(pin_gpio)
self.name = name if name != "GPIO" else "GPIO " + str(pin_gpio)
self.set_blink = False
def on(self):
self.GPIO.on()
def set_value(self,pwm_value):
self.GPIO.value = pwm_value
def off(self):
self.GPIO.off()
def blink(self,time_blink,inter_blink):
alarma_n = ceil(time_blink/(2 * inter_blink))
for k in range(alarma_n):
if not self.set_blink:
break
self.GPIO.on()
sleep(inter_blink)
self.GPIO.off()
sleep(inter_blink)
def on_time(self,time_on):
self.GPIO.on()
sleep(time_on)
self.GPIO.off()
class Turn():
def __init__(self, left, right):
self.left = PWMLED(left)
self.right = PWMLED(right)
def turn_left(self, value=0.2, for_time=0.2):
self.left.value = value
time.sleep(for_time)
self.left.value = 0
def turn_right(self, value=0.2, for_time=0.2):
self.right.value = value
time.sleep(for_time)
self.right.value = 0
def stop(self):
self.right.off()
self.left.off()
def close(self):
self.left.close()
self.right.close()
def main():
# LEDピン設定
factory = PiGPIOFactory()
led = PWMLED(PIN_LED1, pin_factory=factory)
# だんだん明るくする
# 25% -> 50% -> 75% -> 100%
led.value = 0.25
sleep(1)
led.value = 0.50
sleep(1)
led.value = 0.75
sleep(1)
led.value = 1.0
sleep(1)
# 徐々に明るくし、徐々に暗くするを繰り返す
try:
led.pulse()
pause()
except KeyboardInterrupt:
print("stop")
led.off()
startup()
# enter the main program loop
while True:
# check the rotary thread for new input
while len(rot) > 0:
item = rot.popleft()
if menu:
if playing:
if player_stream.is_active():
player_stream.set_pos_skip(item * -5)
else:
player_stream.stop_playing()
player_stream.close()
play_screen.close()
play_led.off()
playing = False
if looping:
loopA = None
loopB = None
looping = False
elif item == -1:
MainMenu.setNextItem()
elif item == 1:
MainMenu.setPrevItem()
dsphlp.dspwrite(lcd, MainMenu.AllItems[MainMenu.CurrentItem])
if recording:
AudioIO.set_recording_volume(input_mixer, input_device, int(item * -2))
# check the buttons thread for new input
while len(record) > 0:
class KillTeam:
def __init__(self):
self.plusButton = Button(17)
self.minusButton = Button(27)
self.okButton = Button(22)
self.canticleLed1 = PWMLED(5) # IncantationOfTheIronSoul
self.canticleLed2 = PWMLED(6) # LitanyOfTheElectromancer
self.canticleLed3 = PWMLED(13) # Chant of the Remorseless Fist
self.canticleLed4 = PWMLED(19) # Shroudpsalm
self.canticleLed5 = PWMLED(26) # Invocation of Machine Might
self.canticleLed6 = PWMLED(21) # Benediction of the Omnissiah
self.initiativeLed = PWMLED(23)
self.movementLed = PWMLED(24)
self.psychicLed = PWMLED(25)
self.shootingLed = PWMLED(12)
self.meleeLed = PWMLED(16)
self.moraleLed = PWMLED(20)
self.selected_canticle = INCANTATION_OF_THE_IRON_SOUL
self.canticle1Used = False
self.canticle2Used = False
self.canticle3Used = False
self.canticle4Used = False
self.canticle5Used = False
self.canticle6Used = False
self.continueGame = True
def select_canticles(self):
self.initiativeLed.off()
self.movementLed.off()
self.psychicLed.off()
self.shootingLed.off()
self.meleeLed.off()
self.moraleLed.off()
self.plusButton.when_pressed = self.canticle_plus_button
self.minusButton.when_pressed = self.canticle_minus_button
self.okButton.when_pressed = self.canticle_ok_button
self.display_canticle()
self.okButton.wait_for_press()
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
sleep(0.5)
def canticle_plus_button(self):
self.selected_canticle += 1
if self.selected_canticle == 8:
self.selected_canticle = INCANTATION_OF_THE_IRON_SOUL
self.display_canticle()
def canticle_minus_button(self):
self.selected_canticle -= 1
if self.selected_canticle == -1:
self.selected_canticle = BENEDICTION_OF_THE_OMNISSIAH
self.display_canticle()
def canticle_ok_button(self):
if self.selected_canticle == 0 or self.selected_canticle == 7:
self.selected_canticle = randint(1, 6)
else:
if self.selected_canticle == INCANTATION_OF_THE_IRON_SOUL:
self.canticle1Used = True
elif self.selected_canticle == LITANY_OF_THE_ELECTROMANCER:
self.canticle2Used = True
elif self.selected_canticle == CHANT_OF_THE_REMORSELESS_FIST:
self.canticle3Used = True
elif self.selected_canticle == SHROUDPSALM:
self.canticle4Used = True
elif self.selected_canticle == INVOCATION_OF_MACHINE_MIGHT:
self.canticle5Used = True
elif self.selected_canticle == BENEDICTION_OF_THE_OMNISSIAH:
self.canticle6Used = True
self.display_canticle(True)
def initiative_phase(self):
self.initiativeLed.on()
self.movementLed.off()
self.psychicLed.off()
self.shootingLed.off()
self.meleeLed.off()
self.moraleLed.off()
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
self.okButton.wait_for_press()
sleep(0.5)
def movement_phase(self):
self.initiativeLed.off()
self.movementLed.on()
self.psychicLed.off()
self.shootingLed.off()
self.meleeLed.off()
self.moraleLed.off()
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
self.okButton.wait_for_press()
sleep(0.5)
def psychic_phase(self):
self.initiativeLed.off()
self.movementLed.off()
self.psychicLed.on()
self.shootingLed.off()
self.meleeLed.off()
self.moraleLed.off()
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
self.okButton.wait_for_press()
sleep(0.5)
def shooting_phase(self):
self.initiativeLed.off()
self.movementLed.off()
self.psychicLed.off()
self.shootingLed.on()
self.meleeLed.off()
self.moraleLed.off()
if self.selected_canticle in [
SHROUDPSALM, BENEDICTION_OF_THE_OMNISSIAH
]:
self.display_canticle(True, True)
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
self.okButton.wait_for_press()
if self.selected_canticle in [
SHROUDPSALM, BENEDICTION_OF_THE_OMNISSIAH
]:
self.display_canticle(True, False)
sleep(0.5)
def melee_phase(self):
self.initiativeLed.off()
self.movementLed.off()
self.psychicLed.off()
self.shootingLed.off()
self.meleeLed.on()
self.moraleLed.off()
if self.selected_canticle in [
LITANY_OF_THE_ELECTROMANCER, CHANT_OF_THE_REMORSELESS_FIST,
INVOCATION_OF_MACHINE_MIGHT
]:
self.display_canticle(True, True)
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
self.okButton.wait_for_press()
if self.selected_canticle in [
LITANY_OF_THE_ELECTROMANCER, CHANT_OF_THE_REMORSELESS_FIST,
INVOCATION_OF_MACHINE_MIGHT
]:
self.display_canticle(True, False)
sleep(0.5)
def morale_phase(self):
self.initiativeLed.off()
self.movementLed.off()
self.psychicLed.off()
self.shootingLed.off()
self.meleeLed.off()
self.moraleLed.on()
if self.selected_canticle in [1]:
self.display_canticle(True, True)
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
self.okButton.wait_for_press()
if self.selected_canticle in [1]:
self.display_canticle(True, False)
sleep(0.5)
def select_if_end_game(self):
self.initiativeLed.pulse()
self.movementLed.pulse()
self.psychicLed.pulse()
self.shootingLed.pulse()
self.meleeLed.pulse()
self.moraleLed.pulse()
self.plusButton.when_pressed = None
self.minusButton.when_pressed = self.end_game_select
self.okButton.when_pressed = None
self.okButton.wait_for_press()
self.plusButton.when_pressed = None
self.minusButton.when_pressed = None
self.okButton.when_pressed = None
sleep(0.5)
def end_game_select(self):
self.continueGame = not self.continueGame
if self.continueGame:
self.initiativeLed.pulse()
self.movementLed.pulse()
self.psychicLed.pulse()
self.shootingLed.pulse()
self.meleeLed.pulse()
self.moraleLed.pulse()
else:
self.initiativeLed.off()
self.movementLed.off()
self.psychicLed.off()
self.shootingLed.off()
self.meleeLed.off()
self.moraleLed.off()
def close(self):
self.initiativeLed.close()
self.movementLed.close()
self.psychicLed.close()
self.shootingLed.close()
self.meleeLed.close()
self.moraleLed.close()
self.canticleLed1.close()
self.canticleLed2.close()
self.canticleLed3.close()
self.canticleLed4.close()
self.canticleLed5.close()
self.canticleLed6.close()
self.plusButton.close()
self.minusButton.close()
self.okButton.close()
def display_canticle(self, selected=False, blinking=False):
if selected:
self.canticleLed1.off()
self.canticleLed2.off()
self.canticleLed3.off()
self.canticleLed4.off()
self.canticleLed5.off()
self.canticleLed6.off()
if self.selected_canticle == 1:
if blinking:
self.canticleLed1.pulse()
else:
self.canticleLed1.on()
elif self.selected_canticle == LITANY_OF_THE_ELECTROMANCER:
if blinking:
self.canticleLed2.pulse()
else:
self.canticleLed2.on()
elif self.selected_canticle == CHANT_OF_THE_REMORSELESS_FIST:
if blinking:
self.canticleLed3.pulse()
else:
self.canticleLed3.on()
elif self.selected_canticle == SHROUDPSALM:
if blinking:
self.canticleLed4.pulse()
else:
self.canticleLed4.on()
elif self.selected_canticle == INVOCATION_OF_MACHINE_MIGHT:
if blinking:
self.canticleLed5.pulse()
else:
self.canticleLed5.on()
elif self.selected_canticle == BENEDICTION_OF_THE_OMNISSIAH:
if blinking:
self.canticleLed6.pulse()
else:
self.canticleLed6.on()
else:
if not self.canticle1Used:
self.canticleLed1.on()
else:
self.canticleLed1.off()
if not self.canticle2Used:
self.canticleLed2.on()
else:
self.canticleLed2.off()
if not self.canticle3Used:
self.canticleLed3.on()
else:
self.canticleLed3.off()
if not self.canticle4Used:
self.canticleLed4.on()
else:
self.canticleLed4.off()
if not self.canticle5Used:
self.canticleLed5.on()
else:
self.canticleLed5.off()
if not self.canticle6Used:
self.canticleLed6.on()
else:
self.canticleLed6.off()
if self.selected_canticle == 1:
self.canticleLed1.pulse()
elif self.selected_canticle == LITANY_OF_THE_ELECTROMANCER:
self.canticleLed2.pulse()
elif self.selected_canticle == CHANT_OF_THE_REMORSELESS_FIST:
self.canticleLed3.pulse()
elif self.selected_canticle == SHROUDPSALM:
self.canticleLed4.pulse()
elif self.selected_canticle == INVOCATION_OF_MACHINE_MIGHT:
self.canticleLed5.pulse()
elif self.selected_canticle == BENEDICTION_OF_THE_OMNISSIAH:
self.canticleLed6.pulse()
else:
self.canticleLed1.pulse()
self.canticleLed2.pulse()
self.canticleLed3.pulse()
self.canticleLed4.pulse()
self.canticleLed5.pulse()
self.canticleLed6.pulse()
class PomodoroTimer(object):
def __init__(self):
self.timer = None
self.led = PWMLED(LIGHT_PIN)
self.buzzer = TonalBuzzer(BUZZER_PIN)
def times_up(self):
print("Time's up")
self.fin()
def start_pomodoro(self, channel):
print("Start Pomodoro")
self.led.blink(on_time=0.3, off_time=0.3, n=5, background=True)
if (self.timer != None):
print("Pomodoro was re-started")
self.timer.cancel()
self.timer = Timer(5, self.times_up)
self.timer.start()
def play_note(self, note, duration=0.04):
self.buzzer.play(Tone.from_note(note))
sleep(duration)
self.buzzer.stop()
def ending_music(self):
# Available Range
# A3, B3, C4, D4, E4, F4, G4, A4, B4
arpeggio = [
"A#3",
"C#4",
"E#4",
"A#3",
"C#4",
"E#4",
"A#3",
"C#4",
"E#4",
"A#3",
"C#4",
"E#4",
"A3",
"C4",
"E4",
"A3",
"C4",
"E4",
"A3",
"C4",
"E4",
"A3",
"C4",
"E4",
"C4",
"E4",
"G4",
"C4",
"E4",
"G4",
"C4",
"E4",
"G4",
"C4",
"E4",
"G4",
"Cb4",
"Eb4",
"Gb4",
"Cb4",
"Eb4",
"Gb4",
"Cb4",
"Eb4",
"Gb4",
"Cb4",
"Eb4",
"Gb4",
"A#3",
"C#4",
"E#4",
"A#3",
"C#4",
"E#4",
"A#3",
"C#4",
"E#4",
"A#3",
"C#4",
"E#4",
"A3",
"C4",
"E4",
"A3",
"C4",
"E4",
"A3",
"C4",
"E4",
"A3",
"C4",
"E4",
]
for note in arpeggio:
self.play_note(note)
self.play_note("A3", duration=0.2)
def fin(self):
self.led.pulse()
self.ending_music()
self.led.off()
def run(self):
self.button = Button(BUTTON_PIN, pull_up=False)
self.button.when_pressed = self.start_pomodoro
pause()
class IntegraLED:
class LEDState(Enum):
on = 0
off = 1
FadeIn = 2
FadeOut = 3
Unknown = 4
def __init__(self, channel, levels=1000, linear=False):
self.factory = PiGPIOFactory()
self.led = PWMLED(channel, pin_factory=self.factory)
self.led.off()
self.led.frequency = 150
self.state = self.LEDState.off
self.levels = levels
self.interval = 1.0 / levels
self.level = 0.0
self.lock = Lock()
self.linear = linear
def doFadeIn(self, duration=5):
self.setStateInterval(self.LEDState.FadeIn, duration)
def doFadeOut(self, duration=5):
self.setStateInterval(self.LEDState.FadeOut, duration)
def doOn(self):
self.setStateInterval(self.LEDState.on, 0)
def doOff(self):
self.setStateInterval(self.LEDState.off, 0)
def doImmediateSwitch(self, state):
if state:
self.doOn()
else:
self.doOff()
def doFade(self, state, duration=5):
if state:
self.doFadeIn(duration)
else:
self.doFadeOut(duration)
def setStateInterval(self, state, duration):
self.lock.acquire()
try:
self.t.cancel()
except:
pass
self.state = state
if duration != 0:
self.interval = float(duration) / self.levels
self.lock.release()
self.updateDaemon()
def updateDaemon(self):
self.lock.acquire()
# Do the fading if in that state
if self.state == self.LEDState.FadeIn:
self.level = self.level + 1.0 / self.levels
elif self.state == self.LEDState.FadeOut:
self.level = self.level - 1.0 / self.levels
elif self.state == self.LEDState.on:
self.level = 1.0
elif self.state == self.LEDState.off:
self.level = 0.0
# Stop fade if level reached
if self.level >= 1:
self.level = 1
self.state = self.LEDState.on
elif self.level <= 0:
self.level = 0
self.state = self.LEDState.off
if self.linear:
self.led.value = self.level
else:
k = 1.5
#newValue = (math.exp(self.level*k) - 1)/(math.e**k - 1)
newValue = float(self.level)**2
newValue = 1 if newValue > 1 else newValue
newValue = 0 if newValue < 0 else newValue
self.led.value = newValue
if (self.state == self.LEDState.FadeIn) | (self.state
== self.LEDState.FadeOut):
self.t = Timer(self.interval, self.updateDaemon)
self.t.daemon = True
self.t.start()
self.lock.release()
#!/usr/bin/python3
# Beispieldatei gpiozero-led-pwm.py
from gpiozero import PWMLED
import sys, time
myled = PWMLED(7, frequency=1000) # BCM-Nummer 7 = Pin 26 des J8-Header
# Frequenz: 1000 Hz
print("LED wird langsam heller")
myled.value = 0
myled.on()
for brightness in range(1, 11):
myled.value = brightness / 10.0
time.sleep(0.5)
print("LED blinkt zehn Mal")
myled.blink(on_time=0.5, off_time=0.25, n=10, background=False)
print("Kurze Pause")
time.sleep(1)
print("LED blinkt dreimal langsam, halbe Helligkeit")
myled.value = 0.1
myled.blink(on_time=1, off_time=1, n=3, background=False)
print("LED aus und Programmende")
myled.off()
logging.debug('Fan ALREADY ON ' + str(int(currentTemp)) +
' - aiming for ' + str(int(temp)))
i = int(i) - 1
else:
if status == 'on':
off += 1
if off > (tries):
#time.sleep(int(tries) * 5)
newLed.pulse()
targetFile.write('0')
targetFile.close()
fanStatus.write('off|' + str(int(currentTemp)))
fanStatus.close()
#GPIO.output(16, GPIO.LOW)
#brightness.ChangeDutyCycle(0)
newLed.off()
logging.debug('Fan TURNED OFF ' + str(int(currentTemp)) +
' - aiming for ' + str(int(temp)))
off = 0
status = 'off'
i = 0
else:
#brightnessLevel = ((int(tries) - off) / 100)
#newLed.value = brightnessLevel
logging.debug('Preparing to TURN OFF. ' +
str(int(currentTemp)) + ' - aiming for ' +
str(int(temp)))
if i < 1:
i = 0
else:
i = int(i) - 1
def run(self, tempo):
if self.song == True:
return
pattern = random.randint(1, 8)
count = 0
f = 60
T = 1 / f
p = 0.9
red1 = PWMLED(17)
orange1 = PWMLED(18)
yellow1 = PWMLED(27)
green1 = PWMLED(22)
blue1 = PWMLED(23)
white1 = PWMLED(24)
red2 = PWMLED(13)
orange2 = PWMLED(19)
yellow2 = PWMLED(26)
green2 = PWMLED(16)
blue2 = PWMLED(20)
white2 = PWMLED(21)
self.song = True
while self.song == True:
print(".", end='')
#in order 2 (slow)
while pattern == 1 and count <= 3:
beat = tempo / 6000
red1.value = 0.1
time.sleep(beat)
red1.off()
orange1.value = 0.2
time.sleep(beat)
orange1.off()
yellow1.value = 0.5
time.sleep(beat)
yellow1.off()
green1.value = 0.05
time.sleep(beat)
green1.off()
blue1.on()
time.sleep(beat)
blue1.off()
white1.on()
time.sleep(beat)
white1.off()
red2.on()
time.sleep(beat)
red2.off()
orange2.on()
time.sleep(beat)
orange2.off()
yellow2.on()
time.sleep(beat)
yellow2.off()
green2.on()
time.sleep(beat)
green2.off()
blue2.on()
time.sleep(beat)
blue2.off()
white2.on()
time.sleep(beat)
white2.off()
count += 1
#alternating
while pattern == 2 and count <= 1:
beat = tempo / 3000
red1.value = 0.1
time.sleep(beat)
red1.off()
yellow1.value = 0.5
time.sleep(beat)
yellow1.off()
blue1.on()
time.sleep(beat)
blue1.off()
red2.on()
time.sleep(beat)
red2.off()
yellow2.on()
time.sleep(beat)
yellow2.off()
blue2.on()
time.sleep(beat)
blue2.off()
orange1.value = 0.2
time.sleep(beat)
orange1.off()
green1.value = 0.05
time.sleep(beat)
green1.off()
white1.on()
time.sleep(beat)
white1.off()
orange2.on()
time.sleep(beat)
orange2.off()
green2.on()
time.sleep(beat)
green2.off()
white2.on()
time.sleep(beat)
white2.off()
count += 1
#in order (fast)
while pattern == 3 and count <= 7:
beat = tempo / 12000
red1.value = 0.1
time.sleep(beat)
red1.off()
orange1.value = 0.2
time.sleep(beat)
orange1.off()
yellow1.value = 0.5
time.sleep(beat)
yellow1.off()
green1.value = 0.05
time.sleep(beat)
green1.off()
blue1.on()
time.sleep(beat)
blue1.off()
white1.on()
time.sleep(beat)
white1.off()
red2.on()
time.sleep(beat)
red2.off()
orange2.on()
time.sleep(beat)
orange2.off()
yellow2.on()
time.sleep(beat)
yellow2.off()
green2.on()
time.sleep(beat)
green2.off()
blue2.on()
time.sleep(beat)
blue2.off()
white2.on()
time.sleep(beat)
white2.off()
count += 1
#spreading out
while pattern == 4 and count <= 7:
beat = tempo / 10000
white1.on()
red2.on()
time.sleep(beat)
white1.off()
red2.off()
blue1.on()
orange2.on()
time.sleep(beat)
blue1.off()
orange2.off()
green1.value = 0.05
yellow2.on()
time.sleep(beat)
green1.off()
yellow2.off()
yellow1.value = 0.5
green2.on()
time.sleep(beat)
yellow1.off()
green2.off()
orange1.value = 0.2
blue2.on()
time.sleep(beat)
orange1.off()
blue2.off()
red1.value = 0.1
white2.on()
time.sleep(beat)
red1.off()
white2.off()
blue2.on()
orange1.value = 0.2
time.sleep(beat)
blue2.off()
orange1.off()
green2.on()
yellow1.value = 0.5
time.sleep(beat)
green2.off()
yellow1.off()
yellow2.on()
green1.value = 0.05
time.sleep(beat)
yellow2.off()
green1.off()
orange2.on()
blue1.on()
time.sleep(beat)
orange2.off()
blue1.off()
count += 1
#color-by-color
while pattern == 5 and count <= 7:
beat = tempo / 6000
red1.value = 0.1
red2.on()
time.sleep(beat)
red1.off()
red2.off()
orange1.on()
orange2.on()
time.sleep(beat)
orange1.off()
orange2.off()
yellow1.on()
yellow2.on()
time.sleep(beat)
yellow1.off()
yellow2.off()
green1.on()
green2.on()
time.sleep(beat)
green1.off()
green2.off()
blue1.on()
blue2.on()
time.sleep(beat)
blue1.off()
blue2.off()
white1.on()
white2.on()
time.sleep(beat)
white1.off()
white2.off()
count += 1
#in order alternating
while pattern == 6 and count <= 3:
beat = tempo / 5000
red1.on()
yellow1.on()
time.sleep(beat)
red1.off()
yellow1.off()
orange1.on()
green1.on()
time.sleep(beat)
orange1.off()
green1.off()
yellow1.on()
blue1.on()
time.sleep(beat)
yellow1.off()
blue1.off()
green1.on()
white1.on()
time.sleep(beat)
green1.off()
white1.off()
blue1.on()
red2.on()
time.sleep(beat)
blue1.off()
red2.off()
white1.on()
orange2.on()
time.sleep(beat)
white1.off()
orange2.off()
red2.on()
yellow2.on()
time.sleep(beat)
red2.off()
yellow2.off()
orange2.on()
green2.on()
time.sleep(beat)
orange2.off()
green2.off()
yellow2.on()
blue2.on()
time.sleep(beat)
yellow2.off()
blue2.off()
green2.on()
white2.on()
time.sleep(beat)
green2.off()
white2.off()
count += 1
#two colors at a time in order
while pattern == 7 and count <= 3:
beat = tempo / 10000
red1.on()
orange1.on()
time.sleep(beat)
red1.off()
yellow1.on()
time.sleep(beat)
orange1.off()
green1.on()
time.sleep(beat)
yellow1.off()
blue1.on()
time.sleep(beat)
green1.off()
white1.on()
time.sleep(beat)
blue1.off()
red2.on()
time.sleep(beat)
white1.off()
orange2.on()
time.sleep(beat)
red2.off()
yellow2.on()
time.sleep(beat)
orange2.off()
green2.on()
time.sleep(beat)
yellow2.off()
blue2.on()
time.sleep(beat)
green2.off()
white2.on()
time.sleep(beat)
blue2.off()
blue2.on()
time.sleep(beat)
white2.off()
green2.on()
time.sleep(beat)
blue2.off()
yellow2.on()
time.sleep(beat)
green2.off()
orange2.on()
time.sleep(beat)
yellow2.off()
red2.on()
time.sleep(beat)
orange2.off()
white1.on()
time.sleep(beat)
red2.off()
blue1.on()
time.sleep(beat)
white1.off()
green1.on()
time.sleep(beat)
blue1.off()
yellow1.on()
time.sleep(beat)
green1.off()
orange1.on()
time.sleep(beat)
yellow1.off()
red1.on()
time.sleep(beat)
red1.off()
count += 1
else:
count = 0
red1.off()
orange1.off()
yellow1.off()
green1.off()
blue1.off()
white1.off()
red2.off()
orange2.off()
yellow2.off()
green2.off()
blue2.off()
white2.off()
pattern = random.randint(1, 8)
"""
from gpiozero import Button, PWMLED
button = Button(17)
red = PWMLED(pin=18, active_high=True, initial_value=1, frequency=100)
green = PWMLED(pin=27, active_high=True, initial_value=0, frequency=100)
def stop():
"""
Releases resources and exits.
"""
print("\nStopping program.")
button.close()
red.close()
green.close()
exit()
if __name__ == '__main__':
print("Press Crtl-C to stop the program.")
try:
while True:
if button.is_pressed:
red.off()
green.on()
else:
red.on()
except KeyboardInterrupt:
stop()
blue_led.on()
red_led.pulse()
green_led.pulse()
button = Button(27)
button.when_released = handle_button_release
button.when_pressed = None
button.hold_time = 3
button.when_held = handle_button_hold
# check initial reservation status
poll_availability()
# schedule the status check to be run every minute
schedule.every(1).minutes.do(poll_availability)
while True:
try:
schedule.run_pending()
time.sleep(1)
except KeyboardInterrupt:
break
finally:
logger.debug("Exiting...")
schedule.clear()
blue_led.off()
red_led.off()
green_led.off()
class Element(Function):
def __init__(self, id, config, inputData, return_queue, cmd_queue):
super().__init__(id, config, inputData, return_queue, cmd_queue)
def execute(self):
#####################################
# #
# REFERENCE IMPLEMENTATION #
# #
#####################################
specificConfig = self.config.get('SpecificConfig')
if not specificConfig:
self.return_queue.put(
Record(None,
message='Trigger: {:04d}'.format(
self.config['Identifier'])))
return
gpioName = None
mainMode = None
subModeLED = None
subModePWMLED = None
gpioWorker = None
cmd = None
self.gpio = None
self.initFlag = False
for attrs in specificConfig:
if attrs['Name'] == 'GPIO':
gpioName = attrs['Data']
if attrs['Name'] == 'MainMode':
mainMode = attrs['Data']
elif attrs['Name'] == 'SubModeLED':
subModeLED = attrs['Data']
elif attrs['Name'] == 'SubModePWMLED':
subModePWMLED = attrs['Data']
if mainMode == 'LED':
self.gpio = LED(gpioName, initial_value=False)
if subModeLED == 'Toggle on input':
gpioWorker = self.ledWorkerToggle
self.gpio.toggle()
self.logLEDstate()
elif subModeLED == 'Control on Input':
gpioWorker = self.ledWorkerCtrl
# set initial state
if self.inputData is not None:
if self.inputData:
self.gpio.on()
else:
self.gpio.off()
self.logLEDstate()
elif subModeLED == 'Blink':
def a(cmd=None):
pass
gpioWorker = a # assign an empty function
self.gpio.blink()
self.return_queue.put(
Record(
None, 'Start LED Blink Mode on GPIO{}'.format(
self.gpio.pin.number)))
elif mainMode == 'PWMLED':
self.gpio = PWMLED(gpioName, initial_value=False)
if subModePWMLED == 'Control on Input':
gpioWorker = self.pwmLedWorkerCtrl
if self.inputData is not None:
self.gpio.value = self.inputData
self.return_queue.put(
Record(
None, 'PWMLED: Set brightness on GPIO{} to {:.2f}'.
format(self.gpio.pin.number, self.inputData)))
elif subModePWMLED == 'Pulse':
def a(cmd=None):
pass
gpioWorker = a # assign an empty function
self.gpio.pulse()
self.return_queue.put(
Record(
None, 'Start PWMLED Pulse Mode on GPIO{}'.format(
self.gpio.pin.number)))
#####################################
# #
# Start of the infinite loop #
# #
#####################################
while (True):
# Example code: Do something
try:
# Block for 1 second and wait for incoming commands
cmd = None
cmd = self.cmd_queue.get(block=True, timeout=1)
except queue.Empty:
pass
if isinstance(cmd, ProcCMD):
if cmd.bStop:
# Stop command received, exit
self.return_queue.put(
Record(None,
'GPIO{} closed'.format(self.gpio.pin.number)))
self.gpio.close()
return
gpioWorker(cmd)
def logLEDstate(self):
self.return_queue.put(
Record(
None,
'Switch LED on GPIO{} to {}'.format(self.gpio.pin.number,
self.gpio.is_active)))
def ledWorkerToggle(self, cmd=None):
if cmd is None:
return
self.gpio.toggle()
self.logLEDstate()
def ledWorkerCtrl(self, cmd=None):
if cmd is None:
return
if cmd.data:
self.gpio.on()
else:
self.gpio.off()
self.logLEDstate()
def pwmLedWorkerCtrl(self, cmd=None):
if cmd is None:
return
try:
self.gpio.value = cmd.data
except Exception:
self.gpio.close()
raise
self.return_queue.put(
Record(
None, 'PWMLED: Set brightness on GPIO{} to {:.2f}'.format(
self.gpio.pin.number, cmd.data)))
from gpiozero import LED, PWMLED
power = LED(35)
activity = PWMLED(47)
# Los LED parpadean, en segundo plano
power.blink(on_time=0.5, off_time=0.5)
# activity.blink(on_time=0.1, off_time=0.1)
activity.pulse(fade_in_time=1, fade_out_time=2)
# Parar la ejecución cuando queramos:
input("Pulsa Enter para finalizar")
power.off()
activity.off()
class LED(object):
def __init__(self, pin_gpio, name="GPIO"):
"""
Constructor del objeto LED
Args:
pin_gpio (int): pin GPIO donde va a estar conectado el dispositivo.
name (str, optional): Nombre con el que se mostrará el dispositivo en los diferentes servicios implementados. Defaults to "GPIO".
"""
self.GPIO = PWMLED(pin_gpio)
self.name = name if name != "GPIO" else "GPIO " + str(pin_gpio)
self.set_blink = False
self.sensors = []
def on(self):
self.GPIO.on()
def set_value(self, pwm_value):
self.GPIO.value = pwm_value
def off(self):
self.GPIO.off()
def blink(self, time_blink, inter_blink):
alarma_n = ceil(time_blink / (2 * inter_blink))
for k in range(alarma_n):
if not self.set_blink:
break
self.GPIO.on()
sleep(inter_blink)
self.GPIO.off()
sleep(inter_blink)
def on_time(self, time_on):
"""
Se queda prendido un cierto tiempo determinado por time on
Args:
time_on (float): Tiempo que estara prendido el LED.
"""
self.GPIO.on()
sleep(time_on)
self.GPIO.off()
def set_light_sensor(self, sensor):
"""
Establece el dispositivo para sensar.
Args:
sensor (LightSensor): Sensor con el que se trabajara
"""
global light_sensor_enable
self.light_sensor = sensor
light_sensor_enable = False
self.sensors.append(sensor)
def use_light_sensor_exp(self,
use_pwm=False,
on_range=(0.5, 1),
debug=False):
"""
Utiliza el sensor de forma indeterminada con los valores que se le hayan asignado.
Args:
use_pwm (bool, optional): Si se requiere que el valor del LED dependa completamente del sensor de luz. Defaults to False.
on_range (tuple, optional): Rango en el que estara encendido el LED. Defaults to (0.5,1).
"""
global light_sensor_enable
light_sensor_enable = True
Thread(target=use_sensor,
args=(self.GPIO, self, self.light_sensor, use_pwm,
on_range)).start()
return
def turn_off_sensor(self):
global light_sensor_enable
light_sensor_enable = False
return
def turn_on_sensor(self):
global light_sensor_enable
light_sensor_enable = True
self.use_light_sensor_exp()
return
def use_light_sensor(self, use_pwm=False, on_range=(0.5, 1), debug=False):
"""
Utiliza el sensor de forma indeterminada con los valores que se le hayan asignado.
Args:
use_pwm (bool, optional): Si se requiere que el valor del LED dependa completamente del sensor de luz. Defaults to False.
on_range (tuple, optional): Rango en el que estara encendido el LED. Defaults to (0.5,1).
"""
self.light_sensor_enable = True
while self.light_sensor_enable:
if debug:
print(self.light_sensor.value)
if not use_pwm:
if on_range[
0] <= self.light_sensor.value and self.light_sensor.value <= on_range[
1]:
self.on()
else:
self.off()
else:
self.GPIO.source = self.light_sensor
message
if command == "fire":
insert_fire_event(
conn,
station,
"fire outbreak",
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
)
SERIAL and sendCommand(message)
if station == STATION_NAME:
status_led and status_led.on()
else:
status_led and status_led.blink(0.5, 0.5)
elif command == "reset":
SERIAL and sendCommand(message)
status_led and status_led.off()
except IndexError:
print("Error processing message")
if time.time() - postTime > POST_INTERVAL:
postTime = time.time()
print("sending values to cloud")
send_values_cloud(conn)
time.sleep(0.1)
# while True:
# a = 1
# msg = ser.readline().decode("utf-8").strip()
# print(msg)
#!/usr/bin/python3
from gpiozero import LED, PWMLED
from time import sleep
import random
LED_W = PWMLED(13, initial_value=0.1)
LED_W.off()
STAR_NUMBERS = [14, 15, 23, 24, 25, 8, 7, 12, 16, 4, 17, 27, 22, 10, 9, 11, 5, 6, 26]
STARS = []
MAX_ID = len(STAR_NUMBERS) - 1
for led_num in STAR_NUMBERS:
STAR = LED(led_num)
STARS.append(STAR)
while True:
for i in range(0, MAX_ID * 2):
star_id = random.randint(0, MAX_ID)
STARS[star_id].on()
sleep(0.2)
for i in range(0, MAX_ID * 2):
star_id = random.randint(0, MAX_ID)
STARS[star_id].off()
sleep(0.2)
from gpiozero.pins.pigpio import PiGPIOFactory
from gpiozero import Buzzer
from gpiozero import PWMLED
from time import sleep
# for Buzzer
"""
bz = Buzzer(12)
bz.beep(n=3, background=False)
"""
# pseudo tonal buzzer
tones = [392, 262, 440, 349, 330, 262, 294]
factory = PiGPIOFactory()
led = PWMLED(12,pin_factory=factory)
for tone in tones:
led.frequency = tone
led.value = 0.1
sleep(1)
led.off()
class led(Sensor):
def __init__(self, sensorType = 0, sensorcode = '', pins = '0', parameters = ''):
#调用父类的构函
Sensor.__init__(self, sensorType, sensorcode, pins, parameters)
for pin in self.Pins:
self.led = PWMLED(pin)
def SetupGPIO(self):
for pin in self.Pins:
GPIO.setup(pin, GPIO.OUT)
pass
def ReadToCache(self):
self.Values.clear()
for pin in self.Pins:
value = float(self.Parameters[0])
self.led.value = value
self.Values.append(value)
#将采集到的数据存入redis缓存
self.SetCache()
print('ReadToCache', datetime.datetime.now(), self.GetKey(), self.Pins, self.Values, self.Redis.GetCount(self.SensorCode))
pass
def GetSqlStr(self):
value0 = "INSERT INTO learn_led(sensor_code,is_led,create_time,status) VALUES"
value1 = "({0},{1},'{2}',0),".format(self.SensorCode,self.Values[0],datetime.datetime.now())
return value0,value1
def Stop(self):
self.Values.clear()
for pin in self.Pins:
self.led.off()
self.Values.append(0)
def SensorControllerSpecial(self,spacket):
try:
flag = False
if spacket.ControlName == 11: #开灯并调节亮度
flag = self.ReSet(spacket.SensorPins, spacket.ControlData)
print('重置传感器',flag)
elif spacket.ControlName == 12: #调节亮度
print('调节亮度',spacket.ControlData)
self.led.value = float(spacket.ControlData)
flag = True
else:
print('无此命令')
return flag
except Exception as e:
return False
def init_led(self):
"""Create and initialise an LED Object"""
global led
led = PWMLED(LED_GPIO_PIN)
led.off()
from datetime import datetime
from time import sleep
from gpiozero import PWMLED
star = PWMLED(2)
#store christmas day in the current year in the c_day variable
c_day=datetime(datetime.now().year,12,25)
#subrotuine to advoid copy pasting code
def get_time():
#get the current time down to the microsecond
today = datetime.now()
#find the difference between c_day and the time in the today variable
rd = c_day-today
#converts rd as a number of seconds to a string to so we can get only everything before the decimal point
#then converts that to an integer and divides that integer by 500,000
time=int(str(rd.total_seconds()).split(".")[0])/500000
return time
while True:
#turns the star on
star.on()
#waits for the amount of seconds returned by get_time
sleep(get_time())
#turns the star off
star.off()
#waits for the amount of seconds returned by get_time
sleep(get_time())
rgbLED.color = (0, 1, 0) # green
time.sleep(1)
rgbLED.color = (0, 0, 1) # blue
time.sleep(1)
rgbLED.color = (1, 1, 1) # bright white
time.sleep(1)
rgbLED.color = (.01, .01, .01) # dim white
time.sleep(1)
rgbLED.off()
# turn on LED
singleLED.value = .01 # dim
time.sleep(1)
singleLED.value = 1 # bright
time.sleep(1)
singleLED.off()
# test the Rangefinder
for thisloop in range(0, 5):
print(thisloop, ' - Distance to nearest object is', rangefind.distance,
'm')
time.sleep(1)
# control the LEDs with the rangefinder
while True:
rangefindDistance = rangefind.distance
DIST = rangefindDistance if rangefindDistance <= 1 else 1
invDIST = .1 / rangefindDistance if .1 / rangefindDistance <= 1 else 1
print(DIST, "-", invDIST)
if DIST < 1:
singleLED.blink(on_time=DIST, off_time=invDIST)
print('* Detected Vibration! *')
print('***********************************')
sleep(1)
def stop():
"""
Releases resources and exits.
"""
print("\nStopping program.")
vibration_switch.close()
red.close()
green.close()
exit()
if __name__ == '__main__':
print("Press Crtl-C to stop the program.")
try:
while True:
if vibration_switch.is_pressed:
green.off()
red.on()
print_message()
red.off()
green.on()
else:
green.on()
except KeyboardInterrupt:
stop()
from gpiozero import LED
from gpiozero import PWMLED
from time import sleep
sololed = PWMLED(17)
for i in range(0,3):
sololed.on()
sleep(.5)
sololed.off()
sleep(.5)
print("begin pulsing")
sololed.pulse(n=3,background=False)
print("end pulsing")
led=[]
sleeptime=.01
for i in range(0,10):
led.append(LED(i+2))
while True:
for i in range(0,10):
print("{} on".format(i))
led[i].on()
sleep(sleeptime)
print(" off")
led[i].off()
sleep(sleeptime)
for i in range(9,-1,-1):
print("{} on".format(i))
class DisplayController:
KILL_THREAD = False
thread = None
DISPLAY_CONFIGURATIONS = [
# [0, 0, 0, 0, 0], # 0
[1, 0, 0, 0, 0], # 1
[1, 1, 0, 0, 0], # 2
[1, 1, 1, 0, 0], # 3
[1, 1, 1, 1, 0], # 4
[1, 1, 1, 1, 1]
] # 5
BRIGHTNESS = 0.10
def __init__(self):
self.leds = [PWMLED(23), PWMLED(24), PWMLED(25), PWMLED(8), PWMLED(7)]
self.recording_led = PWMLED(1)
self.num_messages = 0
def display_message_counter(self, num_messages):
self.num_messages = num_messages
if num_messages == 0:
self.turn_off()
return
# rollover after 5 back to 1
num_messages = (num_messages % 5) - 1
config = self.DISPLAY_CONFIGURATIONS[num_messages]
i = 0
for c in config:
print(c)
if c:
self.leds[i].value = self.BRIGHTNESS
else:
self.leds[i].off()
i = i + 1
def display_recording(self, rec=False):
if (rec):
self.turn_off()
self.recording_led.pulse(fade_in_time=1, fade_out_time=1)
else:
self.recording_led.off()
def increase_display_count(self):
self.display_message_counter(self.num_messages + 1)
def decrease_display_count(self):
self.display_message_counter(self.num_messages - 1)
def turn_off(self, fade_out=False):
for l in self.leds:
l.off()
def display_loading(self, _sleep=.15, _in=.3, _out=.95):
self.turn_off()
for l in self.leds:
l.pulse(fade_in_time=_in, fade_out_time=_out)
sleep(_sleep)
def stop_loading(self):
self.turn_off()
def display_downloading(self, _sleep=.15, _in=.3, _out=.95):
self.turn_off()
for l in reversed(self.leds):
l.pulse(fade_in_time=_in, fade_out_time=_out)
sleep(_sleep)
def display_fetch_error(self):
self.turn_off()
for l in self.leds:
l.blink(on_time=.2, off_time=.2, n=2)
# blink(on_time=1, off_time=1, fade_in_time=0, fade_out_time=0, n=None, background=True)
sleep(.2 * 2 * 2)
self.display_message_counter(self.num_messages)
def display_device_ready(self):
for l in self.leds:
l.pulse(fade_in_time=.36, fade_out_time=.36, n=1, background=True)
sleep(.12)
# fade_in_time=1, fade_out_time=1, n=None, background=True
sleep(.8)
def display_message_playing(self):
self.turn_off()
self.display_message_counter(self.num_messages)
num_messages = (self.num_messages % 5) - 1
self.leds[num_messages].pulse()
