def on(*buttons, fn=None, action=DOWN):
global GAMEPAD
for button in buttons:
if button not in BUTTONS:
if button in DIGITALIO:
dio = DigitalInOut(button)
dio.direction = Direction.INPUT
dio.pull = Pull.DOWN
elif button in TOUCHIO:
dio = TouchIn(button)
else:
print("unknown button {}".format(button))
BUTTONS.append(button)
DIOS.append(dio)
value = tuple(buttons)
def wrapper(fn):
PRESSES.append((fn, buttons, action))
return fn
if fn:
return wrapper(fn)
return wrapper
import neopixel
import adafruit_minimqtt.adafruit_minimqtt as MQTT
from adafruit_io.adafruit_io import IO_MQTT
from digitalio import DigitalInOut, Direction
### WiFi ###
# 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
RELAY = DigitalInOut(board.D10)
RELAY.direction = Direction.OUTPUT
# If you are using a board with pre-defined ESP32 Pins:
esp32_cs = DigitalInOut(board.D13)
esp32_ready = DigitalInOut(board.D11)
esp32_reset = DigitalInOut(board.D12)
spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
"""Use below for Most Boards"""
status_light = neopixel.NeoPixel(board.NEOPIXEL, 1,
brightness=0.2) # Uncomment for Most Boards
wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(
esp, secrets, status_light)
# SPDX-FileCopyrightText: 2019 Mikey Sklar for Adafruit Industries
#
# SPDX-License-Identifier: MIT
import time
import board
from digitalio import DigitalInOut, Direction
pir_pin = board.D24
power_pin = board.D23
pir = DigitalInOut(pir_pin)
pir.direction = Direction.INPUT
power = DigitalInOut(power_pin)
power.direction = Direction.OUTPUT
power.value = False
while True:
if pir.value:
print("POWER ON")
power.value = True
time.sleep(20)
print("POWER OFF")
power.value = False
time.sleep(5)
time.sleep(1)
for i in range(1, 5):
nullingIndex = (index + i) % num_pixels
pixels[nullingIndex] = (0, 0, 0)
pixels.show()
time.sleep(.1)
if index == 0:
color = (color + 50) % 255
return (color, (index + 1) % num_pixels)
buttonA = DigitalInOut(board.BUTTON_A) #button a
buttonA.direction = Direction.INPUT
buttonA.pull = Pull.DOWN
buttonB = DigitalInOut(board.BUTTON_B) # button b
buttonB.direction = Direction.INPUT
buttonB.pull = Pull.DOWN
startRainbowPassIn = 0
startFlashColor = (0, 0)
startMicrophonePeak = 0
curState = 0
numStates = 4
rainbowPassIn = startRainbowPassIn
flashColor = startFlashColor
microphonePeak = startMicrophonePeak
# importing necessary libraries import board #import neopixel import time from digitalio import DigitalInOut, Direction, Pull from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from lcd.lcd import CursorMode # defining both button_alt, button_ud, and button_red as DigitalInOut objects (as buttons # that increase/decrease value, change modifier, and reset mod and num to 1 and 0 respectively) button_alt = DigitalInOut(board.D6) button_alt.direction = Direction.INPUT button_alt.pull = Pull.UP button_ud = DigitalInOut(board.D5) button_ud.direction = Direction.INPUT button_ud.pull = Pull.UP button_res = DigitalInOut(board.D4) button_res.direction = Direction.INPUT button_res.pull = Pull.UP # defining lcd as an LCD object lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) # list that the mod button will cycle through mods = [1, 2, 5, 10, -1, -2, -5, -10] # number that is being increased/decreased
import board
import busio
import pwmio
from digitalio import DigitalInOut, Direction
from adafruit_bluefruitspi import BluefruitSPI
import adafruit_lis3dh
ADVERT_NAME = b'BlinkaNeoLamp'
# RGB LED on D11, 12, 13, we're using a Prop Maker wing
red_led = pwmio.PWMOut(board.D11, frequency=50000, duty_cycle=0)
green_led = pwmio.PWMOut(board.D12, frequency=50000, duty_cycle=0)
blue_led = pwmio.PWMOut(board.D13, frequency=50000, duty_cycle=0)
# Prop maker wing has a power pin for the LED!
power_pin = DigitalInOut(board.D10)
power_pin.direction = Direction.OUTPUT
power_pin.value = True
spi_bus = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
cs = DigitalInOut(board.D8)
irq = DigitalInOut(board.D7)
rst = DigitalInOut(board.D4)
bluefruit = BluefruitSPI(spi_bus, cs, irq, rst, debug=False)
i2c = busio.I2C(board.SCL, board.SDA)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c)
def init_bluefruit():
# Initialize the device and perform a factory reset
print("Initializing the Bluefruit LE SPI Friend module")
CELL_RETRIES=12 # one second per try ec_5_in = AnalogIn(board.A0) vbatt_in = AnalogIn(board.A5) uart = busio.UART(board.TX, board.RX, baudrate=9600) # lora radio spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) cs = DigitalInOut(board.RFM9X_CS) reset = DigitalInOut(board.RFM9X_RST) rfm9x = adafruit_rfm9x.RFM9x(spi, cs, reset, 915.0) # led led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT # done done = DigitalInOut(board.D10) done.direction = Direction.OUTPUT # roaming_switch roam_switch = DigitalInOut(board.D12) roam_switch.direction = Direction.INPUT roam_switch.pull=Pull.UP # default values if probe doesn't work temp=30 ec_5=20
# External constants
DOWN = 1
UP = 2
PROPOGATE = object()
# Internal constants
DIGITALIO = [board.BUTTON_A, board.BUTTON_B]
TOUCHIO = [board.A1, board.A2, board.A3, board.A4, board.A5, board.A6, board.A7]
SAMPLERATE = 8000 # recommended
AUDIO = AudioOut(board.A0)
SPEAKER = DigitalInOut(board.SPEAKER_ENABLE)
SPEAKER.direction = Direction.OUTPUT
# Internal state
RUNNING = True
INTERVALS = {}
TIMERS = {}
BUTTONS = []
DIOS = []
PRESSES = []
def tick(fn):
INTERVALS[fn] = (0, 0)
return fn
# CircuitPython IO demo #1 - General Purpose I/O
import time
from digitalio import DigitalInOut, Direction, Pull
import board
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
switch = DigitalInOut(board.D2) # For Gemma M0, Trinket M0, Metro M0 Express, ItsyBitsy M0 Express
# switch = DigitalInOut(board.D5) # For Feather M0 Express
# switch = DigitalInOut(board.D7) # For Circuit Playground Express
switch.direction = Direction.INPUT
switch.pull = Pull.UP
while True:
# We could also just do "led.value = not switch.value"!
if switch.value:
led.value = False
else:
led.value = True
time.sleep(0.01) # debounce delay
[0b0000, 0b0110, 0b1001, 0b1001, 0b0001, 0b0010, 0b0100, 0b1111, 0b0000,],
[0b0000, 0b0110, 0b1001, 0b0001, 0b0011, 0b0001, 0b1001, 0b0110, 0b0000,],
[0b0000, 0b0011, 0b0101, 0b1001, 0b1111, 0b0001, 0b0001, 0b0001, 0b0000,],
[0b0000, 0b1111, 0b1000, 0b1000, 0b1110, 0b0001, 0b0001, 0b1110, 0b0000,],
[0b0000, 0b0110, 0b1001, 0b1000, 0b0110, 0b1001, 0b1001, 0b0110, 0b0000,],
[0b0000, 0b1111, 0b0001, 0b0001, 0b0010, 0b0100, 0b0100, 0b1000, 0b0000,],
[0b0000, 0b0110, 0b1001, 0b1001, 0b0110, 0b1001, 0b1001, 0b0110, 0b0000,],
[0b0000, 0b0110, 0b1001, 0b1001, 0b0110, 0b0001, 0b1001, 0b0110, 0b0000,],
]
# configure I2C
i2c = busio.I2C(board.SCL, board.SDA)
# turn on LED drivers
sdb = DigitalInOut(board.SDB)
sdb.direction = Direction.OUTPUT
sdb.value = True
# set up the two LED drivers
display = adafruit_is31fl3731.Matrix(i2c, address=0x74)
display2 = adafruit_is31fl3731.Matrix(i2c, address=0x77)
btnA = DigitalInOut(board.BTNA)
btnA.pull = Pull.UP
btnB = DigitalInOut(board.BTNB)
btnB.pull = Pull.UP
btnX = DigitalInOut(board.BTNX)
btnX.pull = Pull.UP
btnY = DigitalInOut(board.BTNY)
btnY.pull = Pull.UP
colors = [PINK, RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE, TEAL, MAGENTA, CYAN]
current_colors = []
# Define sounds the keypad makes
tones = (440, 220, 245, 330, 440) # Initial tones while scrambling
press_tone = 660 # This tone is used when each key is pressed
# Initial key values - this list will be scrambled by the scramble function
key_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Define the STEMMA QT I2C line SDA to be a digital output (nonstandard use)
# SDA will be used as a digital pin to trigger a transistor to
# axctivate a solenoid which will unlock, like a door
solenoid = DigitalInOut(board.SDA)
solenoid.direction = Direction.OUTPUT
# FUNCTIONS ------------------
def keys_clear(): # Set display in the Start mode, key LEDs off
for i in range(12):
macropad.pixels[i] = 0x000000
group[i].text = " "
macropad.pixels.show()
group[9].text = "START"
macropad.display.show(group)
macropad.display.refresh()
def scramble(): # Scramble values of the keys and display on screen
def light_up_rgb(color, brightness_level):
if color == "green":
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=brightness_level)
for r in range(256):
pixels.fill((r,255,0))
time.sleep(0.5)
elif color == "blue":
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=brightness_level)
pixels.fill((0,255,255))
time.sleep(1)
pixels.fill((0,0,0))
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
slide_switch = DigitalInOut(board.SLIDE_SWITCH)
slide_switch.direction = Direction.INPUT
slide_switch.pull = Pull.UP
while True:
if slide_switch.value == True:
b_level = 0.5
import board import busio from digitalio import DigitalInOut, Direction, Pull from PIL import Image, ImageDraw import adafruit_ssd1306 # Create the I2C interface. i2c = busio.I2C(board.SCL, board.SDA) # Create the SSD1306 OLED class. disp = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c) # Input pins: button_A = DigitalInOut(board.D5) button_A.direction = Direction.INPUT button_A.pull = Pull.UP button_B = DigitalInOut(board.D6) button_B.direction = Direction.INPUT button_B.pull = Pull.UP button_L = DigitalInOut(board.D27) button_L.direction = Direction.INPUT button_L.pull = Pull.UP button_R = DigitalInOut(board.D23) button_R.direction = Direction.INPUT button_R.pull = Pull.UP button_U = DigitalInOut(board.D17)
led1_pin = board.GP13 led2_pin = board.GP14 led3_pin = board.GP15 led4_pin = board.GP16 led5_pin = board.GP17 led6_pin = board.GP18 led7_pin = board.GP19 led8_pin = board.GP20 led9_pin = board.GP21 led10_pin = board.GP22 led11_pin = board.GP26 led12_pin = board.GP27 # Setup all Buttons as Inputs with PullUps btn1 = DigitalInOut(btn1_Pin) btn1.direction = Direction.INPUT btn1.pull = Pull.UP btn2 = DigitalInOut(btn2_Pin) btn2.direction = Direction.INPUT btn2.pull = Pull.UP btn3 = DigitalInOut(btn3_Pin) btn3.direction = Direction.INPUT btn3.pull = Pull.UP btn4 = DigitalInOut(btn4_Pin) btn4.direction = Direction.INPUT btn4.pull = Pull.UP btn5 = DigitalInOut(btn5_Pin)
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS from adafruit_hid.keycode import Keycode from digitalio import DigitalInOut, Direction, Pull from analogio import AnalogIn, AnalogOut from touchio import TouchIn import adafruit_dotstar as dotstar import microcontroller import board import time # One pixel connected internally! dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=1) # 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) # The keyboard object! Used if we do HID output, see below time.sleep(1) # Sleep for a bit to avoid a race condition on some systems #keyboard = Keyboard(usb_hid.devices) #keyboard_layout = KeyboardLayoutUS(keyboard) # We're in the US :)
# One pixel connected internally!
dot = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.08)
# pizeo buzzer
buzzer = PWMOut(board.D5, variable_frequency=True)
buzzer.frequency = 262
OFF = 0
ON = 2**15
# Digital input with pullup on D2, D3, D4, D5, D6
buttons = []
for p in [board.D6, board.D9, board.D10, board.A3, board.A4]:
button = DigitalInOut(p)
button.direction = Direction.INPUT
button.pull = Pull.UP
buttons.append(button)
# Digital output on D8, D9, D10, D11, D12
buttonLeds = []
for p in [board.D11, board.D12, board.D13, board.A1, board.A2]:
buttonLed = DigitalInOut(p)
buttonLed.direction = Direction.OUTPUT
buttonLeds.append(buttonLed)
######################### HELPERS ##############################
# Helper to give us a nice color swirl
import neopixel
import rotaryio
import usb_hid
from adafruit_hid.mouse import Mouse
from adafruit_hid.keyboard import Keyboard, Keycode
# 16 position neopixel ring
ring = neopixel.NeoPixel(board.MISO, 16, brightness=0.2, auto_write=False)
# button of rotary encoder
button = DigitalInOut(board.MOSI)
button.pull = Pull.UP
# Use pin A2 as a fake ground for the rotary encoder
fakegnd = DigitalInOut(board.A2)
fakegnd.direction = Direction.OUTPUT
fakegnd.value = False
encoder = rotaryio.IncrementalEncoder(board.A3, board.A1)
#cc = ConsumerControl(usb_hid.devices)
mouse = Mouse(usb_hid.devices)
keyboard = Keyboard(usb_hid.devices)
print("hello from qtpy-knob-scroller!")
# standard colorwheel
def colorwheel(pos):
if pos < 0 or pos > 255:
(r, g, b) = (0, 0, 0)
sky_blue = [0, 120, 135] idle_color = [70, 243, 70] hit_color = [150, 20, 00] # One pixel connected internally! dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, n=1, brightness=0.2) dot[0] = sky_blue led = digitalio.DigitalInOut(board.D13) led.direction = digitalio.Direction.OUTPUT # Digital input with pullup on D0 PIR1 = DigitalInOut(board.D0) PIR1.direction = Direction.INPUT PIR1.pull = Pull.DOWN # Digital input with pullup on D2 PIR2 = DigitalInOut(board.D2) PIR2.direction = Direction.INPUT PIR2.pull = Pull.DOWN f_PIR1 = PIR1.value f_PIR2 = PIR2.value while True: time.sleep(0.5) if PIR1.value and not f_PIR1:
import pulseio import random import touchio from adafruit_motor import servo from sauce import Sauce from item_selection import ItemSelection import busio from digitalio import DigitalInOut, Direction, Pull pwm = pulseio.PWMOut(board.A2, duty_cycle=2**15, frequency=50) pwm1 = pulseio.PWMOut(board.A3, duty_cycle=2**15, frequency=50) pwm2 = pulseio.PWMOut(board.A4, duty_cycle=2**15, frequency=50) pwm3 = pulseio.PWMOut(board.D12, duty_cycle=2**15, frequency=50) pi = DigitalInOut(board.D6) pi.direction = Direction.INPUT pi.pull = Pull.UP sauce_pi = DigitalInOut(board.D7) sauce_pi.direction = Direction.INPUT sauce_pi.pull = Pull.UP sauce_servo = servo.Servo(pwm) plate_servo = servo.Servo(pwm2) spat_servo = servo.Servo(pwm3) sauce_unit = Sauce(sauce_servo, sauce_pi) uart = busio.UART(board.TX, board.RX, baudrate=9600) x = 0 plate_unit = ItemSelection(plate_servo, spat_servo, pi)
# button input example
# touch pin D9 to Ground and the LED turns on
import time
import board
from digitalio import DigitalInOut, Direction, Pull
yellowLed = DigitalInOut(board.A1) #A1 is the yellow LED that doesn't do PWM
yellowLed.direction = Direction.OUTPUT
button = DigitalInOut(board.D9)
button.direction = Direction.INPUT
button.pull = Pull.UP
while True:
if button.value: #if D9 isn't connected to ground
yellowLed.value = False
else:
yellowLed.value = True
#time.sleep(0.01) # debounce delay
# Creator: Jonathan P-A
# Date: September 30
# This program makes an RGB LED turn on for 1 second and then off for 1 second repetedly
import time
import board
from digitalio import DigitalInOut, Direction
ledi = DigitalInOut(board.D1)
ledii = DigitalInOut(board.D2)
lediii = DigitalInOut(board.D3)
ledi.direction = Direction.OUTPUT
ledii.direction = Direction.OUTPUT
lediii.direction = Direction.OUTPUT
while True:
ledi.value = True
ledii.value = True
lediii.value = True
time.sleep(1) #wait 1 second
ledi.value = False
ledii.value = False
lediii.value = False
time.sleep(1) #wait 1 second
import time
from digitalio import DigitalInOut, Direction, Pull
bpm = 120
def play_file(filename):
f = open(filename, "rb")
wave = audioio.WaveFile(f)
a.play(wave)
time.sleep(bpm / 960) # sixteenthNote delay
# Enable the speaker
spkrenable = DigitalInOut(board.SPEAKER_ENABLE)
spkrenable.direction = Direction.OUTPUT
spkrenable.value = True
# Make the cap sense pads
touch1 = touchio.TouchIn(board.A1)
touch2 = touchio.TouchIn(board.A2)
touch3 = touchio.TouchIn(board.A3)
touch4 = touchio.TouchIn(board.A4)
touch5 = touchio.TouchIn(board.A5)
touch6 = touchio.TouchIn(board.A6)
touch7 = touchio.TouchIn(board.A7)
touchPad = [touch1, touch2, touch3, touch4, touch5, touch6, touch7]
#this is a list
audiofiles = [
"bd_tek.wav", "elec_hi_snare.wav", "elec_cymbal.wav", "elec_blip2.wav",
# NeoTrellis to select colors of NeoPixel strip # NeoTrellis connected to Feather M4 (need the extra memory vs. M0) SCL, SDA # NeoPixel 120 strip connected to pin D5 # NeoPixel strip powered over 5V 2A DC wall power supply # On/off button RGB connects En to GND, LED to D13 import time import board from board import SCL, SDA import busio import neopixel from adafruit_neotrellis.neotrellis import NeoTrellis from digitalio import DigitalInOut, Direction button_LED = DigitalInOut(board.D13) button_LED.direction = Direction.OUTPUT button_LED.value = True pixel_pin = board.D5 num_pixels = 120 pixels = neopixel.NeoPixel(pixel_pin, num_pixels, auto_write=False) # create the i2c object for the trellis i2c_bus = busio.I2C(SCL, SDA) # create the trellis object trellis = NeoTrellis(i2c_bus) # color definitions OFF = (0, 0, 0)
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
# Debug Level
# Change the Debug Flag if you have issues with AT commands
debugflag = False
if board.board_id == "challenger_rp2040_wifi":
RX = board.ESP_RX
TX = board.ESP_TX
resetpin = DigitalInOut(board.WIFI_RESET)
rtspin = False
uart = busio.UART(TX, RX, baudrate=11520, receiver_buffer_size=2048)
esp_boot = DigitalInOut(board.WIFI_MODE)
esp_boot.direction = Direction.OUTPUT
esp_boot.value = True
else:
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")
# For Boards that do not have an rtspin like challenger_rp2040_wifi set rtspin to False.
esp = adafruit_espatcontrol.ESP_ATcontrol(uart,
115200,
import board
import neopixel
import time
from digitalio import DigitalInOut, Direction, Pull
import random
btn = DigitalInOut(board.GP20)
btn.direction = Direction.INPUT
btn.pull = Pull.UP
pixelCount = 16
pixels = neopixel.NeoPixel(board.GP26,
pixelCount,
brightness=.1,
auto_write=False)
print("init the neopixels")
#pixels = neopixel.NeoPixel(board.GP1, 16, brightness = 0.5)
#pixels[0] = (10, 0, 0)
pixels.fill((255, 0, 255))
MAX_PINK_RED = 247
MAX_PINK_GREEN = 74
MAX_PINK_BLUE = 230
def rainbow_cycle(wait, step):
j = step
for i in range(pixelCount):
rc_index = (i * 256 // 10) + j * 5
pixels[i] = wheel(rc_index & 255)
pixels.show()
# Playground 808
# Drum machine
import time
import audioio
import board
import touchio
from digitalio import DigitalInOut, Direction
bpm = 120 # beats per minute, change this to suit your tempo
# enable the speaker
spkrenable = DigitalInOut(board.SPEAKER_ENABLE)
spkrenable.direction = Direction.OUTPUT
#spkrenable.value = True ## Send sound out internal speaker and A0 Pin
spkrenable.value = False ## Only send sound out the A0 Pin
# make the input cap sense pads
capPins = (board.A1, board.A2, board.A3, board.A4, board.A5, board.A6,
board.A7)
touchPad = []
for i in range(7):
touchPad.append(touchio.TouchIn(capPins[i]))
# The seven files assigned to the touchpads
audiofiles = [
"bd_tek.wav", "elec_hi_snare.wav", "elec_cymbal.wav", "elec_blip2.wav",
"bd_zome.wav", "bass_hit_c.wav", "drum_cowbell.wav"
]
group.append(nextHourTempLabel)
nextHourLabel = label.Label(font_small, text="+8", color=0x000000)
nextHourLabel.text = "+{}".format(hour)
nextHourLabel.anchor_point = (0.5, 0.0)
nextHourLabel.anchored_position = (10, -7)
group.append(nextHourLabel)
return group
# Wrap everything in a try block so we can restart if anything fails
try:
# turn light sensor on
power = DigitalInOut(board.NEOPIXEL_POWER)
power.direction = Direction.OUTPUT
power.value = False
light_sensor = AnalogIn(board.LIGHT)
#give it a moment to read (just a guess)
time.sleep(0.05)
light_value = light_sensor.value
power.value = True # turn the sensor offset
print("Light is:", light_value)
# No need to update the screen if it is dark and you can't read it
if light_value > 600:
#
# SPDX-License-Identifier: MIT
# Animatronic Hand
# Binary Counting on four fingers up to 15
import time
from digitalio import DigitalInOut, Direction, Pull
import audioio
import audiocore
import board
from adafruit_crickit import crickit
#################### CPX switch
# use the CPX onboard switch to turn on/off (helps calibrate)
switch = DigitalInOut(board.SLIDE_SWITCH)
switch.direction = Direction.INPUT
switch.pull = Pull.UP
#################### Audio setup
print("Let's count in binary.")
wavfiles = ("one.wav", "two.wav", "three.wav", "four.wav", "five.wav",
"six.wav", "seven.wav", "eight.wav", "nine.wav", "ten.wav",
"eleven.wav", "twelve.wav", "thirteen.wav", "fourteen.wav",
"fifteen.wav")
introfile = "intro.wav"
cpx_audio = audioio.AudioOut(board.A0)
def play_file(wavfile):
with open(wavfile, "rb") as f:
draw.rectangle((0, 0, oled.width, oled.height * 2), outline=0, fill=0)
draw.text((0,0), firstLine, font=font, fill=255)
draw.text((0,18), secondLine, font=font, fill=255)
draw.text((0,36), thirdLine, font=font, fill=255)
oled.image(image)
oled.show()
# i2c interface and display
i2c = board.I2C()
RESET_PIN = digitalio.DigitalInOut(board.D4)
oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3c, reset=RESET_PIN)
# button and joystick input
leftButton = DigitalInOut(board.D5)
leftButton.direction = Direction.INPUT
leftButton.pull = Pull.UP
rightButton = DigitalInOut(board.D6)
rightButton.direction = Direction.INPUT
rightButton.pull = Pull.UP
leftJoy = DigitalInOut(board.D27)
leftJoy.direction = Direction.INPUT
leftJoy.pull = Pull.UP
rightJoy = DigitalInOut(board.D23)
rightJoy.direction = Direction.INPUT
rightJoy.pull = Pull.UP
upJoy = DigitalInOut(board.D17)
# CircuitPlaygroundExpress_DigitalIO
import time
import board
from digitalio import DigitalInOut, Direction, Pull
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
button = DigitalInOut(board.BUTTON_A)
button.direction = Direction.INPUT
button.pull = Pull.DOWN
while True:
if button.value: # button is pushed
led.value = True
else:
led.value = False
time.sleep(0.01)
import time
import board
from digitalio import DigitalInOut, Direction, Pull
from lcd.lcd import LCD
from lcd.i2c_pcf8574_interface import I2CPCF8574Interface
from lcd.lcd import CursorMode
lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16)
button = DigitalInOut(board.D2) #make button pin
button.direction = Direction.INPUT
button.pull = Pull.UP #give power to button
switch = DigitalInOut(board.D5) #make switch pin
switch.direction = Direction.INPUT
switch.pull = Pull.UP #give power to switch
lcd.set_cursor_mode(CursorMode.LINE)
press = False #press starts at false until proven otherwise
x = 0 #starts at 0
while True:
print(button.value)
lcd.backlight = True #backlight is on
if not button.value:
if (press == False):
press = True #if press does not equal false then press equals true
if not switch.value:
x = x -1 #if it does not equal switch value then it goes down by one
if switch.value:
x = x +1 #if it does equal switch value then it goes up by one
print((0,))
if button.value:
import board
import time
import neopixel
from digitalio import DigitalInOut, Direction, Pull
from analogio import AnalogIn
import audioio
import touchio
import simpleio
# One pixel connected internally!
dot = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2)
# Built in red LED
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
# Digital input with pullup on D2, D3, and D4
buttons = []
for p in [board.D2, board.D3, board.D4]:
button = DigitalInOut(p)
button.direction = Direction.INPUT
button.pull = Pull.UP
buttons.append(button)
######################### HELPERS ##############################
##
# Helper to give us a nice color swirl
def wheel(pos):
Author: Brent Rubell for Adafruit Industries """ # Import Python System Libraries import time # Import Blinka Libraries import busio from digitalio import DigitalInOut, Direction, Pull import board # Import the SSD1306 module. import adafruit_ssd1306 # Import RFM9x import adafruit_rfm9x # Button A btnA = DigitalInOut(board.D5) btnA.direction = Direction.INPUT btnA.pull = Pull.UP # Button B btnB = DigitalInOut(board.D6) btnB.direction = Direction.INPUT btnB.pull = Pull.UP # Button C btnC = DigitalInOut(board.D12) btnC.direction = Direction.INPUT btnC.pull = Pull.UP # Create the I2C interface. i2c = busio.I2C(board.SCL, board.SDA)
import board import array 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)
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
# keyboard imports
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode as KC
from adafruit_hid.consumer_control_code import ConsumerControlCode
from adafruit_hid.consumer_control import ConsumerControl
# rotary encoder
import rotaryio
encoder = rotaryio.IncrementalEncoder(board.P1_11, board.P0_29)
encoder_last_position = encoder.position
encoder_switch_pin = DigitalInOut(board.P0_31)
encoder_switch_pin.direction = Direction.INPUT
encoder_switch_pin.pull = Pull.UP
encoder_switch_last_position = True
def encoder_update():
global encoder_last_position
global encoder_switch_last_position
if encoder_last_position > encoder.position:
encoder_last_position = encoder.position
keyboard_consumer_control.send(ConsumerControlCode.VOLUME_INCREMENT)
elif encoder_last_position < encoder.position:
encoder_last_position = encoder.position
keyboard_consumer_control.send(ConsumerControlCode.VOLUME_DECREMENT)
from time import sleep
import board
import neopixel
from digitalio import DigitalInOut, Direction, Pull
from supervisor import runtime
from cpgame import after, cancel, every, on, start
from colors import RED, ORANGE, GREEN, YELLOW, BLUE, VIOLET, WHITE, OFF
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=0.02, auto_write=True)
pixels.fill(OFF)
pixels.show()
WAIT = DigitalInOut(board.D7)
WAIT.direction = Direction.INPUT
WAIT.pull = Pull.UP
LED = DigitalInOut(board.D13)
LED.direction = Direction.OUTPUT
STATUS = 9
class state:
active = 0
handshake = 0
data = ""
def send(cmd):
if cmd.endswith("\n"):
