def main():
# 各ピンをbuzzer設定
factory = PiGPIOFactory()
buzzer = TonalBuzzer(BUZZER_PIN, pin_factory=factory)
# 音を鳴らす
try:
# 音符指定
for onpu in ONPUS:
buzzer.play(Tone(onpu))
sleep(0.5)
buzzer.stop()
sleep(0.5)
# midi note指定 (!!!57-81の範囲のみ指定可能)
for note_no in range(60, 80, 5):
buzzer.play(Tone(midi=note_no)) # middle C in MIDI notation
sleep(0.5)
buzzer.stop()
sleep(0.5)
# 周波数指定
for freq in range(300, 400, 100):
buzzer.play(Tone(frequency=freq))
sleep(0.5)
buzzer.stop()
sleep(0.5)
except:
buzzer.stop()
print("stop")
return
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 buzzers():
buzzer = TonalBuzzer(15)
while True:
buzzer.play("A3")
time.sleep(1)
if onStopEvent.is_set():
buzzer.stop()
break
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 __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)
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 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 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 __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 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
)
# 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:
# 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()
from gpiozero import TonalBuzzer
from gpiozero.tones import Tone
b = TonalBuzzer(4)
b.play(Tone("A4"))
from gpiozero import MCP3008
from gpiozero import TonalBuzzer
from gpiozero.tones import Tone
from time import sleep
import time
import pandas as pd
#import sys
import csv
import os
# Analog inputs
HRM = MCP3008(channel = 0) # Heart rate moniter
Temp = MCP3008(channel = 1) # Temperture sensor
# Buzzer
buzzer = TonalBuzzer(27) # 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)
def Noise2():
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 __init__(self):
self.timer = None
self.led = PWMLED(LIGHT_PIN)
self.buzzer = TonalBuzzer(BUZZER_PIN)
### 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=12,seq=(70,80)):
self._buzzer=TonalBuzzer(pin)
self.seq=seq
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)
from gpiozero import TonalBuzzer piezo = TonalBuzzer(21) piezo.stop()
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)
#!/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 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 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()
# 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'))
None
"""
# Creates a dictionary correlating the index in the button list to a
# dictionary key containing values representing evenly spaced intervals
# between the minimum and maximum tone for the provided buzzer
tones_to_listen_for = {
k: (k * (my_buzzer.max_tone.frequency - my_buzzer.min_tone) /
len(my_buttons)) + my_buzzer.min_tone.frequency
for k, v in enumerate(my_buttons)
}
# Infinite loop that sets the buzzer to the tone of the
# button that is first pressed
while True:
for i, button in enumerate(my_buttons):
if button.is_pressed:
my_buzzer.play(Tone(tones_to_listen_for[i]))
break
else:
my_buzzer.play(None)
print(my_buzzer.tone)
sleep(reactivity)
if __name__ == "__main__":
pins = [14, 15, 18, 23, 24, 25, 8, 7, 1, 12, 16]
buzzer = TonalBuzzer(pins[0])
buttons = [Button(pin, pull_up=False) for pin in pins[1::]]
play_me(my_buzzer=buzzer, my_buttons=buttons)
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 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"))
