def SetupUI():
global rotPot, zoomPot, nodePot
rotPot = AnalogIn(board.A1)
zoomPot = AnalogIn(board.A0)
nodePot = AnalogIn(board.A2)
# SPDX-License-Identifier: MIT
"""Bluetooth Key Tracker."""
from adafruit_ble import BLERadio
from adafruit_led_animation.animation import Pulse, Solid
import adafruit_led_animation.color as color
from analogio import AnalogIn
from array import array
from audiobusio import I2SOut
from audiocore import RawSample, WaveFile
from board import BATTERY, D5, D6, D9, NEOPIXEL, RX, TX
from digitalio import DigitalInOut, Direction, Pull
from math import pi, sin
from neopixel import NeoPixel
from time import sleep
battery = AnalogIn(BATTERY)
ble = BLERadio()
hit_status = [color.RED, color.ORANGE, color.AMBER, color.GREEN]
pixel = NeoPixel(NEOPIXEL, 1)
pulse = Pulse(
pixel,
speed=0.01,
color=color.PURPLE, # Use CYAN for Male Key
period=3,
min_intensity=0.0,
max_intensity=0.5)
solid = Solid(pixel, color.GREEN)
# Pin setup
SERVO_PIN = board.A1
FEEDBACK_PIN = board.A5
# Calibration setup
ANGLE_MIN = 0
ANGLE_MAX = 180
# Setup servo
pwm = pulseio.PWMOut(SERVO_PIN, duty_cycle=2**15, frequency=50)
servo = servo.Servo(pwm)
servo.angle = None
# Setup feedback
feedback = AnalogIn(FEEDBACK_PIN)
print("Servo feedback calibration.")
# Move to MIN angle
print("Moving to {}...".format(ANGLE_MIN), end="")
servo.angle = ANGLE_MIN
time.sleep(2)
print("Done.")
feedback_min = feedback.value
# Move to MAX angle
print("Moving to {}...".format(ANGLE_MAX), end="")
servo.angle = ANGLE_MAX
time.sleep(2)
print("Done.")
feedback_max = feedback.value
# Print results
import adafruit_adt7410 from adafruit_bitmap_font import bitmap_font from adafruit_display_text.label import Label from adafruit_button import Button import adafruit_touchscreen from adafruit_pyportal import PyPortal from adafruit_display_shapes.rect import Rect # ------------- Inputs and Outputs Setup ------------- # # init. the temperature sensor i2c_bus = busio.I2C(board.SCL, board.SDA) adt = adafruit_adt7410.ADT7410(i2c_bus, address=0x48) adt.high_resolution = True # init. the light sensor light_sensor = AnalogIn(board.LIGHT) pixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=1) WHITE = 0xffffff RED = 0xff0000 YELLOW = 0xffff00 GREEN = 0x00ff00 BLUE = 0x0000ff PURPLE = 0xff00ff BLACK = 0x000000 # ---------- Sound Effects ------------- # soundDemo = '/sounds/sound.wav' soundBeep = '/sounds/beep.wav' soundTab = '/sounds/tab.wav'
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
import time
import board
from analogio import AnalogIn
import digitalio
import datetime as dt
pot_top = digitalio.DigitalInOut(board.G0)
pot_top.direction = digitalio.Direction.OUTPUT
pot_top.value = True
pot_bot = digitalio.DigitalInOut(board.G2)
pot_bot.direction = digitalio.Direction.OUTPUT
pot_bot = False
lightSensor = AnalogIn(board.G1)
now = dt.datetime.now()
def get_voltage(raw):
return (raw * 3.3) / 65535
# Parameters
x_len = 200 # Number of points to display
y_range = [0, 3.3] # Range of possible Y values to display
# Create figure for plotting
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
xs = list(range(0, 200))
# WIRING:
# 1 Wire connecting VCC to RH to make a voltage divider using the
# internal resistor between RH and RW
# 2 Wire connecting RW to A0
def wiper_voltage(_wiper_pin):
raw_value = _wiper_pin.value
return raw_value / (2 ** 16 - 1) * _wiper_pin.reference_voltage
i2c = busio.I2C(board.SCL, board.SDA)
ds = adafruit_ds1841.DS1841(i2c)
LUT_MAX_INDEX = 71
WIPER_MAX = 127
wiper_pin = AnalogIn(board.A0)
ds.lut_mode_enabled = True
# you only need to run this once per DS1841 since the LUT is stored to EEPROM
# for i in range(0, LUT_MAX_INDEX+1):
# new_lut_val = WIPER_MAX-i
# ds.set_lut(i, new_lut_val)
while True:
for i in range(0, LUT_MAX_INDEX + 1):
ds.lut_selection = i
# for printing to serial terminal:
print(
"\tLUTAR/LUT Selection: %s" % hex(ds.lut_selection),
"\tWiper = %d" % ds.wiper,
try:
# Get the 'temperature' feed from Adafruit IO
temperature_feed = io.get_feed('temperature')
light_feed = io.get_feed('light')
except AdafruitIO_RequestError:
# If no 'temperature' feed exists, create one
temperature_feed = io.create_new_feed('temperature')
light_feed = io.create_new_feed('light')
# Set up ADT7410 sensor
i2c_bus = busio.I2C(board.SCL, board.SDA)
adt = adafruit_adt7410.ADT7410(i2c_bus, address=0x48)
adt.high_resolution = True
# Set up an analog light sensor on the PyPortal
adc = AnalogIn(board.LIGHT)
while True:
try:
light_value = adc.value
print('Light Level: ', light_value)
temperature = adt.temperature
print('Temperature: %0.2f C' % (temperature))
print('Sending to Adafruit IO...')
io.send_data(light_feed['key'], light_value)
io.send_data(temperature_feed['key'], temperature, precision=2)
print('Sent to Adafruit IO!')
except (ValueError, RuntimeError) as e:
# Trinket Gemma Servo Control
# for Adafruit M0 boards
import board
import pulseio
from adafruit_motor import servo
from analogio import AnalogIn
# servo pin for the M0 boards:
pwm = pulseio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)
my_servo = servo.Servo(pwm)
angle = 0
# potentiometer
trimpot = AnalogIn(board.A1) # pot pin for servo control
def remap_range(value, left_min, left_max, right_min, right_max):
# this remaps a value from original (left) range to new (right) range
# Figure out how 'wide' each range is
left_span = left_max - left_min
right_span = right_max - right_min
# Convert the left range into a 0-1 range (int)
value_scaled = int(value - left_min) / int(left_span)
# Convert the 0-1 range into a value in the right range.
return int(right_min + (value_scaled * right_span))
while True:
angle = remap_range(trimpot.value, 0, 65535, 0, 180)
### THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
### IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
### FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
### AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
### LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
### OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
### SOFTWARE.
import time
import board
from analogio import AnalogIn
### All eight pins on CPX board
pins = [ AnalogIn(board.A0),
AnalogIn(board.A1),
AnalogIn(board.A2),
AnalogIn(board.A3),
AnalogIn(board.A4),
AnalogIn(board.A5),
AnalogIn(board.A6),
AnalogIn(board.A7) ]
numpins = len(pins)
refvoltage = pins[0].reference_voltage
adcconvfactor = refvoltage / 65536
### Convert value from pin.value to voltage
def getVoltage(pin):
return pin.value * adcconvfactor
import time
from analogio import AnalogIn
from turtle import *
# The LED will illuminate when an object is close enough to reflect IR back to the detector.
# With board attached to computer, lanuch plotter in Mu to see graphical response rates.
print('\nRunning "turtle_obstacles.py"')
# Pin assignments
leftEmitter = digitalio.DigitalInOut(board.D10)
leftLED = digitalio.DigitalInOut(board.D7)
rightEmitter = digitalio.DigitalInOut(board.D13)
rightLED = digitalio.DigitalInOut(board.D11)
button = digitalio.DigitalInOut(board.D12)
rightDetector = AnalogIn(board.A0)
leftDetector = AnalogIn(board.A1)
# Port setup
leftLED.direction = digitalio.Direction.OUTPUT
leftEmitter.direction = digitalio.Direction.OUTPUT
rightLED.direction = digitalio.Direction.OUTPUT
rightEmitter.direction = digitalio.Direction.OUTPUT
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.UP
# Turn IR LEDs on. You might be able to see them in a camera.
rightEmitter.value = True
leftEmitter.value = True
global mode
if not fastTurn():
if mode == 0:
if not fastTurn():
print("press")
cc.send(ConsumerControlCode.PLAY_PAUSE)
if mode == 1:
kbd.press(Keycode.SPACE)
# kbd.press(Keycode.ZERO)
kbd.release_all()
e1 = Encoder(board.D4, board.D3, upCallback=enc1Up, downCallback=enc1Down)
e2 = Encoder(board.D1, board.D0, upCallback=enc2Up, downCallback=enc2Down)
buttonPin = AnalogIn(board.D2)
while True:
e1.update()
e2.update()
v = buttonPin.value
if 65535 > v > 54500:
b1 = False
b2 = False
elif 54500 > v > 38500:
b1 = True
b2 = False
elif 38500 > v > 29400:
b1 = False
class Peripherals:
"""Peripherals Helper Class for the MagTag Library"""
# pylint: disable=too-many-instance-attributes, too-many-locals, too-many-branches, too-many-statements
def __init__(self):
# Neopixel power
try:
self._neopixel_disable = DigitalInOut(board.NEOPIXEL_POWER)
self._neopixel_disable.direction = Direction.OUTPUT
self._neopixel_disable.value = False
except ValueError:
self._neopixel_disable = None
# Neopixels
self.neopixels = neopixel.NeoPixel(board.NEOPIXEL, 4, brightness=0.3)
# Battery Voltage
self._batt_monitor = AnalogIn(board.BATTERY)
# Speaker Enable
self._speaker_enable = DigitalInOut(board.SPEAKER_ENABLE)
self._speaker_enable.direction = Direction.OUTPUT
self._speaker_enable.value = False
# Light Sensor
self._light = AnalogIn(board.LIGHT)
# Buttons
self.buttons = []
for pin in (board.BUTTON_A, board.BUTTON_B, board.BUTTON_C,
board.BUTTON_D):
switch = DigitalInOut(pin)
switch.direction = Direction.INPUT
switch.pull = Pull.UP
self.buttons.append(switch)
def play_tone(self, frequency, duration):
"""Automatically Enable/Disable the speaker and play
a tone at the specified frequency for the specified duration
It will attempt to play the sound up to 3 times in the case of
an error.
"""
if frequency < 0:
raise ValueError("Negative frequencies are not allowed.")
self._speaker_enable.value = True
attempt = 0
# Try up to 3 times to play the sound
while attempt < 3:
try:
simpleio.tone(board.SPEAKER, frequency, duration)
break
except NameError:
pass
attempt += 1
self._speaker_enable.value = False
def deinit(self):
"""Call deinit on all resources to free them"""
self.neopixels.deinit()
if self._neopixel_disable is not None:
self._neopixel_disable.deinit()
self._speaker_enable.deinit()
for button in self.buttons:
button.deinit()
self._batt_monitor.deinit()
self._light.deinit()
@property
def battery(self):
"""Return the voltage of the battery"""
return (self._batt_monitor.value / 65535.0) * 3.3 * 2
@property
def neopixel_disable(self):
"""
Enable or disable the neopixels for power savings
"""
if self._neopixel_disable is not None:
return self._neopixel_disable.value
return False
@neopixel_disable.setter
def neopixel_disable(self, value):
if self._neopixel_disable is not None:
self._neopixel_disable.value = value
@property
def speaker_disable(self):
"""
Enable or disable the speaker for power savings
"""
return not self._speaker_enable.value
@speaker_disable.setter
def speaker_disable(self, value):
self._speaker_enable.value = not value
@property
def button_a_pressed(self):
"""
Return whether Button A is pressed
"""
return not self.buttons[0].value
@property
def button_b_pressed(self):
"""
Return whether Button B is pressed
"""
return not self.buttons[1].value
@property
def button_c_pressed(self):
"""
Return whether Button C is pressed
"""
return not self.buttons[2].value
@property
def button_d_pressed(self):
"""
Return whether Button D is pressed
"""
return not self.buttons[3].value
@property
def any_button_pressed(self):
"""
Return whether any button is pressed
"""
return False in [self.buttons[i].value for i in range(0, 4)]
@property
def light(self):
"""
Return the value of the light sensor. The neopixel_disable property
must be false to get a value.
.. code-block:: python
import time
from adafruit_magtag.magtag import MagTag
magtag = MagTag()
while True:
print(magtag.peripherals.light)
time.sleep(0.01)
"""
return self._light.value
time_delay_button.direction = digitalio.Direction.INPUT
time_delay_button.pull = digitalio.Pull.DOWN
#ADVANCED SETTINGS
cooldown_delay = 200
passive_mode = False
led_brightness = 0.06
time_delay = 2
rainbow_cycle_count = 8
log_limit = 2000 #lines
i2c = busio.I2C(board.ACCELEROMETER_SCL, board.ACCELEROMETER_SDA)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19)
lis3dh.range = adafruit_lis3dh.RANGE_8_G
analog1in = AnalogIn(board.IR_PROXIMITY)
ir_led = digitalio.DigitalInOut(board.IR_TX)
ir_led.direction = digitalio.Direction.OUTPUT
def set_delay():
global time_delay
global boot_time
for led in range(time_delay):
pixels[led] = RED
pixels.show()
boot_time = time.monotonic()
time.sleep(1)
start_time = time.monotonic()
def get_adc():
with AnalogIn(board.ADC) as ai:
return ai.value / 65535.0
# Project home:
# https://tinys2.io
#
# Import required libraries
import time
import board
from digitalio import DigitalInOut, Direction, Pull
from analogio import AnalogIn
# Setup the NeoPixel power pin
pixel_power = DigitalInOut(board.NEOPIXEL_POWER)
pixel_power.direction = Direction.OUTPUT
# Setup the BATTERY voltage sense pin
vbat_voltage = AnalogIn(board.BATTERY)
# Setup the VBUS sense pin
vbus_sense = DigitalInOut(board.VBUS_SENSE)
vbus_sense.direction = Direction.INPUT
# Helper functions
def set_pixel_power(state):
"""Enable or Disable power to the onboard NeoPixel to either show colour, or to reduce power fro deep sleep."""
global pixel_power
pixel_power.value = state
def get_battery_voltage():
"""Get the approximate battery voltage."""
# I don't really understand what CP is doing under the hood here for the ADC range & calibration,
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
import adafruit_dotstar as dotstar
# One pixel connected internally!
dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=0.2)
# Built in red LED
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
# Analog output on A0
aout = AnalogOut(board.A0)
# Analog input on A1
analog1in = AnalogIn(board.A1)
# Capacitive touch on A2
touch2 = TouchIn(board.A2)
# Used if we do HID output, see below
kbd = Keyboard()
######################### HELPERS ##############################
# Helper to convert analog input to voltage
def getVoltage(pin):
return (pin.value * 3.3) / 65536
# Helper to give us a nice color swirl
def wheel(pos):
import time
import board
import neopixel as neo # Feather M4
from simpleio import map_range, tone
import adafruit_ds3231
from analogio import AnalogIn
from cedargrove_unit_converter.chronos import adjust_dst
from cedargrove_clock_builder.repl_display import ReplDisplay
from cedargrove_clock_builder.led_14x4_display import Led14x4Display # 14-segment LED
i2c = board.I2C()
ds3231 = adafruit_ds3231.DS3231(i2c)
# Feather M4 battery monitor and piezo
batt = AnalogIn(board.VOLTAGE_MONITOR)
# Feather M4 NeoPixel, purple indicator
pixel = neo.NeoPixel(board.NEOPIXEL, 1, brightness=0.01, auto_write=False)
pixel[0] = (200, 0, 200)
pixel.write()
time.sleep(0.1)
print("Battery: {:01.2f} volts".format((batt.value / 65520) * 6.6))
### SETTINGS ###
clock_display = ["led", "repl"] # List of active display(s)
clock_zone = "Pacific" # Name of local time zone
clock_24_hour = False # 24-hour clock = True; 12-hour AM/PM = False
clock_auto_dst = True # Automatic US DST = True
clock_sound = False # Sound is active = True
from time import sleep
import board
import adafruit_ds3502
from analogio import AnalogIn
####### NOTE ################
# this example will not work with Blinka/rasberry Pi due to the lack of analog pins.
# Blinka and Raspberry Pi users should run the "ds3502_blinka_simpletest.py" example
i2c = board.I2C()
ds3502 = adafruit_ds3502.DS3502(i2c)
wiper_output = AnalogIn(board.A0)
while True:
ds3502.wiper = 127
print("Wiper set to %d" % ds3502.wiper)
voltage = wiper_output.value
voltage *= 3.3
voltage /= 65535
print("Wiper voltage: %.2f V" % voltage)
print("")
sleep(1.0)
ds3502.wiper = 0
print("Wiper set to %d" % ds3502.wiper)
voltage = wiper_output.value
voltage *= 3.3
voltage /= 65535
print("Wiper voltage: %.2f V" % voltage)
print("")
# Create SPI bus
spi = busio.SPI(board.SCK, board.MOSI)
# Create the display
WIDTH = 128
HEIGHT = 64
DC = DigitalInOut(board.D7)
CS = DigitalInOut(board.D9)
RST = DigitalInOut(board.D10)
display = adafruit_ssd1306.SSD1306_SPI(WIDTH, HEIGHT, spi, DC, RST, CS)
display.fill(0)
display.show()
# Create the knobs
READS = 5
x_knob = AnalogIn(board.A0)
y_knob = AnalogIn(board.A1)
# Create the clear button
clear_button = DigitalInOut(board.D12)
clear_button.direction = Direction.INPUT
clear_button.pull = Pull.UP
def read_knobs(reads):
avg_x = avg_y = 0
for _ in range(reads):
avg_x += x_knob.value
avg_y += y_knob.value
avg_x /= reads
avg_y /= reads
import touchio from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode import adafruit_dotstar as dotstar import time import neopixel # One pixel connected internally! dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=0.2) # Built in red LED led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT # Analog input on D0 analog1in = AnalogIn(board.D0) # Analog output on D1 aout = AnalogOut(board.D1) # Digital input with pullup on D2 button = DigitalInOut(board.D2) button.direction = Direction.INPUT button.pull = Pull.UP # Capacitive touch on D3 touch = touchio.TouchIn(board.D3) # NeoPixel strip (of 16 LEDs) connected on D4 NUMPIXELS = 16 neopixels = neopixel.NeoPixel(board.D4,
y = -y
yv.append(int(y))
return xv, yv
x1, y1 = happiness(0)
x2, y2 = happiness(1)
xc = len(x1)
yv = [0] * xc
def interp(s, k):
return round(y2[k] + (y1[k] - y2[k]) * s)
analog_in = AnalogIn(board.A1)
spi = board.SPI()
METRO_PINS = {'cs': board.D5, 'dc': board.D6, 'reset': board.D9}
ITSY_BITSY_PINS = {'cs': board.D7, 'dc': board.D9, 'reset': board.D10}
PINS = ITSY_BITSY_PINS
tft_cs = PINS['cs']
tft_dc = PINS['dc']
displayio.release_displays()
display_bus = displayio.FourWire(spi,
command=tft_dc,
chip_select=tft_cs,
reset=PINS['reset'])
# fscale function: # Floating Point Autoscale Function V0.1 # Written by Paul Badger 2007 # Modified fromhere code by Greg Shakar # Ported to Circuit Python by Mikey Sklar import time import board import neopixel from rainbowio import colorwheel from analogio import AnalogIn n_pixels = 16 # Number of pixels you are using mic_pin = AnalogIn(board.A1) # Microphone is attached to this analog pin led_pin = board.D1 # NeoPixel LED strand is connected to this pin sample_window = .1 # Sample window for average level peak_hang = 24 # Time of pause before peak dot falls peak_fall = 4 # Rate of falling peak dot input_floor = 10 # Lower range of analogRead input # Max range of analogRead input, the lower the value the more sensitive # (1023 = max) input_ceiling = 300 peak = 16 # Peak level of column; used for falling dots sample = 0 dotcount = 0 # Frame counter for peak dot dothangcount = 0 # Frame counter for holding peak dot
# Release any resources currently in use for the displays displayio.release_displays() spi = board.SPI() tft_cs = board.D9 tft_dc = board.D10 touch_cs = board.D6 sd_cs = board.D5 neopix_pin = board.D11 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs) display = adafruit_ili9341.ILI9341(display_bus, width=320, height=240) #battery voltage reader vbat_voltage = AnalogIn(board.VOLTAGE_MONITOR) # Define radio parameters. RADIO_FREQ_MHZ = 915.0 # Frequency of the radio in Mhz. Must match your # module! Can be a value like 915.0, 433.0, etc. # Define pins connected to the chip, use these if wiring up the breakout according to the guide: CS = digitalio.DigitalInOut(board.D13) RESET = digitalio.DigitalInOut(board.D12) # Initialze RFM radio rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ) # Note that the radio is configured in LoRa mode so you can't control sync # word, encryption, frequency deviation, or other settings!
# Audio output
cpx_audio = audioio.AudioOut(board.A0)
audio = audioio.WaveFile(open(AUDIO_FILENAME, "rb"))
# Rotating dancer
dancer = crickit.servo_2
dancer.angle = 0
MAX_SERVO_ANGLE = 160
move_direction = 1
# neopixels!
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=1)
pixels.fill((0, 0, 0))
# light sensor
light = AnalogIn(board.LIGHT)
def wheel(pos):
# Input a value 0 to 255 to get a color value.
# The colours are a transition r - g - b - back to r.
if pos < 0 or pos > 255:
return 0, 0, 0
if pos < 85:
return int(255 - pos * 3), int(pos * 3), 0
if pos < 170:
pos -= 85
return 0, int(255 - pos * 3), int(pos * 3)
pos -= 170
return int(pos * 3), 0, int(255 - (pos * 3))
def loop():
for i in (0, numberOfAnalogPins):
data[i] = AnalogIn(board.D5)
vw.vw_send(data, 80)
time.sleep(1) # //send every second
return
# Play a little tune
if winner:
cpx.play_tone(800, 0.2)
cpx.play_tone(900, 0.2)
cpx.play_tone(1400, 0.2)
cpx.play_tone(1100, 0.2)
else:
cpx.play_tone(200, 1)
# Sit here forever
while True:
pass
# Seed the random function with noise
a4 = AnalogIn(board.A4)
a5 = AnalogIn(board.A5)
a6 = AnalogIn(board.A6)
a7 = AnalogIn(board.A7)
seed = a4.value
seed += a5.value
seed += a6.value
seed += a7.value
random.seed(seed)
# Wait a random amount of time
count_time = random.randrange(SHORTEST_DELAY, LONGEST_DELAY + 1)
start_time = time.monotonic()
while time.monotonic() - start_time < count_time:
# CircuitPlaygroundExpress_LightSensor
# reads the on-board light sensor and graphs the brighness with NeoPixels
import time
import board
import neopixel
from analogio import AnalogIn
from simpleio import map_range
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, auto_write=0, brightness=.05)
pixels.fill((0, 0, 0))
pixels.show()
analogin = AnalogIn(board.LIGHT)
while True:
# light value remaped to pixel position
peak = map_range(analogin.value, 2000, 62000, 0, 9)
print(analogin.value)
print(int(peak))
for i in range(0, 9, 1):
if i <= peak:
pixels[i] = (0, 255, 0)
else:
pixels[i] = (0, 0, 0)
pixels.show()
time.sleep(0.01)
from adafruit_midi.note_on import NoteOn from adafruit_midi.note_off import NoteOff from adafruit_midi.control_change import ControlChange from adafruit_midi.pitch_bend import PitchBend # imports MIDI midi = adafruit_midi.MIDI(midi_out=usb_midi.ports[1], out_channel=0) # setup for LIS3DH accelerometer i2c = busio.I2C(board.SCL, board.SDA) lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c) lis3dh.range = adafruit_lis3dh.RANGE_2_G # setup for 3 potentiometers pitchbend_pot = AnalogIn(board.A1) mod_pot = AnalogIn(board.A2) velocity_pot = AnalogIn(board.A3) # setup for two switches that will switch modes mod_select = DigitalInOut(board.D52) mod_select.direction = Direction.INPUT mod_select.pull = Pull.UP strum_select = DigitalInOut(board.D53) strum_select.direction = Direction.INPUT strum_select.pull = Pull.UP # setup for strummer switches strumUP = DigitalInOut(board.D22) strumUP.direction = Direction.INPUT
# envoi d'une tension via le port serie
import time
import board
from analogio import AnalogIn
U0 = AnalogIn(board.A0)
# sur carte trinket M0 A0 sur patte 1
while True:
Upotar = U0.value*3.3/65535
print(Upotar,Upotar)
# print("coucou")
time.sleep(0.05)
# SPDX-FileCopyrightText: 2019 Anne Barela for Adafruit Industries
#
# SPDX-License-Identifier: MIT
from time import sleep
from adafruit_ble.uart_server import UARTServer
from adafruit_bluefruit_connect.packet import Packet
from adafruit_bluefruit_connect.button_packet import ButtonPacket
from adafruit_bluefruit_connect.color_packet import ColorPacket
from board import A0, D13
from analogio import AnalogIn
from digitalio import DigitalInOut, Direction
led = AnalogIn(A0) # Initialize blue LED light detector
solenoid = DigitalInOut(D13) # Initialize solenoid
solenoid.direction = Direction.OUTPUT
solenoid.value = False
uart_server = UARTServer()
while True:
uart_server.start_advertising() # Advertise when not connected.
while not uart_server.connected: # Wait for connection
pass
while uart_server.connected: # Connected
if uart_server.in_waiting: # Check BLE commands
packet = Packet.from_stream(uart_server)
if isinstance(packet, ButtonPacket):
speaker.frequency = 494 speaker.duty_cycle = ON time.sleep(.5) speaker.frequency = 444 time.sleep(.5) # tone 3 speaker.frequency = 494 time.sleep(.5) speaker.duty_cycle = OFF ######################### MAIN LOOP ############################## randomSeedPin = AnalogIn(board.A0) random.seed(randomSeedPin.value) randomSeedPin.deinit() # randomize the starting button activeButtonId = random.randint(0,4) i = 0 while True: # spin internal neopixel LED around for pretty lightssss dot[0] = wheel(i & 255) activeButton = buttons[activeButtonId] activeButtonLed = buttonLeds[activeButtonId] if i < 125:
