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
from digitalio import DigitalInOut, Direction, Pull import time import board interrupter = DigitalInOut(board.D7) interrupter.direction = Direction.INPUT interrupter.pull = Pull.UP counter = 0 photo = False state = False max = 4 start = time.time() while True: photo = interrupter.value if photo and not state: counter += 1 state = photo remaining = max - time.time() if remaining <= 0: print("Interrupts:", str(counter)) max = time.time() + 4 counter = 0
# set up dotstar indicator output (GBR orientation) dot = dotstar.DotStar(board.DOTSTAR_CI, board.DOTSTAR_DI, 1, brightness=0.5) # set up busy indicator output (red LED) busy = DigitalInOut(board.LED_STATUS) busy.direction = Direction.OUTPUT # set up motor controller outputs ain01 = pulseio.PWMOut(board.MOTOR_OUT_1, frequency=25, duty_cycle=0) ain02 = pulseio.PWMOut(board.MOTOR_OUT_2, frequency=25, duty_cycle=0) # set up EOS sensor switch input sensor_eos = DigitalInOut(board.SENSOR_IN) sensor_eos.direction = Direction.INPUT sensor_eos.pull = Pull.UP # Analog input on VOLTAGE_MONITOR v_plus = AnalogIn(board.VOLTAGE_MONITOR) # set up potentiometer control input #ctl = AnalogIn(board.D1) # set up piezo output piezo = pulseio.PWMOut(board.PIEZO, duty_cycle=0, frequency=440, variable_frequency=True) def setup(motor_specs):
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) button_U.direction = Direction.INPUT
index = 8 # midway color selection blend = True # color blending between palette indices # initialize list with all pixels off palette = [0] * num_leds # Declare a NeoPixel object on led_pin with num_leds as pixels # No auto-write. # Set brightness to max. # We will be using FancyLED's brightness control. strip = neopixel.NeoPixel(led_pin, num_leds, brightness=1, auto_write=False) # button setup button = DigitalInOut(board.D2) button.direction = Direction.INPUT button.pull = Pull.UP prevkeystate = False ledmode = 0 # button press counter, switch color palettes # FancyLED allows for assigning a color palette using these formats: # * The first (5) palettes here are mixing between 2-elements # * The last (3) palettes use a format identical to the FastLED Arduino Library # see FastLED - colorpalettes.cpp forest = [fancy.CRGB(0, 255, 0), # green fancy.CRGB(255, 255, 0)] # yellow ocean = [fancy.CRGB(0, 0, 255), # blue fancy.CRGB(0, 255, 0)] # green purple = [fancy.CRGB(160, 32, 240), # purple fancy.CRGB(238, 130, 238)] # violet
#FILENAME = "minerva.bmp" TOUCH = touchio.TouchIn(board.A5) # capacitive touch pad SPEED = 10000 SPEED_ADJUST = 2500 # This value changes the increment for button speed adjustments BRIGHTNESS = 1.0 # Set brightness here, NOT in NeoPixel constructor GAMMA = 2.7 # Adjusts perceived brighthess linearity NUM_PIXELS = 30 # NeoPixel strip length (in pixels) NEOPIXEL_PIN = board.A1 # Pin where NeoPixels are connected DELAY_TIME = 0.01 # Timer delay before it starts LOOP = False # Set to True for looping # button setup 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 # switch setup switch = DigitalInOut(board.SLIDE_SWITCH) switch.direction = Direction.INPUT switch.pull = Pull.UP #status led setup led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT if switch.value:
""" This example script shows how to read button state with debouncing that does not rely on time.sleep(). """ import board from digitalio import DigitalInOut, Direction, Pull btn = DigitalInOut(board.SWITCH) btn.direction = Direction.INPUT btn.pull = Pull.UP prev_state = btn.value while True: cur_state = btn.value if cur_state != prev_state: if not cur_state: print("BTN is down") else: print("BTN is up") prev_state = cur_state
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: dot[0] = hit_color
(15): (KEY, [Keycode.O]), (16): (KEY, [Keycode.LEFT_ARROW]), (17): (KEY, [Keycode.DOWN_ARROW]), (18): (KEY, [Keycode.RIGHT_ARROW]), (19): (KEY, [Keycode.ALT]), (20): (KEY, [Keycode.U]), } switches = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21 ] for i in range(21): switches[i] = DigitalInOut(pins[i]) switches[i].direction = Direction.INPUT switches[i].pull = Pull.UP switch_state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] while True: for button in range(21): if switch_state[button] == 0: if not switches[button].value: try: if keymap[button][0] == KEY: kbd.press(*keymap[button][1]) else: cc.send(keymap[button][1]) except ValueError: # deals w six key limit pass switch_state[button] = 1
# 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 pi = DigitalInOut(board.D6) pi.direction = Direction.INPUT pi.pull = Pull.UP dot = neopixel.NeoPixel(board.NEOPIXEL, 1) lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) r = 255 g = 0 b = 0 toggle = True time_toggle = True current_time = 0 interrupts = 0 while True: dot.fill((r, g, b))
# import modules import board import neopixel from digitalio import DigitalInOut, Direction, Pull import time # declare objects and variables switch = DigitalInOut(board.SLIDE_SWITCH) switch.direction = Direction.INPUT switch.pull = Pull.UP buttonA = DigitalInOut(board.BUTTON_A) buttonA.direction = Direction.INPUT buttonA.pull = Pull.DOWN buttonAPre = False buttonB = DigitalInOut(board.BUTTON_B) buttonB.direction = Direction.INPUT buttonB.pull = Pull.DOWN buttonBPre = False pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.05, auto_write=False) # color variables OFF = (0, 0, 0) WHITE = (255, 255, 255) ORANGE = (255, 35, 0) BLUE = (0, 0, 255)
from adafruit_motor import servo from busio import I2C import neopixel import board # Create seesaw object i2c = I2C(board.SCL, board.SDA) seesaw = Seesaw(i2c) led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT # Two onboard CPX buttons for FOG buttona = DigitalInOut(board.BUTTON_A) buttona.direction = Direction.INPUT buttona.pull = Pull.DOWN buttonb = DigitalInOut(board.BUTTON_B) buttonb.direction = Direction.INPUT buttonb.pull = Pull.DOWN # Use the signal port for potentiometer w/switch MORECOW = 2 # A switch on Signal #1 SWITCH = 3 # A potentiometer on Signal #2 # Add a pullup on the switch seesaw.pin_mode(SWITCH, seesaw.INPUT_PULLUP) # Servo angles BELL_START = 60 BELL_END = 75 MOUTH_START = 95
Please support Adafruit and open source hardware by purchasing products from Adafruit! Written by Dave Astels for Adafruit Industries Copyright (c) 2018 Adafruit Industries Licensed under the MIT license. All text above must be included in any redistribution. """ import board from digitalio import DigitalInOut, Direction, Pull from adafruit_circuitplayground import cp button_a = DigitalInOut(board.A1) button_a.direction = Direction.INPUT button_a.pull = Pull.UP button_b = DigitalInOut(board.A2) button_b.direction = Direction.INPUT button_b.pull = Pull.UP cp.pixels.brightness = 0.3 cp.pixels.fill((0, 0, 0)) # Turn off the NeoPixels if they're on! def touch_a(): return not button_a.value def touch_b(): return not button_b.value
# See https://learn.adafruit.com/circuitpython-essentials/circuitpython-storage # for a discussion # import board from digitalio import DigitalInOut, Direction, Pull import storage # Use DPAD switches to control filesystem mode # left_pin = DigitalInOut(board.D3) left_pin.direction = Direction.INPUT left_pin.pull = Pull.UP right_pin = DigitalInOut(board.D4) right_pin.direction = Direction.INPUT right_pin.pull = Pull.UP up_pin = DigitalInOut(board.D1) up_pin.direction = Direction.INPUT up_pin.pull = Pull.UP down_pin = DigitalInOut(board.D0) down_pin.direction = Direction.INPUT down_pin.pull = Pull.UP # If any DPAD switch is not pressed, then CircuitPython can write to the drive. # To allow the host to write, press all 4 DPAD buttons during boot. # print("DPAD left = ", left_pin.value) print("DPAD right = ", right_pin.value) print("DPAD up = ", up_pin.value)
# "num_pixels": 8, # "order": neopixel.GRB, # "brightness_lvl": 0.2, # "led_object": None, # }, # "left_middle": {}, # "right_rib": {}, # "right_chest": {}, # "right_abs": {}, # "right_middle": {}, } # BUTTON REGISTER button = DigitalInOut(board.BUTTON_A) button.direction = Direction.INPUT button.pull = Pull.DOWN # BUTTON STATES prevkeystate = False ledmode = 0 # button press counter, switch color palettes memorySnapshot() # TODO: Add the other devices # SETUP create_neopixel_objects(device="left_rib") # create_neopixel_objects(device="left_chest") # create_neopixel_objects(device="left_abs") # create_neopixel_objects(device="left_middle") # create_neopixel_objects(device="right_rib") # create_neopixel_objects(device="right_chest") # create_neopixel_objects(device="right_abs")
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 adafruit_dotstar as dotstar import neopixel import board import time from digitalio import DigitalInOut, Direction, Pull dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=0.2) led_pin = board.D1 # Which pin your pixels are connected to num_leds = 10 # How many LEDs you have strip = neopixel.NeoPixel(led_pin, num_leds, brightness=1, auto_write=False) b1 = DigitalInOut(board.D2) b1.direction = Direction.INPUT b1.pull = Pull.UP b2 = DigitalInOut(board.D0) b2.direction = Direction.INPUT b2.pull = Pull.UP SOFTCYAN = (0, 85, 85) SOFTYELLOW = (85, 76, 0) WHEEL = (0, 0, 0) WHITE = (255, 255, 255) CYAN = (0, 255, 255) YELLOW = (255, 230, 0) RED = (255, 10, 30) BLUE = (30, 10, 255) GREEN = (30, 255, 10) COLORS = [SOFTCYAN, SOFTYELLOW, WHEEL, WHITE, CYAN, YELLOW, RED, BLUE, GREEN]
import random dotstar = DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=0.3) led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT rightEye = DigitalInOut(board.D0) leftEye = DigitalInOut(board.D3) sensor = DigitalInOut(board.D4) piezo = pulseio.PWMOut(board.D2, duty_cycle=0, frequency=250, variable_frequency=True) rightEye.direction = Direction.OUTPUT leftEye.direction = Direction.OUTPUT sensor.direction = Direction.INPUT sensor.pull = Pull.UP loopCount = 0 rightEye.value = True leftEye.value = True dotstar[0] = (0, 0, 255) def moved(): dotstar[0] = (255, 255, 0) squeak(3) time.sleep(2)
# For the Metro cs = digitalio.DigitalInOut(board.D10) dc = digitalio.DigitalInOut(board.D9) display = ili9341.ILI9341(spi, cs=cs, dc=dc, width=320, height=240) display.write(0x36, b'\x3E') bf = bitmapfont.BitmapFont(320, 240, display.pixel) # (240, 320, display.pixel) bf.init() led = simpleio.DigitalOut(board.D13) GoButton = DigitalInOut(board.D4) # pin 4 gets 3.3v to start the party. GoButton.direction = Direction.INPUT GoButton.pull = Pull.UP def Rounder(IntInput, MaxNum): if (IntInput > MaxNum): # print("number over " + (str(MaxNum)) + "! Lowered " + (str(IntInput))) IntInput /= 2 IntInput = int(round(IntInput)) # print(" to:" + (str(IntInput))) # print("") return(IntInput) def Limiter(IntInput, MaxNum): while (IntInput > MaxNum): # print("number over " + (str(MaxNum)) + "! Lowered " + (str(IntInput))) IntInput /= 2 IntInput = int(round(IntInput))
import time import board #these libraries are needed from digitalio import DigitalInOut, Direction, Pull from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) PI = DigitalInOut(board.D5) PI.direction = Direction.INPUT #making photointerrupter pin and declaring as DigitalInOut object PI.pull = Pull.UP x = 0 #Set at zero until proven otherwise interrupt = False while True: #print(PI.value) lcd.backlight = True if PI.value: if interrupt == False: interrupt = True #if interrupt isn't false then it is true x = x + 1 #count up by one if PI value if not PI.value: interrupt = False #if not PI value then it is back to starting x=0 x = x #print(("Interrupted")) if time.monotonic() % 4 == 0: #print value every 4 times PI is interrupted lcd.set_cursor_pos(0, 0) #cursor at start of first row lcd.print("Interrupted: ") lcd.set_cursor_pos(0, 12) #cursor at end of first row lcd.print(str(x))
from adafruit_seesaw.pwmout import PWMOut from adafruit_motor import servo from busio import I2C import board # Create seesaw object for Circuit Playground Express to talk to Crickit i2c = I2C(board.SCL, board.SDA) seesaw = Seesaw(i2c) led = DigitalInOut(board.D13) # Set up Red LED led.direction = Direction.OUTPUT button_A = DigitalInOut(board.BUTTON_A) # Set up switch A button_A.direction = Direction.INPUT button_A.pull = Pull.DOWN # Create servos list servos = [] for ss_pin in (17, 16): # Only use 2 servos, append , 15, 14 if using 4 pwm = PWMOut(seesaw, ss_pin) pwm.frequency = 50 _servo = servo.Servo(pwm, min_pulse=600, max_pulse=2500) _servo.angle = 90 # starting angle, middle servos.append(_servo) def servo_front(direction): if direction > 0: index = 50 while index <= 90:
import neopixel from digitalio import DigitalInOut, Direction, Pull import time brightness = 0.0 target = 0.5 pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=brightness) pixels.fill((255, 255, 255)) led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT button_left = DigitalInOut(board.BUTTON_A) button_left.direction = Direction.INPUT button_left.pull = Pull.DOWN button_right = DigitalInOut(board.BUTTON_B) button_right.direction = Direction.INPUT button_right.pull = Pull.DOWN press = DigitalInOut(board.A1) press.direction = Direction.INPUT press.pull = Pull.UP rotary_left = DigitalInOut(board.A2) rotary_left.direction = Direction.INPUT rotary_left.pull = Pull.DOWN rotary_right = DigitalInOut(board.A3) rotary_right.direction = Direction.INPUT
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 variables for the r, g, b values for the built-in led # on the board 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 lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) mods = [1, 2, 5, 10, -1, -2, -5, -10] num = 0 m = 0
if len(addrs) == 4: if '1e' in addrs: if '39' in addrs: if '6b' in addrs: if '76' in addrs: iicdevs = "V" print("All devices present!") iicdevstr = "" for h in addrs: iicdevstr += h print('Checking Charge Status Pin') charge_status = DigitalInOut(m.pin.P0_16) charge_status.direction = Direction.INPUT charge_status.pull = Pull.UP print("Charge Pin:\t%s" % (str(charge_status.value))) print("Checking Battery Voltage") analog_in = AnalogIn(m.pin.P0_31) print("Voltage:\t%s" % (str(analog_in.value))) qrstring = bytes( ",IIC:%s,IICDEV:%s,ADC:%s" % (iicdevs, iicdevstr, str(analog_in.value).strip()), 'utf-8') print(qrstring) qr = adafruit_miniqr.QRCode() qr.add_data(qrstring) qr.make() palette = displayio.Palette(2)
""" import json from digitalio import DigitalInOut, Direction, Pull import analogio light = analogio.AnalogIn(board.LIGHT) snooze_button = DigitalInOut(board.D3) snooze_button.direction = Direction.INPUT snooze_button.pull = Pull.UP #################### # variables # mugsy support mugsy_background = 'mugsy_background.bmp' # weather support icon_file = None icon_sprite = None celcius = secrets['celcius'] # display/data refresh timers
# Demo the Piper Command Center Joystick library # import board from digitalio import DigitalInOut, Direction, Pull from adafruit_hid.mouse import Mouse import usb_hid from adafruit_debouncer import Debouncer from piper_command_center import PiperJoystickAxis # Setup DPAD # left_pin = DigitalInOut(board.D3) left_pin.direction = Direction.INPUT left_pin.pull = Pull.UP left = Debouncer(left_pin) right_pin = DigitalInOut(board.D4) right_pin.direction = Direction.INPUT right_pin.pull = Pull.UP right = Debouncer(right_pin) # Provide a ground for the joystick - this is to facilitate # easier wiring joystick_gnd = DigitalInOut(board.A5) joystick_gnd.direction = Direction.OUTPUT joystick_gnd.value = 0 # Setup joystick pins, and choose an outputScale which results in an # easy to control mouse pointer # x_axis = PiperJoystickAxis(board.A4, outputScale=20)
# 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 def wheel(pos):
BUTTON_PIN = board.D17 JOYDOWN_PIN = board.D27 JOYLEFT_PIN = board.D22 JOYUP_PIN = board.D23 JOYRIGHT_PIN = board.D24 JOYSELECT_PIN = board.D16 buttons = [ BUTTON_PIN, JOYUP_PIN, JOYDOWN_PIN, JOYLEFT_PIN, JOYRIGHT_PIN, JOYSELECT_PIN ] for i, pin in enumerate(buttons): buttons[i] = DigitalInOut(pin) buttons[i].direction = Direction.INPUT buttons[i].pull = Pull.UP button, joyup, joydown, joyleft, joyright, joyselect = buttons class Input(Enum): BUTTON = auto() UP = auto() DOWN = auto() LEFT = auto() RIGHT = auto() SELECT = auto() def get_inputs(): inputs = [] if not button.value:
import board import time import usb_hid from digitalio import DigitalInOut, Direction, Pull from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode switch = DigitalInOut(board.GP4) switch.direction = Direction.INPUT switch.pull = Pull.UP bt1 = DigitalInOut(board.GP18) bt1.direction = Direction.INPUT bt1.pull = Pull.UP bt2 = DigitalInOut(board.GP20) bt2.direction = Direction.INPUT bt2.pull = Pull.UP led = DigitalInOut(board.GP10) led.direction = Direction.OUTPUT keyboard = Keyboard(usb_hid.devices) while True: if not bt1.value: if switch.value: #MacOs print("Button 1, Switch position 1") led.value = not led.value
from digitalio import DigitalInOut, Direction, Pull from adafruit_seesaw.seesaw import Seesaw from adafruit_seesaw.pwmout import PWMOut from adafruit_motor import servo, motor from busio import I2C import board i2c = I2C(board.SCL, board.SDA) ss = Seesaw(i2c) print("Crickit demo!") # use the CPX onboard switch to turn on/off (helps calibrate) switch = DigitalInOut(board.SLIDE_SWITCH) switch.direction = Direction.INPUT switch.pull = Pull.UP #################### 4 Servos servos = [] for ss_pin in (17, 16, 15, 14): pwm = PWMOut(ss, ss_pin) pwm.frequency = 50 _servo = servo.Servo(pwm) _servo.angle = 90 # starting angle, middle servos.append(_servo) #################### 2 DC motors motors = [] for ss_pin in ((22, 23), (18, 19)): pwm0 = PWMOut(ss, ss_pin[0]) pwm1 = PWMOut(ss, ss_pin[1])
def cbackRelease(): k.release_all() dot[0] = (0, 0, 0) led.value = 0 dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=lB) dot[0] = (0, 0, 0) k = Keyboard() kL = KeyboardLayoutUS(k) bR = DigitalInOut(board.D2) bR.direction = Direction.INPUT bR.pull = Pull.DOWN bL = DigitalInOut(board.D0) bL.direction = Direction.INPUT bL.pull = Pull.DOWN tA = touchio.TouchIn(board.D3) tB = touchio.TouchIn(board.D4) tC = touchio.TouchIn(board.D1) led = DigitalInOut(board.D13) led.direction = Direction.OUTPUT def calibrate(): sTime = time.monotonic()
# Import Blinka Libraries import busio from digitalio import DigitalInOut, Direction, Pull import board # Import the SSD1306 module. import adafruit_ssd1306 # Import the RFM69 radio module. import adafruit_rfm69 ############################################################################# # Initialize RFM69 Board ############################################################################# # 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) # 128x32 OLED Display
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: dot[0] = hit_color
# SPDX-License-Identifier: MIT import board from digitalio import DigitalInOut, Direction, Pull from adafruit_funhouse import FunHouse from adafruit_debouncer import Debouncer RED = 0x200000 GREEN = 0x002000 funhouse = FunHouse(default_bg=None) funhouse.peripherals.dotstars.fill(RED) switch_pin = DigitalInOut(board.A1) switch_pin.direction = Direction.INPUT switch_pin.pull = Pull.UP switch = Debouncer(switch_pin) def send_io_data(door_value): funhouse.peripherals.led = True print("Sending data to adafruit IO!") funhouse.network.push_to_io("door", door_value) funhouse.peripherals.led = False send_io_data(0) while True: switch.update()
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"): line = cmd