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: