def _init_parts(self):
self.r_led = Led(self.red_led_pin)
self.g_led = Led(self.green_led_pin)
self.lock = Lock(self.relay_pin)
self.black_btn = PushButton(self.black_btn_pin) # add button
self.red_btn = PushButton(self.red_btn_pin) # delete button
self.r_led.off()
self.g_led.off()
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.press)
self.switch.set_callback_down(self.release)
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.toggle)
self.recording = False
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.push_button = PushButton(self.btn_pin)
self.push_button.set_callback_pressed_long(
self.on_push_button_pressed_long)
self.push_button.set_callback_released(
self.on_push_button_released_short)
self.recording = False # recording is set when recording mode is on
self.global_state = False # global_state is set when application is "powered on"
class Hardware(object):
__metaclass__ = ABCMeta
def __init__(self):
self._init_pins()
self._init_parts()
@abstractmethod
def _init_pins(self):
raise NotImplementedError()
def _init_parts(self):
self.r_led = Led(self.red_led_pin)
self.g_led = Led(self.green_led_pin)
self.lock = Lock(self.relay_pin)
self.black_btn = PushButton(self.black_btn_pin) # add button
self.red_btn = PushButton(self.red_btn_pin) # delete button
self.r_led.off()
self.g_led.off()
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.press)
self.switch.set_callback_down(self.release)
def main():
parser = argparse.ArgumentParser(description='Send morse code')
parser.add_argument('-m', '--message', help='Message', default='SOS')
parser.add_argument('-d',
'--duration',
help='Element duration',
default=None,
type=float)
parser.add_argument('-s',
'--speed',
help="Speed in wpm (Words per minutes)",
default=None,
type=float)
parser.add_argument('--with-sound',
dest='sound',
help="With sound",
action='store_true')
parser.add_argument('--with-led',
dest='led',
help="With LED connected to GPIO",
action='store_true')
parser.add_argument('--pin-out',
dest='pin_out',
help="GPIO pin number on which LED is connected",
default=13,
type=int)
args = parser.parse_args()
message = args.message
element_duration = args.duration
wpm = args.speed
print("text : %r" % message)
print("morse: %s" % mtalk.encode(message))
print("bin : %s" % mtalk.encode(message, encoding_type='binary'))
print("")
element_duration = _get_element_duration(element_duration, wpm)
if args.sound:
app = ListenableSampleGeneratorApp(message, element_duration)
elif args.led:
import pingo
from pingo.parts.led import Led
board = pingo.detect.get_board()
led_pin = board.pins[args.pin_out]
led = Led(led_pin)
app = LedSampleGeneratorApp(message, element_duration, led=led)
else:
app = PrintableSampleGeneratorApp(message, element_duration)
app.run()
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.toggle)
self.recording = False
def __init__(self):
# GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.push_button = PushButton(self.btn_pin)
self.push_button.set_callback_pressed_long(self.on_push_button_pressed_long)
self.push_button.set_callback_released(self.on_push_button_released_short)
self.recording = False
self.global_state = True
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.press)
self.switch.set_callback_down(self.release)
def loop(self):
self.led.off()
self.switch.start()
#self.led.blink(times=0) # blink foreever
try:
while(True):
time.sleep(1)
except KeyboardInterrupt:
print("User Cancelled (Ctrl C)")
self.stop_at_exit()
def press(self):
print("press")
self.toggle()
def release(self):
print("release")
def toggle(self):
self.led.toggle()
def stop_at_exit(self):
self.led.off()
self.switch.stop()
self.led.stop()
self.board.cleanup()
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.press)
self.switch.set_callback_down(self.release)
def loop(self):
self.led.off()
self.switch.start()
#self.led.blink(times=0) # blink foreever
try:
while (True):
time.sleep(1)
except KeyboardInterrupt:
print("User Cancelled (Ctrl C)")
self.stop_at_exit()
def press(self):
print("press")
self.toggle()
def release(self):
print("release")
def toggle(self):
self.led.toggle()
def stop_at_exit(self):
self.led.off()
self.switch.stop()
self.led.stop()
self.board.cleanup()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pingo
from pingo.parts.led import Led
from time import sleep
board = pingo.detect.get_board()
led_pin = board.pins[11]
led = Led(led_pin)
led.blink(times=0, on_delay=0.8, off_delay=0.2) # blink foreever
while(True):
led.blink(times=5, on_delay=0.8, off_delay=0.2) # blink foreever
sleep(10)
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.toggle)
self.recording = False
def loop(self):
self.init_led_and_switch()
try:
while (True):
time.sleep(1)
except KeyboardInterrupt:
print("User Cancelled (Ctrl C)")
self.stop_at_exit()
def toggle(self):
print("press")
self.recording = not self.recording
if self.recording:
self.led.blink(times=0, on_delay=0.8,
off_delay=0.2) # blink foreever
self.start_recording()
else:
self.led.stop() # stop blinking
self.led.on()
self.stop_recording()
def init_led_and_switch(self):
self.led.on()
self.switch.start()
def start_recording(self):
print("start recording")
def stop_recording(self):
print("stop recording")
def stop_at_exit(self):
self.led.off()
self.switch.stop()
self.led.stop()
self.board.cleanup()
class App(object):
def __init__(self):
# GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.push_button = PushButton(self.btn_pin)
self.push_button.set_callback_pressed_long(self.on_push_button_pressed_long)
self.push_button.set_callback_released(self.on_push_button_released_short)
self.recording = False
self.global_state = True
def loop(self):
self.init_led_and_switch()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
logger.info("User Cancelled (Ctrl C)")
self.stop_at_exit()
def init_led_and_switch(self):
self._update_led()
self.push_button.start()
def _update_led(self):
if self.global_state:
logger.info("power on")
self.led.on()
else:
logger.info("power off")
self.led.off()
def on_push_button_pressed_long(self):
logger.info("push button pressed long")
self.global_state = not self.global_state
self._update_led()
def on_push_button_released_short(self):
logger.info("push button released")
self.recording = not self.recording
if self.recording:
self.led.blink(times=0, on_delay=0.2, off_delay=0.8) # blink forever
self.start_recording()
else:
self.led.stop() # stop blinking
self.stop_recording()
def start_recording(self):
logger.info("start recording")
def stop_recording(self):
logger.info("stop recording")
def stop_at_exit(self):
logger.info("stopping at exit")
self.led.stop()
self.led.off()
self.push_button.stop()
self.board.cleanup()
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.toggle)
self.recording = False
def loop(self):
self.init_led_and_switch()
try:
while(True):
time.sleep(1)
except KeyboardInterrupt:
print("User Cancelled (Ctrl C)")
self.stop_at_exit()
def toggle(self):
print("press")
self.recording = not self.recording
if self.recording:
self.led.blink(times=0, on_delay=0.8, off_delay=0.2) # blink foreever
self.start_recording()
else:
self.led.stop() # stop blinking
self.led.on()
self.stop_recording()
def init_led_and_switch(self):
self.led.on()
self.switch.start()
def start_recording(self):
print("start recording")
def stop_recording(self):
print("stop recording")
def stop_at_exit(self):
self.led.off()
self.switch.stop()
self.led.stop()
self.board.cleanup()
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.push_button = PushButton(self.btn_pin)
self.push_button.set_callback_pressed_long(
self.on_push_button_pressed_long)
self.push_button.set_callback_released(
self.on_push_button_released_short)
self.recording = False # recording is set when recording mode is on
self.global_state = False # global_state is set when application is "powered on"
def loop(self):
self.init_led_and_switch()
try:
while (True):
time.sleep(1)
except KeyboardInterrupt:
logger.info("User Cancelled (Ctrl C)")
self.stop_at_exit()
def init_led_and_switch(self):
self._update_led()
self.push_button.start()
def _update_led(self):
if self.global_state:
logger.info("power on")
self.led.on()
else:
logger.info("power off")
self.led.off()
def on_push_button_pressed_long(self):
logger.info("push button pressed long")
# In case we stop the system even when we're still recording
if self.recording:
self.led.stop() # stop blinking
self.stop_recording()
self.recording = False
time.sleep(0.5) # wait the thread closure. Need to be reviewed
self.global_state = not self.global_state
self._update_led()
def on_push_button_released_short(self):
logger.info("push button released")
if self.global_state:
logger.info("short push and system was ON")
self.recording = not self.recording
if self.recording:
self.led.blink(times=0, on_delay=0.2,
off_delay=0.8) # blink forever
self.start_recording()
else:
self.led.stop() # stop blinking
self.stop_recording()
else:
logger.info("short push and system was off")
def start_recording(self):
logger.info("start recording")
def stop_recording(self):
logger.info("stop recording")
def stop_at_exit(self):
logger.info("stopping at exit")
self.led.stop()
self.led.off()
self.push_button.stop()
self.board.cleanup()
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.pushtype)
self.recording = False
self.GlobalState = False
def loop(self):
self.init_led_and_switch()
try:
while(True):
time.sleep(1)
except KeyboardInterrupt:
print("User Cancelled (Ctrl C)")
self.stop_at_exit()
def pushtype(self):
timer = 0
while(self.switch.pin.state == pingo.HIGH):
timer += 1
time.sleep(0.1)
if(timer <= 10):
push_type = " short_push"
if self.GlobalState:
self.toggle()
else:
push_type = " long_push"
self.GlobalState = not self.GlobalState
if self.GlobalState:
self.led.on()
print("Power on")
else:
self.led.off()
print("Power off")
print(str(timer) + push_type)
def toggle(self):
print("press")
self.recording = not self.recording
if self.recording:
self.led.blink(times=0, on_delay=0.2, off_delay=0.8) # blink forever
self.start_recording()
else:
self.led.stop() # stop blinking
self.stop_recording()
def init_led_and_switch(self):
self.led.off()
self.switch.start()
def start_recording(self):
print("start recording")
def stop_recording(self):
print("stop recording")
def stop_at_exit(self):
print("stopping")
self.led.stop()
self.led.off()
self.switch.stop()
self.board.cleanup()
def main():
""" Fonction principale """
MASTER = "04F1D561EE0280"
BDD_NAME = "nfc2.db"
# Definition des ports en entre/sortie
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(4, GPIO.OUT) # Sortie relais
GPIO.output(4, GPIO.LOW) # initialise la sortie relais
board = pingo.detect.get_board()
red_led_pin = board.pins[12] # GPIO18
r_led = Led(red_led_pin)
green_led_pin = board.pins[11] # GPIO17
g_led = Led(green_led_pin)
r_led.off()
g_led.off()
black_btn_pin = board.pins[15] # GPIO22
red_btn_pin = board.pins[22] # GPIO25
black_btn_pin.mode = pingo.IN
red_btn_pin.mode = pingo.IN
# Test leds
g_led.on()
r_led.on()
sleep(1)
g_led.off()
r_led.off()
# Creation de la table si elle n'existe pas
createTable(BDD_NAME)
# Debut du programme
while True:
uid = lecture()
# ************************************
# *** Detection de la carte MASTER ***
# ************************************
if uid == MASTER: # Si la carte maitre est detectee
# Condition pour l'AJOUT d une carte
if (
black_btn_pin.state == pingo.LOW and red_btn_pin.state == pingo.HIGH
): # Si seul le bouton poussoir noir est appuye
logger.debug("Presente la carte a ajouter")
# Clignotement LED verte
# Donne aussi le temps de présenter la carte a enregistrer
for i in range(4):
g_led.on()
sleep(0.4)
g_led.off()
sleep(0.4)
# g_led.blink(times=5, on_delay=0.4, off_delay=0.4) # blink
# Fin clignotement
uid = lecture()
listebdd = getlisteofcards(BDD_NAME) # Lecture de la base de donnee
if str(uid) in str(listebdd): # Si la carte est dans la BDD
logger.debug("la carte " + str(uid) + " est deja autorisee")
r_led.on() # Allumer LED rouge
elif str(uid) == "None": # Si pas de carte detectee
logger.debug("Aucune carte detectee")
r_led.on() # Allumer LED rouge
else:
insertcard(BDD_NAME, uid)
g_led.on() # Allumer LED verte
sleep(1)
g_led.off() # Eteindre LED verte
sleep(1)
r_led.off() # Eteindre LED rouge
# Condition pour la SUPPRESSION d une carte
elif (
black_btn_pin.state == pingo.HIGH and red_btn_pin.state == pingo.LOW
): # Si seul le bouton poussoir rouge est appuye
logger.debug("Presente la carte a supprimer")
# Clignotement LED rouge
# Donne aussi le temps de présenter la carte
for i in range(4):
r_led.on()
sleep(0.4)
r_led.off()
sleep(0.4)
# r_led.blink(times=4, on_delay=0.4, off_delay=0.4) # blink forever
uid = lecture()
listebdd = getlisteofcards(BDD_NAME) # Lecture de la base de donnee
if uid == MASTER: # Si on presente la carte maitre
logger.warning("Tentative de suppression de la carte MAITRE")
r_led.on() # Allumer LED rouge
sleep(1)
r_led.off() # Eteindre LED rouge
elif str(uid) in str(listebdd): # Si la carte est dans la BDD
deletecard(BDD_NAME, uid) # Suppression dans la BDD
g_led.on() # Allumer LED verte
sleep(1)
g_led.off() # Eteindre LED verte
else:
logger.debug("La carte %s n est pas dans la base de donnee" % (uid))
r_led.on() # Allumer LED rouge
sleep(1)
r_led.off() # Eteindre LED rouge
if (
uid != "" and red_btn_pin.state == pingo.HIGH and black_btn_pin.state == pingo.HIGH
): # Si aucun bouton poussoir n est presse
listebdd = getlisteofcards(BDD_NAME) # Lecture de la base de donnee
if str(uid) in str(listebdd): # Si la carte est dans la BDD
logger.info("%s ouvre de la porte" % (uid))
g_led.on() # Allumer LED verte
GPIO.output(4, GPIO.HIGH) # Declencher relais
sleep(5)
g_led.off() # Eteindre LED verte
GPIO.output(4, GPIO.LOW) # Arret du declenchement du relais
logger.debug("Verrouillage de la porte")
sleep(1)
class App(object):
def __init__(self):
#GPIO.setwarnings(False)
self.board = pingo.detect.get_board()
led_pin = self.board.pins[13]
self.led = Led(led_pin)
self.btn_pin = self.board.pins[7]
self.switch = Switch(self.btn_pin)
self.switch.set_callback_up(self.pushtype)
self.recording = False
self.GlobalState = False
def loop(self):
self.init_led_and_switch()
try:
while (True):
time.sleep(1)
except KeyboardInterrupt:
print("User Cancelled (Ctrl C)")
self.stop_at_exit()
def pushtype(self):
timer = 0
while (self.switch.pin.state == pingo.HIGH):
timer += 1
time.sleep(0.1)
if (timer <= 10):
push_type = " short_push"
if self.GlobalState:
self.toggle()
else:
push_type = " long_push"
self.GlobalState = not self.GlobalState
if self.GlobalState:
self.led.on()
print("Power on")
else:
self.led.off()
print("Power off")
print(str(timer) + push_type)
def toggle(self):
print("press")
self.recording = not self.recording
if self.recording:
self.led.blink(times=0, on_delay=0.2,
off_delay=0.8) # blink forever
self.start_recording()
else:
self.led.stop() # stop blinking
self.stop_recording()
def init_led_and_switch(self):
self.led.off()
self.switch.start()
def start_recording(self):
print("start recording")
def stop_recording(self):
print("stop recording")
def stop_at_exit(self):
print("stopping")
self.led.stop()
self.led.off()
self.switch.stop()
self.board.cleanup()
