""" '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