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)
btn = digitalio.DigitalInOut(board.SW1)
btn.direction = digitalio.Direction.INPUT
btn.pull = digitalio.Pull.UP
led_r = digitalio.DigitalInOut(board.LED2_R)
led_r.direction = digitalio.Direction.OUTPUT
led_g = digitalio.DigitalInOut(board.LED2_G)
led_g.direction = digitalio.Direction.OUTPUT
led_b = digitalio.DigitalInOut(board.LED2_B)
led_b.direction = digitalio.Direction.OUTPUT
led_r.value, led_g.value, led_b.value = True, True, True
# Set up a keyboard device.
kbd = Keyboard()
layout = KeyboardLayoutUS(kbd)
while True:
if not btn.value:
kbd.send(Keycode.GUI, Keycode.R)
led_g.value = False
time.sleep(0.5)
layout.write('notepad\n')
led_g.value = True
led_b.value = False
time.sleep(0.5)
led_b.value = True
layout.write('secret message')
led_r.value = False
time.sleep(3)
led_r.value = True
# 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)
b = result[0] | result[1] << 8
for i in range(x, y):
if not (1 << i) & b:
pressed[i] = 1
else:
pressed[i] = 0
return pressed
held = [0] * 16
while True:
pressed = read_button_states(0, 16)
if pressed[0]:
pixels[0] = colourwheel(0 * 16) # Map pixel index to 0-255 range
if not held[0]:
layout.write("volu")
kbd.send(Keycode.ENTER)
#held[0] = 1
elif pressed[1]:
pixels[1] = colourwheel(1 * 16) # Map pixel index to 0-255 range
if not held[1]:
layout.write("mpc next")
kbd.send(Keycode.ENTER)
held[1] = 1
elif pressed[2]:
pixels[2] = colourwheel(2 * 16) # Map pixel index to 0-255 range
if not held[2]:
)
#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)
keyboard_layout.release_all()
elif line[:4] == "WAIT":
time.sleep(float(line[4:]))
#set up RGB led to be Blue, now that all instructions have been carried out
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)
# 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.
layout.write('!?_*\t')
# Type lowercase 'x'.
kbd.send(Keycode.X)
# Type capital 'Y'.
kbd.send(Keycode.SHIFT, Keycode.Y)
if not btn2.value:
# Debounce
time.sleep(0.3)
while not btn2.value:
pass
# Toggle mouse wheel up/down by one unit
progress_bar.value = now % 30
event = keys.events.get()
# wakeup if knob turned or button pressed
if knob.position != knob_pos or event:
if not awake:
last_update = 0 # force an update
awake = True
knob_pos = knob.position
wake_up_time = now
# handle key presses
if event:
if event.pressed:
key_pressed = event.key_number
# knob
if key_pressed == 12:
keyboard_layout.write(totp_codes[current_key])
keyboard.send(Keycode.ENTER)
# keeb
elif key_pressed != current_key:
# is it a configured key?
if totp_keys[key_pressed]:
current_key = key_pressed
pixels.fill(0)
last_update = 0 # force an update
# update codes
if progress_bar.value < 0.5 and now - last_compute > 2:
totp_codes = compute_codes(timebase(now))
last_compute = now
# update display
if now - last_update > DISPLAY_RATE and awake:
pixels[current_key] = totp_keys[current_key][2]
buttonpins = [board.BUTTON_A, board.BUTTON_B]
buttons = []
buttonkeys = [Keycode.LEFT_ARROW, Keycode.RIGHT_ARROW]
controlkey = Keycode.SHIFT
time.sleep(1)
kbd = Keyboard()
layout = KeyboardLayoutUS(kbd)
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:
for button in buttons:
if button.value:
print('Button #%d Pressed' % i)
i = buttons.index(button)
led.value = True
k = buttonkeys[i]
layout.write(k) if type(k) is str else kbd.press(controlkey, k)
led.value = False
_hy_anon_var_1 = None
else:
i = buttons.index(button)
k = buttonkeys[i]
_hy_anon_var_1 = kbd.release(controlkey, k)
class Impl:
def __init__(self):
# incoming keypad
self.keypad = MatrixKeypad(row_pins, col_pins, layers)
# outgoing keypresses
self.keyboard = None
self.keyboard_layout = None
g = displayio.Group(max_size=7)
self.labels = labels = []
labels.append(Label(terminalio.FONT, max_glyphs=32, scale=2, color=0))
labels.append(Label(terminalio.FONT, max_glyphs=32, scale=3, color=0))
labels.append(Label(terminalio.FONT, max_glyphs=32, scale=3, color=0))
labels.append(Label(terminalio.FONT, max_glyphs=32, scale=3, color=0))
labels.append(Label(terminalio.FONT, max_glyphs=32, scale=3, color=0))
labels.append(Label(terminalio.FONT, max_glyphs=32, scale=3, color=0))
for li in labels:
g.append(li)
bitmap = displayio.Bitmap((display.width + 126) // 127,
(display.height + 126) // 127, 1)
palette = displayio.Palette(1)
palette[0] = 0xffffff
tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette)
bg = displayio.Group(scale=127)
bg.append(tile_grid)
g.insert(0, bg)
display.show(g)
def getch(self):
while True:
time.sleep(.02)
c = self.keypad.getch()
if c is not None:
return c
def setline(self, i, text):
li = self.labels[i]
text = text[:31] or " "
if text == li.text:
return
li.text = text
li.anchor_point = (0, 0)
li.anchored_position = (1, max(1, 41 * i - 7) + 6)
def refresh(self):
pass
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 start_redraw(self):
display.auto_refresh = False
def end_redraw(self):
display.auto_refresh = True
def end(self):
pass
'KEYPAD_BACKSLASH': Keycode.KEYPAD_BACKSLASH,
'APPLICATION': Keycode.APPLICATION,
'POWER': Keycode.POWER
}
setter = 0
timer = 0
cpx.pixels.brightness = 0.01
cpx.pixels.fill((255, 0, 0))
#print(lines)
while True:
if cpx.button_a:
for line in lines:
line = line.split()
print(line)
if line[0] == "STRING":
layout.write(' '.join(line[1:]))
setter = 1
if line[0] == "DELAY":
sleep(int(line[1]))
timer = 1
if not setter and not timer:
for l in line:
kbd.press(command_dispatcher[l])
print("Done")
for l in line:
kbd.release(command_dispatcher[l])
print("------")
setter = 0
from adafruit_circuitplayground.express import cpx
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
kbd = Keyboard()
layout = KeyboardLayoutUS(kbd)
while True:
if cpx.button_a:
# Type 'abc' followed by Enter (a newline).
layout.write('\noof\n')
while cpx.button_a:
pass
)
tg.flip_y = True
g1.append(tg)
g = displayio.Group()
g.append(g1)
g.append(label)
display.show(g)
display.auto_refresh = False
i = 0
spin = ".oOo"
old_payload = None
while True:
cam.capture(bitmap)
for row in qrdecoder.decode(bitmap, qrio.PixelPolicy.EVEN_BYTES):
payload = row.payload
try:
payload = payload.decode("utf-8")
except UnicodeError:
payload = str(payload)
if payload != old_payload:
label.text = payload
keyboard_layout.write(payload)
old_payload = payload
# Clear out the odd bytes, so that the bitmap displays as greyscale
view[1::2] = 0
bitmap.dirty()
display.refresh(minimum_frames_per_second=0)
keys[k].set_led(*colours[current_layer])
# Loop through all of the keys in the layer and if they're pressed, get the
# key code from the layer's key map
for k in layers[current_layer].keys():
if keys[k].pressed:
key_press = layers[current_layer][k]
# If the key hasn't just fired (prevents refiring)
if not fired:
fired = True
# Send the right sort of key press and set debounce for each
# layer accordingly (layer 2 needs a long debounce)
if (
(current_layer == 1) |
(current_layer == 4)
):
debounce = short_debounce
keyboard.send(key_press)
elif current_layer == 2:
debounce = long_debounce
layout.write(key_press)
elif current_layer == 3:
debounce = short_debounce
consumer_control.send(key_press)
# If enough time has passed, reset the fired variable
if fired and time.monotonic() - keybow.time_of_last_press > debounce:
fired = False
hid = HIDService(HID_DESCRIPTOR)
device_info = DeviceInfoService(software_revision=adafruit_ble.__version__,
manufacturer="Adafruit Industries")
print(device_info.manufacturer)
advertisement = ProvideServicesAdvertisement(hid)
advertisement.appearance = 961
ble = adafruit_ble.BLERadio()
print(to_hex(bytes(advertisement)))
if not ble.connected:
print("advertising")
ble.start_advertising(advertisement)
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:
# c = sys.stdin.read(1)
# sys.stdout.write(c)
#kl.write(c)
kl.write("h")
# print("sleeping")
time.sleep(0.1)
ble.start_advertising(advertisement)
# tuple means it's a single action
if isinstance(_cur_actions, tuple):
# put it in a list by itself
_cur_actions = [_cur_actions]
# loop over the actions
for _action in _cur_actions:
# HID keyboard keys
if _action[0] == KEY:
kbd.press(*_action[1])
kbd.release(*_action[1])
# String to write from layout
elif _action[0] == STRING:
kbd_layout.write(_action[1])
# Consumer control code
elif _action[0] == MEDIA:
cc.send(_action[1])
# Key press
elif _action[0] == KEY_PRESS:
kbd.press(*_action[1])
# Key release
elif _action[0] == KEY_RELEASE:
kbd.release(*_action[1])
# if there are multiple actions
if len(_cur_actions) > 1:
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:
led.value = True
print("A2 touched!")
layout.write("3Ff0rT@9j2y&") # enter your own password here
time.sleep(1)
time.sleep(0.01)
elif OS == MAC:
kbd.send(Keycode.ALT, Keycode.M)
elif OS == LINUX:
kbd.press(Keycode.CONTROL, Keycode.SHIFT)
kbd.press(Keycode.U)
kbd.release_all()
kbd.send(Keycode.ZERO)
kbd.send(Keycode.THREE)
kbd.send(Keycode.B)
kbd.send(Keycode.C)
kbd.send(Keycode.ENTER)
if caps[2]:
if ENABLE_KEYBOARD:
if OS == WINDOWS:
type_alt_code(227)
elif OS == MAC:
kbd.send(Keycode.ALT, Keycode.P)
elif OS == LINUX:
kbd.press(Keycode.CONTROL, Keycode.SHIFT)
kbd.press(Keycode.U)
kbd.release_all()
kbd.send(Keycode.ZERO)
kbd.send(Keycode.THREE)
kbd.send(Keycode.C)
kbd.send(Keycode.ZERO)
kbd.send(Keycode.ENTER)
if caps[3]:
if ENABLE_KEYBOARD:
layout.write('https://www.digikey.com/python\n')
time.sleep(0.1)
## elif isinstance(color, int):
## # pull apart rgb values in int, adjust, then re-assemble
## r = (color >> 16) & 0xff
## g = (color >> 8) & 0xFF
## b = color & 0xfF
## rgblist = adjust_color([r, g, b])
## return (rgblist[0] << 16) + (rgblist[1] << 8) + rgblist[2]
## else:
## raise ValueError("Unexpected color type: " + type(color))
# Loop forever
while True:
# If left button pressed and die has been rolled at least once
# then type the total score and press enter and zero total
if cpx.button_a and roll_total > 0:
layout.write(str(roll_total) + '\n')
roll_total = 0
# If right button pressed the decrease brightness
# wrap around at 0 to original maximum value
if cpx.button_b:
if dice_brightness == 0:
dice_brightness = DICE_MAXBRIGHTNESS
else:
dice_brightness -= 1
cpx.pixels.brightness = 1 / (2**(DICE_MAXBRIGHTNESS - dice_brightness))
##dice_color = adjust_color(dice_color,
## 1 / (2**(DICE_MAXBRIGHTNESS - dice_brightness)))
##show_die(cpx.pixels, roll_number, dice_color)
# wait for use to take finger off button
while cpx.button_b:
if mac:
leftCtrl = Keycode.LEFT_GUI
else:
leftCtrl = Keycode.LEFT_CONTROL
sleep(1)
keyboard = Keyboard()
layout = KeyboardLayoutUS(keyboard)
sleep(0.500)
if windows:
keyboard.press(Keycode.LEFT_GUI, Keycode.R)
sleep(0.01)
keyboard.release_all()
sleep(0.200)
layout.write("cmd\n")
sleep(0.100)
elif mac:
keyboard.press(Keycode.LEFT_GUI)
layout.write(" ")
sleep(0.1)
keyboard.release_all()
layout.write("terminal")
sleep(0.5)
keyboard.press(Keycode.RETURN)
sleep(0.1)
keyboard.release_all()
sleep(0.5)
else:
keyboard.press(leftCtrl)
layout.write("t")
# 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
pw_subdir = unlock_code + '/' selected_keynum = 0 default_pixels = num_to_neo[selected_keynum % 16] if unlock_code: unlock_failures = 0 else: default_color = color_unlock_mode default_pixels = [0,3] unlock_code = "" set_neo(pixels, default_pixels, default_color, True) unlock_entry_mode = unlock_entry_mode ^ True elif t1: if unlock_entry_mode: unlock_code = unlock_code + '1' else: if selected_keynum == 9999: selected_keynum = 0 elif obj_exists(data_dir + pw_subdir + (zero_pads + str(selected_keynum + 1))[-4:] + '.txt'): selected_keynum += 1 else: selected_keynum = 0 default_pixels = num_to_neo[selected_keynum % 16] set_neo(pixels, default_pixels, color_keynum, True) elif t2: if unlock_entry_mode: unlock_code = unlock_code + '2' else: target_string = load_raw_keyfile(data_dir + pw_subdir, (zero_pads + str(selected_keynum))[-4:] + '.txt') if target_string: keyboard_layout.write(target_string)
print("Waiting for button presses")
while True:
# check each button
# when pressed, the LED will light up,
# when released, the keycode or string will be sent
# this prevents rapid-fire repeats!
for button in buttons:
if button.value: # pressed?
i = buttons.index(button)
print("Button #%d Pressed" % i)
# turn on the LED
led.value = True
while button.value:
pass # wait for it to be released!
# type the keycode or string
k = buttonkeys[i] # get the corresp. keycode/str
if type(k) is str:
layout.write(k)
else:
kbd.press(controlkey, k) # press...
kbd.release_all() # release!
# turn off the LED
led.value = False
time.sleep(0.01)
while ble.connected or not ble_enabled.value:
if not central.value:
led.value = True
print("Running")
while True:
i = random.randint(0, upper)
if not buttons[i].value:
break
audio.play(wave)
if i == 0:
print("Button 1")
pixels.fill((0, 0, 255))
if ble_enabled.value:
kl.write("Button 1")
elif i == 1:
print("Button 2")
pixels.fill((0, 255, 0))
if ble_enabled.value:
kl.write("Button 2")
elif i == 2:
print("Button 3")
pixels.fill((255, 255, 255))
if ble_enabled.value:
kl.write("Button 3")
if not ble_enabled.value:
print(
"BLE HID has been disabled, slide the slide switch to the left to re-enable"
)
# For QT Py M0:
# led = digitalio.DigitalInOut(board.SCK)
led.direction = digitalio.Direction.OUTPUT
print("Waiting for key pin...")
while True:
# Check each pin
for key_pin in key_pin_array:
if not key_pin.value: # Is it grounded?
i = key_pin_array.index(key_pin)
print("Pin #%d is grounded." % i)
# Turn on the red LED
led.value = True
while not key_pin.value:
pass # Wait for it to be ungrounded!
# "Type" the Keycode or string
key = keys_pressed[i] # Get the corresponding Keycode or string
if isinstance(key, str): # If it's a string...
keyboard_layout.write(key) # ...Print the string
else: # If it's not a string...
keyboard.press(control_key, key) # "Press"...
keyboard.release_all() # ..."Release"!
# Turn off the red LED
led.value = False
time.sleep(0.01)
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)
if not button_3.value:
k.send(Keycode.SHIFT, Keycode.L) # add shift modifier
time.sleep(0.4)
if not button_4.value:
kl.write("e")
time.sleep(0.4)
if not button_5.value:
k.send(Keycode.ENTER)
time.sleep(0.4)
ble.start_advertising(advertisement)
if len(pulse1) != len(pulse2):
return False
for i in range(len(pulse1)):
threshold = int(pulse1[i] * fuzzyness)
if abs(pulse1[i] - pulse2[i]) > threshold:
return False
return True
# Create pulse input and IR decoder.
pulsein.clear()
pulsein.resume()
# Loop waiting to receive pulses.
while True:
led[0] = (0, 0, 0) # LED off
# Wait for a pulse to be detected.
pulses = decoder.read_pulses(pulsein)
led[0] = (0, 0, 100) # flash blue
print("\tHeard", len(pulses), "Pulses:", pulses)
# Got a pulse set, now compare.
if fuzzy_pulse_compare(key1_pulses, pulses):
print("****** KEY 1 DETECTED! ******")
keyboard.press(Keycode.SPACE)
keyboard.release_all()
if fuzzy_pulse_compare(key2_pulses, pulses):
print("****** KEY 2 DETECTED! ******")
keyboard_layout.write("hello!")
while scroll_lock:
update_lock()
time.sleep(0.1)
print("Meeting starting")
start = time.monotonic() # Press reset on your board to reset the time
previous_scroll_lock = False
while True:
update_lock()
pixel.fill((0xFF if num_lock else 0x0, 0xFF if caps_lock else 0x0,
0xFF if scroll_lock else 0x0)) # Create a color
if scroll_lock != previous_scroll_lock:
now = time.monotonic()
current = now - start
hours = int((current / 3600))
minutes = int((current / 60) % 60)
seconds = int(current % 60)
if hours == 0:
string = "{minutes:02d}:{seconds:02d} ".format(minutes=minutes,
seconds=seconds)
else:
string = "{hours}:{minutes:02d}:{seconds:02d} ".format(
hours=hours, minutes=minutes, seconds=seconds)
print("Sending : ", string)
layout.write(string)
previous_scroll_lock = scroll_lock
time.sleep(0.1)
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
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
# I/O
pin_ready = digitalio.DigitalInOut(board.D3)
pin_ready.direction = digitalio.Direction.INPUT
pin_ready.pull = digitalio.Pull.UP
meter = mitutoyo.Digimatic(req=board.D0, clock=board.D1, data=board.D2)
# USB HID keyboard emulation.
time.sleep(1)
kbd = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(kbd)
print("Ready.")
while True:
# wait until ready goes low
while pin_ready.value:
time.sleep(0.1)
reading = meter.read()
if reading:
print("Typing %s." % reading)
layout.write(str(reading) + "\n")
# wait until ready goes up again to just get a single reading per press
while not pin_ready.value:
time.sleep(0.1)
