"""
'mib_servo.py'.
=================================================
sweeping a servo with an analog potentiometer
requires:
- Adafruit_CircuitPython_Motor
"""
import time
import analogio
import board
import pwmio
from adafruit_motor import servo
SERVO = servo.Servo(pwmio.PWMOut(board.D9))
POTE = analogio.AnalogIn(board.A0)
def servo_sweep():
"""sweeps the servo."""
for angle_fwd in range(0, 180, 1):
SERVO.angle = angle_fwd
time.sleep(0.01)
for angle_bkwd in range(180, 0, -1):
SERVO.angle = angle_bkwd
time.sleep(0.01)
def pote_sweep():
"""assigns servo value to an analog potentiometer value."""
val = POTE.value / 65536
# Last updated 9/2/2020 by Austin Trask
import time
import board
import busio
import digitalio
import analogio
import adafruit_rfm9x
# Device ID
FEATHER_ID = b'1'
print("startup")
# For monitoring battery voltage
vbat_voltage = analogio.AnalogIn(board.VOLTAGE_MONITOR)
# Define CS pin for RFM95W LoRa
CS = digitalio.DigitalInOut(board.D10)
# Initialize SPI bus for RFM95W LoRa
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
# Define radio frequency
RADIO_FREQ_MHZ = 433.0
#RADIO_FREQ_MHZ = 915.0
# Define RESET pin
RESET = digitalio.DigitalInOut(board.D11)
# Initialize LoRa Radio
# create an i2c object
i2c = busio.I2C(board.SCL, board.SDA)
# instantiate the sensor objects
veml = adafruit_veml6075.VEML6075(i2c, integration_time=100)
sgp30 = adafruit_sgp30.Adafruit_SGP30(i2c)
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
# change this to match the location's pressure (hPa) at sea level
bme280.sea_level_pressure = 1013.25
# init. the graphics helper
gfx = weatherstation_helper.WeatherStation_GFX()
# init. the ADC
adc = analogio.AnalogIn(board.D4)
# Set up Adafruit IO Feeds
print('Getting Group data from Adafruit IO...')
station_group = io.get_group('weatherstation')
feed_list = station_group['feeds']
altitude_feed = feed_list[0]
eco2_feed = feed_list[1]
humidity_feed = feed_list[2]
pressure_feed = feed_list[3]
temperature_feed = feed_list[4]
tvoc_feed = feed_list[5]
uv_index_feed = feed_list[6]
wind_speed_feed = feed_list[7]
"""
Convert the potentiometer value to a voltage value. Prints the voltage value to the serial console
every two seconds.
REQUIRED HARDWARE:
* potentiometer on pin GP26.
"""
import time
import board
import analogio
potentiometer = analogio.AnalogIn(board.GP26)
get_voltage = 3.3 / 65535
while True:
voltage = potentiometer.value * get_voltage
print(voltage)
time.sleep(2)
return btn
fret_green = make_button(board.D2)
fret_red = make_button(board.D3)
fret_yellow = make_button(board.D4)
fret_blue = make_button(board.D5)
fret_orange = make_button(board.D6)
button_select = make_button(board.D8)
button_start = make_button(board.D9)
strum_down = make_button(board.D10)
strum_up = make_button(board.D11)
pitch_wheel = analogio.AnalogIn(board.A0)
notes = {
(True, False, False, False, False): 60, # C
(True, False, True, False, False): 61, # C♯
(True, True, False, False, False): 62, # D
(True, True, True, False, False): 63, # D♯
(False, True, False, False, False): 64, # E
(False, True, True, False, False): 65, # F
(False, True, False, True, False): 66, # F♯
(False, False, True, False, False): 67, # G
(False, False, True, False, True): 68, # A♯
(False, False, True, True, False): 69, # A
(False, False, False, True, True): 70, # B♭
(False, False, False, True, False): 71, # B
(False, False, False, False, True): 72, # C
import array, math, time
import audiobusio, board, analogio
from adafruit_circuitplayground.express import cpx
import adafruit_fancyled as fancy
import myfunction
Value = time.monotonic()
time.sleep(1)
T2 = int(time.monotonic() - Value)
T1 = int(time.monotonic() - Value)
analogIn_1 = analogio.AnalogIn(board.A1)
CURVE = 2
SCALE_EXPONENT = math.pow(10, CURVE * -0.1)
samples = array.array('H', [0] * 80)
buttonPre = False
TH = 600
cpx.pixels.brightness = 0.1
cpx.pixels.fill(0)
offset = 0
mic = audiobusio.PDMIn(board.MICROPHONE_CLOCK,
board.MICROPHONE_DATA,
sample_rate=16000,
bit_depth=16)
colorList = [0, 0, 0]
# PROJ01 - Theremin
# (CircuitPython)
# this circuit was designed for use with the Metro Express Explorers Guide on Learn.Adafruit.com
# by Asher Lieber for Adafruit Industries.
import board
import analogio
import pulseio
from simpleio import map_range
piezo = pulseio.PWMOut(board.D9)
photo = analogio.AnalogIn(board.A0)
while True:
# map photo sensor value to hearable sound on piezo
val = int(map_range(photo.value, 0, 65520, 1000, 64000))
piezo.duty_cycle = val
RX = board.RX
TX = board.TX
uart = busio.UART(TX, RX, baudrate=9600, timeout=30)
gps = adafruit_gps.GPS(uart, debug=False)
gps.send_command(b'PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
gps.send_command(b'PMTK220,1000')
pad = GamePadShift(digitalio.DigitalInOut(board.BUTTON_CLOCK),
digitalio.DigitalInOut(board.BUTTON_OUT),
digitalio.DigitalInOut(board.BUTTON_LATCH))
joystick_x = analogio.AnalogIn(board.JOYSTICK_X)
joystick_y = analogio.AnalogIn(board.JOYSTICK_Y)
pressed = pad.get_pressed()
select = 0
b = 0
last_print = time.monotonic()
a = 0
homelat = 38.888
homelon = -77.115
def haversine(lat1, lon1, lat2, lon2):
import simpleio # Define pin connected to piezo buzzer. buzzer = board.D5 # Define tone of buzzer TONE_FREQ = [262] # Setup digital input for PIR sensor: pir = digitalio.DigitalInOut(board.A2) # Main loop that will run forever: old_value = pir.value #photocell is connected to pin A5 on the microcontroller photocell = analogio.AnalogIn(board.A5) #conversion from analog value to respective voltage def analog_voltage(adc): return adc.value / 65535 * adc.reference_voltage # create the I2C shared bus i2c = busio.I2C(board.SCL, board.SDA) am = adafruit_am2320.AM2320(i2c) light = photocell.value voltage = analog_voltage(photocell) #bidirectional serial protocol that uses a mutual baud rate instead of a shared clock line. uart = busio.UART(board.TX, board.RX, baudrate=115200, bits=8, parity=None, stop=1)
import time
import simpleio
import analogio
from lcd.lcd import LCD
from lcd.i2c_pcf8574_interface import I2CPCF8574Interface
from lcd.lcd import CursorMode
# Talk to the LCD at I2C address 0x27.
# The number of rows and columns defaults to 4x20, so those
# arguments could be omitted in this case.
lcd1 = LCD(I2CPCF8574Interface(board.I2C(), 0x3f), num_rows=2, num_cols=16)
lcd2 = LCD(I2CPCF8574Interface(board.I2C(), 0x27), num_rows=2, num_cols=16)
posPot = analogio.AnalogIn(board.A1)
valPot = analogio.AnalogIn(board.A2)
PID = False
values = [3.56, 3.56, 1.23, PID]
oldValues = [0, 0, 0, 0]
kP = 0
kI = 1
kD = 2
pid = 3
def setScreen():
'''Prints out all static messages at once'''
# Start at the first line, first column (numbering from zero).
motionSensorPin = board.A6
analogVelostatPin = board.A3
led = digitalio.DigitalInOut(ledOutputPin)
led.direction = digitalio.Direction.OUTPUT
relay = digitalio.DigitalInOut(relayPin)
relay.switch_to_output()
motionSensor = digitalio.DigitalInOut(motionSensorPin)
motionSensor.switch_to_input()
lastMotionSensorValue = motionSensor.value
motionSensorStartTime = time.time()
motionSensorEndTime = motionSensorStartTime
analogVelostat = analogio.AnalogIn(analogVelostatPin)
light = analogio.AnalogIn(lightSensorPin)
thermistor = adafruit_thermistor.Thermistor(thermistorPin, 10000, 10000, 25,
3950)
onboardpixels = local.SetupOnboardNeopixels()
numPixels = 30
strandpixels = local.SetupNeopixelsStrand(strandPixelPin, 30)
peakColor = (100, 0, 255) # Color of the peak pixel for audio display
mic = audiobusio.PDMIn(board.MICROPHONE_CLOCK,
board.MICROPHONE_DATA,
sample_rate=16000,
# Pixels 2-6: Clockwise around the ring
# The Gemma M0 D0 output supports DMA for Neopixels, but not in Python
# If you swtich to native Arduino try this: https://learn.adafruit.com/dma-driven-neopixels
ring_len = 7
neopixel_len = ring_len * 2
neopixel_pin = board.D0
neopixel = neopixel.NeoPixel(neopixel_pin,
neopixel_len,
brightness=1.0,
auto_write=False)
# Noepixels don't light if scaled below this value
neopixel_min = 0.0045
# Analog light sensor GA1A12S202
sensor_pin = board.A1
sensor = analogio.AnalogIn(sensor_pin)
# The raw analog sample scale is 2^16, but the sensor can't quite use that whole range
# GA1A12S202 can output about 2k to 60k, logarithmic (which is useful, since eyes are also log-ish)
sensor_min = 2000
sensor_max = 60000
sensor_range = sensor_max - sensor_min
def neopixel_limits(value):
value = min(1.0, value)
if (value > neopixel_min):
value = max(neopixel_min, value)
else:
value = 0.0
return value
"""
'usb_scroll.py'.
=================================================
control a NeoPixel using an (NEC) IR Remote
requires:
- adafruit_hid
- simpleio
"""
import time
import analogio
import board
import digitalio
from adafruit_hid import mouse
from simpleio import map_range
button = digitalio.DigitalInOut(board.D6)
pot = analogio.AnalogIn(board.A0)
m = mouse.Mouse()
while True:
if not button.value: # move while button is pressed
m.move(0, 0, int(map_range(pot.value, 50, 65520, -5, 5)))
time.sleep(.08)
import time
import analogio
import board
import microcontroller
import neopixel
import adafruit_ble_broadcastnet
print("This is BroadcastNet sensor:", adafruit_ble_broadcastnet.device_address)
battery = analogio.AnalogIn(board.VOLTAGE_MONITOR)
divider_ratio = 2
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)
while True:
measurement = adafruit_ble_broadcastnet.AdafruitSensorMeasurement()
battery_voltage = (
battery.value / 2**16 * divider_ratio * battery.reference_voltage # pylint: disable=no-member
)
r = 16 - int(((battery_voltage - 3.6) / 0.6) * 16)
r = min(16, max(r, 0))
g = int(((battery_voltage - 3.6) / 0.6) * 16)
g = min(16, max(g, 0))
pixel[0] = r << 16 | g << 8
measurement.battery_voltage = int(battery_voltage * 1000)
measurement.temperature = (
microcontroller.cpu.temperature # pylint: disable=no-member
)
print(measurement)
adafruit_ble_broadcastnet.broadcast(measurement)
pixel[0] = 0
_animations = [
animations.Fade(0.66),
animations.Chase(0.66),
animations.HeartBeat(60),
animations.Sparkle(pixels.n, 0.25, 1.25)
]
currentAnimation = 0
elapsedAnimation = 0.0
# Colors are defined in colors.py for space efficiency (packed into .mpy file).
currentColor = 0
elapsedColor = 0.0
# Setup code:
# Initialize random number generator with light sensor value:
with analogio.AnalogIn(board.LIGHT) as light:
random.seed(light.value)
# Clear all the pixels.
pixels.fill((0, 0, 0))
pixels.write()
# Setup animation globals:
animations.clock = clock
animations.pixels = pixels
# Main loop:
while True:
# Check if slide switch is off and turn off all the pixels.
if not circuitplayground.slide_switch.value:
# Turn off pixels and sleep (ideally this would deep sleep the CPU
# but for now it just spins in a loop internally).
pixels.fill((0, 0, 0))
import board
import analogio
vbat_voltage = analogio.AnalogIn(board.D9)
def get_voltage(pin):
return (pin.value * 3.3) / 65536 * 2
battery_voltage = get_voltage(vbat_voltage)
print("VBat voltage: {:.2f}".format(battery_voltage))
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 the modules import board import analogio import time #set up the ADC to the correct pins adc = analogio.AnalogIn(board.JOYSTICK_X) # Flip, Scale, and Offset values obtained from ADC polarity = -1 scale = .0625 offset = 2056 # Smooth the output sample_count = 10 # Convert the signal to digital-ish? # If so, set up a null spot that will represent 0 read_as_analog = 1 x_null = 1000 x_null_neg = x_null * -1
"""
'temperature.py'.
=================================================
Writes TMP36 data to the REPL
"""
import time
import analogio
import board
from simpleio import map_range
temp_sensor = analogio.AnalogIn(board.A0)
def get_voltage(_temp_sensor):
"""gets the TMP36's voltage."""
voltage_val = map_range(_temp_sensor.value, 0, 65535, 0, 3.3)
return voltage_val
while True:
temp = get_voltage(temp_sensor)
# convert to celsius
temp = (temp - 0.5) * 100
print(" Temperature =", temp)
time.sleep(1)
# Create some buttons. The physical buttons are connected
# to ground on one side and these and these pins on the other.
button_pins = (board.D2, board.D3, board.D4, board.D5)
# Map the buttons to button numbers on the Gamepad.
# gamepad_buttons[i] will send that button number when buttons[i]
# is pushed.
gamepad_buttons = (1, 2, 8, 15)
buttons = [digitalio.DigitalInOut(pin) for pin in button_pins]
for button in buttons:
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.UP
# Connect an analog two-axis joystick to A4 and A5.
ax = analogio.AnalogIn(board.A4)
ay = analogio.AnalogIn(board.A5)
# Equivalent of Arduino's map() function.
def range_map(x, in_min, in_max, out_min, out_max):
return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
while True:
# Buttons are grounded when pressed (.value = False).
for i, button in enumerate(buttons):
gamepad_button_num = gamepad_buttons[i]
if button.value:
gp.release_buttons(gamepad_button_num)
print(" release", gamepad_button_num, end='')
import time import board from adafruit_pyportal import PyPortal from adafruit_button import Button import neopixel import analogio # Set the background color BACKGROUND_COLOR = 0x443355 # Set the NeoPixel brightness BRIGHTNESS = 0.3 light_sensor = analogio.AnalogIn(board.LIGHT) strip_1 = neopixel.NeoPixel(board.D4, 30, brightness=BRIGHTNESS) strip_2 = neopixel.NeoPixel(board.D3, 30, brightness=BRIGHTNESS) # Turn off NeoPixels to start strip_1.fill(0) strip_2.fill(0) # Setup PyPortal without networking pyportal = PyPortal(default_bg=BACKGROUND_COLOR) # Button colors RED = (255, 0, 0) ORANGE = (255, 34, 0) YELLOW = (255, 170, 0) GREEN = (0, 255, 0) CYAN = (0, 255, 255)
import board
import analogio
import time
pr_UR = analogio.AnalogIn(board.A3)
pr_UL = analogio.AnalogIn(board.A2)
pr_LR = analogio.AnalogIn(board.A4)
pr_LL = analogio.AnalogIn(board.A5)
while True:
print('Upper right: {}'.format(pr_UR.value))
print('Upper left: {}'.format(pr_UL.value))
print('Lower right: {}'.format(pr_LR.value))
print('Lower left: {}'.format(pr_LL.value))
time.sleep(1)
TILTED_LEFT = 5
TILTED_RIGHT = 6
TILTED_FORWARD = 7
TILTED_BACKWARD = 8
INVERTED_TILTED_LEFT = 9
INVERTED_TILTED_RIGHT = 10
INVERTED_TILTED_FORWARD = 11
INVERTED_TILTED_BACKWARD = 12
i2c = busio.I2C(board.ACCELEROMETER_SCL, board.ACCELEROMETER_SDA)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19)
lis3dh.range = adafruit_lis3dh.RANGE_2_G
ir_pwm = pulseio.PWMOut(board.IR_TX, frequency=20000, duty_cycle=65536 // 4)
proximity = analogio.AnalogIn(board.IR_PROXIMITY)
'''
total = 0
for i in range(max_color):
x, y, z = lis3dh.acceleration
total += y
average = total / max_color.0
print('Average: {} m/s^2'.format(average))
'''
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)
pixels.fill((0, 0, 0))
pixels.show()
'''
slide_switch = digitalio.DigitalInOut(board.D7)
slide_switch.direction = digitalio.Direction.INPUT
import digitalio
import time
import analogio
import neopixel
import adafruit_sdcard
import storage
import adafruit_pcf8523
import os
# red board led
led = digitalio.DigitalInOut(board.D13)
led.direction = digitalio.Direction.OUTPUT
# create two tmp36 objects on A0 and A1 inputs
TMP36_A_PIN = board.A0
tmp36_a = analogio.AnalogIn(TMP36_A_PIN)
TMP36_B_PIN = board.A1
tmp36_b = analogio.AnalogIn(TMP36_B_PIN)
# neopixel is D8 for Feather M4 Express
pixel_pin = board.NEOPIXEL
num_pixels = 1
ORDER = neopixel.RGB
pixel = neopixel.NeoPixel(pixel_pin,
num_pixels,
brightness=0.02,
pixel_order=ORDER)
# blink on-board LED as a running indicator, in place of neopixel
def strobe_led(delay):
import time
import board
import analogio
piezo = analogio.AnalogIn(board.A1)
lastVoltage = 0.0
checkDelaySeconds = 0.001
while True:
currentVoltage = piezo.value / 65536
# print("(", currentVoltage, ")")
if (currentVoltage > 0.15):
print("Hit!")
while (currentVoltage > 0.15):
print("(", currentVoltage, ")")
currentVoltage = piezo.value / 65536
time.sleep(checkDelaySeconds)
print("Stop Hit!")
print("( 0 )")
print("( 0 )")
print("( 0 )")
time.sleep(checkDelaySeconds)
"""
'squeeze.py'.
=================================================
force sensitive resistor (fsr) with circuitpython
"""
import analogio
import board
import pulseio
FORCE_SENS_RESISTOR = analogio.AnalogIn(board.A2)
LED = pulseio.PWMOut(board.D10)
while True:
LED.duty_cycle = FORCE_SENS_RESISTOR.value
# SPDX-FileCopyrightText: 2021 Brent Rubell for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""
'audio.py'.
=================================================
alarm circuit with a FSR and a speaker
requires:
- CircuitPython_CharLCD Module
"""
import audioio
import analogio
import board
f = open("siren.wav", "rb")
a = audioio.AudioOut(board.A0, f)
fsr = analogio.AnalogIn(board.A2)
threshold = 200
while True:
if fsr.value < threshold:
a.play(loop=True)
else:
a.pause()
def __init__(self, pin):
self._photocell = analogio.AnalogIn(pin)
import digitalio
import adafruit_character_lcd as LCD
import board
import analogio
from simpleio import map_range
# LCD setup
lcd_columns = 16
lcd_rows = 2
lcd_rs = digitalio.DigitalInOut(board.D7)
lcd_en = digitalio.DigitalInOut(board.D8)
lcd_d7 = digitalio.DigitalInOut(board.D12)
lcd_d6 = digitalio.DigitalInOut(board.D11)
lcd_d5 = digitalio.DigitalInOut(board.D10)
lcd_d4 = digitalio.DigitalInOut(board.D9)
lcd_backlight = digitalio.DigitalInOut(board.D13)
lcd = LCD.cirpyth_char_lcd(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows, lcd_backlight)
therm = analogio.AnalogIn(board.A0)
# loop forever
while True:
# get temperature from sensor
tmp = (((
(map_range(therm.value, 0, 65535, 0, 3.3)) - .5) * 100) * 1.8) + 32
lcd.clear()
# lcd.message('temp: ' + str(therm.value * .004882814)[:5] + ' * f')
lcd.message('temp: ' + str(tmp)[:5] + ' * f')
time.sleep(.6)
import board # needed for everything
import struct # needed for serial
import random # needed for random
import neopixel # needed for LEDs
import busio # needed for serial
import analogio # needed for light sensor
import adafruit_thermistor # needed for temp sensor
# set up serial
uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=.1)
#set up leds
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)
#set up light sensor
light = analogio.AnalogIn(board.LIGHT)
#set up temp sensor
thermistor = adafruit_thermistor.Thermistor(board.TEMPERATURE, 10000, 10000,
25, 3950)
# basic setup
def initial_setup():
pixels.brightness = .1
pixels.fill([255, 255, 255])
pixels.show()
# process serial comms
def process_serial_input():
from board import D7, D8, D9, D10, D11, D12, D13, A0
# Character LCD Config:
# modify this if you have a different sized charlcd
lcd_columns = 16
lcd_rows = 2
# Metro Express Pin Config:
lcd_rs = digitalio.DigitalInOut(D7)
lcd_en = digitalio.DigitalInOut(D8)
lcd_d7 = digitalio.DigitalInOut(D12)
lcd_d6 = digitalio.DigitalInOut(D11)
lcd_d5 = digitalio.DigitalInOut(D10)
lcd_d4 = digitalio.DigitalInOut(D9)
lcd_backlight = digitalio.DigitalInOut(D13)
light = analogio.AnalogIn(A0)
# Init the lcd class
lcd = adafruit_character_lcd.Character_LCD(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6,
lcd_d7, lcd_columns, lcd_rows, lcd_backlight)
while True:
lcd.clear()
percent = str(100-((light.value/65535)*100))
nice = percent[:percent.find('.')]
lcd.message(nice + "% bright")
lcd.message(str(light.value))
time.sleep(1)
# increment our elapsed_secs variable each time a second passes
