def Run(command):
thresh = 5
while(True):
if(command == 1):
api.PlayAction(52)
buzzer=Buzzer()
buzzer.play(4)
print('Plank')
command = 0
thresh=5
elif(command == 0):
api.PlayAction(55)
print('Crawl')
cry= random.randint(1,thresh)
thresh-=1
print(cry)
if(cry==1):
command = 2
print('Cry')
FB=api.passAccelData(1)
print(FB)
if( FB > 440 or FB < 350):
command = 4
elif(command==2):
FB= api.passAccelData(1)
print('crying: ')
print(FB)
buzzer=Buzzer()
buzzer.play(1)
if( FB > 420 or FB < 360):
command = 3
elif(command==3):
api.PlayAction(52)
FB = api.passAccelData(1)
buzzer=Buzzer()
buzzer.play(2)
while(FB > 420 or FB < 360):
buzzer=Buzzer()
buzzer.play(3)
FB = api.passAccelData(1)
print(FB)
command=1
elif(command ==4):
for i in range(0,10):
buzzer=Buzzer()
buzzer.play(1)
print('Sorry...')
command = 3
def main():
gpio_classes = [
] # Add any GPIO class we use, so we can clean up at the end
try:
buzzerController = Buzzer()
ledController = LED()
gpio_classes.append(buzzerController)
gpio_classes.append(ledController)
sensor = UltraSonic()
socket = ServerSocket()
socket.setLightsUpdated(ledController.setState)
sensor.setHandDetectedCallback(lambda: (buzzerController.playSound(
) or True) and socket.sendFlameState(True))
sensor.setHandRemovedCallback(lambda: socket.sendFlameState(False))
sensor.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Program stopped...")
for g in gpio_classes:
g.cleanup()
def start_beeping(self, key):
if self.alarms.get(key) is not None:
self.alarms[key]["is_beeping"] = True
self.buzzer = Buzzer(manage_gpio=False)
self.buzzer.start()
log.info(f"Start beeping for key: {key}.")
else:
log.error(f"No alarm found for key {key}.")
def __init__(self, serial_port, baudrate):
# App start moment in millis
self.start_time = int(round(time.time() * 1000))
# Create smart grid table
self.smart_grid_table = SmartGridTable()
# Create buzzer
self.buzzer = Buzzer()
# Message buffer
self.message_buffer = []
# Define message functions
self.message_functions = {
MessageTypes.TABLE_CONNECTED: self.table_connected,
MessageTypes.MODULE_PLACED: self.module_placed,
MessageTypes.NEIGHBOR_CHANGED: self.table_neighbor_changed,
MessageTypes.CONFIG_CHANGED: self.module_config_changed,
MessageTypes.FLOW_DISABLED: self.flow_disabled,
MessageTypes.FLOW_CONFIG: self.send_flow_config,
MessageTypes.COLOR_CHANGED: self.send_flow_color,
MessageTypes.TIME_SYNC: self.send_time_sync,
MessageTypes.RESET_TABLES: self.reset_table_sections,
MessageTypes.BUZZER_ENABLE: self.buzzer_enabled,
MessageTypes.POWER_BOUNDARIES_CHANGED:
self.power_boundaries_changed,
MessageTypes.SHUTDOWN_APP: self.shutdown_app
}
# Define send config and time sync timers
self.send_flow_config_timer = start_daemon_timer(0, None, start=False)
self.time_sync_timer = start_daemon_timer(SYNC_DELAY,
self.need_time_sync_msg)
# Create and start gateway connection (threaded)
self.gateway_conn = GatewayConnector(self.add_message, serial_port,
baudrate)
start_daemon_thread(self.gateway_conn.start_serial_read, ())
log('--------GW CONN STARTED')
# Create and start flask server (threaded)
self.api = ApiServer(self.smart_grid_table, self.add_message)
start_daemon_thread(self.api.run, ())
log('--------API STARTED')
# Create and start GUI (threaded)
self.gui = Gui(self.smart_grid_table, self.add_message)
start_daemon_thread(self.gui.run, ())
log('--------GUI STARTED')
log('--------RESETTING Table SectionS')
self.need_reset_table_sections()
# Start message handler in main thread
log('--------START MESSAGE HANDLING')
self.handle_messages()
def test_alarm(self):
d1 = datetime.date.today()
t1 = datetime.datetime.today()
for i, a in enumerate(self.config['Alarmas']):
d2 = datetime.datetime.strptime(str(a["Last"]), "%Y-%m-%d").date()
if d1 > d2:
if t1.weekday() in a['Dias']:
if t1.hour == a["Hora"] and t1.minute == a["Minuto"]:
print("Es el momento de " + a["Nombre"])
self.config["Alarmas"][i]["Last"] = str(
datetime.date.today())
print(self.config["Alarmas"][i]["Last"])
self.buzzerActivo = Buzzer(a, self)
class Controller:
stopAllThread = False
def __init__(self):
self.beacon = Beacon()
self.view = View(self)
self.bluetoothThread = threading.Thread(target=self.refreshDataInView)
self.alarmeThread = threading.Thread(target=self.manageAlarme)
self.buzzer = Buzzer()
def main(self):
self.initViewFromBeacon()
self.bluetoothThread.start()
self.alarmeThread.start()
self.view.main()
self.stopAllThread = True
def initViewFromBeacon(self):
self.view.temperatureVar.set(self.beacon.temperature)
self.view.alarmeVar.set(self.beacon.alarmeStatus)
def refreshDataInView(self):
while (self.stopAllThread == False):
self.beacon.refreshTemperature()
temperature = self.beacon.getTemperature()
self.view.temperatureVar.set(str(temperature) + " °C")
time.sleep(5)
def on_off_alarme(self):
self.beacon.switchAlarmeStatus()
self.view.alarmeVar.set(self.beacon.alarmeStatus)
def manageAlarme(self):
while (self.stopAllThread == False):
if (self.beacon.alarmeStatus == "ON"
and self.beacon.isAlarmeActivated == True):
self.buzzer.startBuzzer()
time.sleep(1.5)
def setup(config):
# Comment the config entries you don't have/need
config['temp_humidity'] = AdafruitTempHumidity(Adafruit_DHT.AM2302, '4')
config['temp_humidity_save_file'] = '/home/pi/temp_humidity.csv'
config['temp_humidity_save_interval'] = 30
#serial = spi(port=0, device=0, gpio=noop())
#device = max7219(serial)
#seg = sevensegment(device)
#config['led_display'] = LumaLedMatrix(seg)
serial = spi(device=0, port=0, gpio_DC=23, gpio_RST=24)
oled_device = sh1106(serial)
config['oled'] = OLed(oled_device)
config['oled'].contrast(0)
config['oled'].start_loop()
config['buzzer'] = Buzzer(PassiveBuzzer(16))
def main():
GPIO_TRIGGER = 66 #P8.7
GPIO_ECHO = 67 #P8.8
PWM_PORT = 6 #P8.13
LPF_A = 0.5
MIN_DIST = 50.0
MAX_DIST = 150.0
DIST_RANGE = MAX_DIST - MIN_DIST
MIN_FREQ = 220
MAX_FREQ = 880
FREQ_RANGE = MAX_FREQ - MIN_FREQ
try:
print("Press Ctrl+C to finish")
meter = Ultrasonic(GPIO_TRIGGER, GPIO_ECHO)
buzz = Buzzer(6)
dist = meter.read()
time.sleep(0.5)
while True:
distRead = meter.read()
if distRead != Ultrasonic.OUT_OF_RANGE:
dist += (distRead - dist) * LPF_A
print("~ {0:.3f} cm".format(dist))
if dist > MIN_DIST and dist < MAX_DIST:
freq = (((dist - MIN_DIST) / DIST_RANGE) *
FREQ_RANGE) + MIN_FREQ
buzz.playNote(freq, 0.5)
else:
time.sleep(0.5)
else:
print("Out of range!")
time.sleep(0.5)
except KeyboardInterrupt:
print("\nCtrl+C pressed.")
finally:
print("Bye!")
meter.cleanup()
buzz.cleanup()
def main():
"""Main setup and loop"""
buzzer = Buzzer()
logger = Logger(buzzer, 1)
logger.info("Initialising reader")
config = Config(logger)
scanner = Scanner(config, logger)
buzzer.ready()
# Loop until either config is successfully downloaded, or a config card is
# scanned
err = True
while err and not config.ready:
buzzer.ready()
err, _ = scanner.scan()
if err:
err = config.update_config()
handler = Handler(logger, config)
handler.get_assignments()
logger.info("Ready")
while True:
scanner.wait()
err, data = scanner.scan()
if err:
continue
if data is True:
handler.get_assignments()
else:
handler.send(data)
from flask import Blueprint, redirect, url_for
from buzzer import Buzzer
from GPIO import GPIO_initialize
bp_buzzer = Blueprint('buzzer', __name__, url_prefix='/buzzer')
GPIO_initialize()
buzz = Buzzer(22)
@bp_buzzer.route('/on/<buzzer_name>')
def buzzer_on(buzzer_name):
buzz.on()
return redirect(url_for('index'))
@bp_buzzer.route('/off/<buzzer_name>')
def buzzer_off(buzzer_name):
buzz.off()
return redirect(url_for('index'))
from temperature import TemperatureSensor
from light import LightSensor
from movement import MovementSensor
from morse import convertStrToMorse
import RPi.GPIO as GPIO
from threading import Thread
app = Flask(__name__)
socketio = SocketIO(app)
#Utilisation d'une norme de nommage pour les broches
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
redLed = Led(16)
blueLed = Led(12)
buzzer = Buzzer(14)
tempSensor = TemperatureSensor('28-01131a3de1fd')
lightSensor = LightSensor(27)
@app.route('/')
def home():
temp = tempSensor.read_temp()
return render_template('home.html', temp=temp)
@app.route('/temp')
def temp():
temp = tempSensor.read_temp()
compare = Signal(bool(0))
alarm_toggle = Signal(bool(1))
alarm_act = Signal(bool(0))
alarm_out = Signal(bool(0))
sev_seg_digit = Signal(intbv(0, min=0, max=128))
select_digit = Signal(intbv(0, min=0, max=64))
clkDriver = ClkDriver(clk1us)
clock = Clock(clk1s, clk500ms, clk1ms, clk1us, reset)
timblk = Timer(tim_secs1, tim_secs10, tim_mins1, tim_mins10, tim_hrs1, tim_hrs10, clk1s, clk500ms, set_time, set_hrs, set_mins, reset)
alarm = Alarm(ala_mins1, ala_mins10, ala_hrs1, ala_hrs10, clk500ms, set_ala, set_hrs,
set_mins, reset)
compblk = AlarmCompare(tim_mins1, tim_mins10, tim_hrs1, tim_hrs10, ala_mins1, ala_mins10, ala_hrs1, ala_hrs10, compare)
buz = Buzzer(alarm_act, alarm_out, clk1ms, alarm_toggle, compare, reset)
outmux = Outmux(sev_seg_digit, select_digit, tim_secs1, tim_secs10, tim_mins1, tim_mins10, tim_hrs1, tim_hrs10,
ala_mins1, ala_mins10, ala_hrs1, ala_hrs10, set_ala, clk1ms, reset)
sim = Simulation(clkDriver, clock, timblk, alarm, compblk, buz, outmux)
toVHDL(Clock, clk1s, clk500ms, clk1ms, clk1us, reset)
toVHDL(Timer, tim_secs1, tim_secs10, tim_mins1, tim_mins10, tim_hrs1, tim_hrs10, clk1s, clk500ms, set_time, set_hrs, set_mins, reset)
toVHDL(Alarm, ala_mins1, ala_mins10, ala_hrs1, ala_hrs10, clk500ms, set_ala, set_hrs, set_mins, reset)
toVHDL(Buzzer, alarm_act, alarm_out, clk1ms, alarm_toggle, compare, reset)
toVHDL(Outmux, sev_seg_digit, select_digit, tim_secs1, tim_secs10, tim_mins1, tim_mins10, tim_hrs1, tim_hrs10,
ala_mins1, ala_mins10, ala_hrs1, ala_hrs10, set_ala, clk1ms, reset)
#toVerilog(Timer, tim_secs1, tim_secs10, tim_mins1, tim_mins10, tim_hrs1, tim_hrs10, clk1s, clk500ms, set_time, set_hrs, set_mins, reset)
#toVerilog(Clock, clk1s, clk500ms, clk1ms, clk1us, reset)
#traceSignals(Clock, clk1s, clk500ms, clk1ms, clk1us, reset)
"""
test_buzzer_tune.py - Exemple d'utilisation de Buzzer sur PYBStick
Fiche produit:
---> https://shop.mchobby.be/fr/micropython/1830-pybstick-lite-26-micropython-et-arduino-3232100018303-garatronic.html
------------------------------------------------------------------------
History:
26 june 2020 - Meurisse D. - initial code
"""
from buzzer import Buzzer
from time import sleep
bz = Buzzer()
# Play a melody:
# List of note + rythm (coma separated)
# First char = The note as contained in NOTES dictionnary
# Second char = note duration (defaut=1 if missing)
tune1 = "c,c,g,g,a,a,g2,f,f,e,e,d,d,c2, 4"
tune2 = "c2,c,d3,c3,f3,e3,c2,c,d3,c3,g3,f3, 4"
bz.tune(tune1, tempo=300) # Slower
sleep(1)
bz.tune(tune2, tempo=200) # Faster
print("That's all Folks!")
class HelpPage(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
label = tk.Label(self, text="help page for all the penises: ")
button_page = tk.Button(self, text="Home", anchor="sw",
command=lambda: controller.show_frame(HomePage))
button_quit = tk.Button(self, text="quit", anchor="sw", command=self.quit)
label.grid(row=0, column=0, pady=10, padx=10, sticky="w")
button_page.grid(row=3, column=1, pady=10, padx=10, sticky="se")
button_quit.grid(row=4, column=1, pady=10, padx=10, sticky="se")
rpi = Board()
sense = _SenseHat(rpi)
pir = PIR(rpi, 6) # passing in board object and pin number of the pir
buzz = Buzzer(rpi, 20)
ldr = LDR(rpi, 21)
app = App()
app.mainloop()
# buzzer pin = 20
# pir pin = 6
# ldr pin = 21
def print_file(filename):
print "printing"
os.system("lpr %s" % filename)
buzzer = Buzzer(True)
buzzer.buzz()
import os
import sys
sys.path.append('../src')
from buzzer import Buzzer
from led import Led
from pisocket import Pisocket
import json
import time
mybuzzer = Buzzer(12)
myled = Led(21)
mysocket = Pisocket(10080, 1)
try:
while True:
json_dict = mysocket.wait_and_accept()
tone = json_dict['tone']
level = int(json_dict['level'])
if tone != 'na':
#print json_dict
mybuzzer.softtonewrite(tone, level)
myled.on()
else:
mybuzzer.softtonestop()
myled.off()
#print json_dict
except KeyboardInterrupt:
pass
from gpiozero import LED, MotionSensor
from buzzer import Buzzer
leds = red, green, blue = [LED(pin) for pin in (18, 23, 24)]
green.on()
pir = MotionSensor(25)
buzzer = Buzzer(8)
try:
while True:
pir.wait_for_motion()
buzzer.buzz(200, .2)
green.off()
while pir.motion_detected:
for n in range(10):
red.blink(.1, 0, 1, background=False)
blue.blink(.1, 0, 1, background=False)
green.on()
except KeyboardInterrupt:
pass
for led in leds:
led.off()
time()
jmp = Button(21)
btn_power = Button(26, hold_time=2)
btn_channel = Button(13, hold_time=2)
btn_start = Button(6)
channel = 11
power = 8
current_mode = ''
input_queue = queue.Queue()
output_queue = queue.Queue()
sp = SerialProcess()
lcd = Lcd()
buzzer = Buzzer()
buzzer.start()
if is_tx():
print("Tx Mode")
else:
print("Rx mode")
while True:
while not sp.is_open():
sp = SerialProcess()
print('port is open')
try:
t = threading.Thread(target=io_jobs)
import sys
sys.path.append('../src')
from tact import Tact
from led import Led
from buzzer import Buzzer
from time import sleep
mybuzzer = Buzzer(18)
mytact0 = Tact(21)
mytact1 = Tact(20)
myled = Led(16)
song = [['c', 'c', 'g', 'g', 'a', 'a', 'g', 'f', 'f', 'e', 'e', 'd', 'd', 'c'],
['c', 'd', 'e', 'c', 'd', 'e', 'g', 'e', 'd', 'c', 'd', 'e', 'd']]
index = 0
push = False
scale = 2
count = 0
select = 0
switch = False
scount = 0
try:
while True:
if select == 1:
myled.on()
else:
myled.off()
""" test_buzzer.py - Exemple d'utilisation de Buzzer sur PYBStick Fiche produit: ---> https://shop.mchobby.be/fr/micropython/1830-pybstick-lite-26-micropython-et-arduino-3232100018303-garatronic.html ------------------------------------------------------------------------ History: 26 june 2020 - Meurisse D. - initial code """ from buzzer import Buzzer from time import sleep bz = Buzzer() # Play the Do @ 523 Hertz bz.tone( 523 ) # Wait one second sleep( 1 ) # Play the Fa @ 349 Hertz bz.tone( 349 ) # Wait one second sleep( 1 ) # Silent bz.tone()
return signals[index]
class SonyBuzzMock():
@staticmethod
def get_devices():
return [DeviceMock()]
##
##
##
try:
devices = SonyBuzzer.get_devices()
#devices = SonyBuzzMock.get_devices()
buzzer = Buzzer(devices)
teams = ['A', 'B', 'C', 'D']
index = None
for i, team in enumerate(teams):
controller = buzzer.get_controller(0, i)
print 'Team ', team
controller.light_on(i)
r = buzzer.read(
0, i, 0, timeout=4) # accepts read for controller i and button 0
controller.light_off(i)
if r is not None:
index = i
print "Player OK"
else:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from sound import Sound
from buzzer import Buzzer
from dc import DC
from pumpe import Pumpe
from barometer import Barometer
soundModul = Sound('testSoundModul')
soundModul.test()
buzzerModul = Buzzer('testBuzzer')
buzzerModul.test()
#dualColorModul = DC('test dual Color')
#dualColorModul.test()
pumpe = Pumpe()
pumpe.test()
barometer = Barometer()
barometer.test()
import json
import requests
import threading
import time
from pprint import pprint
import paho.mqtt.client as mqtt
from dataLoader import serverData, DANGER_THRESHOLD
from detector import Detector
from buzzer import Buzzer
buzzer = Buzzer()
detector = Detector()
lock = threading.Lock()
readings = []
def detector_callback(client, userdata, message):
print("detector_callback: " + message.topic + " " + "\"" +
str(message.payload, "utf-8") + "\"")
with lock:
if str(message.payload, "utf-8") == "ON":
# Set the internal flag to start the detector
print("starting the sensor")
detector.stop_sensing = False
elif str(message.payload, "utf-8") == "OFF":
# Set the detector's internal flag to stop sensing
detector.stop_sensing = True
def main():
buz = Buzzer(6, S / 2.0)
notes = [
# (B4,H),
# (C5,Q),
# (D5,Q),
# (D5,Q),
# (C5,Q),
# (B4,Q),
# (A4,Q),
# (G4,Q),
# (G4,Q),
# (A4,Q),
# (B4,Q),
# (B4,H),
# (A4,H),
# (B4,H),
# (C5,Q),
# (D5,Q),
# (D5,Q),
# (C5,Q),
# (B4,Q),
# (A4,Q),
# (G4,Q),
# (G4,Q),
# (A4,Q),
# (B4,Q),
# (A4,Q+E),
# (G4,E),
# (G4,H),
# (A4,H),
# (B4,Q),
# (G4,Q),
# (A4,Q),
# (B4,E),
# (C5,E),
# (B4,Q),
# (G4,Q),
# (A4,Q),
# (B4,E),
# (C5,E),
# (B4,Q),
# (A4,Q),
# (G4,Q),
# (A4,Q),
# (D4,H),
# (B4,H),
# (C5,Q),
# (D5,Q),
# (D5,Q),
# (C5,Q),
# (B4,Q),
# (A4,Q),
# (G4,Q),
# (G4,Q),
# (A4,Q),
# (B4,Q),
# (A4,Q+E),
# (G4,E),
# (G4,H),
#
# (M, W),
#
# (D4, H),
# (G4, H),
# (B4, H),
# (D4, H),
# (B4, H),
# (G4, H),
# (D4, H),
#
# (M, W),
#
# (G4, H),
# (A4, H),
# (F4, H),
# (F3, H),
# (C4, H),
#
# (M, W),
#
# (As4, H),
# (C4, H),
# (Gs4, H),
# (Gs3, H),
# (Ds4, H),
#
# (M, W),
#
(C5, H),
(B4, Q),
(A4, Q),
(G4, Q),
(F4, Q),
(E4, Q),
(D4, Q),
(C4, W),
#
(M, W),
#
(C4, H),
(D4, Q),
(E4, Q),
(F4, Q),
(G4, Q),
(A4, Q),
(B4, Q),
(C5, W)
]
try:
for note in notes:
buz.playNote(note[0], note[1])
finally:
buz.cleanup()
def Run(command):
thresh = 5
while (True):
if (command == 1):
api.PlayAction(52)
buzzer = Buzzer()
buzzer.play(4)
print('Plank')
command = 0
thresh = 5
elif (command == 0):
api.PlayAction(55)
print('Crawl')
cry = random.randint(1, thresh)
thresh -= 1
print(cry)
if (cry == 1):
command = 2
print('Cry')
FB = api.passAccelData(1)
print(FB)
if (FB > 440 or FB < 350):
command = 4
elif (command == 2):
FB = api.passAccelData(1)
print('crying: ')
print(FB)
buzzer = Buzzer()
buzzer.play(1)
if (FB > 420 or FB < 360):
command = 3
elif (command == 3):
api.PlayAction(52)
FB = api.passAccelData(1)
buzzer = Buzzer()
buzzer.play(2)
while (FB > 420 or FB < 360):
buzzer = Buzzer()
buzzer.play(3)
FB = api.passAccelData(1)
print(FB)
command = 1
elif (command == 4):
for i in range(0, 10):
buzzer = Buzzer()
buzzer.play(1)
print('Sorry...')
command = 3
reflow_profiles = LoadProfiles(config['default_alloy'])
temp_sensor = Sensor(hwspi=config['sensor_pins']['hwspi'],
cs=config['sensor_pins']['cs'],
miso=config['sensor_pins']['miso'],
sck=config['sensor_pins']['sck'],
offset=config['sensor_offset'],
cache_time=int(1000 / config['sampling_hz']))
heater = machine.Signal(machine.Pin(config['heater_pins']['heater'],
machine.Pin.OUT),
invert=config['heater_pins']['heater_active_low'])
heater.off()
buzzer = Buzzer(config['buzzer_pin'])
def measure_temp():
global TEMP_GUI_LAST_UPDATE
while True:
try:
t = temp_sensor.get_temp()
except Exception as e:
t = str(e)
gui.temp_update(t)
gc.collect()
utime.sleep_ms(int(1000 / config['display_refresh_hz']))
def buzzer_activate():
while True:
if buzzer.song:
import sys
sys.path.append('../src')
from buzzer import Buzzer
from time import sleep
mybuzzer = Buzzer(12)
scale = ['c', 'd', 'e', 'f', 'g', 'a', 'b']
for i in range(2,4):
for tone in scale:
mybuzzer.softtonewrite(tone, i)
sleep(1)
GPIO.cleanup()
GPIO_PIR = 7
GPIO_BUTT = 19
GPIO_LED = 18
GPIO_BUZZ = 24
GPIO_TEMP = 4
TEMP_THRESH = 30
loop = True
e1 = eventListener(0.05)
e2 = eventListener(5)
pir = PIR_sensor(GPIO_PIR)
pir.initialize()
temp_s = Temp_sensor()
buzzer = Buzzer(GPIO_BUZZ)
L22 = None
times = 0
def pirCallback():
global times, buzzer
times += 1
if (times >= 3):
buzzer.stop()
# print("motion")
pass
def buttCallback(pressed):
class App:
def __init__(self):
self._running = True
self._display_surf = None
self.size = self.weight, self.height = 480, 320
self.actual = None
self.texto = None
self.config = {}
self.buzzerActivo = None
def test_alarm(self):
d1 = datetime.date.today()
t1 = datetime.datetime.today()
for i, a in enumerate(self.config['Alarmas']):
d2 = datetime.datetime.strptime(str(a["Last"]), "%Y-%m-%d").date()
if d1 > d2:
if t1.weekday() in a['Dias']:
if t1.hour == a["Hora"] and t1.minute == a["Minuto"]:
print("Es el momento de " + a["Nombre"])
self.config["Alarmas"][i]["Last"] = str(
datetime.date.today())
print(self.config["Alarmas"][i]["Last"])
self.buzzerActivo = Buzzer(a, self)
def do_stopAlarm(self):
self.buzzerActivo = None
pass
def on_init(self):
pygame.init()
pygame.font.init()
pygame.mixer.init()
if os.path.exists('config.txt'):
with open('config.txt') as json_file:
self.config = json.load(json_file)
else:
self.config['Alarmas'] = [{
"Nombre":
"Alarma 1",
"Hora":
13,
"Minuto":
2,
"Dias": [0, 2, 4, 6],
"Last":
str(datetime.date.today() + datetime.timedelta(days=-1))
}, {
"Nombre":
"Alarma 2",
"Hora":
13,
"Minuto":
3,
"Dias": [1, 3, 5],
"Last":
str(datetime.date.today() + datetime.timedelta(days=-1))
}, {
"Nombre":
"Alarma 3",
"Hora":
13,
"Minuto":
4,
"Dias": [0, 3, 5],
"Last":
str(datetime.date.today() + datetime.timedelta(days=-1))
}]
self.texto = pygame.font.Font("DroidSansMono.ttf", 48)
# self._display_surf = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
self._display_surf = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
self._running = True
self.actual = Reloj()
self.actual.on_init(self)
def on_event(self, event):
if event.type == pygame.QUIT:
self._running = False
if event.type == pygame.MOUSEBUTTONDOWN:
if not self.buzzerActivo is None:
self.buzzerActivo.click()
self.actual.click()
def on_loop(self):
self.actual.doProc()
self.test_alarm()
if not (self.buzzerActivo is None):
self.buzzerActivo.doProc()
pass
def on_render(self):
self.actual.render()
if not (self.buzzerActivo is None):
self.buzzerActivo.render()
pygame.display.flip()
pass
def on_cleanup(self):
with open('config.txt', 'w') as outfile:
json.dump(self.config, outfile)
pygame.quit()
def go_configSCR(self):
self.actual = ConfigMenu()
self.actual.on_init(self)
def go_mainSCR(self):
self.actual = Reloj()
self.actual.on_init(self)
def go_alarmas(self):
self.actual = Alarmas()
self.actual.on_init(self)
def go_setAlarm(self, n):
self.actual = SetAlarm()
self.actual.on_init(self, n)
def on_execute(self):
if self.on_init() == False:
self._running = False
while self._running:
for event in pygame.event.get():
self.on_event(event)
self.on_loop()
self.on_render()
self.on_cleanup()
import RPi.GPIO as GPIO from buzzer import Buzzer from time import sleep GPIO.setmode(GPIO.BOARD) pir = 11 pitch = 659 # SETUP GPIO.setup(pir, GPIO.IN) buzzer = Buzzer() while True: sleep(0.01) moved = GPIO.input(pir) if(moved) : buzzer.buzz(pitch,0.01)
parser.add_argument("-k", "--client_key_file", help="Client Key File", default='private.pem')
parser.add_argument("-p", "--port", help="MQTT port", type=int, default=8883)
parser.add_argument("-q", "--qos", help="MQTT QoS", type=int, default=1)
parser.add_argument("-d", "--beep_duration", help="time in seconds for a beep duration", type=float, default=0.06)
parser.add_argument("-w", "--quiet_duration", help="time in seconds between beeps", type=float, default=0.1)
parser.add_argument("-n", "--beep_count", help="number of beeps", type=int, default=2)
parser.add_argument("-i", "--pin", help="gpio pin (using BCM numbering)", type=int, default=6)
parser.add_argument("-s", "--buzzer_name", help="buzzer name", default='buzzer')
parser.add_argument("-y", "--config_file", help="yaml config file", default='buzzer.yml')
parser.add_argument("-g", "--log_level", help="log level", type=int, default=logging.INFO)
args = parser.parse_args()
# logging setup
logger = set_logger(level=args.log_level)
# read subscriptions from config and create buzzer
buzzer = Buzzer(args.buzzer_name, args.pin)
buzzer.start()
SUBSCRIPTIONS = yaml.load(open(args.config_file))
# connect with Amazon IoT and go
mqtt = MqttClient(args.endpoint, args.log_level, args.port)
mqtt.set_tls(args.ca_file, args.client_cert_file, args.client_key_file)
for sub in SUBSCRIPTIONS.keys():
mqtt.add_callback(sub, receive_command)
mqtt.add_subscription(sub, qos=args.qos)
mqtt.run()
""" test_buzzer_notes.py - Exemple d'utilisation de Buzzer sur PYBStick Fiche produit: ---> https://shop.mchobby.be/fr/micropython/1830-pybstick-lite-26-micropython-et-arduino-3232100018303-garatronic.html ------------------------------------------------------------------------ History: 26 june 2020 - Meurisse D. - initial code """ from buzzer import Buzzer, NOTES from time import sleep bz = Buzzer() tempo = 300 # Play tempo note_duration = 2 # Duration of the note # Display available notes (space is for silent) print( ", ".join(NOTES.keys()) ) for note in NOTES.keys(): print( "Play note: %s " % note ) bz.note( note, tempo*note_duration ) # 600*1000uS per note sleep( 0.3 ) # Wait 300ms to ear each note # Silent bz.tone()
from buzzer import Buzzer
from temperature import TemperatureSensor
from light import LightSensor
from movement import MovementSensor
from morse import convertStrToMorse
import RPi.GPIO as GPIO
from threading import Thread
app = Flask(__name__)
socketio = SocketIO(app)
#Utilisation d'une norme de nommage pour les broches
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
redLed = Led(18)
greenLed = Led(24)
buzzer = Buzzer(22)
tempSensor = TemperatureSensor('28-01131a4f0da1')
lightSensor = LightSensor(27)
@app.route('/')
def home():
temp = tempSensor.read_temp()
return render_template('home.html', temp=temp)
@app.route('/temp')
def temp():
temp = tempSensor.read_temp()
return str(temp)
def __init__(self):
self.msg = None
self.wl_up = False
self.wl_signal = 0
self.conn_ok = False
model = GoopyModel()
display = GoopyDisplay(model)
stat_sched = GoopySched()
stat_sched.add(display)
stat_sched.add(WlStat(model, 'wlan0'))
stat_sched.add(ConnStat(model, 'dwarf.agr.fm'))
stat_sched.start()
buzzer = Buzzer()
buzzer.beep_startup()
try:
while True:
sleep(60)
except:
stat_sched.stop()
display.shutdown()
buzzer.shutdown()
from board import Board
from led import Led
from rgb import RGB_led
from button import Button
from buzzer import Buzzer
from pir import Pir
from temp import Temperature
from time import sleep
rpi = Board()
led = Led(rpi, 13)
rgb = RGB_led(rpi, 20, 21, 16)
button = Button(rpi, 22)
buzzer = Buzzer(rpi, 24)
button2 = Button(rpi, 7)
pir = Pir(rpi, 14)
'''
light = False
while True:
if button.pressed:
if not light:
led.led_on()
light = True
button.pressed = False
elif light:
led.led_off()
light = False
button.pressed = False
'''
buz = False
while True:
