def __init__(self):
"""Constructor"""
threading.Thread.__init__(self) # Parent class constructor
# GPIO setup
self.unlock_pin = gpiozero.LED(TwiddleLock.unlock_pin)
self.lock_pin = gpiozero.LED(TwiddleLock.lock_pin)
self.service_btn = gpiozero.Button(TwiddleLock.service_btn_pin, bounce_time = 0.2, hold_time = 3)
self.buzzer = gpiozero.Buzzer(TwiddleLock.buzzer_pin)
# Potentiometer setup
self.adc = Adafruit_MCP3008.MCP3008(mosi = TwiddleLock.spi_mosi_pin, miso = TwiddleLock.spi_miso_pin, clk = TwiddleLock.spi_clk_pin, cs = TwiddleLock.spi_ss_pin)
self.potentiometer = Potentiometer(self.adc, TwiddleLock.adc_pot_channel)
self.potentiometer.start()
# LCD screen setup
self.lcd = RPI_LCD.LCD(18, 17, 27, 22, 23, 24)
# Variable setup
self.log = []
self.dir = []
self.service_btn_held_last = False
self.locked = True
self.secure = True
self.combo_in_progress = False
self.to_close = False
self.correct_combo = Combination([10, 20, 10], [-1, 1, -1])
def load_configuration(self, configuration):
config = configparser.ConfigParser()
config.read(configuration)
self.distance = int(config["DEFAULT"]["distance"])
self.GREEN_LED = gpiozero.LED(int(config["GPIO"]["light_green"]),
active_high=False,
initial_value=True)
self.RED_LED = gpiozero.LED(int(config["GPIO"]["light_red"]),
active_high=False)
self.TOP = gpiozero.Button(int(config["GPIO"]["sensor_top"]),
pull_up=True,
active_state=None)
self.BOTTOM = gpiozero.Button(int(config["GPIO"]["sensor_bottom"]),
pull_up=True,
active_state=None)
self.MAX_TIME = int(config["TIMING"]["auto_reset_time"])
self.MIN_TIME = int(config["TIMING"]["ignore_time"])
self.mqtt_server = str(config["SERVER"]["mqtt"])
self.name = config["DEFAULT"]["name"]
self.rider = Rider()
self.status = Mode
print("[Info]: Loaded configuration: " + self.name)
return
def __init__(self):
defaultCorretion = 0.45
maxPW=(2.0+defaultCorretion)/1000
minPW=(1.0-defaultCorretion)/1000
self.servo1 = GZ.Servo(self.__servo1Pin, min_pulse_width=minPW, max_pulse_width=maxPW, frame_width = 20/1000)
self.servo2 = GZ.Servo(self.__servo2Pin, min_pulse_width=minPW, max_pulse_width=maxPW, frame_width = 20/1000)
print ("Waiting for servo start")
self.servo1.value = -1
time.sleep(0.5)
self.servo2.value = 1
time.sleep(0.5)
self.servo1.detach()
self.servo2.detach()
self.led1 = GZ.LED(self.__led1Pin)
self.led2 = GZ.LED(self.__led2Pin)
self.switchModeLed = GZ.LED(self.__switchModeLedPin)
self.button1 = GZ.Button(self.__button1Pin, pull_up = True)
self.button2 = GZ.Button(self.__button2Pin, pull_up = True)
self.pSensor = GZ.Button(self.__pSensorPin)
self.button1.when_pressed = self.pressButton1
self.button2.when_pressed = self.pressButton2
self.pSensor.when_pressed = self.detectObject
# init stepper motor
stepperMotor_pins = (14, 15, 18)
direction = 20
step = 21
self.stepperMotor = RpiMotorLib.A4988Nema(direction, step, stepperMotor_pins, "A4988")
def __init__(self, clv):
global MySelf
# ----------------------------------------------------------------------
# Activate leds, if we are on Raspberry
# ----------------------------------------------------------------------
self.OK = UseLeds
MySelf = self
# ----------------------------------------------------------------------
# Activate leds, if -L defined
# Reason for -L is that usage of GPIO might be conflicting with other
# applications on the Raspberry
# ----------------------------------------------------------------------
if self.OK and clv != None:
self.OK = clv.rpiLeds
# ----------------------------------------------------------------------
# Create 5 leds on these Pins as outputs.
# The numbers are the numbers of the IO-Pins of the Raspi
# Don't forget to add the series resistor of 470 Ohm
# ----------------------------------------------------------------------
if self.OK:
self.LedTacx = gpiozero.LED(5) # Orange
self.LedShutdown = gpiozero.LED(6) # Red
self.LedCadence = gpiozero.LED(13) # White
self.LedBLE = gpiozero.LED(19) # Blue
self.LedANT = gpiozero.LED(26) # Green
self.BtnShutdown = gpiozero.Button(3)
# ----------------------------------------------------------------------
# Show leds for power-up
# ----------------------------------------------------------------------
if self.OK:
self.PowerupTest()
def initialise():
# I happen to have the following coloured wires attached
# to my PCB, and wire them to the Pi in the following order
#
# Orange Vdd 3.3V
# Yellow NC -
# Green Vled 5V
# Blue GND GND
#
# Purple CLK GPIO 14
# Grey SDI GPIO 15
# White LE GPIO 18
# Black OE GPIO 23
#
controls = {}
controls["lock"] = threading.Lock()
controls["CLK"] = gpiozero.LED(14)
controls["SDI"] = gpiozero.LED(15)
controls["LE"] = gpiozero.LED(18)
controls["OE"] = gpiozero.LED(23)
# OE is active low, so turn on to disable all lights to start with.
controls["OE"].on()
return controls
def init_inprogress(self):
self.switch = gpio.Button(26)
self.switch.when_pressed = self.run_dif
self.led_r = gpio.LED(5)
self.led_g = gpio.LED(6)
self.led_flash = gpio.LED(19)
self.label_prog = ttk.Label(self.frame_inprogress,
text='Analyzing',
font='-weight bold -size 20')
self.label_img = ttk.Label(self.frame_inprogress)
self.button_back = ttk.Button(self.frame_inprogress,
text='Back',
command=self.inprogress2main)
self.pb_dif = ttk.Progressbar(self.frame_inprogress,
orient='horizontal',
mode='indeterminate',
length=400)
self.label_prog.grid(row=1, column=1)
self.label_img.grid(row=2, column=1)
self.pb_dif.grid(row=3, column=1)
self.button_back.grid(row=4, column=1)
self.frame_inprogress.rowconfigure(0, weight=1)
self.frame_inprogress.rowconfigure(5, weight=1)
self.frame_inprogress.columnconfigure(0, weight=1)
self.frame_inprogress.columnconfigure(2, weight=1)
def __init__ (self, state_file = None ):
if state_file is None:
state_file = STATE_FILE
self.statefile = state_file
self.reverse_of = { 'CLOSING': self.open, 'CLOSED': self.open,
'OPENING':self.close, 'OPEN': self.close }
self.button = gpiozero.Button(BUTTON)
self.pressure_sensor = gpiozero.Button(PRESSURE)
self.open_led = gpiozero.LED(LED_O)
self.close_led = gpiozero.LED(LED_C)
self.open_relay = gpiozero.OutputDevice(RELAY_O)
self.close_relay = gpiozero.OutputDevice(RELAY_C)
self.led_of = {'OPENING': self.open_led, 'OPEN': self.open_led,
'CLOSING': self.close_led, 'CLOSED': self.close_led }
self.button.when_pressed = self.press_button
self.pressure_sensor.when_pressed = self.sense_pressure
try:
handle = open(self.statefile)
self.set_state(handle.read().rstrip())
print(f"*** State File Says {self.state} ***")
handle.close()
except IOError:
print(f"Failed to open state file {self.statefile}")
def main():
load1 = gpiozero.LED(20, active_high=False)
load2 = gpiozero.LED(21, active_high=False)
load1.on()
load2.on()
time.sleep(10)
load1.off()
load2.off()
def __init__(self):
self.state = "PARKED"
self.parked_led = gpiozero.LED(GPIO_PIN_OUT_PARKED_LED)
self.shooting_led = gpiozero.LED(GPIO_PIN_OUT_SHOOTING_LED)
self.state_button = gpiozero.Button(GPIO_PIN_IN_STATE_BUTTON, pull_up=False, hold_time=3)
self.state_button.when_pressed = self.toggle_state
self.state_button.when_held = self.shutdown
self.enter_parked()
def basic_led_on():
red_led = gz.LED(14)
yellow_led = gz.LED(15)
green_led = gz.LED(18)
red_led.on()
yellow_led.on()
green_led.on()
time.sleep(3)
print("Goodbye")
def __init__(self, red_pin, green_pin, blue_pin):
#self.red = gpiozero.PWMLED(red_pin, frequency=80, initial_value=1)
#self.green = gpiozero.PWMLED(green_pin, frequency=80, initial_value=1)
#self.blue = gpiozero.PWMLED(blue_pin, frequency=80, initial_value=1)
""" unfortunately the PWM on the rpi can't be stable enough
so it flickers too much. That's why I use digital IO instead """
self.red = gpiozero.LED(red_pin)
self.green = gpiozero.LED(green_pin)
self.blue = gpiozero.LED(blue_pin)
self.leds = [self.red, self.green, self.blue]
self.off()
def fancy_blink():
red_led = gz.LED(14)
yellow_led = gz.LED(15)
green_led = gz.LED(18)
red_led.blink()
time.sleep(0.5)
yellow_led.blink()
time.sleep(0.5)
green_led.blink()
signal.pause()
def __init__(self):
self.state = DoorStateEnum.HALF_OPENED
self.threeWayActivatorThread = ThreeWayActivatorThread(
gpiozero.LED(active_high=False, pin=MOTOR_ACTIVATOR_PIN))
self.threeWayActivatorThread.start()
self.internalControlButton = gpiozero.Button(pin=4, pull_up=False)
self.internalControlButton.when_pressed = self.activate
self.door_locker = gpiozero.LED(pin=21,
active_high=False,
initial_value=True)
def __init__(self,
step,
direction,
ms1,
ms2,
ms3,
enable,
microstepping=1,
rpm=1,
steps_per_rev=200,
Kp=0.2,
Ki=0.1):
#Assign GPIO for the big easy driver
self.dir = gpiozero.LED(direction)
self.ms1 = gpiozero.LED(ms1)
self.ms2 = gpiozero.LED(ms2)
self.ms3 = gpiozero.LED(ms3)
self.en = gpiozero.LED(enable)
#assign the queue
self.queue = mp.Queue()
#Set motor speed
self.rpm = rpm
self.spr = steps_per_rev
self.Kp = Kp
self.Ki = Ki
self.microstepping = microstepping
#Set initial pin conditions
self.set_microstep(self.microstepping)
self.en.on()
self.dir.off()
#Start the motor in the next process
args = (
step,
self.queue,
self.rpm,
self.microstepping,
self.spr,
self.Kp,
self.Ki,
)
try:
p1 = mp.Process(target=self.turn, args=args)
p1.start()
except Exception as e:
logging.error(e)
def _setup_hardware(self):
""" Create instances of all peripherals needed. """
self._red_LED = gpiozero.LED(12)
self._green_LED = gpiozero.LED(13)
self._blue_LED = gpiozero.LED(19)
self._button = gpiozero.Button(4,
hold_time=3,
hold_repeat=False,
pull_up=True)
self._button.when_pressed = self._on_button_press
self._button.when_released = self._on_button_release
self._button.when_held = self._on_button_hold
def setupSpi():
global dataControlPin
global resetPin
global chipSelectPin
global spiDevice
dataControlPin = gpiozero.LED(DC_GPIO)
resetPin = gpiozero.LED(RES_GPIO)
chipSelectPin = gpiozero.LED(CS_GPIO)
spiDevice = spidev.SpiDev(0, 0)
spiDevice.mode = 3
spiDevice.lsbfirst = False
spiDevice.max_speed_hz = SPI_SPEED_HZ
def __init__(self,
leftOn=17,
leftDir=27,
rightOn=23,
rightDir=24,
modePin=22):
# Motor Stuff
self.leftMotor = gpiozero.PWMLED(leftOn, frequency=50)
self.leftDir = gpiozero.LED(leftDir)
self.rightMotor = gpiozero.PWMLED(rightOn, frequency=50)
self.rightDir = gpiozero.LED(rightDir)
self.mode = gpiozero.LED(modePin)
self.mode.on()
def manual_blink():
red_led = gz.LED(14)
yellow_led = gz.LED(15)
green_led = gz.LED(18)
# for k in range(5):
while True:
red_led.on()
yellow_led.on()
green_led.on()
time.sleep(1)
red_led.off()
yellow_led.off()
green_led.off()
time.sleep(1)
def __init__(self):
self.mashtun = devices.JamMaker(0, 27, self.mash_temp_reached)
self.boiler = devices.JamMaker(1, 22, self.boil_temp_reached)
self.mashpump = gpiozero.LED(2)
self.temppump = gpiozero.LED(3)
self.boilpump = gpiozero.LED(4)
self.mashvalve = devices.TwoWayValve(14, 15, "mash", "temp", 2)
self.boilvalve = devices.TwoWayValve(17, 18, "mash", "boil", 2)
testrecipe = recipes.Recipe(mash_stages=[(50, 1), (64, 1), (68, 1),
(74, 1)],
boiling_time=1,
mash_water=1,
sparge_water=1)
self.process = process.BrewProcess(testrecipe, self)
threading.Timer(5, self.print_status).start()
def __init__(self):
self.__logger = logging.getLogger(__name__)
self.__logger.info("VibraAnnouncer.__init__() called")
super(VibraAnnouncer, self).__init__()
# Output-GPIO zuordnen
self.__vm_left_front = io.LED(5) # GPIO 5 für VM left front
self.__vm_left_back = io.LED(12) # GPIO 5 für VM left back
self.__vm_middle = io.LED(6) # GPIO 6 für VM middle
self.__vm_right_front = io.LED(13) # GPIO 13 für VM right front
self.__vm_right_back = io.LED(16) # GPIO 16 für VM right back
self.__impulsdauer = config.vibration['impulsdauer']
self.__nachpause = config.vibration['nachpause']
self.__signalpause = config.vibration['signalpause']
def pinMode(pin, mode):
assert pin >= 0 and pin < 28
assert mode == 1 or mode == 0
if mode == 1:
pins[pin] = gpiozero.Button(pin)
else:
pins[pin] = gpiozero.LED(pin)
def register(self):
try:
self.__logger.debug("Regestriere Raspberry GPIO...")
from gpiozero.pins.native import NativeFactory
from gpiozero import Device
Device.pin_factory = NativeFactory()
self.__logger.debug("InputPin = %s", self._config["rpiDoor/openedPin"])
self.input = gpiozero.Button(pin=self._config["rpiDoor/openedPin"])
self.__logger.debug("OuputPin = %s", self._config["rpiDoor/unlockPin"])
self.out = gpiozero.LED( pin=self._config["rpiDoor/unlockPin"])
self.input.when_activated = lambda: self.InputHandler(True )
self.input.when_deactivated = lambda: self.InputHandler(False)
schedule.every(15).minutes.do(self.sendUpdate)
self.__logger.debug("Regestiere MQTT Topics")
unique_id = "sensor.doorOpener-{}.{}".format(self._device_id, self._config["rpiDoor/name"].replace(" ", "_"))
self.topic = self._config.get_autodiscovery_topic(conf.autodisc.Component.SWITCH, self._config["rpiDoor/name"], None)
payload = self.topic.get_config_payload(self._config["rpiDoor/name"], None, unique_id=unique_id,
json_attributes=True, value_template="{{ value_json.sw }}")
self.__client.publish(self.topic.config, payload=payload, qos=0, retain=True)
self.__client.message_callback_add(self.topic.command, self.on_message)
self._registered_callback_topics.append(self.topic.command)
self.__client.subscribe(self.topic.command)
self.sendUpdate()
except Exception as e:
self.__logger.exception("Register hat fehler verursacht!")
raise e
def __init__(self, pinNumber):
self.updateQueue = queue.Queue(maxsize=0)
self.isLedOn = False
self.currentTimeInMs = int(time.time() * 1000)
self.lastTimeMark = 0
self.upcomingToggleMark = self.NO_PENDING_TOGGLE_MARK
self.led = gpiozero.LED(pinNumber)
def __init__(self, eventCallback, config):
debounce = 0.01
self.eventCallback = eventCallback
self.config = config
self.buttons = {}
# create gpio button objects for each button and register callbacks for them
for pin in set(self.config.pinButtonMap) | set(
self.config.pinSwitchLowMap) | set(
self.config.pinSwitchHighMap):
thisbutton = gpiozero.Button(pin,
bounce_time=debounce,
hold_time=self.config.repeatFirst /
1000)
if pin in self.config.pinButtonMap:
thisbutton.hold_repeat = self.config.repeatDelay / 1000
thisbutton.when_held = self.pressCallback
if pin in self.config.pinSwitchHighMap:
thisbutton.when_pressed = self.downPressCallback
else:
thisbutton.when_pressed = self.pressCallback
elif pin in self.config.pinSwitchHighMap:
thisbutton.when_pressed = self.downCallback
if pin in self.config.pinSwitchLowMap:
thisbutton.when_released = self.upCallback
self.buttons[pin] = thisbutton
self.rxGoodLED = None
# create a gpio LED object for the status light if there is a pin defined
if self.config.rxGoodPin is not None:
self.rxGoodLED = gpiozero.LED(self.config.rxGoodPin)
# socket to notify the main loop of a button press
self.recvSock, self.sendSock = socket.socketpair()
# thread save queue to store the actual events
self.eventQueue = queue.Queue()
def __init__(self, name, gpiopin, blynk_vpin, on_value, min_pause, *args,
**kwargs):
self.name = name
self.gpiopin = gpiopin
self.vpin = blynk_vpin
self.on_value = on_value
try:
self.gpio_obj = gpiozero.LED(gpiopin)
except gpiozero.exc.GPIOPinInUse:
raise gpiozero.exc.GPIOPinInUse
self.min_pause = min_pause
try:
with open("settings/last_turned_on.json") as file_settings:
last_turned_on = dict(json.load(file_settings))
except FileNotFoundError:
last_turned_on = dict()
last_turned_on[name] = str(datetime.datetime.today() +
datetime.timedelta(days=-1))
with open('settings/last_turned_on.json', 'w') as outfile:
json.dump(last_turned_on, outfile)
if name not in last_turned_on.keys():
last_turned_on[name] = str(datetime.datetime.today() +
datetime.timedelta(days=-1))
with open('settings/last_turned_on.json', 'w') as outfile:
json.dump(last_turned_on, outfile)
self.last_date_turned_on = datetime.datetime.strptime(
last_turned_on[name], "%Y-%m-%d %H:%M:%S.%f")
def initPin(self, pin):
if pin == self.pin:
logging.warning('Cannot init a PIN which is in-use')
return
t = gpiozero.LED(pin, active_high=False)
t.off()
t.close()
def setup_cb(pin,mode):
#print("pin=%d,status=%d" %(pin,)
# do gpio setup
if mode == "out":
try:
led = GPIO.LED(pin)
self.add_digital_hw_pin(pin, None, gpioOut_h, led)
logging.getLogger().debug(str(pin)+ str(mode))
except:
pass
if mode == "in":
print(pull)
if pull=="up":
button = GPIO.DigitalInputDevice(pin, pullup=True)
elif pull=="down":
button = GPIO.DigitalInputDevice(pin, pullup=False)
elif pull=="button":
button = GPIO.Button(pin)
else:
button = GPIO.InputDevice(pin)
self.add_digital_hw_pin(pin, gpioRead_h, None, button)
# note the gpiozero button / led objects are payload as "state"
logging.getLogger().debug(str(pin)+ str(mode))
def manual_traffic_light():
red_led = gz.LED(14)
yellow_led = gz.LED(15)
green_led = gz.LED(18)
# Loop forever, green for 5, yellow for 1, red for 3
while True:
green_led.on()
time.sleep(5)
green_led.off()
yellow_led.on()
time.sleep(1)
yellow_led.off()
red_led.on()
time.sleep(3)
red_led.off()
def _main():
logging.basicConfig(handlers=[RotatingFileHandler(LOG_PATH, maxBytes=100000, backupCount=1)], format='%(asctime)s.%(msecs)03d %(levelname)-8s %(message)s', datefmt='%Y-%m-%dT%H:%M:%S', level=logging.INFO)
led = gpio.LED(47, active_high=False)
nClients = numberOfSSHOpen(FILE_PATH)
updateLed(led, nClients)
i = inotify.adapters.Inotify()
mask = inotify.constants.IN_CREATE | inotify.constants.IN_MODIFY | inotify.constants.IN_DELETE | inotify.constants.IN_DELETE_SELF | inotify.constants.IN_MOVED_FROM | inotify.constants.IN_MOVED_TO
i.add_watch(FILE_PATH, mask)
for event in i.event_gen(yield_nones=False):
if 'IN_MODIFY' in event[1]:
logging.debug("File was modified")
n = numberOfSSHOpen(FILE_PATH)
if n != nClients:
updateLed(led, n)
nClients = n
logging.info("There are %d clients conected" % n)
elif 'IN_DELETE' in event[1]:
logging.critical("File was delete!!!")
led.blink(0.1, 0.1, 20)
led.on()
sys.exit(0)
else:
(_, type_names, path, filename) = event
logging.debug("PATH=[{}] FILENAME=[{}] EVENT_TYPES={}".format(path, filename, type_names))
def main():
led = gpiozero.LED(17)
led.on() # light when app is running
active_buzzer = gpiozero.Buzzer(20)
button1 = gpiozero.Button(26)
button2 = gpiozero.Button(19)
button3 = gpiozero.Button(13)
button4 = gpiozero.Button(6)
button5 = gpiozero.Button(5)
button6 = gpiozero.Button(22)
button7 = gpiozero.Button(27)
button1.when_pressed = active_buzzer.toggle
button2.when_pressed = active_buzzer.on
button3.when_pressed = active_buzzer.off
button4.when_pressed = active_buzzer.beep
button5.when_pressed = lambda: active_buzzer.beep(0.1, 0.1, 1)
button6.when_pressed = lambda: active_buzzer.beep(0.3, 0.1, 1)
running = True
def close():
nonlocal running
print("closing...")
running = False
button7.when_pressed = close
while running:
pass
