def __work(self, sl):
while(True):
if not self.queue.empty():
#Hay valores en la cola
if (not self.manualMode or (self.manualMode and self.playNext)):
#O estamos en modo automático, o en manual con playNext activado
audioFile = self.queue.get()
logging.info("Audio Thread: Playing audio - "+str(audioFile))
#Required for CircuitPlayground Express
#speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)
#speaker_enable.switch_to_output(value=True)
data = open("./audio_files/data_smoke_test_LDC93S1_pcms16le_1_16000.wav", "rb")
wav = audiocore.WaveFile(data)
a = audiopwmio.PWMAudioOut(board.SPEAKER)
a.play(wav)
while a.playing:
pass
logging.info("Audio Thread: Finished audio - "+str(audioFile))
logging.info ("Audio Thread: Current queue size - "+str(self.queue.qsize()))
self.queue.task_done()
self.playNext = False
else:
#Estamos en modo manual sin playNext activado
logging.info("Audio Thread: Awaiting manual trigger")
else:
logging.info("Audio Thread: Empty Queue")
logging.info("Audio Thread: Sleeping for - "+str(sl)+"ms")
time.sleep(sl)
def button2_handler():
global buzzer
buzzer.deinit()
LED[18].deinit()
LR_FILENAME = "L-R.wav"
data = open(LR_FILENAME, "rb")
wav = audiocore.WaveFile(data)
dac = audiopwmio.PWMAudioOut(board.GP18, right_channel=board.GP19)
initialize_OLED()
if I2C:
oled.text('GP21 PRESSED', 30, 10, 1)
oled.text('CHECK AUDIO', 32, 25, 1)
oled.text('LEFT RIGHT CHANNEL', 10, 40, 1)
deinitialize_OLED()
dac.play(wav)
time.sleep(3)
dac.stop()
initialize_OLED()
if I2C:
oled.text('GP21 PRESSED', 30, 20, 1)
oled.text('CHECK RGB', 37, 40, 1)
deinitialize_OLED()
RGB.value = False
neopixel_write(RGB, pixel_red)
time.sleep(0.5)
neopixel_write(RGB, pixel_green)
time.sleep(0.5)
neopixel_write(RGB, pixel_blue)
time.sleep(0.5)
neopixel_write(RGB, pixel_white)
time.sleep(0.5)
neopixel_write(RGB, pixel_off)
time.sleep(0.5)
dac.deinit()
LED[18] = digitalio.DigitalInOut(board.GP19)
LED[18].direction = digitalio.Direction.OUTPUT
buzzer = pwmio.PWMOut(board.GP18, variable_frequency=True)
import audiomp3
import audiopwmio
from adafruit_crickit import crickit
ss = crickit.seesaw # Crickit seesaw setup
button = crickit.SIGNAL1 # momentary switch to trigger animation
ss.pin_mode(button, ss.INPUT_PULLUP)
LED = crickit.SIGNAL4 # standard LED for eyeball lighting
ss.pin_mode(LED, ss.OUTPUT)
attract_switch = crickit.SIGNAL8 # attract mode switch or jumper
ss.pin_mode(attract_switch, ss.INPUT_PULLUP)
audio = audiopwmio.PWMAudioOut(
board.A0) # Feather outputs this pin to Crickit amplifier
audio_files = [ # use your own mono .mp3 files
"phrase_01.mp3", "phrase_02.mp3", "phrase_03.mp3"
]
current_audio_file = 0
# two motors
motor_eye = crickit.dc_motor_1
motor_lid = crickit.dc_motor_2
def open_lid():
motor_lid.throttle = 1 # full speed open
time.sleep(0.25)
motor_lid.throttle = 0 # hold
def _generate_sample(self, length=100):
if self._sample is not None:
return
self._sine_wave = array.array("H", self._sine_sample(length))
self._sample = audiopwmio.PWMAudioOut(board.SPEAKER)
self._sine_wave_sample = audiocore.RawSample(self._sine_wave)
for i in range(SIN_LENGTH)
]
tones = (
RawSample(array.array("H", sine_wave),
sample_rate=1800 * SIN_LENGTH), # Bit 0
RawSample(array.array("H", sine_wave),
sample_rate=1400 * SIN_LENGTH), # Bit 1
)
bit_0 = tones[0]
bit_1 = tones[1]
carrier = tones[1]
char_pause = 0.0 # pause time between chars, set to 0 for fastest rate possible
dac = audiopwmio.PWMAudioOut(
board.A2) # the CLUE edge connector marked "#0" to STEMMA speaker
# The CLUE's on-board speaker works OK, not great, just crank amplitude to full before trying.
# dac = audiopwmio.PWMAudioOut(board.SPEAKER)
LTRS = (
"\b",
"E",
"\n",
"A",
" ",
"S",
"I",
"U",
"\r",
"D",
"R",
import digitalio
import time
import math
import os
trigger = digitalio.DigitalInOut(board.D4)
trigger.switch_to_output(True)
sample_prefix = "jeplayer-splash"
samples = []
for fn in os.listdir("/"):
if fn.startswith(sample_prefix):
samples.append(fn)
dac = audiopwmio.PWMAudioOut(left_channel=board.D12, right_channel=board.D13)
for filename in samples:
print("playing", filename)
with open(filename, "rb") as sample_file:
try:
sample = audiocore.WaveFile(sample_file)
except OSError as e:
print(e)
continue
trigger.value = False
dac.play(sample)
while dac.playing:
time.sleep(0.1)
dac.pause()
time.sleep(0.1)
dac.resume()
"""
CircuitPython multiple MP3 playback example for Raspberry Pi Pico.
Plays two MP3 files consecutively, once time each.
"""
import board
import audiomp3
import audiopwmio
audio = audiopwmio.PWMAudioOut(board.GP0)
mp3files = ["slow.mp3", "happy.mp3"]
mp3 = open(mp3files[0], "rb")
decoder = audiomp3.MP3Decoder(mp3)
for filename in mp3files:
decoder.file = open(filename, "rb")
audio.play(decoder)
print("Playing:", filename)
while audio.playing:
pass
print("Done playing!")
class Sprite:
""" Class holds sprite (eggs, fireballs) state information. """
def __init__(self, col, start_time):
self.column = col # 0-3
self.is_fire = (random.random() < 0.25) # 1/4 chance of fireballs
self.start_time = start_time # For drop physics
self.paused = False
# ONE-TIME INITIALIZATION --------------
macropad = MacroPad(rotation=90)
macropad.display.auto_refresh = False
macropad.pixels.auto_write = False
macropad.pixels.brightness = 0.5
audio = audiopwmio.PWMAudioOut(board.SPEAKER) # For background audio
font = bitmap_font.load_font(PATH + 'cursive-smart.pcf')
# Create 3 displayio groups -- one each for the title, play and end screens.
title_group = displayio.Group()
title_bitmap, title_palette = adafruit_imageload.load(
PATH + 'title.bmp', bitmap=displayio.Bitmap, palette=displayio.Palette)
title_group.append(
displayio.TileGrid(title_bitmap,
pixel_shader=title_palette,
width=1,
height=1,
tile_width=title_bitmap.width,
tile_height=title_bitmap.height))
# Plays a simple 8ksps 440 Hz sin wave
#
# Adapted from "Audio output via digital PWM article"
# https://circuitpython.readthedocs.io/en/latest/shared-bindings/audiopwmio/index.html
# for Maker Pi Pico
#
# Copy this file to Maker Pi Pico CIRCUITPY drive as code.py to run it on power up.
#
import audiocore
import audiopwmio
import board
import array
import time
import math
# Generate one period of sine wav.
length = 8000 // 440
sine_wave = array.array("H", [0] * length)
for i in range(length):
sine_wave[i] = int(math.sin(math.pi * 2 * i / length) * (2**15) + 2**15)
dac = audiopwmio.PWMAudioOut(board.GP18)
sine_wave = audiocore.RawSample(sine_wave, sample_rate=8000)
dac.play(sine_wave, loop=True)
time.sleep(1)
dac.stop()
s8[i] = int(math.sin(math.pi * 2 * i / length) * (2**7))
samples.append(audiocore.RawSample(s8, sample_rate=16000))
# unsigned 16 bit
u16 = array.array("H", [0] * length)
for i in range(length):
u16[i] = int(math.sin(math.pi * 2 * i / length) * (2**15) + 2**15)
samples.append(audiocore.RawSample(u16, sample_rate=8000))
# signed 16 bit
s16 = array.array("h", [0] * length)
for i in range(length):
s16[i] = int(math.sin(math.pi * 2 * i / length) * (2**15))
samples.append(audiocore.RawSample(s16, sample_rate=8000))
dac = audiopwmio.PWMAudioOut(board.D13)
for sample, name in zip(samples, sample_names):
print(name)
trigger.value = False
dac.play(sample, loop=True)
time.sleep(1)
dac.stop()
time.sleep(0.1)
trigger.value = True
print()
print("done")
import audiopwmio
import digitalio
#import adafruit_character_lcd.character_lcd as characterlcd
#THIS ONE
import adafruit_character_lcd.character_lcd_i2c as character_lcd
from random import randint
import time
lcd_columns = 16
lcd_rows = 4
i2c = busio.I2C(board.SCL, board.SDA)
lcd = character_lcd.Character_LCD_I2C(i2c, 16, 2)
a = audiopwmio.PWMAudioOut(board.SPEAKER)
#lcd_rs = digitalio.DigitalInOut(board.D26)
#lcd_en = digitalio.DigitalInOut(board.D19)
#lcd_d7 = digitalio.DigitalInOut(board.D27)
#lcd_d6 = digitalio.DigitalInOut(board.D22)
#lcd_d5 = digitalio.DigitalInOut(board.D24)
#lcd_d4 = digitalio.DigitalInOut(board.D25)
#lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows)
normalAudioFiles = []
drunkAudioFiles = []
audioFiles = []
for file in os.listdir("./audio_files/normal"):
