at_top = True
set_drive(True, False, False)
home_pickles()
print_status("Homed")
# Main Program
state = 0
cycle_start = time.monotonic()
while True:
if state is 0:
if drop.value is False or time.monotonic(
) - cycle_start > CYCLE_TIME * 60:
sound.value, light.value = True, True
time.sleep(5)
print_status("Dropping")
state = 1
if state is 1: # drop down, slow at the end
set_drive(False, False, False)
if lower_slow.value is False:
slow_start = time.monotonic()
print_status("Stopping")
while time.monotonic() - slow_start < BOTTOM_SLOW: # feather brake
set_drive(True, False, False)
time.sleep(BRAKE_TIME * BRAKE_RATE)
set_drive(False, False, False)
def setAngle(angle, msec):
step = [0, 0, 0, 0, 0, 0, 0, 0]
msec = msec / motionSpeed # now 15//default 10; //speedy 20 Speed Adj
for val in range(8):
target = servoSetInit[val] - angle[val]
target = min(max(target, 0), 1800)
if target != servoAngle[val]: # Target != Present
step[val] = (target - servoAngle[val]) / msec
#print(step)
for _ in range(msec):
for val in range(8):
servoAngle[val] += step[val]
#print("setting servo %d to %d" % (val, int(servoAngle[val] / 10)))
servoWrite(val, servoAngle[val] / 10)
#time.sleep(msec / 1000)
print(servoAngle)
servoInitialSet()
led.value = False
setAngle([0, 0, -200, 0, 0, 0, 0, 0], 500)
setAngle([0, 0, -1800, 0, 0, 0, 1800, 0], 500)
setAngle([900, 0, -1800, 0, -900, 0, 1800, 0], 500)
setAngle([900, 0, -200, 0, -900, 0, 0, 0], 500)
setAngle([900, 0, -1800, 0, -900, 0, 1800, 0], 500)
setAngle([900, 0, -200, 0, -900, 0, 0, 0], 500)
setAngle([0, 0, -200, 0, 0, 0, 0, 0], 500)
led.value = True
servoFree()
TH1 = 5000
TH2 = 17000
TH3 = 29000
TH4 = 41000
TH5 = 53000
while True:
analogValue = analogIn.value
print((analogIn.value, TH1, TH2, TH3, TH4, TH5))
if analogValue > TH5:
led1.value = True
led2.value = True
led3.value = True
led4.value = True
led5.value = True
elif analogValue > TH4:
led1.value = True
led2.value = True
led3.value = True
led4.value = True
led5.value = False
elif analogValue > TH3:
led1.value = True
led2.value = True
led3.value = True
led4.value = False
import time
import board
from digitalio import DigitalInOut, Direction, Pull
button = DigitalInOut(board.D1)
button.direction = Direction.INPUT
button.pull = Pull.UP
led = DigitalInOut(board.D2)
led.direction = Direction.OUTPUT
while True:
if button.value:
led.value = True # check if the pushbutton is pressed.
else:
led.value = False # turn LED off
time.sleep(0.01) # debounce delay
fwd_cmd = str.encode("f")
rev_cmd = str.encode("r")
fast_cmd = str.encode("h")
slow_cmd = str.encode("l")
fstep_cmd = str.encode("u")
rstep_cmd = str.encode("d")
x_cmd = str.encode("x")
flag = True
while True:
uart.start_advertising()
# Wait for a connection
while not uart.connected:
Gled.value = True
Rled.value = False
FWD_PIN.value = False
REV_PIN.value = False
SLOW_PIN.value = False
FAST_PIN.value = False
FSTEP_PIN.value = False
RSTEP_PIN.value = False
pass
while uart.connected:
one_byte = uart.read(1)
print(one_byte)
if one_byte:
# stringcar_m0_ex_init_test_2020-09-03
# Cedar Grove StringCar M0 Express v06 initial test
import board
import time
import pulseio
from digitalio import DigitalInOut, Direction, Pull
from analogio import AnalogIn
import adafruit_dotstar as dotstar
from simpleio import map_range, tone
# Red Status LED
led = DigitalInOut(board.LED_STATUS)
led.direction = Direction.OUTPUT
led.value = False
# The RGB LED
dot = dotstar.DotStar(board.DOTSTAR_CI, board.DOTSTAR_DI, 1, brightness=0.1)
dot[0] = (128, 0, 128) # yellow startup status
import busio
try:
stemma = busio.I2C(board.SCL, board.SDA)
stemma_connected = True
print("STEMMA DEVICE CONNECTED")
except:
stemma_connected = False
print("Stemma device disconnected")
time.sleep(3)
# Analog input on VOLTAGE_MONITOR
# so we need to reset the Music Maker after Linux is booted
# Rework Instructions:
# 1. Cut Reset pad (https://learn.adafruit.com/adafruit-music-maker-featherwing/pinouts#reset-jumper-and-pad-2992586-25)
# 1a. Reset line is normally connected to System reset which would cause the whole System to reset
# 2. Solder wire from RST via to adjacent pad (AD4)
# 2a. When looking at the bottom, there's a Via under the "f" in feather and connects to the via under the first "e" in feather
# 3. Apply solder jumper on MIDI jumper
# 3a. https://learn.adafruit.com/adafruit-music-maker-featherwing/midi-synth#solder-closed-midi-jumper-2292069-2
# reset the chip using General Purpose I/O
import board
from digitalio import DigitalInOut, Direction
reset = DigitalInOut(board.AD4)
reset.direction = Direction.OUTPUT
reset.value = False
sleep(0.01)
reset.value = True
sleep(0.01)
import serial
# MIDI uses baud rate 31250 KBaud
VS1053_MIDI = serial.Serial('/dev/ttyS0', baudrate=31250)
# Now convert player_miditest.ino to Python
# https://github.com/adafruit/Adafruit_VS1053_Library/blob/master/examples/player_miditest/player_miditest.ino
# See http://www.vlsi.fi/fileadmin/datasheets/vs1053.pdf Pg 31
VS1053_BANK_DEFAULT = 0x00
VS1053_BANK_DRUMS1 = 0x78
# sendMeasurement(str(getTemp(temp1)))
elif command == COMMAND_DICT['temp2']:
sendMeasurement(str(temp2Value))
elif command == COMMAND_DICT['set-current']:
MODE = 'current'
targetCurrent = int.from_bytes(uart.read(header), 'big') / 1000
output = int(targetCurrent * 2**16 * 14.7 / 5 / 3.3)
print("Set current to {}".format(targetCurrent))
elif command == COMMAND_DICT['set-power']:
MODE = 'power'
targetPower = int.from_bytes(uart.read(header), 'big') / 1000
else:
if watchdog > 10:
print("Watchdog")
targetCurrent = 0
else:
watchdog += 1
if battValue > 0.1:
faultLed.value = False
if MODE == 'power':
targetCurrent = targetPower / battValue
error = int((targetCurrent - currentValue) * 2**16 / 3.3)
output += error // 4
mos.value = min(max(output, 0), 2**16 - 1)
else:
faultLed.value = True
import pulseio
import pwmio
from digitalio import DigitalInOut, Direction, Pull
# pylint: disable=eval-used
# Switch to select 'stealth-mode'
switch = DigitalInOut(board.SLIDE_SWITCH)
switch.direction = Direction.INPUT
switch.pull = Pull.UP
# Button to see output debug
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
# Speaker as haptic feedback
spkr_en = DigitalInOut(board.SPEAKER_ENABLE)
spkr_en.direction = Direction.OUTPUT
spkr_en.value = True
spkr = DigitalInOut(board.SPEAKER)
spkr.direction = Direction.OUTPUT
# Allow any button to trigger activity!
button_a = DigitalInOut(board.BUTTON_A)
button_a.direction = Direction.INPUT
button_a.pull = Pull.DOWN
button_b = DigitalInOut(board.BUTTON_B)
button_b.direction = Direction.INPUT
button_b.pull = Pull.DOWN
pwm = pwmio.PWMOut(board.REMOTEOUT, frequency=38000,
duty_cycle=2 ** 15, variable_frequency=True)
pulse = pulseio.PulseOut(pwm)
greenLed = DigitalInOut(board.A2)
greenLed.direction = Direction.OUTPUT
yellowLed = DigitalInOut(board.A1)
yellowLed.direction = Direction.OUTPUT
while True:
audio.play(wave)
audio.pause()
t = time.monotonic()
while time.monotonic(
) - t < 2: #plays for 2 seconds once x is above the threshold below
x, y, z = [
value / lis3d_sh.STANDARD_GRAVITY
for value in accelerometer.acceleration
]
print("x = %0.3f G, y = %0.3f G, z = %0.3f G" % (x, y, z))
if x > 0.1:
redLed.value = True
else:
redLed.value = False
if x > 0.2:
greenLed.value = True
else:
greenLed.value = False
if x > 0.3:
yellowLed.value = True
audio.resume()
else:
yellowLed.value = False
audio.pause
def button2Down(): if not shortDelay(delayTime=0.01): cc.send(ConsumerControlCode.SCAN_PREVIOUS_TRACK) button1Pin = DigitalInOut(board.D0) button1Pin.direction = Direction.OUTPUT button2Pin = DigitalInOut(board.D1) button2Pin.direction = Direction.OUTPUT buttonInPin = DigitalInOut(board.D2) buttonInPin.direction = Direction.INPUT buttonInPin.pull = Pull.DOWN Encoder = Encoder(board.D4, board.D3, upCallback=rotatedUp, downCallback=rotatedDown) while True: Encoder.update() # Btn 1 button1Pin.value = True if buttonInPin.value: button1Down() button1Pin.value = False # Btn 2 button2Pin.value = True if buttonInPin.value: button2Down() button2Pin.value = False
import time
import board
import busio, supervisor, os
from digitalio import DigitalInOut, Direction # pylint: disable=unused-import
import adafruit_miniesptool
print("ESP32 mini prog")
resetpin = DigitalInOut(board.RTS)
gpio0pin = DigitalInOut(board.DTR)
resetpin.direction = Direction.OUTPUT
gpio0pin.direction = Direction.OUTPUT
resetpin.value = 1
gpio0pin.value = 1
import adafruit_sdcard, storage
spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
cs = DigitalInOut(board.xSDCS)
sdcard = adafruit_sdcard.SDCard(spi, cs)
vfs = storage.VfsFat(sdcard)
storage.mount(vfs, "/sd")
def print_directory(path, tabs=0):
for file in os.listdir(path):
stats = os.stat(path + "/" + file)
filesize = stats[6]
isdir = stats[0] & 0x4000
MIRROR_OFFSET = (0, 0) START_THRESHOLD = 20 TIMED_WAVE_STOP = 5000 POWER = (128, 128, 128, 128) i2c = busio.I2C(board.SCL, board.SDA) xshut_left = DigitalInOut(board.D1) xshut_left.direction = Direction.OUTPUT xshut_right = DigitalInOut(board.D3) xshut_right.direction = Direction.OUTPUT pixels = DigitalInOut(board.D4) pixels.direction = Direction.OUTPUT # Reset all the sensors xshut_left.value = False xshut_right.value = False time.sleep(.01) xshut_left.value = True xshut_right.value = True time.sleep(.01) # Initialize the sensors one at a time so we can assign them different addresses xshut_right.value = False sensor_left = adafruit_vl53l0x.VL53L0X(i2c, I2C_ADDRESS_LEFT, TIMEOUT) xshut_right.value = True sensor_right = adafruit_vl53l0x.VL53L0X(i2c, I2C_ADDRESS_RIGHT, TIMEOUT) # change read time sensor_left.measurement_timing_budget = READ_TIME sensor_right.measurement_timing_budget = READ_TIME
# CUSTOMISE SENSITIVITY HERE: smaller numbers = more sensitive to motion
HIT_THRESHOLD = 250
SWING_THRESHOLD = 150
# Set to the length in seconds of the "on.wav" file
POWER_ON_SOUND_DURATION = 1.7
# NeoPixel setup
NUM_PIXELS = 34 # Number of pixels used in project
NEOPIXEL_PIN = board.D5
POWER_PIN = board.D10
enable = DigitalInOut(POWER_PIN)
enable.direction = Direction.OUTPUT
enable.value = False
strip = neopixel.NeoPixel(NEOPIXEL_PIN,
NUM_PIXELS,
brightness=.5,
auto_write=False)
strip.fill(0) # NeoPixels off ASAP on startup
strip.show()
# default NeoPixel color is white
COLOR = (255, 255, 255)
# NeoPixel animations
pulse = Pulse(strip, speed=0.05, color=COLOR, period=3)
solid = Solid(strip, color=COLOR)
comet = Comet(strip, speed=0.05, color=COLOR, tail_length=40)
blinkInterval = 0.5
blinkTime = time.monotonic() + blinkInterval
# loop forever
while True:
# gather inputs
# see if the button has changed
if button.value != buttonPre:
# reset the previous value
buttonPre = button.value
if button.value:
ledMode += 1
if ledMode > 1:
ledMode = 0
# do output based on mode
if ledMode == 1:
# is it time to toggle the led?
if time.monotonic() >= blinkTime:
# blink
print("blink")
# toggle led value
led.value = not led.value
# increment the blinkTime
blinkTime += blinkInterval
else:
led.value = False
blinkTime = time.monotonic()
clkState = GPIO.input(clk)
dtState = GPIO.input(dt)
if clkState != clkLastState:
if dtState != clkState:
mode += 1
if mode == 1:
print("You are on mode " + str(mode) + ". Click the Touch Module to Continue")
if pad.value:
print("Words")
sleep(3)
print("Cat")
sleep(3)
print("Bat")
sleep(3)
print("Dog")
pad.value = False
elif mode == 2:
print("You are on mode " + str(mode) + ". Click the Touch Module to Continue")
if pad.value:
print("Letters")
sleep(3)
print("A")
sleep(3)
print("B")
sleep(3)
print("C")
pad.value = False
elif mode == 3:
print("You are on mode " + str(mode) + ". Click the Touch Module to Continue")
if pad.value:
print("Numbers")
time.sleep(0.040)
index = index + 4
if direction < 0:
index = 100
while index >= 50:
servos[0].angle = index
time.sleep(0.040)
index = index - 4
time.sleep(0.020)
print("Its Stumble Bot Time")
while True:
if button_A.value: # If button A is pressed, start bot
led.value = True # Turn on LED 13 to show we're gone!
for i in range(5):
print("back 1")
servo_back(1)
time.sleep(0.100)
print("front 1")
servo_front(1)
time.sleep(0.100)
print("back 2")
servo_back(-1)
time.sleep(0.100)
print("front 2")
servo_front(-1)
time.sleep(0.100)
led.value = False
# end if
import board
import busio
from digitalio import DigitalInOut, Direction
spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
csag = DigitalInOut(board.D5)
csag.direction = Direction.OUTPUT
csag.value = True
csm = DigitalInOut(board.D6)
csm.direction = Direction.OUTPUT
csm.value = True
sensor = adafruit_lsm9ds1.LSM9DS1_SPI(spi, csag, csm)
sensor.accel_range = adafruit_lsm9ds1.ACCELRANGE_4G
sensor.mag_gain = adafruit_lsm9ds1.MAGGAIN_8GAUSS
sensor.gyro_scale = adafruit_lsm9ds1.GYROSCALE_500DP
while True:
# Read acceleration, magnetometer, gyroscope, temperature.
accel_x, accel_y, accel_z = sensor.acceleration
mag_x, mag_y, mag_z = sensor.magnetic
gyro_x, gyro_y, gyro_z = sensor.gyro
temp = sensor.temperature
# Print values.
print('Acceleration (m/s^2): ({0:0.3f},{1:0.3f},{2:0.3f})'.format(
accel_x, accel_y, accel_z))
print('Magnetometer (gauss): ({0:0.3f},{1:0.3f},{2:0.3f})'.format(
mag_x, mag_y, mag_z))
print('Gyroscope (degrees/sec): ({0:0.3f},{1:0.3f},{2:0.3f})'.format(
gyro_x, gyro_y, gyro_z))
# Screaming Cauldron
# for Adafruit Industries Learning Guide
from digitalio import DigitalInOut, Direction
from analogio import AnalogIn
import neopixel
import board
import time
led = DigitalInOut(board.D13) # on board red LED
led.direction = Direction.OUTPUT
aFXPin = DigitalInOut(board.D2) # pin used to drive the AudioFX board
aFXPin.direction = Direction.OUTPUT
aFXPin.value = False # runs once at startup
time.sleep(.1) # pause a moment
aFXPin.value = True # then turn it off
analog0in = AnalogIn(board.D1)
neoPin = board.D0 # pin int0 which the NeoPixels are plugged
numPix = 30 # number of NeoPixels
pixels = neopixel.NeoPixel(neoPin, numPix, auto_write=0, brightness=.8)
pixels.fill((
0,
0,
0,
))
pixels.show()
button_1 = DigitalInOut(board.BUTTON_A)
button_1.switch_to_input(pull=Pull.DOWN)
# feed button
button_feed = DigitalInOut(board.A1)
button_feed.direction = Direction.INPUT
button_feed.pull = Pull.UP
# motor controller
motor = DigitalInOut(board.A2)
motor.direction = Direction.OUTPUT
# enable audio speaker
speaker = DigitalInOut(board.SPEAKER_ENABLE)
speaker.direction = Direction.OUTPUT
speaker.value = True
# blink all neopixels red 3 times
def errorBlink():
for i in range(3):
pixels.fill(RED)
pixels.show()
sleep(0.1)
pixels.fill(OFF)
pixels.show()
sleep(0.1)
# runs motor for 'duration' (in seconds) then turns off motor
def runMotor(duration):
motor.value = True
pixels.fill(BLUE)
# Create an instance of the Adafruit IO REST client
io = RESTClient(aio_username, aio_key, wifi)
try:
# Get the 'digital' feed from Adafruit IO
digital_feed = io.get_feed('digital')
except AdafruitIO_RequestError:
# If no 'digital' feed exists, create one
digital_feed = io.create_new_feed('digital')
# Set up LED
LED = DigitalInOut(board.D13)
LED.direction = Direction.OUTPUT
while True:
# Get data from 'digital' feed
print('getting data from IO...')
feed_data = io.receive_data(digital_feed['key'])
# Check if data is ON or OFF
if int(feed_data['value']) == 1:
print('received <- ON\n')
elif int(feed_data['value']) == 0:
print('received <= OFF\n')
# Set the LED to the feed value
LED.value = int(feed_data['value'])
time.sleep(5)
from digitalio import DigitalInOut, Direction
# button access
import busio
from adafruit_bus_device.i2c_device import I2CDevice
# midi comms
import usb_midi
import adafruit_midi
from adafruit_midi.note_on import NoteOn
from adafruit_midi.note_off import NoteOff
# led setup
cs = DigitalInOut(board.GP17)
cs.direction = Direction.OUTPUT
cs.value = 0
pixels = adafruit_dotstar.DotStar(board.GP18,
board.GP19,
16,
brightness=0.5,
auto_write=True)
# button setup
i2c = busio.I2C(board.GP5, board.GP4)
device = I2CDevice(i2c, 0x20)
# midi setup
midi = adafruit_midi.MIDI(midi_out=usb_midi.ports[1], out_channel=9)
# enums
# Get wifi details and more from a secrets.py file
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
# With a Particle Argon
RX = board.ESP_TX
TX = board.ESP_RX
resetpin = DigitalInOut(board.ESP_WIFI_EN)
rtspin = DigitalInOut(board.ESP_CTS)
uart = busio.UART(TX, RX, timeout=0.1)
esp_boot = DigitalInOut(board.ESP_BOOT_MODE)
esp_boot.direction = Direction.OUTPUT
esp_boot.value = True
print("ESP AT commands")
esp = adafruit_espatcontrol.ESP_ATcontrol(uart,
115200,
reset_pin=resetpin,
rts_pin=rtspin,
debug=False)
print("Resetting ESP module")
esp.hard_reset()
first_pass = True
while True:
try:
if first_pass:
print("Scanning for AP's")
_MICROSTEPS_PER_REV = const(_MICROSTEPS * _STEPS // 2)
_MICROSTEPS_PER_CYCLE = const(_MICROSTEPS * 2)
def _pwm_for_microstep(ms):
x = math.cos(4 * math.pi * ms / _MICROSTEPS_PER_CYCLE)
return int((x + 1) * (_PWM_MAX // 2))
_PWM_TABLE = [_pwm_for_microstep(ms) for ms in range(_MICROSTEPS_PER_CYCLE)]
# Use the LED to indicate when the coils are energised.
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
led.value = True
# Bipolar stepper -- the two coils are A0-A1 and B0-B1.
pin_a0 = DigitalInOut(board.D8)
pin_a0.direction = Direction.OUTPUT
pin_a1 = DigitalInOut(board.D7)
pin_a1.direction = Direction.OUTPUT
pin_b0 = DigitalInOut(board.D5)
pin_b0.direction = Direction.OUTPUT
pin_b1 = DigitalInOut(board.D6)
pin_b1.direction = Direction.OUTPUT
# The h-bridge takes a PWM input, one for each of A and B.
pin_pwm_a = PWMOut(board.D9, frequency=200000, duty_cycle=0)
pin_pwm_b = PWMOut(board.D4, frequency=200000, duty_cycle=0)
espfirmware += "{:c}".format(_)
print("ESP32 Firmware:", espfirmware)
print("ESP32 MAC: {5:02X}:{4:02X}:{3:02X}:{2:02X}:{1:02X}:{0:02X}".format(
*esp.MAC_address))
# initial digital write values
m4_d_w_val = False
esp_d_w_val = False
while True:
print("\nESP32 DIGITAL:")
# ESP32 digital read
try:
M4_D_W_PIN.value = m4_d_w_val
print("M4 wrote:", m4_d_w_val, end=" ")
# b/c ESP32 might have reset out from under us
esp_init_pin_modes(ESP_D_R_PIN, ESP_D_W_PIN)
esp_d_r_val = esp.set_digital_read(ESP_D_R_PIN)
print("--> ESP read:", esp_d_r_val)
except (RuntimeError, AssertionError) as e:
print("ESP32 Error", e)
esp_reset_all()
# ESP32 digital write
try:
# b/c ESP32 might have reset out from under us
esp_init_pin_modes(ESP_D_R_PIN, ESP_D_W_PIN)
esp.set_digital_write(ESP_D_W_PIN, esp_d_w_val)
print("ESP wrote:", esp_d_w_val, "--> Red LED")
import time
import board
from digitalio import DigitalInOut, Direction
# CircuitPython for Pico maps LED to GPIO25
led = DigitalInOut(board.LED)
led.direction = Direction.OUTPUT
while True:
led.value = not led.value
time.sleep(1)
return [0, int(pos * 3), int(255 - pos * 3)]
######################### MAIN LOOP ##############################
i = 0
seen = False
while True:
# spin internal LED around!
dot[0] = wheel(i)
dot.show()
data = uart.read(32)
if i % 10 is 0:
seen = False
if data is not None:
seen = True
# use A0 as capacitive touch to turn on internal LED
if touch_in.value:
uart.write(arr_on)
print(arr_on)
else:
uart.write(arr_off)
print(arr_off)
# optional! uncomment below & save to have it sent a keypress
# keyboard.press(Keycode.A)
# keyboard.release_all()
# uart.write(seen.encode("utf-8"))
led.value = seen
i = (i + 1) % 256 # run from 0 to 255
# effect: type of vibration
# delay: time between vibrations
def vibe(num_zzz, effect, delay):
drv.sequence[0] = adafruit_drv2605.Effect(effect)
for _ in range(0, num_zzz):
drv.play() # play the effect
time.sleep(delay) # for 0.5 seconds
drv.stop()
# start BLE
ble.start_advertising(advertisement)
while True:
blue_led.value = False
print("Waiting for connection")
# NeoPixel is red when not connected to BLE
while not ble.connected:
blue_led.value = False
pixel.fill(color.RED)
pixel.show()
print("Connected")
while ble.connected:
blue_led.value = True # blue LED is on when connected
all_ids.clear()
for connection in ble.connections:
if not connection.paired:
# pairs to phone
import random
import time
import audioio
import board
from digitalio import DigitalInOut, Direction
import neopixel
import touchio
SAMPLERATE = 8000
START_COUNT = 4
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)
spkrenable = DigitalInOut(board.SPEAKER_ENABLE)
spkrenable.direction = Direction.OUTPUT
spkrenable.value = True
# Yoinked this from another example
def create_sample(frequency):
length = SAMPLERATE // frequency
sine_wave = array.array("H", [0] * int(length))
for i in range(length):
sine_wave[i] = int(math.sin(math.pi * 2 * i / 18) * (2**15) + 2**15)
sample = audioio.AudioOut(board.SPEAKER, sine_wave)
# Mismatch is intentional...weird API?
sample.frequency = SAMPLERATE
return sample
def clear():
# use the slide switch to turn blink on or off
# import modules and libraries
import board
from digitalio import DigitalInOut, Direction, Pull
import time
# declare variables and objects
# declare led digitalio object and set its direction
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
# declare switch digitalio object, set direction and pull
switch = DigitalInOut(board.D7)
switch.direction = Direction.INPUT
switch.pull = Pull.UP
# repeat this code forever
while True:
print(switch.value)
led.value = switch.value
time.sleep(0.1)
import time from digitalio import DigitalInOut, Direction, Pull import pulseio ############## Switch to select 'stealth-mode' switch = DigitalInOut(board.SLIDE_SWITCH) switch.direction = Direction.INPUT switch.pull = Pull.UP # Button to see output debug led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT ############## Speaker as haptic feedback spkr_en = DigitalInOut(board.SPEAKER_ENABLE) spkr_en.direction = Direction.OUTPUT spkr_en.value = False spkr = DigitalInOut(board.SPEAKER) spkr.direction = Direction.OUTPUT ############## Allow any button to trigger activity! button_a = DigitalInOut(board.BUTTON_A) button_a.direction = Direction.INPUT button_a.pull = Pull.DOWN button_b = DigitalInOut(board.BUTTON_B) button_b.direction = Direction.INPUT button_b.pull = Pull.DOWN pwm = pulseio.PWMOut(board.REMOTEOUT, frequency=38000, duty_cycle=2 ** 15, variable_frequency=True) pulse = pulseio.PulseOut(pwm)
