class Keyboard():
def __init__(self):
self.keyboard = adafruit_hid.keyboard.Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(self.keyboard)
def press(self, key):
self.keyboard.press(key)
def release_all(self):
self.keyboard.release_all()
def write(self, text):
self.keyboard_layout.write(text)
def paste(self, text):
if self.keyboard is None:
if usb_hid:
self.keyboard = Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(self.keyboard)
else:
return
if self.keyboard_layout is None:
raise ValueError("USB HID not available")
text = str(text)
self.keyboard_layout.write(text)
raise RuntimeError("Pasted")
def __init__(self, config):
"""
Init and binds the H/W
"""
# Pimoroni's RGB Keypad - Default wiring
self.KEYPAD = RgbKeypad()
self.KEYS = self.KEYPAD.keys
# DS3231 module, i2c1, SCL=GP11 and SDA=GP10
i2c = busio.I2C(board.GP11, board.GP10)
self.DS = DS3231(i2c)
print(self.DS.datetime) # Just to check time at boot when dev
self.CONFIG = config
# USB HID
keyboard = Keyboard(usb_hid.devices)
if self.CONFIG.get("layout", "us") == "fr":
# More to come
from adafruit_hid.keyboard_layout_fr import KeyboardLayoutFR
self.LAYOUT = KeyboardLayoutFR(keyboard)
else:
# Default US layout
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
self.LAYOUT = KeyboardLayoutUS(keyboard)
# Pico display
self.DISPLAY = pico_dio.get_display()
self.SCREENS = dict()
self.SCREENS["splash"] = pico_dio.get_splash()
self.DISPLAY.show(self.SCREENS["splash"])
self.UPDATE_INDEX = 0
self.LOCKED = False
self.LAST_CODE = ""
self.OTP = None
self.MODE = 0
self.PAGE = 0
self.INDEX = None
self.LAST_COUNTER = 0 # time // 30, OTP counter
self.SCREENS["OTP"] = pico_dio.get_otp_group()
self.SCREENS["PAGE"] = pico_dio.get_page_group()
self.display_page(self.PAGE)
for key in self.KEYS:
@self.KEYPAD.on_press(key)
def press_handler(a_key):
self.handle_numpad(button_to_numpad(a_key.number))
def paste(self, text):
if self.keyboard is None:
if usb_hid:
self.keyboard = Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(self.keyboard)
else:
return
if self.keyboard_layout is None:
self.add_trail("No USB")
else:
text = str(text)
self.keyboard_layout.write(text)
self.add_trail(f"Pasted {text}")
def __init__(self,
name="Generic Keyboard",
gpio_row=None,
gpio_col=None,
layout=None,
layers=None,
macro_layer=None):
self.name = name
self.kbd = Keyboard(usb_hid.devices) # Setup keyboard HID device
self.kbd_layout = KeyboardLayoutUS(self.kbd)
self.keymap = KeyboardHwLayout(layout) # map layout to hw layout
self.key_row = [] # write
self.key_col = [] # read
self.last_scan_matrix = {
} # used to determine diff between scans (if a release needs to be signalled)
# Layers 0, 1, 2, 3 where 0 is the default layer 1 & 2 is the extended layers and 3 is the macro layer
self.current_layer = 0
# Setup write pins
for pin in gpio_row:
key_pin = digitalio.DigitalInOut(pin)
key_pin.direction = digitalio.Direction.OUTPUT
self.key_row.append(key_pin)
# Setup read pins
for pin in gpio_col:
key_pin = digitalio.DigitalInOut(pin)
key_pin.direction = digitalio.Direction.INPUT
key_pin.pull = digitalio.Pull.UP
self.key_col.append(key_pin)
def __init__(self,
joy_x_pin=board.A4,
joy_y_pin=board.A3,
joy_z_pin=board.D2,
joy_gnd_pin=board.A5,
dpad_l_pin=board.D3,
dpad_r_pin=board.D4,
dpad_u_pin=board.D1,
dpad_d_pin=board.D0,
mc_top_pin=board.SCK,
mc_middle_pin=board.MOSI,
mc_bottom_pin=board.MISO,
outputScale=20.0,
deadbandCutoff=0.1,
weight=0.2):
self.x_axis = PiperJoystickAxis(joy_x_pin,
outputScale=outputScale,
deadbandCutoff=deadbandCutoff,
weight=weight)
self.y_axis = PiperJoystickAxis(joy_y_pin,
outputScale=outputScale,
deadbandCutoff=deadbandCutoff,
weight=weight)
self.joy_z = PiperJoystickZ(joy_z_pin)
self.dpad = PiperDpad(dpad_l_pin, dpad_r_pin, dpad_u_pin, dpad_d_pin)
self.minecraftbuttons = PiperMineCraftButtons(mc_top_pin,
mc_middle_pin,
mc_bottom_pin)
# Drive pin low if requested for easier joystick wiring
if joy_gnd_pin is not None:
# Provide a ground for the joystick - this is to facilitate
# easier wiring
self.joystick_gnd = DigitalInOut(joy_gnd_pin)
self.joystick_gnd.direction = Direction.OUTPUT
self.joystick_gnd.value = 0
self.keyboard = Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(
self.keyboard) # Change for non-US
self.mouse = Mouse(usb_hid.devices)
# State
#
self.state = _UNWIRED
self.timer = time.monotonic()
self.last_mouse_wheel = time.monotonic()
self.last_mouse = time.monotonic()
self.dotstar_led = adafruit_dotstar.DotStar(board.APA102_SCK,
board.APA102_MOSI, 1)
self.dotstar_led.brightness = 0.2
self.up_pressed = False
self.down_pressed = False
self.left_pressed = False
self.right_pressed = False
self.mc_mode = _MC_DEFAULT
self.mc_flyingdown_req = False
self.mc_sprinting_req = False
self.mc_crouching_req = False
self.mc_utility_req = False
# A simple neat keyboard demo in circuitpython
# The button pins we'll use, each will have an internal pulldown
buttonpins = [board.BUTTON_A, board.BUTTON_B]
# our array of button objects
buttons = []
# The keycode sent for each button, will be paired with a control key
buttonkeys = [Keycode.A, "Hello World!\n"]
controlkey = Keycode.SHIFT
# the keyboard object!
# sleep for a bit to avoid a race condition on some systems
time.sleep(1)
kbd = Keyboard()
# we're americans :)
layout = KeyboardLayoutUS(kbd)
# make all pin objects, make them inputs w/pulldowns
for pin in buttonpins:
button = DigitalInOut(pin)
button.direction = Direction.INPUT
button.pull = Pull.DOWN
buttons.append(button)
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
print("Waiting for button presses")
while True:
# check each button
def __init__(self, debug=False):
self.debug = debug
#self.mouse = Mouse(usb_hid.devices)
self.keyboard = Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(
self.keyboard) # Change for non-US
self.default_delay = 0
self.string_delay = 0
self.last_cmd = ""
self.last_arg = ""
# Keycode only has US mappings, not sure if AdaFruit has others
#
# TODO - consider a data structure which consumes less RAM for
# constrained platforms.
#
# Keep a separate structure for multi-key combos to lower memory
# usage.
#
self.tuple_keymap = {
"CTRL-ALT": (Keycode.CONTROL, Keycode.ALT),
"CTRL-SHIFT": (Keycode.CONTROL, Keycode.SHIFT),
"ALT-SHIFT": (Keycode.ALT, Keycode.SHIFT)
}
self.keymap = {
"ALT": Keycode.ALT,
"APP": Keycode.APPLICATION,
"BREAK": Keycode.PAUSE,
"CAPSLOCK": Keycode.CAPS_LOCK,
"CONTROL": Keycode.CONTROL,
"CTRL": Keycode.CONTROL,
"DELETE": Keycode.DELETE,
"DOWNARROW": Keycode.DOWN_ARROW,
"DOWN": Keycode.DOWN_ARROW,
"END": Keycode.END,
"ENTER": Keycode.ENTER,
"ESC": Keycode.ESCAPE,
"ESCAPE": Keycode.ESCAPE,
"GUI": Keycode.GUI,
"HOME": Keycode.HOME,
"INSERT": Keycode.INSERT,
"LEFTARROW": Keycode.LEFT_ARROW,
"LEFT": Keycode.LEFT_ARROW,
"MENU": Keycode.APPLICATION,
"NUMLOCK": Keycode.KEYPAD_NUMLOCK,
"PAGEUP": Keycode.PAGE_UP,
"PAGEDOWN": Keycode.PAGE_DOWN,
"PAUSE": Keycode.PAUSE,
"PRINTSCREEN": Keycode.PRINT_SCREEN,
"RIGHTARROW": Keycode.RIGHT_ARROW,
"RIGHT": Keycode.RIGHT_ARROW,
"SCROLLLOCK": Keycode.SCROLL_LOCK,
"SHIFT": Keycode.SHIFT,
"SPACE": Keycode.SPACE,
"TAB": Keycode.TAB,
"UPARROW": Keycode.UP_ARROW,
"UP": Keycode.UP_ARROW,
"WINDOWS": Keycode.WINDOWS,
"a": Keycode.A,
"A": Keycode.A,
"b": Keycode.B,
"B": Keycode.B,
"c": Keycode.C,
"C": Keycode.C,
"d": Keycode.D,
"D": Keycode.D,
"e": Keycode.E,
"E": Keycode.E,
"f": Keycode.F,
"F": Keycode.F,
"g": Keycode.G,
"G": Keycode.G,
"h": Keycode.H,
"H": Keycode.H,
"i": Keycode.I,
"I": Keycode.I,
"j": Keycode.J,
"J": Keycode.J,
"k": Keycode.K,
"K": Keycode.K,
"l": Keycode.L,
"L": Keycode.L,
"m": Keycode.M,
"M": Keycode.M,
"n": Keycode.N,
"N": Keycode.N,
"o": Keycode.O,
"O": Keycode.O,
"p": Keycode.P,
"P": Keycode.P,
"q": Keycode.Q,
"Q": Keycode.Q,
"r": Keycode.R,
"R": Keycode.R,
"s": Keycode.S,
"S": Keycode.S,
"t": Keycode.T,
"T": Keycode.T,
"u": Keycode.U,
"U": Keycode.U,
"v": Keycode.V,
"V": Keycode.V,
"w": Keycode.W,
"W": Keycode.W,
"x": Keycode.X,
"X": Keycode.X,
"y": Keycode.Y,
"Y": Keycode.Y,
"z": Keycode.Z,
"Z": Keycode.Z,
#
# The DuckyScript encoder didn't appear to have the following codes and
# probably used the STRING command to deal with some of them. Adding them shouldn't
# hurt but does consume RAM. Some are Mac specific.
#
"F1": Keycode.F1,
"F2": Keycode.F2,
"F3": Keycode.F3,
"F4": Keycode.F4,
"F5": Keycode.F5,
"F6": Keycode.F6,
"F7": Keycode.F7,
"F8": Keycode.F8,
"F9": Keycode.F9,
"F10": Keycode.F10,
"F11": Keycode.F11,
"F12": Keycode.F12,
"F13": Keycode.F13,
"F14": Keycode.F14,
"F15": Keycode.F15,
"F16": Keycode.F16,
"F17": Keycode.F17,
"F18": Keycode.F18,
"F19": Keycode.F19,
"BACKSLASH": Keycode.BACKSLASH,
"COMMA": Keycode.COMMA,
"COMMAND": Keycode.COMMAND,
"FORWARD_SLASH": Keycode.FORWARD_SLASH,
"GRAVE_ACCENT": Keycode.GRAVE_ACCENT,
"LEFT_BRACKET": Keycode.LEFT_BRACKET,
"OPTION": Keycode.ALT,
"PERIOD": Keycode.PERIOD,
"POUND": Keycode.POUND,
"QUOTE": Keycode.QUOTE
}
k.release_all()
dot[0] = (0, 0, 0)
led.value = 0
""" Set up the board's input and output """
# Set up the "Dotstar" RGB LED on the Trinket M0 board
# They're designed to work in a sequence with a string of other LEDs,
# but since you only have one you'll just set the value for dot[0]
dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=lB)
dot[0] = (0, 0, 0)
# Set up the Keyboard object
k = Keyboard()
kL = KeyboardLayoutUS(k)
# The "Right" physical button, or "bR", is wired up so that pressing down will
# make an electrical connection from pin D2 on the board to the ground power connection.
# For this to work, set the pin D2 to be an Input, with an internal resistor pulling
# the pin "up" away from the ground.
bR = DigitalInOut(board.D2)
bR.direction = Direction.INPUT
bR.pull = Pull.UP
# Note! If you have a "v1" board from RoboThon, you will need to pull the pin DOWN instead.
# There was a small electrical change that was made to the board after this first version.
# Same for the "Left" physical button, "bL", but this time on pin D0.
bL = DigitalInOut(board.D0)
bL.direction = Direction.INPUT
bL.pull = Pull.UP
class Calculator:
def __init__(self):
self._number1 = N("0")
self._number2 = None
self.trail = ["Ready."]
self.entry = ""
self.op = None
self.keyboard = None
self.keyboard_layout = None
def paste(self, text):
if self.keyboard is None:
if usb_hid:
self.keyboard = Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(self.keyboard)
else:
return
if self.keyboard_layout is None:
self.add_trail("No USB")
else:
text = str(text)
self.keyboard_layout.write(text)
self.add_trail(f"Pasted {text}")
def add_trail(self, msg):
self.trail = self.trail[-3:] + [str(msg).upper()]
@property
def number1(self):
return self._number1
@number1.setter
def number1(self, number):
self._number1 = number
self.add_trail(number)
@property
def number2(self):
if self.entry == "":
if self._number2 is not None:
return self._number2
return None
return N(self.entry)
@number2.setter
def number2(self, number):
self._number2 = number
self.entry = ''
def clear(self):
self.number1 = N("0")
def clear_entry(self):
self.number2 = None
def key_pressed(self, k): # pylint: disable=too-many-branches
if k == K_CL:
if self.entry:
self.entry = self.entry[:-1]
elif self.op:
print("clear op")
self.op = None
elif self.number2 is None:
self.clear()
else:
print("clear entry - op = ", self.op)
self.clear_entry()
if len(k) == 1 and k in "0123456789":
self.entry = self.entry + k
if k == "." and not "." in self.entry:
if self.entry == "":
self.entry = "0"
self.entry = self.entry + k
if k == K_PA:
if self.number2 is not None:
self.paste(self.number2)
else:
self.paste(self.number1)
if k == "=":
self.do_binary_op(0)
if k == "%":
self.do_binary_op(1)
op = unary.get(k)
if op:
self.do_unary_op(op)
if k in binary:
if self.number2 is not None:
if self.op:
self.do_binary_op(0)
else:
self.number1 = self.number2
self.clear_entry()
self.op = k
def do_unary_op(self, op):
if self.number2 is not None:
self.number2 = op(self.number2)
else:
self.number1 = op(self.number1)
def do_binary_op(self, i):
if self.op and self.number2 is not None:
op = binary[self.op][i]
self.op = None
self.number1 = op(self.number1, self.number2)
self.clear_entry()
def show(self):
rows = [""] * 4
trail = self.trail
if len(trail) > 0:
rows[2] = trail[-1]
if len(trail) > 1:
rows[1] = trail[-2]
if len(trail) > 2:
rows[0] = trail[-3]
entry_or_number = self.entry or self.number2
cursor = ' :' if (self.number2 is None or self.entry != "") else ""
op = self.op or ''
op = 'd' if op == '/' else op
rows[-1] = f"{op}{entry_or_number or ''}{cursor}"
for r in rows:
print(r)
text_area.text = "\n".join(rows)
from adafruit_hid.keyboard import Keyboard
gc.collect()
from adafruit_hid.keycode import Keycode
gc.collect()
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
gc.collect()
import board
import pulseio
import adafruit_dotstar
import adafruit_irremote
import time
# The keyboard object!
time.sleep(1) # Sleep for a bit to avoid a race condition on some systems
keyboard = Keyboard()
keyboard_layout = KeyboardLayoutUS(keyboard) # We're in the US :)
led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
decoder = adafruit_irremote.GenericDecode()
pulsein = pulseio.PulseIn(board.REMOTEIN, maxlen=100, idle_state=True)
# Expected pulse, pasted in from previous recording REPL session:
key1_pulses = [0]
key2_pulses = [1]
print('IR listener')
# Fuzzy pulse comparison function:
def fuzzy_pulse_compare(pulse1, pulse2, fuzzyness=0.2):
from adafruit_hid.keycode import Keycode
# A simple neat keyboard demo in CircuitPython
# The pins we'll use, each will have an internal pullup
keypress_pins = [board.A1, board.A2]
# Our array of key objects
key_pin_array = []
# The Keycode sent for each button, will be paired with a control key
keys_pressed = [Keycode.A, "Hello World!\n"]
control_key = Keycode.SHIFT
# The keyboard object!
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 :)
# Make all pin objects inputs with pullups
for pin in keypress_pins:
key_pin = digitalio.DigitalInOut(pin)
key_pin.direction = digitalio.Direction.INPUT
key_pin.pull = digitalio.Pull.UP
key_pin_array.append(key_pin)
# For most CircuitPython boards:
led = digitalio.DigitalInOut(board.D13)
# For QT Py M0:
# led = digitalio.DigitalInOut(board.SCK)
led.direction = digitalio.Direction.OUTPUT
print("Waiting for key pin...")
5: Keycode.SPACE,
6: Keycode.SHIFT}
https://learn.adafruit.com/vote-keyboard/software
import board
from digitalio import DigitalInOut, Direction, Pull
import adafruit_dotstar as dotstar
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
dot = dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1, brightness=0.2)
dot[0] = (0, 0, 0)
kbd = Keyboard()
kbdLayout = KeyboardLayoutUS(kbd)
state = []
pins = {}
buttonMap = [
dict(row="D4", col="D0", id=1),
dict(row="D4", col="D1", id=2),
dict(row="D4", col="D2", id=3),
dict(row="D3", col="D2", id=4),
dict(row="D3", col="D0", id=5),
dict(row="D3", col="D1", id=6)]
# Set up row pins
for pin in ["D4", "D3"]:
p = DigitalInOut(getattr(board, pin))
p.direction = Direction.OUTPUT
pins[pin] = p
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import time
import random
from adafruit_circuitplayground.express import cpx
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
keyboard = Keyboard()
layout = KeyboardLayoutUS(keyboard)
ROLL_THRESHOLD = 30 # Total acceleration
DICE_COLOR = (0xEA, 0x62, 0x92) # Dice digits color
DICE_MAXBRIGHTNESS = 6
# dictionary storing the NeoPixels to set for each face
dice_pixels = {
1 : (2,),
2 : (4, 9),
3 : (0, 4, 7),
4 : (1, 3, 6, 8),
5 : (0, 2, 4, 5, 9),
6 : (0, 2, 4, 5, 7, 9)
}
print("Secrets are kept in secrets.py, please add them there!")
raise
except KeyError:
print("TOTP info not found in secrets.py.")
raise
# set board to use PCF8523 as its RTC
pcf = adafruit_pcf8523.PCF8523(board.I2C())
rtc.set_time_source(pcf)
#-------------------------------------------------------------------------
# H I D S E T U P
#-------------------------------------------------------------------------
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 :)
#-------------------------------------------------------------------------
# D I S P L A Y S E T U P
#-------------------------------------------------------------------------
display = board.DISPLAY
# Secret Code font by Matthew Welch
# http://www.squaregear.net/fonts/
font = bitmap_font.load_font("/secrcode_28.bdf")
name = label.Label(terminalio.FONT, text="?"*18, color=0xFFFFFF)
name.anchor_point = (0.0, 0.0)
name.anchored_position = (0, 0)
code = label.Label(font, text="123456", color=0xFFFFFF)
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from digitalio import DigitalInOut, Direction
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
touch0 = touchio.TouchIn(board.A0)
touch1 = touchio.TouchIn(board.A1)
touch2 = touchio.TouchIn(board.A2)
# the keyboard object
# sleep for a bit to avoid a race condition on some systems
time.sleep(1)
kbd = Keyboard()
layout = KeyboardLayoutUS(kbd)
while True:
if touch0.value:
led.value = True
print("A0 touched!")
layout.write("?F3ErPs5.C.m.0.d.S.") # enter your own password here
time.sleep(1)
if touch1.value:
led.value = True
print("A1 touched!")
layout.write("6@LKNs(WV[vq6N") # enter your own password here
time.sleep(1)
if touch2.value:
from adafruit_displayio_layout.widgets.icon_widget import IconWidget from adafruit_featherwing import tft_featherwing_35 # seems to help the touchscreen not get stuck with chip not found time.sleep(3) # display and touchscreen initialization displayio.release_displays() tft_featherwing = tft_featherwing_35.TFTFeatherWing35() display = tft_featherwing.display touchscreen = tft_featherwing.touchscreen # HID setup kbd = Keyboard(usb_hid.devices) cc = ConsumerControl(usb_hid.devices) kbd_layout = KeyboardLayoutUS(kbd) # variables to envorce timout between icon presses COOLDOWN_TIME = 0.5 LAST_PRESS_TIME = -1 # 'mock' icon indexes for the layer buttons # used for debouncing PREV_LAYER_INDEX = -1 NEXT_LAYER_INDEX = -2 HOME_LAYER_INDEX = -3 # start on first layer current_layer = 0 # Make the main_group to hold everything
# neopixel.mpy
import board
import time
import usb_hid
import neopixel
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2)
time.sleep(1) # sleep for a bit to avoid a race condition on some systems
kbd = Keyboard(usb_hid.devices) # the keyboard object!
layout = KeyboardLayoutUS(kbd) # you're americans :)
num_lock = False # NUM LOCK
caps_lock = False # CAPS LOCK
scroll_lock = False # SCROLL LOCK
def update_lock():
global num_lock, caps_lock, scroll_lock
report = int.from_bytes(usb_hid.devices[0].last_received_report, "big")
num_lock = (report & 0x01) == 0x01 # NUM LOCK
caps_lock = (report & 0x02) == 0x02 # CAPS LOCK
scroll_lock = (report & 0x04) == 0x04 # SCROLL LOCK
update_lock()
"""programme 6-8-2 : saisie dans un tableur""" # importation des modules natifs utiles from time import * from board import * from digitalio import * # importation de modules supplémentaires from adafruit_lsm6ds import * import usb_hid from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS # Instanciation du clavier clavier = Keyboard(usb_hid.devices) layout = KeyboardLayoutUS(clavier) # Instanciation du bus de communication I2C sur le module Feather bus_i2c = I2C() # Instanciation de l'accéléromètre LSM6DS33 accelerometre = LSM6DS33(bus_i2c) # Instanciation de la LED interne et du bouton interne led = DigitalInOut(D13) led.direction = Direction.OUTPUT led.value = False bouton = DigitalInOut(SWITCH) bouton.pull = Pull.UP # Attente d'appui sur le bouton permettant à l'utilisateur de se placer # sur la feuille de son tableur while bouton.value:
esp.set_analog_write(27, 1)
#Print SSID of network and assigned address
print(
f"Connected to {secrets['SSID']}. IP Addr is {esp.pretty_ip(esp.ip_address)}"
)
#Get instructions from remote flask server.
instruction_URL = f"http://{secrets['server_ip']}:8000/download/{secrets['duckyname']}"
#Create request, and get text of response
instructions = requests.get(instruction_URL).text.split('\n')
print(instructions)
keyboard = Keyboard(usb_hid.devices)
keyboard_layout = KeyboardLayoutUS(keyboard)
#Parsing instructions.
for line in instructions:
if line[:6] == "STRING":
keyboard_layout.write(line[6:])
elif line[:3] == "WIN" or line[:5] == "SUPER":
keyboard.press(Keycode.GUI)
keyboard.release_all()
elif line[:5] == "ENTER":
keyboard.press(Keycode.ENTER)
keyboard.release_all()
elif line[:4] == "CTRL":
other_key = line[5:]
keyboard.press(Keycode.CONTROL)
keyboard_layout.write(other_key)
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
import adafruit_thermistor
# Switch to quickly enable/disable
# light level
# temperature
# Set the keyboard object!
# Sleep for a bit to avoid a race condition on some systems
time.sleep(1)
kbd = Keyboard()
layout = KeyboardLayoutUS(kbd) # US is only current option...
print("Time\tLight\tTemperature\tX\tY\tZ") # Print column headers
def slow_write(string): # Typing should not be too fast for
for c in string: # the computer to be able to accept
layout.write(c)
time.sleep(0.2) # use 1/5 second pause between characters
while True:
if cpx.switch: # If the slide switch is on, don't log
continue
# Turn on the LED to show we're logging
def keyboard_config(key_to_be_pressed):
kbd = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(kbd)
kbd.send(key_to_be_pressed)
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode
from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode
from digitalio import DigitalInOut, Direction, Pull
cs = DigitalInOut(board.GP17)
cs.direction = Direction.OUTPUT
cs.value = 0
num_pixels = 16
pixels = adafruit_dotstar.DotStar(board.GP18, board.GP19, num_pixels, brightness=0.1, auto_write=True)
i2c = busio.I2C(board.GP5, board.GP4)
device = I2CDevice(i2c, 0x20)
kbd = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(kbd)
def colourwheel(pos):
if pos < 0 or pos > 255:
return (0, 0, 0)
if pos < 85:
return (255 - pos * 3, pos * 3, 0)
if pos < 170:
pos -= 85
return (0, 255 - pos * 3, pos * 3)
pos -= 170
return (pos * 3, 0, 255 - pos * 3)
def read_button_states(x, y):
pressed = [0] * 16
with device:
device.write(bytes([0x0]))
result = bytearray(2)
led.value = False
# Configure buttons on Maker Pi Pico
btn1 = digitalio.DigitalInOut(board.GP20)
btn2 = digitalio.DigitalInOut(board.GP21)
btn3 = digitalio.DigitalInOut(board.GP22)
btn1.direction = digitalio.Direction.INPUT
btn2.direction = digitalio.Direction.INPUT
btn3.direction = digitalio.Direction.INPUT
btn1.pull = digitalio.Pull.UP
btn2.pull = digitalio.Pull.UP
btn3.pull = digitalio.Pull.UP
# Set up keyboard and mouse.
kbd = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(kbd)
mouse = Mouse(usb_hid.devices)
direction = True
while True:
# Test buttons on Maker Pi Pico
if not btn1.value:
# Debounce
time.sleep(0.3)
while not btn1.value:
pass
# Type 'abc' followed by newline.
layout.write('abc\n')
# Type numbers followed by newline.
layout.write('789\n')
# Type symbols followed by tab.
from digitalio import DigitalInOut, Direction, Pull
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode
switch = DigitalInOut(board.GP20)
switch.direction = Direction.INPUT
switch.pull = Pull.UP
switch2 = DigitalInOut(board.GP21)
switch2.direction = Direction.INPUT
switch2.pull = Pull.UP
keyboard = Keyboard(usb_hid.devices)
keyboard_layout = KeyboardLayoutUS(keyboard)
while True:
if not switch.value:
print('y')
keyboard.press(Keycode.LEFT_ALT, Keycode.F1)
keyboard.release_all()
if not switch2.value:
print('y')
keyboard.press(Keycode.LEFT_ALT, Keycode.F2)
keyboard.release_all()
print('---')
time.sleep(0.2)
from adafruit_hid.keycode import Keycode
from digitalio import DigitalInOut, Direction, Pull
# A simple neat keyboard demo in circuitpython
# The button pins we'll use, each will have an internal pulldown
buttonpins = [board.BUTTON_A, board.BUTTON_B]
# our array of button objects
buttons = []
# the keyboard object!
# sleep for a bit to avoid a race condition on some systems
time.sleep(1)
kbd = Keyboard()
# we're americans :)
layout = KeyboardLayoutUS(kbd)
sending = False
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
def init():
# make all pin objects, make them inputs w/pulldowns
for pin in buttonpins:
button = DigitalInOut(pin)
button.direction = Direction.INPUT
button.pull = Pull.DOWN
buttons.append(button)
print("Press A to start send key")
print("Press B to stop sending key")
# Use default HID descriptor
hid = HIDService()
device_info = DeviceInfoService(
software_revision=adafruit_ble.__version__, manufacturer="Adafruit Industries"
)
advertisement = ProvideServicesAdvertisement(hid)
advertisement.appearance = 961
scan_response = Advertisement()
ble = adafruit_ble.BLERadio()
if ble.connected:
for c in ble.connections:
c.disconnect()
print("advertising")
ble.start_advertising(advertisement, scan_response)
k = Keyboard(hid.devices)
kl = KeyboardLayoutUS(k)
while True:
while not ble.connected:
pass
print("Start typing:")
while ble.connected:
c = sys.stdin.read(1)
sys.stdout.write(c)
kl.write(c)
# print("sleeping")
time.sleep(0.1)
ble.start_advertising(advertisement)
class HidScript:
def __init__(self, debug=False):
self.debug = debug
#self.mouse = Mouse(usb_hid.devices)
self.keyboard = Keyboard(usb_hid.devices)
self.keyboard_layout = KeyboardLayoutUS(
self.keyboard) # Change for non-US
self.default_delay = 0
self.string_delay = 0
self.last_cmd = ""
self.last_arg = ""
# Keycode only has US mappings, not sure if AdaFruit has others
#
# TODO - consider a data structure which consumes less RAM for
# constrained platforms.
#
# Keep a separate structure for multi-key combos to lower memory
# usage.
#
self.tuple_keymap = {
"CTRL-ALT": (Keycode.CONTROL, Keycode.ALT),
"CTRL-SHIFT": (Keycode.CONTROL, Keycode.SHIFT),
"ALT-SHIFT": (Keycode.ALT, Keycode.SHIFT)
}
self.keymap = {
"ALT": Keycode.ALT,
"APP": Keycode.APPLICATION,
"BREAK": Keycode.PAUSE,
"CAPSLOCK": Keycode.CAPS_LOCK,
"CONTROL": Keycode.CONTROL,
"CTRL": Keycode.CONTROL,
"DELETE": Keycode.DELETE,
"DOWNARROW": Keycode.DOWN_ARROW,
"DOWN": Keycode.DOWN_ARROW,
"END": Keycode.END,
"ENTER": Keycode.ENTER,
"ESC": Keycode.ESCAPE,
"ESCAPE": Keycode.ESCAPE,
"GUI": Keycode.GUI,
"HOME": Keycode.HOME,
"INSERT": Keycode.INSERT,
"LEFTARROW": Keycode.LEFT_ARROW,
"LEFT": Keycode.LEFT_ARROW,
"MENU": Keycode.APPLICATION,
"NUMLOCK": Keycode.KEYPAD_NUMLOCK,
"PAGEUP": Keycode.PAGE_UP,
"PAGEDOWN": Keycode.PAGE_DOWN,
"PAUSE": Keycode.PAUSE,
"PRINTSCREEN": Keycode.PRINT_SCREEN,
"RIGHTARROW": Keycode.RIGHT_ARROW,
"RIGHT": Keycode.RIGHT_ARROW,
"SCROLLLOCK": Keycode.SCROLL_LOCK,
"SHIFT": Keycode.SHIFT,
"SPACE": Keycode.SPACE,
"TAB": Keycode.TAB,
"UPARROW": Keycode.UP_ARROW,
"UP": Keycode.UP_ARROW,
"WINDOWS": Keycode.WINDOWS,
"a": Keycode.A,
"A": Keycode.A,
"b": Keycode.B,
"B": Keycode.B,
"c": Keycode.C,
"C": Keycode.C,
"d": Keycode.D,
"D": Keycode.D,
"e": Keycode.E,
"E": Keycode.E,
"f": Keycode.F,
"F": Keycode.F,
"g": Keycode.G,
"G": Keycode.G,
"h": Keycode.H,
"H": Keycode.H,
"i": Keycode.I,
"I": Keycode.I,
"j": Keycode.J,
"J": Keycode.J,
"k": Keycode.K,
"K": Keycode.K,
"l": Keycode.L,
"L": Keycode.L,
"m": Keycode.M,
"M": Keycode.M,
"n": Keycode.N,
"N": Keycode.N,
"o": Keycode.O,
"O": Keycode.O,
"p": Keycode.P,
"P": Keycode.P,
"q": Keycode.Q,
"Q": Keycode.Q,
"r": Keycode.R,
"R": Keycode.R,
"s": Keycode.S,
"S": Keycode.S,
"t": Keycode.T,
"T": Keycode.T,
"u": Keycode.U,
"U": Keycode.U,
"v": Keycode.V,
"V": Keycode.V,
"w": Keycode.W,
"W": Keycode.W,
"x": Keycode.X,
"X": Keycode.X,
"y": Keycode.Y,
"Y": Keycode.Y,
"z": Keycode.Z,
"Z": Keycode.Z,
#
# The DuckyScript encoder didn't appear to have the following codes and
# probably used the STRING command to deal with some of them. Adding them shouldn't
# hurt but does consume RAM. Some are Mac specific.
#
"F1": Keycode.F1,
"F2": Keycode.F2,
"F3": Keycode.F3,
"F4": Keycode.F4,
"F5": Keycode.F5,
"F6": Keycode.F6,
"F7": Keycode.F7,
"F8": Keycode.F8,
"F9": Keycode.F9,
"F10": Keycode.F10,
"F11": Keycode.F11,
"F12": Keycode.F12,
"F13": Keycode.F13,
"F14": Keycode.F14,
"F15": Keycode.F15,
"F16": Keycode.F16,
"F17": Keycode.F17,
"F18": Keycode.F18,
"F19": Keycode.F19,
"BACKSLASH": Keycode.BACKSLASH,
"COMMA": Keycode.COMMA,
"COMMAND": Keycode.COMMAND,
"FORWARD_SLASH": Keycode.FORWARD_SLASH,
"GRAVE_ACCENT": Keycode.GRAVE_ACCENT,
"LEFT_BRACKET": Keycode.LEFT_BRACKET,
"OPTION": Keycode.ALT,
"PERIOD": Keycode.PERIOD,
"POUND": Keycode.POUND,
"QUOTE": Keycode.QUOTE
}
# Dropped the following to save memory (for now):
# "0": Keycode.ZERO, "1": Keycode.ONE,
# "2": Keycode.TWO, "3": Keycode.THREE,
# "4": Keycode.FOUR, "5": Keycode.FIVE,
# "6": Keycode.SIX, "7": Keycode.SEVEN,
# "8": Keycode.EIGHT, "9": Keycode.NINE,
# "RIGHT_ALT": Keycode.RIGHT_ALT,
# "RIGHT_BRACKET": Keycode.RIGHT_BRACKET,
# "RIGHT_CONTROL": Keycode.RIGHT_CONTROL,
# "RIGHT_GUI": Keycode.RIGHT_GUI,
# "RIGHT_SHIFT": Keycode.RIGHT_SHIFT,
# "SEMICOLON": Keycode.SEMICOLON,
# Execute a single command in a HidScript file
# REPEAT handled in process
#
def _exec_cmd(self, cmd, arg):
if cmd == "REM":
pass
elif cmd == "STRING":
if self.string_delay:
for c in arg:
self.keyboard_layout.write(c)
time.sleep(self.string_delay)
else:
self.keyboard_layout.write(arg)
elif cmd in self.keymap:
if arg and arg in self.keymap:
self.keyboard.send(self.keymap[cmd], self.keymap[arg])
else:
self.keyboard.send(self.keymap[cmd])
elif cmd in self.tuple_keymap:
for keycode in self.tuple_keymap[cmd]:
self.keyboard.press(keycode)
if arg and arg in self.keymap:
self.keyboard.send(self.keymap[arg])
else:
self.keyboard.release_all()
if cmd == "DELAY":
time.sleep(int(arg) / 100.0)
elif (cmd == "DEFAULTDELAY") or (cmd == "DEFAULT_DELAY"):
self.default_delay = int(arg) / 100.0
elif (cmd == "STRINGDELAY") or (cmd == "STRING_DELAY"):
self.string_delay = int(arg) / 1000.0
else:
time.sleep(self.default_delay)
# Process a HidScript file
#
def process(self, scriptname):
try:
with open(scriptname) as f:
for line in f:
# Eliminate leading or trailing whitespace
# TODO - does this break any STRING commands?
#
line = line.strip()
values = line.split(" ", 1)
if self.debug: print("Script line: ", line)
cmd = values[0]
if len(values) == 2:
arg = values[1]
else:
arg = ""
# Handle REPEAT command at this level, but all other commands
# are handled by _exec_cmd()
#
if cmd == "REPEAT":
arg = int(arg)
for i in range(arg):
self._exec_cmd(self.last_cmd, self.last_arg)
else:
self.last_cmd = cmd
self.last_arg = arg
self._exec_cmd(cmd, arg)
except OSError:
if self.debug: print("Could not read file: ", scriptname)
# SPDX-FileCopyrightText: 2018 Anne Barela for Adafruit Industries
#
# SPDX-License-Identifier: MIT
import usb_hid
from adafruit_circuitplayground.express import cpx
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
kbd = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(kbd)
while True:
if cpx.button_a:
# Type 'Jane Doe' followed by Enter (a newline).
layout.write('Jane Doe\n')
while cpx.button_a:
pass
manufacturer="Adafruit Industries")
advertisement = ProvideServicesAdvertisement(hid)
advertisement.appearance = 961
scan_response = Advertisement()
scan_response.complete_name = "CircuitPython HID"
ble = adafruit_ble.BLERadio()
if not ble.connected:
print("advertising")
ble.start_advertising(advertisement, scan_response)
else:
print("already connected")
print(ble.connections)
k = Keyboard(hid.devices)
kl = KeyboardLayoutUS(k)
while True:
while not ble.connected:
pass
print("Start typing:")
while ble.connected:
if not button_1.value: # pull up logic means button low when pressed
#print("back") # for debug in REPL
k.send(Keycode.BACKSPACE)
time.sleep(0.1)
if not button_2.value:
kl.write("Bluefruit") # use keyboard_layout for words
time.sleep(0.4)
