def get_distance():
# print("Distance Measurement In Progress")
if isinstance(GPIO, MockGPIO):
time.sleep(2)
return 15
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)
GPIO.output(TRIG, False)
# print("Waiting For Sensor To Settle")
time.sleep(1)
GPIO.output(TRIG, True)
time.sleep(0.00001)
GPIO.output(TRIG, False)
while GPIO.input(ECHO) == 0:
pulse_start = time.time()
while GPIO.input(ECHO) == 1:
pulse_end = time.time()
pulse_duration = pulse_end - pulse_start
distance = pulse_duration * 17150
distance = round(distance, 2)
print("Distance:", distance, "cm")
return distance
def IsReedClosed(self, reed_pin:int)->bool:
"""
Gibt an, ob der Magnetkontakt am entsprechenden Pin geschlossen ist.
Da es immer wieder Probleme durch Interferenzen mit dem Weidezaun gab, werden
hier 15 Messungen in 0,7 Sekunden durchgeführt.
Wenn mindestens 5x der Kontakt als geschlossen ermittelt wurde, wird der
gehen wir hier von einem echten Schließen aus.
:param int reed_pin: Pin des Magnetkontakts, also entweder :data:`config.REED_UPPER`
oder :data:`config.REED_LOWER`
:returns: Ob der angegebene Magentkontakt geschlossen ist.
.. seealso::
:meth:`IsDoorOpen`
:meth:`IsDoorClosed`
:meth:`SyncMoveDoor`
"""
triggered = i = 0
for i in range(15):
if GPIO.input(reed_pin) == REED_CLOSED:
if triggered > 4:
# der Magnetkontakt war jetzt 4x
# geschlossen, damit ist die Bedingung erfüllt
self.info("Reed trigger: %d of %d", triggered, i)
return True
triggered += 1
if i < 14: # nach dem letzten Messen warten wir nicht
time.sleep(0.05)
self.info("Reed trigger: %d of %d", triggered, i)
return False
def test_OutdoorLight(self):
# --- Aussenbeleuchtung ---
self.assertFalse(self.board.IsOutdoorLightOn(), "Outdoor light should be initially off.")
with GPIO.write_context():
self.assertEqual(GPIO.input(LIGHT_OUTDOOR), RELAIS_OFF, "Outdoor light pin is not off.")
self.board.SwitchOutdoorLight(False)
self.assertFalse(self.board.IsOutdoorLightOn(), "Outdoor light should be off.")
with GPIO.write_context():
self.assertEqual(GPIO.input(LIGHT_OUTDOOR), RELAIS_OFF, "Outdoor light pin is not off.")
self.board.SwitchOutdoorLight(True)
self.assertTrue(self.board.IsOutdoorLightOn(), "Outdoor light should be on.")
with GPIO.write_context():
self.assertEqual(GPIO.input(LIGHT_OUTDOOR), RELAIS_ON, "Outdoor light pin is not on.")
self.board.SwitchOutdoorLight(False)
self.assertFalse(self.board.IsOutdoorLightOn(), "Outdoor light should be off.")
with GPIO.write_context():
self.assertEqual(GPIO.input(LIGHT_OUTDOOR), RELAIS_OFF, "Outdoor light pin is not off.")
def OnShutdownButtonPressed(self, *_args):
"""
Interrupt-Methode für den Taster am Pin :data:`config.SHUTDOWN_BUTTON`.
Wird mit einer Bouncetime von 200ms an beiden Flanken gerufen, also sowohl
wenn der Taster gedrückt also auch losgelassen wurde.
Da der Taster über einen 10K - Pullup den Pin auf LOW zieht, wird
bei einem LOW Signal davon ausgegangen, dass der Taster gedrückt und
bei einem HIGH Signal losgelassen wurde.
Zur Vermeidung der Interpretation von Fehlsignalen, wird auch genau diese
Reihenfolge (erst drücken, dann loslassen) erwartet und in allen andere
Fällen keine Verarbeitung durchgeführt.
Hierzu wird der Zeitpunkt des Drückens in :attr:`shutdown_btn_time`
verwendet. Bei einem LOW-Signal (gedrückt) muss dieser 0 sein und wird
dann auf die aktuelle Zeit gesetzt, bei HIGH (losgelassen) darf er
nicht 0 sein und wird nach Auswertung wieder auf 0 gesetzt.
Die so ermittelt Zeit führt dann zu jeweiligen Aktion:
- länger als :data:`config.BTN_DURATION_SHUTDOWN` Sekunden: Shutdown
- länger als :data:`config.BTN_DURATION_REBOOT` Sekunden: Reboot
- weniger als :data:`config.BTN_DURATION_REBOOT` Sekunden: keine Aktion
Die Aktionen werden über ``os.system`` ausgeführt, der Prozess muss also
entsprechende Rechte verfügen.
"""
# der Button zieht das permanente HIGH-Signal auf LOW, wenn
# er gedrückt wird (PULL_UP)
if GPIO.input(SHUTDOWN_BUTTON) == GPIO.LOW:
# der Knopf ist gedrückt.
if self.shutdown_btn_time != 0:
# da stimmt was nicht, wir ignorieren lieber alles,
# setzen den Wert aber zurück
self.shutdown_btn_time = 0
return
self.shutdown_btn_time = time.time()
else:
# der Knopf wurde losgelassen
if self.shutdown_btn_time == 0:
# auch hier wäre jetzt was verkehrt, also
# ignorieren
return
# jetzt prüfen, wie lange er gedrückt war.
pressed_duration = time.time() - self.shutdown_btn_time
# und setzen den Wert wieder zurück
self.shutdown_btn_time = 0
self.info("Shutdown button has been pressed for %.2f seconds.", pressed_duration)
if pressed_duration > BTN_DURATION_SHUTDOWN:
# shutdown
self.info("Shutting system down.")
os.system("sudo shutdown -h now")
elif pressed_duration > BTN_DURATION_REBOOT:
# reboot
self.info("Rebooting system.")
os.system("sudo reboot -h now")
def OpenDoorTest(self):
ctrl = self.controller
ftr = base.Future(ctrl.OpenDoor)
self.assertTrue(ftr.WaitForExectionStart(0.5),
"Door open command is running.")
with self.assertRaises(TimeoutError):
ftr.WaitForResult(0.5)
with GPIO.write_context():
motor_on = GPIO.input(MOTOR_ON)
move_dir = GPIO.input(MOVE_DIR)
self.assertEqual(ctrl.automatic, DOOR_AUTO_OFF,
"Door automatic is temporary disabled.")
self.assertEqual(motor_on, RELAIS_ON, "Motor is running.")
self.assertEqual(move_dir, MOVE_UP, "Door is moving up.")
self.assertTrue(ctrl.board.IsDoorMoving(), "Door state is 'moving'.")
return ftr
def CloseDoorTest(self):
ctrl = self.controller
ctrl.board.door_state = DOOR_OPEN
with GPIO.write_context():
GPIO.output(REED_UPPER, REED_CLOSED) # Kontakt oben geschlossen
GPIO.output(REED_LOWER, REED_OPENED) # Kontakt unten offen
ftr = base.Future(ctrl.CloseDoor)
self.assertTrue(ftr.WaitForExectionStart(0.5),
"Door close command is running.")
with self.assertRaises(TimeoutError):
ftr.WaitForResult(2)
with GPIO.write_context():
motor_on = GPIO.input(MOTOR_ON)
move_dir = GPIO.input(MOVE_DIR)
self.assertEqual(ctrl.automatic, DOOR_AUTO_OFF,
"Door automatic is temporary disabled.")
self.assertEqual(motor_on, RELAIS_ON, "Motor is running.")
self.assertEqual(move_dir, MOVE_DOWN, "Door is moving down.")
self.assertTrue(ctrl.board.IsDoorMoving(), "Door state is 'moving'.")
return ftr
