def __init__(self, r, g, b, ww, cw):
# set up pwm pins
factory = PiGPIOFactory()
self.red = PWMLED(r, pin_factory=factory)
self.green = PWMLED(g, pin_factory=factory)
self.blue = PWMLED(b, pin_factory=factory)
self.warm = PWMLED(ww, pin_factory=factory)
self.cool = PWMLED(cw, pin_factory=factory)
# initialize state vector
self.i = 5
self.states = [0, 0, 0, 0, 0, 0]
self.states[self.i] = 1
self.on = False
# pwm value
self.val = 0.5
def ledWithVaryingBrightness(gpio="GPIO26"):\
# PWM (pulse-width-modulation)
led = PWMLED(gpio)
led.value = 0.5 # half brightness
sleep(1)
led.value = 1 # full brightness
sleep(1)
led.value = 0 # off
sleep(1)
def initialize_mfc():
mfc_pin1 = 5
mfc_pin2 = 6
mfc_pin3 = 13
# Although these are not LEDs,
# PWMLED is the easiest pwm implementation
# in gpiozero and will be used for mfcs
mfc1 = PWMLED(mfc_pin1)
mfc2 = PWMLED(mfc_pin2)
mfc3 = PWMLED(mfc_pin3)
mfc1.value = 0.0
mfc2.value = 0.0
mfc3.value = 0.0
return mfc1, mfc2, mfc3
def __init__(self):
"""
instantiate objects
this process will establish communication links
if fail then raise an exception that will terminate the program
"""
# dictionary of flight parameters
self.parameters = {"descent_vel": 0.25, "logging_interval": 0.1}
# Pulse the green LED constantly while script is running
self.green_led = PWMLED(22)
self.green_led.pulse(fade_in_time=0.5, fade_out_time=0.5)
# Flash the red LED if an error occurs
self.red_led = LED(17)
# If the button is held for 3 seconds then end the script
self.button = Button(26)
self.button.hold_time = 3
self.button.when_held = self.__prepare_exit
self.gcs = GroundControlStation()
if self.gcs.initSuccessful:
self.report("Link to GCS established")
else:
# if fail to open link to GCS no means of reporting so enter specific sequence
self.alert_initialisation_failure()
raise ValueError(
"Failed to communicate with Ground Control Station")
self.fc = FlightController()
if self.fc.initSuccessful:
self.report("Link to FC established")
else:
self.report("Link to FC failed")
raise ValueError("Failed to communicate with Flight Controller")
self.uC = MicroController()
if self.uC.initSuccessful:
self.report("Link to uC established")
else:
self.report("Link to uC failed")
raise ValueError("Failed to communicate with Micro Controller")
self.logger = DataLogging()
self.vision = LandingVision()
self.scheduler = RecurringTimer(self.parameters["logging_interval"],
self.__monitor_flight)
# Setting up class attributes
self.abortFlag = None
self.emergency_land = False
self.state = "Initial"
self.received_mission = None
self.mission_title = "Default mission name"
self.reporting_count = 0
def button_3():
while True:
if BUTTON3.value == 1 and LED1.value == 0:
turn_led_on()
PWMLED(12, True, 0.50, 100) # De functie heb ik nog niet werkende gekregen spijtig genoeg.
time.sleep(0.25)
if BUTTON3.value == 1 and LED1.value == 1:
turn_led_off()
time.sleep(0.25)
class CustomSliderWidget(BoxLayout):
Value_Slider_One = '0'
Value_Slider_Two = '0'
Value_Slider_Three = '0'
slider_min = NumericProperty(0)
slider_max = NumericProperty(1)
fontsize = NumericProperty(50)
sliderheight = StringProperty('40dp')
try:
led_red = PWMLED(17) #17
led_green = PWMLED(22) #22
led_blue = PWMLED(27) #27
print("successfully declared PWM LEDs")
except NameError:
pass
def setvalue_one(self, *args):
self.textboxone.text = str(float(format(args[1], '.5f')))
value_output = float(args[1])
try:
self.led_red.value = value_output
print('Changed the value of the Red LED')
except AttributeError:
print('Value change not succesful ', value_output)
def setvalue_two(self, *args):
self.textboxtwo.text = str(float(format(args[1], '.5f')))
try:
self.led_green.value = float(args[1])
print('Changed the value of the Green LED')
except AttributeError:
pass
def setvalue_three(self, *args):
self.textboxthree.text = str(float(format(args[1], '.5f')))
try:
self.led_blue.value = float(args[1])
print('Changed the value of the Blue LED')
except AttributeError:
pass
def __init__(self, gpio_pin, state=None):
print("LED_INIT")
self._led = PWMLED(pin=gpio_pin, frequency=100)
self._led.value = 0
self._brightness_queue = Queue(0)
self._brightness_thread = None
self._max_brightness = 0.7
self._doc = None
if (state):
self.set_state(state)
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 __init__(self, gpio_pin, brightness=100):
"""
Constructor of a PWM LED.
:param gpio_pin:
GPIO pin assignment (not the header pin number)
:param brightness:
Brightness percentage. Defaults to 100%.
"""
self.led = PWMLED(gpio_pin)
self.brightness = brightness / 100.0 # brightness value is from 0 to 1.0
def getLEDs(pins):
leds = {}
for pin in pins:
try:
leds[pin] = PWMLED(pin)
except:
pass
return leds
def pwm(self, pin_number: int, value: float) -> bool:
if (
pin_number in self.pins and
self.pins[pin_number]['mode'] in [None, self.MODE_OUT]
):
self.pins[pin_number]['mode'] = self.MODE_OUT
if self.pins[pin_number]['obj'] is None:
self.pins[pin_number]['obj'] = PWMLED(pin_number, pin_factory=self.remote_gpio)
self.pins[pin_number]['obj'].value = value
return True
return False
def _setupBtnLedPins(self):
"""Sets up the board's lcd & led based on my breadboard's pin configuration"""
#------------------------------------------ Buttons & LED ------------------------------------------#
self.__leds = {
"red": PWMLED(6),
"yellow": PWMLED(13),
"green": PWMLED(19),
"blue": PWMLED(26)
}
self.__btns = {
"red": Button(12),
"yellow": Button(16),
"green": Button(20),
"blue": Button(21)
}
#------------------------------------------ Btn-LED Pairs ------------------------------------------#
createPairs = lambda name: (
name, ButtonLedPair(self.getLedObj(name), self.getBtnObj(name)))
self.btnLedPairs = dict(map(createPairs, list(self.getLedNames())))
def init_fan(self, pin, frequency, speed):
try:
self.deinit_fan()
self.fan = PWMLED(pin=pin,
initial_value=speed,
frequency=frequency,
pin_factory=self.pin_factory)
self._logger.info("PWM pin initialized with pin factory: " +
str(self.fan.pin_factory))
except:
self._logger.error("Error occurred while initializing PWM pin")
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 ledPWMStart(pinNum, sleepTimeSec):
"""
ledpwm.value = 0 # off
ledpwm.value = 0.5 # half brightness
ledpwm.value = 1 # full brightness
"""
ledpwm = PWMLED(pinNum)
pwmVal = [x * 0.1 for x in range(0, 10)]
while True:
for val in pwmVal:
ledpwm.value = val
sleep(sleepTimeSec / 2)
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 main():
# Set r, g and b as global variables and define them
# I had to define them here because of a weird quirk in the Daemonize library, this was a headache
global r
global g
global b
r = PWMLED(os.getenv('GPIO_RED'))
g = PWMLED(os.getenv('GPIO_GREEN'))
b = PWMLED(os.getenv('GPIO_BLUE'))
# Define UDP socket and bind to it
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((address, port))
# Create variable which is checked by threads to see if they should stop
global stopthread
# Continue listening for input
while True:
data, addr = sock.recvfrom(1024)
instructions = data.decode('ascii').split(",")
print(instructions)
if 'cthread' in locals():
stopthread = True
cthread.join()
if instructions[0] == 'single':
set(instructions[-1])
if instructions[0] == 'strobe':
stopthread = False
cthread = Thread(target=strobe, args=(instructions,))
cthread.start()
if instructions[0] == 'fade':
stopthread = False
cthread = Thread(target=fade, args=(instructions,))
cthread.start()
if instructions[0] == 'breathe':
stopthread = False
cthread = Thread(target=breathe, args=(instructions,))
cthread.start()
def main():
# now just write the code you would use in a real Raspberry Pi
from Adafruit_CharLCD import Adafruit_CharLCD
from gpiozero import Buzzer, LED, PWMLED, Button, DistanceSensor, LightSensor, MotionSensor
from lirc import init, nextcode
from py_irsend.irsend import send_once
from time import sleep
def show_sensor_values():
lcd.clear()
lcd.message(
"Distance: %.2fm\nLight: %d%%" % (distance_sensor.distance, light_sensor.value * 100)
)
def send_infrared():
send_once("TV", ["KEY_4", "KEY_2", "KEY_OK"])
lcd = Adafruit_CharLCD(2, 3, 4, 5, 6, 7, 16, 2)
buzzer = Buzzer(16)
led1 = LED(21)
led2 = LED(22)
led3 = LED(23)
led4 = LED(24)
led5 = PWMLED(25)
led5.pulse()
button1 = Button(11)
button2 = Button(12)
button3 = Button(13)
button4 = Button(14)
button1.when_pressed = led1.toggle
button2.when_pressed = buzzer.on
button2.when_released = buzzer.off
button3.when_pressed = show_sensor_values
button4.when_pressed = send_infrared
distance_sensor = DistanceSensor(trigger=17, echo=18)
light_sensor = LightSensor(8)
motion_sensor = MotionSensor(27)
motion_sensor.when_motion = led2.on
motion_sensor.when_no_motion = led2.off
init("default")
while True:
code = nextcode()
if code != []:
key = code[0]
lcd.clear()
lcd.message(key + "\nwas pressed!")
sleep(0.2)
def ledWithVaryingBrightness(gpio=""):
from gpiozero import PWMLED
from time import sleep
led = PWMLED(gpio)
time = 5
while time > 0:
led.value = 0 # off
sleep(1)
led.value = 0.5 # half brightness
sleep(1)
led.value = 1 # full brightness
sleep(1)
def __init__(self, config):
'''
:param motorPin0:
:param motorPin1:
:param real:
:param deadZone: speeds too low to attempt to move motor
:param frontWhite:
:param frontRed:
:param rearRed:
:param readWhite:
'''
self.motor = None
self.frontWhiteLight = None
self.frontRedLight = None
self.rearWhiteLight = None
self.rearRedLight = None
self.redBrightness = config["redBrightness"]
self.whiteBrightness = config["whiteBrightness"]
# really on a pi with a motor?
self.real = config["real"]
self.deadZone = config["deadZone"]
# user-facing controls
self.requestedSpeed = 0
self.headlights = False
self.reverse = False
self.config = config
if config["real"]:
self.motor = Motor(config["motorPin0"], config["motorPin1"])
if config["frontWhitePin"] is not None:
self.frontWhiteLight = PWMLED(config["frontWhitePin"])
if config["frontRedPin"] is not None:
self.frontRedLight = PWMLED(config["frontRedPin"])
if config["rearWhitePin"] is not None:
self.rearWhiteLight = PWMLED(config["rearWhitePin"])
if config["rearRedPin"] is not None:
self.rearRedLight = PWMLED(config["rearRedPin"])
def __init__(self,
green_leds=[6, 13, 19, 26],
red_leds=[12, 16, 20, 21],
indicator=22):
# Init leds
# self.green_leds = LEDBarGraph(6, 13, 19, 26, pwm=True)
self.green_leds = LEDBarGraph(*green_leds, pwm=True)
# self.red_leds = LEDBarGraph(12, 16, 20, 21, pwm=True)
self.red_leds = LEDBarGraph(*red_leds, pwm=True)
self.indicator = PWMLED(indicator)
self.vote_getter = VoteGetter()
self.curr_votes = Votes(100, 1)
self.leds_from_votes(self.curr_votes)
def getLEDs(pins):
leds = {}
for pin in pins:
try:
leds[pin] = {
'LED': PWMLED(pin),
'Overwrite': False
}
except:
pass
return leds
def main():
led = PWMLED(conf.LED_PIN)
led.blink()
# each item in conf.BTNS[] is an individual button setting
for this in conf.BTNS:
this['button'] = Button(this['PIN'])
this['button']when_released = put_curry(this['LABEL'])
print("ready!")
led.pulse()
pause()
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 __init__(self, baseClock):
self.baseClock = baseClock
self.r = LedThread(PWMLED("GPIO5"), baseClock)
self.g = LedThread(PWMLED("GPIO12"), baseClock)
self.b = LedThread(PWMLED("GPIO16"), baseClock)
self.r2 = LedThread(PWMLED("GPIO20", False), baseClock)
self.g2 = LedThread(PWMLED("GPIO18", False), baseClock)
self.b2 = LedThread(PWMLED("GPIO22", False), baseClock)
def __init__(self):
self.btn_forward = Button(gpio_pins.BTN_FORWARD_GPIO)
self.btn_back = Button(gpio_pins.BTN_BACK_GPIO)
self.led_btn_fwd = PWMLED(gpio_pins.LED_FWD_BTN)
self.led_btn_back = PWMLED(gpio_pins.LED_BACK_BTN)
# self.lid_sensor = Button(gpio_pins.LID_SWITCH)
self.ud_sensor = ScrollSensor(*gpio_pins.SCROLL_UPDOWN_SENSORS,
gpio_pins.SCROLL_UPDOWN_ENDSTOP)
self.lr_sensor = ScrollSensor(*gpio_pins.SCROLL_LR_SENSORS,
gpio_pins.SCROLL_LR_ENDSTOP)
self.motor_lr = Motor(*gpio_pins.MOTOR_CTRL_LR)
self.motor_ud = Motor(*gpio_pins.MOTOR_CTRL_UPDOWN)
self.led_layer = PWMOutputDevice(gpio_pins.LED_LAYER)
self.led_backlight = PWMOutputDevice(gpio_pins.LED_BACKLIGHT)
self.camera = None
self.soundcache = {}
self.blocked = False
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 Air:
relays = PiGPIOFactory(host='192.168.1.20') #RELAY PINS
air_pin = PWMLED(18, pin_factory=relays)
def __init__(self):
self.data = []
def blow(self, time):
relays = self.relays
air_pin = self.air_pin
air_pin.value = 1
print("blow")
print(time)
sleep(time)
air_pin.value = 0
def _rebuild_pwmled(self):
old_value = 0.
if self._pwmled is not None:
if not self._active or self._bcm_pin is None:
_log.info('Disabling PWM led.')
else:
old_value = self._pwmled.value
self._pwmled.off()
self._pwmled = None
if self._bcm_pin is not None and self._active:
_log.info('Rebuilding PWM led on pin %d with frequency %d.',
self._bcm_pin, self._frequency)
self._pwmled = PWMLED(self.bcm_pin,
frequency=self.frequency,
initial_value=old_value)
def main():
try:
led = PWMLED(14)
log.info("Reading from GPIO pin: %s" % (led.pin))
while True:
brighten(led)
dim(led)
except KeyboardInterrupt:
log.info("...^C pressed...")
except:
log.error(str(sys.exc_info()[1]))
log.error(traceback.format_tb(sys.exc_info()[2]))
finally:
log.info("Cleaning up/closing.")
led.close() # this ensures a clean exit
