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():
""" Main loop """
args = get_args()
params = load_params(args)
test = False
if args.version:
print(u'Version : {}'.format(__version__))
sys.exit(0)
if args.infos:
print_infos(params)
sys.exit(0)
if args.verbose:
print_infos(params)
count = 1
if args.test:
count = args.test
test = True
# exit(0)
factory = RPiGPIOFactory()
fan = PWMLED(params['gpio_pin'], pin_factory=factory)
fan.on()
fan_on = False
fan.value = 0
temp_seuil = (params['temp_max'] + params['temp_min']) / 2
while count > 0:
if test:
count += -1
temp = get_temp()
if not fan_on and temp > temp_seuil:
fan_on = True
if temp < params['temp_min']:
fan_on = False
fan.value = 0
if fan_on:
voltage = get_voltage(params)
fan.value = voltage
if test:
print(u'temp: {} voltage: {}'.format(temp, fan.value), flush=True)
time.sleep(params['sleep_interval'])
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()
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())
green_led.pulse()
else:
logger.info("Meeting room free at the moment!")
red_led.off()
green_led.on()
if __name__=="__main__":
try:
logger.info("Starting up the experiment...")
# setup pins
blue_led = PWMLED(22) # used as a status indicator
red_led = PWMLED(17) # used as "reserved" indicator
green_led = PWMLED(4) # used as "free" indicator
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)
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)))
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
class HD44780:
def __init__(self, pin_rs=7, pin_e=8, pins_db=[25, 24, 23, 18]):
self.pin_rs=pin_rs
self.pin_e=pin_e
self.pins_db=pins_db
self.contrast = PWMLED(15,frequency=25)
self.contrast.on()
self.contrast.value=.55
self.Contrastbutton = Button(14)
self.Contrastbutton.when_pressed = self.ContrastPressed
self.brightness = PWMLED(20,frequency=60)
self.brightness.on()
self.brightness.value=.95
self.Brightnessbutton = Button(21)
self.Brightnessbutton.when_pressed = self.BrightnessPressed
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.pin_e, GPIO.OUT)
GPIO.setup(self.pin_rs, GPIO.OUT)
for pin in self.pins_db:
GPIO.setup(pin, GPIO.OUT)
self.clear()
def ContrastPressed(self):
nCurrentContrastValue = self.contrast.values.next() + .1
self.contrast.value = nCurrentContrastValue if nCurrentContrastValue < 1 else .05
self.clear()
self.message("Contrast: " + str(self.contrast.values.next()))
def BrightnessPressed(self):
nCurrentBrightnessValue = self.brightness.values.next() + .1
self.brightness.value = nCurrentBrightnessValue if nCurrentBrightnessValue < 1.01 else .10
self.clear()
self.message("Brightness: " + str(self.brightness.values.next()))
def clear(self):
""" Blank / Reset LCD """
self.cmd(0x33) # $33 8-bit mode
self.cmd(0x32) # $32 8-bit mode
self.cmd(0x28) # $28 8-bit mode
self.cmd(0x0C) # $0C 8-bit mode
self.cmd(0x06) # $06 8-bit mode
self.cmd(0x01) # $01 8-bit mode
def cmd(self, bits, char_mode=False):
""" Send command to LCD """
sleep(0.001)
bits=bin(bits)[2:].zfill(8)
GPIO.output(self.pin_rs, char_mode)
for pin in self.pins_db:
GPIO.output(pin, False)
for i in range(4):
if bits[i] == "1":
GPIO.output(self.pins_db[::-1][i], True)
GPIO.output(self.pin_e, True)
GPIO.output(self.pin_e, False)
for pin in self.pins_db:
GPIO.output(pin, False)
for i in range(4,8):
if bits[i] == "1":
GPIO.output(self.pins_db[::-1][i-4], True)
GPIO.output(self.pin_e, True)
GPIO.output(self.pin_e, False)
def message(self, text):
""" Send string to LCD. Newline wraps to second line"""
for char in text:
if char == '\n':
self.cmd(0xC0) # next line
else:
self.cmd(ord(char),True)
"""
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()
setVolume(1.0) #Set the volume a little more louder for shutdown sound
pygame.mixer.music.play()
def setVolume(volumeLevel):
pygame.mixer.music.set_volume(volumeLevel)
########Setup up our GPIO Pins
GPIO.setmode(GPIO.BCM)
GPIO.setup(ledGPIO, GPIO.OUT)
btn = Button(buttonGPIO, hold_time=holdTime)
#########This happens at Startup
pygame.init()
playSoundFile(startupSound)
while (pygame.mixer.music.get_busy()
): #Wait till our song finishes, then shutdown
GPIO.output(ledGPIO, True)
continue
whiteLED = PWMLED(ledGPIO)
whiteLED.on()
btn.when_held = when_held
btn.when_pressed = when_pressed
btn.when_released = when_released
pause() #This is much better than using an infinite loop
#and constantly checking if buttons were pressed;
#it doesn't drain too much CPU, so that's good.
#########
ecodes.KEY_0,
)
evdev_device = 0
try:
evdev_device = int(sys.argv[1])
except IndexError:
pass
except ValueError:
pass
print("Almost there, pulse the eyes to let the user know")
eyes = PWMLED(21)
eyes.blink(0.5, 0.25, 0.25, 0.25, 3, False)
eyes.on()
print("Initialised, now handling events")
try:
# Only run the motors at 50% initially
power = 0.5
# Process the (lirc-spawned) events
device = InputDevice("/dev/input/event" + str(evdev_device))
for event in device.read_loop():
if event.type == ecodes.EV_KEY:
if event.value == 1: # key down
if event.code in robot_movement:
robot_movement[event.code](power)
elif event.code in robot_power:
power = (event.code - 1) / 10
rec_stream.stop_recording()
rec_stream.close()
reclist = get_recordingsList(basepath + '/recordings/')
MainMenu.replaceLevelItemList('0.', reclist[0])
record_led.off()
standard_screen()
while len(play) > 0:
item = play.popleft()
if item == 0 and menu and MainMenu.CurrentItem.startswith('0.') and not playing:
selectedrecording = int(MainMenu.CurrentItem.split('.')[MainMenu.CurrentLevel])
custom_chars.load_progress()
player = AudioIO.Player(channels=output_channels, rate=output_rate, device=output_device)
player_stream = player.open(reclist[1][selectedrecording])
player_stream.start_playing()
play_screen = dsphlp.display_screen(lcd)
play_led.on()
playing = True
elif playing:
player_stream.toggle()
play_led.toggle()
while len(loop) > 0:
item = loop.popleft()
if item == 0 and menu and not playing:
if MainMenu.CurrentLevel == 0:
standard_screen()
idle = True
menu = False
else:
MainMenu.levelAscent()
dsphlp.dspwrite(lcd, MainMenu.AllItems[MainMenu.CurrentItem])
elif item == 0 and idle and not shutdown_bit:
prev_led = PWMLED(22)
while True:
# update staus LEDs
if b"paused" in subprocess.check_output(["mpc", "status"]):
toggle_led.pulse(fade_in_time=0.5,
fade_out_time=0.5,
n=None,
background=True)
next_led.pulse(fade_in_time=0.5,
fade_out_time=0.5,
n=None,
background=True)
prev_led.pulse(fade_in_time=0.5,
fade_out_time=0.5,
n=None,
background=True)
else:
toggle_led.pulse(fade_in_time=0.5,
fade_out_time=0,
n=1,
background=True)
next_led.pulse(fade_in_time=0.5, fade_out_time=0, n=1, background=True)
prev_led.pulse(fade_in_time=0.5, fade_out_time=0, n=1, background=True)
sleep(0.4)
toggle_led.on()
prev_led.on()
next_led.on()
# wait for status to change
subprocess.check_output(["mpc", "idle"])
from gpiozero import MCP3008, PWMLED
from time import sleep
LED_PIN = 18
adc = MCP3008(channel=0)
pwm_led = PWMLED(LED_PIN)
pwm_led.on()
while True:
print("{:.0%}".format(adc.value))
pwm_led.value = adc.value
sleep(0.2)
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 PWMLED
status_led = PWMLED(24)
type = int(input("Enter type: "))
if type == 0:
status_led.on()
elif type == 1:
status_led.blink(0.5, 0.5)
while True:
a = 1
#lut_partial_update
epd = epd2in7.EPD()
epd.init()
epd.Clear(0xFF)
print("cleaned")
#GPIO setup
greenLed = PWMLED("BOARD33")
yellowLed = PWMLED("BOARD35")
redLed = PWMLED("BOARD37")
greenButton = Button("BOARD36")
yellowButton = Button("BOARD38")
redButton = Button("BOARD40", hold_time=5)
greenLed.on()
#Epaper function
def updateEpaperLoop():
month = time.strftime("%m")
day = time.strftime("%d")
wk_day = time.strftime("%A")
hour_number = time.strftime("%H")
min_number = time.strftime("%M")
sec_number = time.strftime("%S")
date = month + "/" + day + " " + wk_day
hourMin = hour_number + ":" + min_number
print("Got time")
statusName = "thinking"
img = imageGenerator.generateImage((epd.height, epd.width), date, hourMin,
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()
if(run_on_remote):
print("connecting with remote ... ")
remote_factory = PiGPIOFactory(host=remote_host)
left = PWMLED(27, pin_factory=remote_factory)
right = PWMLED(22, pin_factory=remote_factory)
vor = PWMLED(13, pin_factory=remote_factory)
back = PWMLED(19, pin_factory=remote_factory)
print("connected")
else:
left = PWMLED(13)
right = PWMLED(19)
vor = PWMLED(22)
back = PWMLED(27)
control_led = PWMLED(17)
control_led.on()
#home = 192.168.2.205
#svenja = 192.168.178.41
throttle_stages = [0.2, 0.3, 0.5, 0.7, 0.9, 1.0]
current_throttle_stage = 2
class MyController(Controller):
#https://pypi.org/project/pyPS4Controller/
def __init__(self, **kwargs):
Controller.__init__(self, **kwargs)
##arrows
def on_up_arrow_press(self):
rpi_temp = round(sensor.read_temperature())
rpi_light_level = round(light_sensor.value * 100)
responses.append(f"edge_rpi-{rpi_temp}-{rpi_light_level}")
for response in responses:
values = response.split("-")
if len(values) == 3:
temp = int(values[1])
light_level = int(int(values[2]) / 255 * 100) if not values[0].startswith('edge') else int(values[2])
insert_sensor_data(
conn, f"{STATION_NAME} {values[0]}", temp, light_level
)
if temp > TEMP_THRESHOLD and light_level > LIGHT_THRESHOLD:
print("fire outbreak detected")
status_led and status_led.on()
curr_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
event = "fire outbreak"
SERIAL and sendCommand(f"{STATION_NAME} fire")
insert_fire_event(conn, STATION_NAME, event, curr_time)
send_event_cloud(STATION_NAME, event, curr_time)
while message_cache:
try:
message = message_cache.pop().strip()
message_arr = message.split(" ")
station = message_arr[0]
command = message_arr[1]
message
if command == "fire":
insert_fire_event(
#!/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()
led1_fadein = 3
led1_fadeout = 1.5
hold_time = 3.0
#----- functions ------
def shut_down():
led1.pulse(led1_fadein, led1_fadeout)
system("sudo shutdown -h now")
sleep(40) # should take no more than 40 secs to shutdown
#----- start of main logic------
while True:
led1.on()
btn1.wait_for_press()
led1.blink(0.2, 0.2)
start_time = time()
while btn1.value == True:
sleep(0.1)
duration = time() - start_time
if duration > hold_time:
shut_down()
#----- end of main logic -----
p = subprocess.Popen(["/usr/bin/vcgencmd", "measure_temp"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).communicate()[0]
# extract the raw value
val = p.split('=')[1].split('\'')[0]
# convert string to float
return float(val)
def convertF(degreesc):
return (degreesc * 1.8) + 32
def intensity(value, min, max):
if value < min:
return 0.0
elif value > max:
return 1.0
else:
return (1.0) * (value - min) / (max - min)
led = PWMLED(17)
led.on()
while True:
led.value = intensity(convertF(readTemp()), 115, 125)
print led.value
time.sleep(0.5)
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))
forwardLed.off()
if event.key == pygame.K_a:
leftLed.off()
if event.key == pygame.K_s:
reverseLed.off()
if event.key == pygame.K_d:
rightLed.off()
else:
keys = pygame.key.get_pressed()
if keys[pygame.K_w]:
forwardVoltage += increment
if forwardVoltage > 1:
forwardVoltage = 1
print("Brightness limit reached")
forwardLed.on()
reverseLed.off()
forwardLed.value = forwardVoltage
print("w pressed")
if keys[pygame.K_s]:
reverseVoltage += increment
if reverseVoltage > 1:
reverseVoltage = 1
print("Brightness limit reached")
reverseLed.on()
forwardLed.off()
reverseLed.value = reverseVoltage
print("s pressed")
if keys[pygame.K_a]:
