def __init__(self, level='lvl0'): #instantiating all the motors and sensors on the bot self.robot = Robot(left=MOTOR_L, right=MOTOR_R) self.sonic = DistanceSensor(echo=SONIC_ECHO, trigger=SONIC_TRIG) self.ir_l = MCP3008(IR_L) self.ir_r = MCP3008(IR_R) self.button = MCP3008(BTN) self.bz = TonalBuzzer(BZ) self.led = RGBLED(R, G, B) #creating custom variables self.speed = self.get_speed(level)
class ResultsBuzzer: def __init__(self, pin): self.buzzer = TonalBuzzer(pin) self.min = Tone(self.buzzer.min_tone).frequency self.max = Tone(self.buzzer.max_tone).frequency self.conversion = (self.max - self.min) / 100 def update(self, light_value): # light_value goes from 0 to 100, # so we need to convert it first value = round(self.max - light_value * self.conversion) self.buzzer.play(Tone(frequency=value))
def __init__(self, lcd_rs, lcd_e, lcd_data, buzzer_pin, red_led_pin, yellow_led_pin, green_led_pin, button_pins, fm_username: str, fm_key: str, spot_client: str, spot_secret: str, spot_refresh: str): self.lcd = CharLCD(numbering_mode=GPIO.BCM, cols=lcd_width, rows=2, pin_rs=lcd_rs, pin_e=lcd_e, pins_data=lcd_data, auto_linebreaks=True) self.lcd.cursor_mode = 'hide' self.leds = TrafficLights(red=red_led_pin, yellow=yellow_led_pin, green=green_led_pin, pwm=True) self.buzzer = TonalBuzzer(buzzer_pin) self.buzzer_lock = Lock() self.notif_button = Button(button_pins[0]) self.notif_button.when_activated = self.handle_notif_click self.button2 = Button(button_pins[1]) self.button2.when_activated = lambda: self.queue_text('hey', 'hey') self.button3 = Button(button_pins[2]) self.button4 = Button(button_pins[3]) self.button4.when_held = self.handle_network_hold self.location = DisplayLocation.home self.pulled_idle_text = dict() self.notification_queue = Queue() self.display_queue = Queue() self.display_thread = Thread(target=self.display_worker, name='display', daemon=True) self.network_active = True self.rsession = Session() self.fmnet = FMNetwork(username=fm_username, api_key=fm_key) self.spotnet = SpotNetwork( NetworkUser(client_id=spot_client, client_secret=spot_secret, refresh_token=spot_refresh)).refresh_access_token() self.network_pull_thread = Thread(target=self.network_pull_worker, name='puller', daemon=True)
class buzzer(object): def __init__(self,pin=12,seq=(70,80)): self._buzzer=TonalBuzzer(pin) self.seq=seq def beep(self,n=1,t=.1): for i in range(0,n): for tn in self.seq: try: self._buzzer.play(Tone(midi=tn)) except: pass sleep(t) self._buzzer.stop()
def alarm_buzzer_melody(): tone_buzzer = TonalBuzzer(27) for _ in range(5): tone_buzzer.play(Tone("C4")) sleep(0.15) tone_buzzer.play(Tone("G4")) sleep(0.15) tone_buzzer.play(Tone("F4")) sleep(0.15) tone_buzzer.stop() sleep(2)
def __init__(self, conf_path=util.CONF, env_path=util.ENV): with open(conf_path) as cf: self.conf = json.load(cf) with open(env_path) as ef: self.env = json.load(ef) self.lock = asyncio.Lock() self.event_loop = asyncio.get_running_loop() self.button = Button(self.conf['button']) self.buzzer = TonalBuzzer(self.conf['buzzer']) self.servokit = ServoKit(channels=16, freq=self.conf['servo']['freq']) self.screen_backlight = self.servokit.servo[self.conf['servo'] ['backlight']['channel']] self.screen_backlight.set_pulse_width_range( 0, 100000 // self.conf['servo']['freq']) self.screen_backlight.fraction = 0 spi = board.SPI() cs_pin = digitalio.DigitalInOut( getattr(board, f'D{self.conf["screen"]["cs"]}')) dc_pin = digitalio.DigitalInOut( getattr(board, f'D{self.conf["screen"]["dc"]}')) reset_pin = digitalio.DigitalInOut( getattr(board, f'D{self.conf["screen"]["rst"]}')) self.screen = st7789.ST7789( spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=24000000, ) self.servo_update_rate = self.conf['servo']['update_rate'] self._double_press_max_interval = .5 self.reset_servos() self._head.angle = self.rarm.fraction = self.larm.fraction = 0 time.sleep(.5) self.relax_lift() self.relax_head() self.cam = None
def transmission_start_end(): tbuzzer = TonalBuzzer(22) led.blink(0.025, 0.025) tbuzzer.play(Tone(frequency=500)) sleep(3) led.off() tbuzzer.stop() tbuzzer.close() return render_template('json.html')
def __init__(self): threading.Thread.__init__(self) self.stop_event = threading.Event() self.setDaemon(True) self._rcv_que = Queue() self._buzzer = {} for key, pin in BUZZER_DICT.items(): self._buzzer[key] = TonalBuzzer(pin, pin_factory=PiGPIOFactory()) return
def buzzers(): buzzer = TonalBuzzer(15) while True: buzzer.play("A3") time.sleep(1) if onStopEvent.is_set(): buzzer.stop() break
def get_tag(): buzzer = TonalBuzzer(17) buzzer.play(220) clf = nfc.ContactlessFrontend('tty:AMA2:pn532') target = None while target is None: target = clf.sense(nfc.clf.RemoteTarget('106A'), nfc.clf.RemoteTarget('106B'), nfc.clf.RemoteTarget('212F')) if target is None: pass else: buzzer.stop() tag = nfc.tag.activate(clf, target) clf.close() return str(tag).split("ID=")[1]
def main(): # 各ピンをbuzzer設定 factory = PiGPIOFactory() buzzers = {} for key, pin in buzzer_pins.items(): buzzers[key] = TonalBuzzer(pin, pin_factory=PiGPIOFactory()) # 音を鳴らす try: for _ in range(5): for key, buzzer in buzzers.items(): buzzer.play(Tone("A4")) sleep(0.5) buzzer.play(Tone(220.0)) # Hz sleep(0.5) buzzer.play(Tone(60)) # middle C in MIDI notation sleep(0.5) buzzer.stop() except KeyboardInterrupt: print("stop") return
from time import sleep from gpiozero import TonalBuzzer from gpiozero.tones import Tone buzzerPin = 'GPIO13' buzzer = TonalBuzzer(buzzerPin, octaves=3) crappy_jingle = [ Tone('C#6'), 'P', 'P', 'P', Tone('C#5'), Tone('F#5'), Tone('C#5'), Tone('G#5') ] for note in crappy_jingle: print(note) if note != 'P': buzzer.play(note) sleep(0.25)
class CozmarsServer: async def __aenter__(self): await self.lock.acquire() self.lmotor = Motor(*self.conf['motor']['left']) self.rmotor = Motor(*self.conf['motor']['right']) # self.reset_servos() self.reset_motors() self.lir = LineSensor(self.conf['ir']['left'], queue_len=3, sample_rate=10, pull_up=True) self.rir = LineSensor(self.conf['ir']['right'], queue_len=3, sample_rate=10, pull_up=True) sonar_cfg = self.conf['sonar'] self.sonar = DistanceSensor(trigger=sonar_cfg['trigger'], echo=sonar_cfg['echo'], max_distance=sonar_cfg['max'], threshold_distance=sonar_cfg['threshold'], queue_len=5, partial=True) self._sensor_event_queue = None self._button_last_press_time = 0 def cb(ev, obj, attr): return lambda: self._sensor_event_queue and self.event_loop.call_soon_threadsafe( self._sensor_event_queue.put_nowait, (ev, getattr(obj, attr))) def button_press_cb(): if self._sensor_event_queue: now = time.time() if now - self._button_last_press_time <= self._double_press_max_interval: ev = 'double_pressed' else: ev = 'pressed' self.event_loop.call_soon_threadsafe( self._sensor_event_queue.put_nowait, (ev, True)) self._button_last_press_time = now self.lir.when_line = self.lir.when_no_line = cb( 'lir', self.lir, 'value') self.rir.when_line = self.rir.when_no_line = cb( 'rir', self.rir, 'value') self.button.hold_time = 1 self.button.when_pressed = button_press_cb self.button.when_released = cb('pressed', self.button, 'is_pressed') self.button.when_held = cb('held', self.button, 'is_held') self.sonar.when_in_range = cb('in_range', self.sonar, 'distance') self.sonar.when_out_of_range = cb('out_of_range', self.sonar, 'distance') self.screen.fill(0) self.screen_backlight.fraction = .05 return self async def __aexit__(self, exc_type, exc, tb): self.stop_all_motors() self.buzzer.stop() for a in [ self.sonar, self.lir, self.rir, self.lmotor, self.rmotor, self.cam ]: a and a.close() self.screen_backlight.fraction = None self.lock.release() def __del__(self): self.button.close() self.buzzer.close() def __init__(self, conf_path=util.CONF, env_path=util.ENV): with open(conf_path) as cf: self.conf = json.load(cf) with open(env_path) as ef: self.env = json.load(ef) self.lock = asyncio.Lock() self.event_loop = asyncio.get_running_loop() self.button = Button(self.conf['button']) self.buzzer = TonalBuzzer(self.conf['buzzer']) self.servokit = ServoKit(channels=16, freq=self.conf['servo']['freq']) self.screen_backlight = self.servokit.servo[self.conf['servo'] ['backlight']['channel']] self.screen_backlight.set_pulse_width_range( 0, 100000 // self.conf['servo']['freq']) self.screen_backlight.fraction = 0 spi = board.SPI() cs_pin = digitalio.DigitalInOut( getattr(board, f'D{self.conf["screen"]["cs"]}')) dc_pin = digitalio.DigitalInOut( getattr(board, f'D{self.conf["screen"]["dc"]}')) reset_pin = digitalio.DigitalInOut( getattr(board, f'D{self.conf["screen"]["rst"]}')) self.screen = st7789.ST7789( spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=24000000, ) self.servo_update_rate = self.conf['servo']['update_rate'] self._double_press_max_interval = .5 self.reset_servos() self._head.angle = self.rarm.fraction = self.larm.fraction = 0 time.sleep(.5) self.relax_lift() self.relax_head() self.cam = None @staticmethod def conf_servo(servokit, conf): servo = servokit.servo[conf['channel']] servo.set_pulse_width_range(conf['min_pulse'], conf['max_pulse']) return servo def reset_motors(self): self.motor_compensate = { 'forward': list(self.conf['motor']['forward']), 'backward': list(self.conf['motor']['backward']) } def reset_servos(self): self.rarm = CozmarsServer.conf_servo(self.servokit, self.conf['servo']['right_arm']) self.larm = CozmarsServer.conf_servo(self.servokit, self.conf['servo']['left_arm']) self._head = CozmarsServer.conf_servo(self.servokit, self.conf['servo']['head']) self._head.set_actuation_range(-20, 20) def save_conf(self, conf_path=util.CONF): # only servo and motor configs are changed for servo_name, servo in zip(('right_arm', 'left_arm', 'head'), (self.rarm, self.larm, self._head)): self.conf['servo'][servo_name]['max_pulse'] = servo.max_pulse self.conf['servo'][servo_name]['min_pulse'] = servo.min_pulse for dir in ('forward', 'backward'): self.conf['motor'][dir] = list(self.motor_compensate[dir]) with open(conf_path, 'w') as f: json.dump(self.conf, f, indent=2) def calibrate_motor(self, direction, left, right): self.motor_compensate[direction] = [left, right] def calibrate_servo(self, channel, min_pulse=None, max_pulse=None): ''' for s in self.conf['servo'].values(): if isinstance(s, dict) and s.get('channel')==channel: s['min_pulse'] = min_pulse s['max_pulse'] = max_pulse ''' servo = self.servokit.servo[channel] servo.set_pulse_width_range(min_pulse or servo.min_pulse, max_pulse or servo.max_pulse) def get_env(self, name): return self.env[name] def set_env(self, name, value): self.env[name] = value def del_env(self, name): del self.env[name] def save_env(self, env_path=util.ENV): with open(env_path, 'w') as f: json.dump(self.env, f, indent=2) def real_speed(self, sp): ''' 1. compensate for speed inbalance of two motors 2. the motors won't run when speed is lower than .2, so we map speed from (0, 1] => (.2, 1], (0, -1] => (-.2, -1] and 0 => 0 ''' if not isinstance(sp, Iterable): sp = (sp, sp) sp = (s * self.motor_compensate['forward' if s > 0 else 'backward'][i] for i, s in enumerate(sp)) return tuple((s * .8 + (.2 if s > 0 else -.2) if s else 0) for s in sp) def mapped_speed(self, sp): # real speed -> mapped speed if not isinstance(sp, Iterable): sp = (sp, sp) sp = (((s - ((.2 if s > 0 else -.2))) / .8 if s else 0) for s in sp) return tuple( max( -1, min( 1, s / self.motor_compensate['forward' if s > 0 else 'backward'] [i])) for i, s in enumerate(sp)) async def speed(self, speed=None, duration=None): if speed is None: return self.mapped_speed((self.lmotor.value, self.rmotor.value)) speed = self.real_speed(speed) while (self.lmotor.value, self.rmotor.value) != speed: linc = speed[0] - self.lmotor.value if 0 < abs(linc) < .3: self.lmotor.value = speed[0] elif linc: self.lmotor.value += .3 if linc > 0 else -.3 rinc = speed[1] - self.rmotor.value if 0 < abs(rinc) < .3: self.rmotor.value = speed[1] elif rinc: self.rmotor.value += .3 if rinc > 0 else -.3 await asyncio.sleep(.05) if duration: await asyncio.sleep(duration) await self.speed((0, 0)) def stop_all_motors(self): self.lmotor.value = self.rmotor.value = 0 self.relax_lift() self.relax_head() async def backlight(self, *args): if not args: return self.screen_backlight.fraction or 0 value = args[0] duration = speed = None try: duration = args[1] speed = args[2] except IndexError: pass if not (duration or speed): self.screen_backlight.fraction = value or 0 return elif speed: if not 0 < speed <= 1 * self.servo_update_rate: raise ValueError( f'Speed must be 0 ~ {1*self.servo_update_rate}') duration = (value - self.screen_backlight.fraction) / speed steps = int(duration * self.servo_update_rate) interval = 1 / self.servo_update_rate try: inc = (value - self.screen_backlight.fraction) / steps for _ in range(steps): await asyncio.sleep(interval) self.screen_backlight.fraction += inc except (ZeroDivisionError, ValueError): pass finally: self.screen_backlight.fraction = value def relax_lift(self): self.larm.relax() self.rarm.relax() def relax_head(self): self._head.relax() async def lift(self, *args): if not args: return self.rarm.fraction height = args[0] if height == None: self.rarm.fraction = self.larm.fraction = height return if not 0 <= height <= 1: raise ValueError('Height must be 0 to 1') duration = speed = None try: duration = args[1] speed = args[2] except IndexError: pass if not (self.rarm.fraction != None and (speed or duration)): self.rarm.fraction = height self.larm.fraction = height return elif speed: if not 0 < speed <= 1 * self.servo_update_rate: raise ValueError( f'Speed must be 0 ~ {1*self.servo_update_rate}') duration = abs(height - self.larm.fraction) / speed if duration == 0: return steps = int(duration * self.servo_update_rate) interval = 1 / self.servo_update_rate try: inc = (height - self.larm.fraction) / steps for _ in range(steps): await asyncio.sleep(interval) self.larm.fraction += inc self.rarm.fraction += inc except (ZeroDivisionError, ValueError): pass finally: self.rarm.fraction = height self.larm.fraction = height async def head(self, *args): if not args: return self._head.angle angle = args[0] if angle == None: self._head.angle = None return if not -20 <= angle <= 20: raise ValueError('Angle must be -20 ~ 20') duration = speed = None try: duration = args[1] speed = args[2] except IndexError: pass if not (self._head.angle != None and (speed or duration)): self._head.angle = angle return elif speed: if not 0 < speed <= 80 * self.servo_update_rate: raise ValueError( f'Speed must be 0 ~ {80*self.servo_update_rate}') duration = abs(angle - self._head.angle) / speed steps = int(duration * self.servo_update_rate) interval = 1 / self.servo_update_rate try: inc = (angle - self._head.angle) / steps for _ in range(steps): await asyncio.sleep(interval) self._head.angle += inc except (ZeroDivisionError, ValueError): pass finally: self._head.angle = angle def display(self, image_data, x, y, x1, y1): self.screen._block(x, y, x1, y1, image_data) def fill(self, color565, x, y, w, h): self.screen.fill_rectangle(x, y, w, h, color565) def pixel(self, x, y, color565): return self.screen.pixel(x, y, color565) def gif(self, gif, loop): #https://github.com/adafruit/Adafruit_CircuitPython_RGB_screen/blob/master/examples/rgb_screen_pillow_animated_gif.py raise NotImplemented async def play(self, *, request_stream): async for freq in request_stream: self.buzzer.play( Tone.from_frequency(freq)) if freq else self.buzzer.stop() async def tone(self, freq, duration=None): self.buzzer.play( Tone.from_frequency(freq)) if freq else self.buzzer.stop() if duration: await asyncio.sleep(duration) self.buzzer.stop() async def sensor_data(self, update_rate=None): timeout = 1 / update_rate if update_rate else None try: # if the below queue has a max size, it'd better be a `RPCStream` instead of `asyncio.Queue`, # and call `force_put_nowait` instead of `put_nowait` in `loop.call_soon_threadsafe`, # otherwise if the queue if full, # an `asyncio.QueueFull` exception will be raised inside the main loop! self._sensor_event_queue = asyncio.Queue() yield 'lir', self.lir.value yield 'rir', self.rir.value while True: try: yield await asyncio.wait_for( self._sensor_event_queue.get(), timeout) except asyncio.TimeoutError: yield 'sonar', self.sonar.distance except Exception as e: self._sensor_event_queue = None raise e def double_press_max_interval(self, *args): if args: self._double_press_max_interval = args[0] else: return self._double_press_max_interval def hold_repeat(self, *args): if args: self.button.hold_repeat = args[0] else: return self.button.hold_repeat def hold_time(self, *args): if args: self.button.hold_time = args[0] else: return self.button.hold_time def threshold_distance(self, *args): if args: self.sonar.threshold_distance = args[0] else: return self.sonar.threshold_distance def max_distance(self, *args): if args: self.sonar.max_distance = args[0] else: return self.sonar.max_distance def distance(self): return self.sonar.distance def microphone_volume(self, *args): from subprocess import check_output if args: if 0 <= args[0] <= 100: check_output(f'amixer set Boost {args[0]}%'.split(' ')) else: raise ValueError('volume must be 0 ~ 100') else: a = check_output('amixer get Boost'.split(' ')) return int(a[a.index(b'[') + 1:a.index(b'%')]) async def capture(self, options): import picamera, io if self.cam is None or self.cam.closed: self.cam = picamera.PiCamera() self.cam.vflip = self.cam.hflip = True delay = options.pop('delay', 0) standby = options.pop('standby', False) try: buf = io.BytesIO() delay and await asyncio.sleep(delay) self.cam.capture(buf, **options) buf.seek(0) return buf.read() finally: not standby and self.cam.close() async def camera(self, width, height, framerate): import picamera, io, threading, time try: queue = RPCStream(2) stop_ev = threading.Event() def bg_run(loop): nonlocal queue, stop_ev, width, height, framerate with picamera.PiCamera(resolution=(width, height), framerate=framerate) as cam: # Camera warm-up time time.sleep(2) stream = io.BytesIO() for _ in cam.capture_continuous(stream, 'jpeg', use_video_port=True): if stop_ev.isSet(): break stream.truncate() stream.seek(0) loop.call_soon_threadsafe(queue.force_put_nowait, stream.read()) # queue.put_nowait(stream.read()) stream.seek(0) loop = asyncio.get_running_loop() # threading.Thread(target=bg_run, args=[loop]).start() bg_task = loop.run_in_executor(None, bg_run, loop) while True: yield await queue.get() finally: stop_ev.set() await bg_task async def microphone(self, samplerate=16000, dtype='int16', block_duration=.1): import sounddevice as sd channels = 1 # blocksize_sec = .1 # bytes_per_sample = dtype[-2:]//8 # blocksize = int(blocksize_sec * channels * samplerate * bytes_per_sample) blocksize = int(block_duration * channels * samplerate) loop = asyncio.get_running_loop() queue = RPCStream(2) def cb(indata, frames, time, status): nonlocal queue, loop if status: print(status, file=sys.stderr) raise sd.CallbackAbort loop.call_soon_threadsafe(queue.force_put_nowait, bytes(indata)) with sd.RawInputStream(callback=cb, samplerate=samplerate, blocksize=blocksize, channels=channels, dtype=dtype): while True: yield await queue.get()
from gpiozero import DistanceSensor from time import sleep from gpiozero import TonalBuzzer from gpiozero.tones import Tone b = TonalBuzzer(14) b.play(Tone("A4")) sleep(.1) b.play(Tone("C4")) sleep(.1) b.stop() sensorleft = DistanceSensor(echo=24, trigger=23, max_distance=3) sensorright = DistanceSensor(echo=6, trigger=5, max_distance=3) while True: print( f'DistanceLeft: {sensorleft.distance * 100:.2f} DistanceRight: {sensorright.distance * 100:.2f}' ) sleep(1.0) exit(0)
from gpiozero import TonalBuzzer from gpiozero.tones import Tone from signal import pause from time import sleep b = TonalBuzzer(25) b.play(Tone(220)) sleep(.1) b.play(Tone(500)) sleep(.1)
) # Import from gpiozero import MCP3008 from gpiozero import TonalBuzzer from gpiozero.tones import Tone from time import sleep import time import pandas as pd import csv # Analog inputs HRM = MCP3008(channel=0) # Heart rate moniter Temp = MCP3008(channel=1) # Temperture sensor # Buzzer buzzer = TonalBuzzer(12) # Buzzer # Named Varibles def Noise1(): buzzer.play(Tone('A4')) sleep(.3) buzzer.play(Tone('B4')) sleep(.15) buzzer.play(Tone('C4')) sleep(.15) buzzer.play(Tone('D4')) sleep(.35)
from gpiozero import TonalBuzzer from gpiozero.tones import Tone from guizero import App, Box, PushButton, Text import time qnum = 0 questions = [ "What is the capital of Ontario?", "In what year did the Toronto Raptors win the NBA Title?", "Who was Laura Secord?" ] answers = [["Ottawa", "Toronto", "Moosejaw", "Windsor"], ["1995", "2015", "2019", "2000"], ["Chocolate", "Prime Minister", "Laura Who?", "Heroine of 1812"]] correct_answers = [1, 2, 3] b = TonalBuzzer(18) def playTone(freq): b.play(maxToneTone(freq)) time.sleep(4) b.stop() def getButton(channel, event): global qnum, correct_answers, b print("Got {} on {}".format(event, channel)) eh.light.off() if correct_answers[qnum] == 0: eh.light.blue.on() elif correct_answers[qnum] == 1:
from gpiozero import Robot from time import sleep #from gpiozero import Buzzer #bz = Buzzer(14) #bz.on() from gpiozero import TonalBuzzer from gpiozero.tones import Tone b = TonalBuzzer(14) b.play(Tone("A4")) blackWinter = Robot(left=(7, 8), right=(9, 10)) blackWinter.forward() sleep(1) blackWinter.stop()
from gpiozero import LED, Button, TonalBuzzer from gpiozero.tones import Tone from time import sleep ledG = LED(26) ledR = LED(21) ledB = LED(20) ledY = LED(19) butG = Button(6) butR = Button(16) butB = Button(12) butY = Button(13) bz = TonalBuzzer(25) time1 = 0.1 time2 = 0.05 time3 = 0.025 # define output functions def green(time): ledG.on() bz.play(Tone(659.255)) sleep(time) ledG.off() sleep(time) bz.stop() return
# https://gpiozero.readthedocs.io/en/stable/ # https://gpiozero.readthedocs.io/en/stable/api_input.html#distancesensor-hc-sr04 # https://gpiozero.readthedocs.io/en/stable/api_output.html#tonalbuzzer from gpiozero import DistanceSensor, TonalBuzzer from picamera import PiCamera from datetime import datetime from time import sleep sensor = DistanceSensor(17, 4, max_distance=10) #(echo,trigger) camera = PiCamera() buzzer = TonalBuzzer(19) def buzzer_alert(): notes = ['A5', 'A3', 'A5', 'A3', 'A5'] for note in notes: buzzer.play(note) sleep(0.5) buzzer.stop() def take_photo(): output_folder_path = "" timestamp = datetime.now() #.isoformat() camera.capture( f"/home/pi/Documents/reference_code/picamera_captures/{timestamp}.jpg") while True: print(sensor.distance)
from gpiozero import TonalBuzzer from gpiozero.tones import Tone from time import sleep buzz = TonalBuzzer(18) frequency = 8000 period = frequency / 60 with open("sample-data.txt", "r") as file: samples = file.readlines() for sample in samples: buzz.value = float(sample.replace("\n", "")) sleep(period) buzz.stop()
def __init__(self,pin=12,seq=(70,80)): self._buzzer=TonalBuzzer(pin) self.seq=seq
### TonalBuzzer not support PiGPIO #from gpiozero.pins.pigpio import PiGPIOFactory from gpiozero import TonalBuzzer from time import sleep #tones = ["C4", "E4", "G4"] tones = ["G4", "C4", "A4", "F4", "E4", "C4", "D4"] tbz = TonalBuzzer(12) for tone in tones: tbz.play(tone) sleep(1) tbz.stop() sleep(0.1)
def __init__(self, pin): self.buzzer = TonalBuzzer(pin) self.min = Tone(self.buzzer.min_tone).frequency self.max = Tone(self.buzzer.max_tone).frequency self.conversion = (self.max - self.min) / 100
# Imports from gpiozero import MCP3008, LED, TonalBuzzer # Gpiozero is used to comm with pins on Raspberry Pi from gpiozero.tones import Tone # Used to make defined sounds from time import sleep # Used to control timing on Pi import pandas as pd # DataFrame Tool import numpy as np # Basically a great calculator for now #from sklearn import linear_model # M.L. tool # Analog inputs HRM = MCP3008(channel = 0) # Heart rate moniter Temp = MCP3008(channel = 1) # Temperture sensor HRM2 = MCP3008(channel = 2) # Possible Photo sensor # Buzzer buzzer = TonalBuzzer(17) # Buzzer # LED red = LED(22) # Red LED green = LED(27) # Green LED # Named Varibles def Noise1(): # String of Buzzing 1 buzzer.play(Tone('A4')) sleep(.3) buzzer.play(Tone('B4')) sleep(.15) buzzer.play(Tone('C4')) sleep(.15) buzzer.play(Tone('D4'))
class Ticker: def __init__(self, lcd_rs, lcd_e, lcd_data, buzzer_pin, red_led_pin, yellow_led_pin, green_led_pin, button_pins, fm_username: str, fm_key: str, spot_client: str, spot_secret: str, spot_refresh: str): self.lcd = CharLCD(numbering_mode=GPIO.BCM, cols=lcd_width, rows=2, pin_rs=lcd_rs, pin_e=lcd_e, pins_data=lcd_data, auto_linebreaks=True) self.lcd.cursor_mode = 'hide' self.leds = TrafficLights(red=red_led_pin, yellow=yellow_led_pin, green=green_led_pin, pwm=True) self.buzzer = TonalBuzzer(buzzer_pin) self.buzzer_lock = Lock() self.notif_button = Button(button_pins[0]) self.notif_button.when_activated = self.handle_notif_click self.button2 = Button(button_pins[1]) self.button2.when_activated = lambda: self.queue_text('hey', 'hey') self.button3 = Button(button_pins[2]) self.button4 = Button(button_pins[3]) self.button4.when_held = self.handle_network_hold self.location = DisplayLocation.home self.pulled_idle_text = dict() self.notification_queue = Queue() self.display_queue = Queue() self.display_thread = Thread(target=self.display_worker, name='display', daemon=True) self.network_active = True self.rsession = Session() self.fmnet = FMNetwork(username=fm_username, api_key=fm_key) self.spotnet = SpotNetwork( NetworkUser(client_id=spot_client, client_secret=spot_secret, refresh_token=spot_refresh)).refresh_access_token() self.network_pull_thread = Thread(target=self.network_pull_worker, name='puller', daemon=True) def start(self): logger.info('starting ticker') self.lcd.clear() self.display_thread.start() self.network_pull_thread.start() self.set_status(green=True) def set_status(self, green: bool = False, yellow: bool = False): self.leds.green.value = 1 if green else 0 self.leds.yellow.value = 1 if yellow else 0 # HANDLERS def handle_notif_click(self): if not self.notification_queue.empty(): while not self.notification_queue.empty(): self.display_queue.put(self.notification_queue.get()) self.leds.red.off() else: self.queue_text('No Notifications', '', interrupt=True, time=1) def handle_network_hold(self): self.network_active = not self.network_active logger.info(f'setting network activity {self.network_active}') if self.network_active: self.set_status(green=True) else: self.set_status(yellow=True) self.beep() # THREADS def network_pull_worker(self): """thread function for pulling network display items and update cache""" while True: if self.network_active: try: total = self.fmnet.get_scrobble_count_from_date( input_date=date.today()) logger.debug(f'loaded daily scrobbles {total}') # self.queue_text('Scrobbles Today', total) self.pulled_idle_text['daily_scrobbles'] = DisplayItem( 'Scrobbles Today', str(total)) except LastFMNetworkException as e: logger.exception(e) self.queue_text( 'Last.FM Error', f'{e.http_code}, {e.error_code}, {e.message}') try: artists = self.fmnet.get_top_artists( period=FMNetwork.Range.WEEK, limit=3) logger.debug(f'loaded top artists') self.pulled_idle_text['weekly_artists'] = DisplayItem( 'Weekly Artists', ', '.join([str(i) for i in artists]), iterations=1) except LastFMNetworkException as e: logger.exception(e) self.queue_text( 'Last.FM Error', f'{e.http_code}, {e.error_code}, {e.message}') # try: # from_time = date.today() # from_time = datetime(year=from_time.year, month=from_time.month, day=1) # # to_time = datetime.now() # # total = len(self.fmnet.get_recent_tracks(from_time=from_time, to_time=to_time, page_limit=200)) # logger.debug(f'loaded monthly scrobbles {total}') # # # self.queue_text('Scrobbles Today', total) # self.pulled_idle_text['monthly_scrobbles'] = DisplayItem('This Month', str(total)) # except LastFMNetworkException as e: # logger.exception(e) # self.queue_text('Last.FM Error', f'{e.http_code}, {e.error_code}, {e.message}') try: playlist_total = len(self.spotnet.get_user_playlists()) logger.debug(f'loaded daily scrobbles {playlist_total}') self.pulled_idle_text['playlist_count'] = DisplayItem( 'Playlists', str(playlist_total)) except SpotifyNetworkException as e: logger.exception(e) self.queue_text('Spotify Error', f'{e.http_code}, {e.message}') sleep(net_thread_interval) def display_worker(self): """LCD controller, reads queue for new items to display or roll over idle items""" while True: if not self.display_queue.empty(): display_item = self.display_queue.get(block=False) logger.info( f'dequeued {display_item}, size {self.display_queue.qsize()}' ) self.write_display_item(display_item) self.display_queue.task_done() else: if len(self.idle_text ) > 0 and self.location == DisplayLocation.home: for key, item in self.idle_text.items(): if not self.display_queue.empty(): break logger.debug(f'writing {key}') self.write_display_item(item) else: self.write_to_lcd(['Ticker...', '']) sleep(display_thread_interval) # DISPLAY def write_display_item(self, display_item): """write display item to LCD now""" if display_item.message is None: display_item.message = '' if len(display_item.message) > lcd_width: buffer = [display_item.title, ''] self.write_to_lcd(buffer) self.loop_string(display_item.message, buffer, row=1, iterations=display_item.iterations) else: buffer = [display_item.title, display_item.message] self.write_to_lcd(buffer) sleep(display_item.time) def queue_notification(self, title, message, wrap_line=False, iterations=2): logger.debug( f'queueing {title}/{message} {iterations} times, wrapped: {wrap_line}' ) self.notification_queue.put( DisplayItem(title, str(message), wrap_line, iterations)) self.leds.red.pulse() def queue_text(self, title, message, wrap_line=False, time=5, iterations=2, interrupt=False): logger.debug( f'queueing {title}/{message} {iterations} times, wrapped: {wrap_line}' ) item = DisplayItem(title, str(message), wrap_line=wrap_line, iterations=iterations, time=time) if interrupt: self.write_display_item(item) else: self.display_queue.put(item) def write_to_lcd(self, framebuffer): """Write the framebuffer out to the specified LCD.""" self.lcd.home() for row in framebuffer: self.lcd.write_string(row.ljust(lcd_width)[:lcd_width]) self.lcd.write_string('\r\n') def loop_string(self, string, framebuffer, row, delay=0.4, iterations=2): padding = ' ' * lcd_width s = padding + string + padding for round_trip in range(iterations): for i in range(len(s) - lcd_width + 1): framebuffer[row] = s[i:i + lcd_width] self.write_to_lcd(framebuffer) sleep(delay) @property def idle_text(self) -> dict: """merge last pulled with system pullable text items""" system_idle = dict() now = datetime.now() system_idle['date'] = DisplayItem(title=now.strftime('%d.%m.%y'), message=now.strftime('%R')) return {**system_idle, **self.pulled_idle_text} # SOUND def beep(self): self.buzzer_lock.acquire() self.buzzer.play(Tone("A4")) sleep(0.1) self.buzzer.stop() sleep(0.1) self.buzzer_lock.release()
#!/usr/bin/python import time import subprocess import RPi.GPIO as GPIO from gpiozero import TonalBuzzer from gpiozero.tones import Tone from gpiozero import Button buzz = TonalBuzzer(21) btnPin = 20 button = Button(20) def delay(times): time.sleep(times/1100.0) def tone(pitch, duration): if pitch == 0: delay(duration) return buzz.play(pitch) delay(duration) buzz.stop() delay(2) def play_sound(): tone(440, 257.54323222) delay(1.19731860632) tone(466, 257.54323222) delay(1.19731860632) tone(523, 257.54323222)
from gpiozero import LED, PWMLED, TonalBuzzer from gpiozero.tones import Tone from signal import pause from time import sleep import anvil.server anvil.server.connect("YOUR API KEY") red = LED(17) blue = PWMLED(27) b = TonalBuzzer(22) @anvil.server.callable def red_toggle(): red.toggle() @anvil.server.callable def red_blink(): red.blink(0.5,0.5) @anvil.server.callable def blue_brightness(brightness): blue.value = brightness @anvil.server.callable def music(): b.play(Tone("C4")) sleep(0.2) b.play(Tone("C4")) sleep(0.2) b.play(Tone("G4")) sleep(0.2) b.play(Tone("G4"))
from picamera import PiCamera import RPi.GPIO as GPIO import time from time import sleep from gpiozero import MotionSensor, Button, TonalBuzzer import requests import json import os.path from mfrc522 import SimpleMFRC522 pir = MotionSensor(23) camera = PiCamera() reader = SimpleMFRC522() btn = Button(16) bz = TonalBuzzer(17) notify = False #Notify that the door is unlocked def pressed(): lock1_response = requests.put( 'http://localhost:5000/info/security/haveKey', data=None) lock1_response = requests.put( 'http://localhost:5000/info/security/haveMotion', data=None) bz.play("A4") time.sleep(1) bz.stop() notify = False print("The house is protected!") def authenticate():
from gpiozero import Motor, Servo, TonalBuzzer from gpiozero.tools import sin_values from signal import pause motor = Motor(2, 3) servo = Servo(4) buzzer = TonalBuzzer(5) motor.source = sin_values() servo.source = motor buzzer.source = motor pause()