kbd = Keyboard(usb_hid.devices) layout = KeyboardLayoutUS(kbd) pix = cpx.pixels pix.brightness = 0.4 while True: x, y, z = cpx.acceleration for i in range(10): #print(int(x),int(y),int(z)) pix[i] = (abs(int(x)) * 10 % 255, abs(int(y)) * 10 % 255, abs(int(z)) * 10 % 255) if cpx.switch: continue if x > 3: kbd.press(Keycode.LEFT_ARROW) sleep(0.2) kbd.release(Keycode.LEFT_ARROW) if x < -3: kbd.press(Keycode.RIGHT_ARROW) sleep(0.2) kbd.release(Keycode.RIGHT_ARROW) if y > 3: kbd.press(Keycode.UP_ARROW) print("up") #sleep(0.2) #kbd.release(Keycode.UP_ARROW) if y < -4: kbd.release(Keycode.UP_ARROW) kbd.press(Keycode.DOWN_ARROW)
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 isinstance(k, 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)
led2.value = False led3.value = False led4.value = False led5.value = False led6.value = False led7.value = False led8.value = False led9.value = False led10.value = False led11.value = False led12.value = True else: pass if not btn1.value: keyboard.press(key_Ctrl, key_Keypad1) time.sleep(0.1) keyboard.release(key_Ctrl, key_Keypad1) selectedInput = 1 elif not btn2.value: keyboard.press(key_Ctrl, key_Keypad2) time.sleep(0.1) keyboard.release(key_Ctrl, key_Keypad2) selectedInput = 2 elif not btn3.value: keyboard.press(key_Ctrl, key_Keypad3) time.sleep(0.1) keyboard.release(key_Ctrl, key_Keypad3) selectedInput = 3 elif not btn4.value: keyboard.press(key_Ctrl, key_Keypad4)
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 switch.value: # If the slide switch is off, don't log continue # Turn on the LED to show we're logging led.value = True temp = thermistor.temperature # In Celsius # if you want Fahrenheit, uncomment the line below # temp = temp * 9 / 5 + 32 # Format data into value 'obj_output' obj_output = "{},{},{}".format(time.time(), light.value, temp) slow_write(obj_output + "\n") # print to csv file kbd.press(Keycode.DOWN_ARROW) # Code to go to next row time.sleep(0.01) kbd.release_all() for _ in range(3): time.sleep(0.015) kbd.release_all() time.sleep(0.025) # Wait a bit more for Google Sheets led.value = False # Change 0.1 to whatever time you need between readings time.sleep(1.0)
initial_timeout = 0.02 letter_timeout = 0.2 timeout = initial_timeout while True: # Check each pin for key_pin in key_pin_array: i = key_pin_array.index(key_pin) key = keys_pressed[i] # Get the corresponding Keycode if not key_state_array[key] and not key_pin.value: # Is it grounded? # Register key as pressed key_state_array[key] = True if key_state_array[key] and key_pin.value: # Register key as unpressed key_state_array[key] = False # For each of the keys, if it's pressed, then actually press the key for key, value in key_state_array.items(): if value: keyboard.press(key) if key != Keycode.CONTROL: timeout = letter_timeout # Release all keys keyboard.release_all() time.sleep(timeout) timeout = initial_timeout
last_press = time.monotonic() snore_count = -1 while True: pressed = set(trellis.pressed_keys) now = time.monotonic() sleep_time = now - last_press sleeping = sleep_time > TIMEOUT for down in pressed - current_press: if down in keymap and not sleeping: print("down", down) # Lower the brightness so that we don't draw too much current when we turn all of # the LEDs on. trellis.pixels.brightness = 0.2 trellis.pixels.fill(keymap[down][0]) if keymap[down][1] == KEY: kbd.press(*keymap[down][2]) else: cc.send(keymap[down][2]) # else if the entry starts with 'l' for layout.write last_press = now for up in current_press - pressed: if up in keymap: print("up", up) if keymap[up][1] == KEY: kbd.release(*keymap[up][2]) # Reset the LEDs when there was something previously pressed (current_press) but nothing now # (pressed). if not pressed and current_press: trellis.pixels.brightness = 1 trellis.pixels.fill((0, 0, 0))
if mode_counter > (len(keys_pressed) - 1): mode_counter = 0 print("mode counter: %d" % mode_counter) # 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 print(i) key = keys_pressed[mode_counter][i] print(key) keyboard.press(key) # "Press"... keyboard.release_all() # ..."Release"! # Turn off the red LED led.value = False pixels.fill(mode_color[mode_counter]) pixels.show() time.sleep(0.1)
mode = '' for num in range(len(keys) - 1): if keys[num] == '': keys.pop(num) for i in range(3): if keys[i] == '#clicking': mode = 'click' elif keys[i] == '#typing': print(keys) for string in keys: strsplit = string.split(' ') if strsplit[0] == 'type': typestring = strsplit[1].upper() for key in typestring: try: keyboard.press(keycodes[key]) sleep(0.05) keyboard.release(keycodes[key]) except: print('Unknown Keycode') elif strsplit[0] == 'delay': sleep(int(strsplit[1]) * 0.1) elif strsplit[0] == 'press': keyboard.press(keycodes[strsplit[1]]) elif strsplit[0] == 'release': keyboard.release(keycodes[strsplit[1]]) elif strsplit[0] == '#': None else: for key in strsplit: if mode == 'click':
""" from adafruit_circuitplayground.express import cpx from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS from time import sleep kbd = Keyboard() layout = KeyboardLayoutUS(kbd) trigger = 0 mode = 0 while True: mode = cpx.switch if cpx.button_a: trigger = 1 if cpx.button_b: trigger = 0 if trigger == 1: if mode == False: kbd.press(Keycode.CONTROL, Keycode.V) kbd.release(Keycode.CONTROL, Keycode.V) kbd.press(Keycode.RETURN) kbd.release(Keycode.RETURN) if mode == True: kbd.press(Keycode.CONTROL, Keycode.V) kbd.release(Keycode.CONTROL, Keycode.V) sleep(0.01)
led = digitalio.DigitalInOut(board.D13) led.switch_to_output() print("Waiting for button presses") while True: # check each button for button in buttons: if not button.value: # pressed? i = buttons.index(button) leds[i].value = True print("Button #%d Pressed" % i) # turn on the LED led.value = True while not button.value: pass # wait for it to be released! # type the keycode! k = buttonkeys[i] # get the corresp. keycode kbd.press(controlkey, k) kbd.release_all() # turn off the LED led.value = False leds[i].value = False time.sleep(0.01)
""" pin = [board.GP8, board.GP7, board.GP9, board.GP4] key = [Keycode.ONE, Keycode.TWO, Keycode.GRAVE_ACCENT, Keycode.ESCAPE] """ all_key = list(map(lambda x: set_button(x), pin)) last_value = list(map(lambda x: x.value, all_key)) """ import time loop_test = 10000 start = time.time() x = 0 while x < loop_test: #second test x = x + 1 for i, button in enumerate(all_key): if last_value[i] != button.value: last_value[i] = button.value if not button.value: usb_keyboard.press(key[i]) else: usb_keyboard.release(key[i]) print("Loop frequency : {}".format(str(loop_test / (time.time() - start)))) """ while True: for i, button in enumerate(all_key): if last_value[i] != button.value: last_value[i] = button.value if button.value: usb_keyboard.release(key[i]) else: usb_keyboard.press(key[i])
last_press = time.monotonic() snore_count = -1 while True: pressed = set(trellis.pressed_keys) now = time.monotonic() sleep_time = now - last_press sleeping = sleep_time > TIMEOUT for down in pressed - current_press: if down in keymap and not sleeping: print("down", down) # Lower the brightness so that we don't draw too much current when we turn all of # the LEDs on. trellis.pixels.brightness = 0.2 trellis.pixels.fill(keymap[down][0]) if keymap[down][1] == KEY: kbd.press(*keymap[down][2]) if type(keymap[down][2]) == tuple else kbd.press(keymap[down][2]) else: cc.send(keymap[down][2]) # else if the entry starts with 'l' for layout.write last_press = now for up in current_press - pressed: if up in keymap: print("up", up) if keymap[up][1] == KEY: if type(keymap[down][2]) == tuple: kbd.release(*keymap[down][2]) else: kbd.release(keymap[down][2]) # Reset the LEDs when there was something previously pressed (current_press) but nothing now # (pressed).
x_axis = analogio.AnalogIn(board.A0) y_axis = analogio.AnalogIn(board.A1) def get_voltage(pin): return (pin.value * 3.3) / 65535 # ADC 12-bits [0 - 3.3] while True: x = get_voltage(x_axis) y = get_voltage(y_axis) #print(f"x={x:.4f} | y={y:.4f}") if x < 0.3: keyboard.press(Keycode.LEFT_ARROW) time.sleep(0.1) keyboard.release(Keycode.LEFT_ARROW) elif x > 3.0: keyboard.press(Keycode.RIGHT_ARROW) time.sleep(0.1) keyboard.release(Keycode.RIGHT_ARROW) elif y < 0.3: keyboard.press(Keycode.DOWN_ARROW) time.sleep(0.1) keyboard.release(Keycode.DOWN_ARROW) elif y > 3.0: keyboard.press(Keycode.UP_ARROW)
time.sleep(0.006) clk.value = False time.sleep(0.006) clk.direction = Direction.INPUT kbd = Keyboard() pulses = pulseio.PulseIn(board.D3, maxlen=12, idle_state=True) pulses.resume() while True: if not clk.value: time.sleep(0.005) pulses.pause() a = tuple([int(pulses[pulse] / 80) for pulse in range(1, len(pulses))]) if not a: pass elif a in mapping.modifiers: #if we pressed a modifer, well press it kbd.press(mapping.modifiers[a]) elif a[0] in (17, 24) and a[2:] in mapping.modifiers: #the first part of the tuple is always 17 or 24 for releases #so if we released a modifer, release it kbd.release(mapping.modifiers[a[2:]]) elif a in mapping.keys: kbd.press(mapping.keys[a]) kbd.release(mapping.keys[a]) else: print(a) pulses.clear() pulses.resume()
# if i ==0: # continue # if i>6: # break # txt += row[0] valid = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm .0987654321" with open('tweet.csv', 'r', encoding="utf8") as f: results = [] for i, line in enumerate(f): if i == 0: continue if i > 6: break words = line.split(',') txt += words[0][:-1] for i in txt: if i in valid: txt2 += i # print(results) try: layout.write(txt2) kbd.press(Keycode.RETURN) kbd.release(Keycode.RETURN) except: kbd.press(Keycode.RETURN) kbd.release(Keycode.RETURN) if cp.button_b: kbd.press(Keycode.GRAVE_ACCENT) kbd.release(Keycode.GRAVE_ACCENT)
import board import digitalio import time from adafruit_hid.keyboard import Keyboard from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS from adafruit_hid.keycode import Keycode led = digitalio.DigitalInOut(board.A3) led.direction = digitalio.Direction.OUTPUT switch = digitalio.DigitalInOut(board.D2) switch.direction = digitalio.Direction.INPUT switch.pull = digitalio.Pull.UP time.sleep(1) # Sleep for a bit to avoid a race condition on some systems keyboard = Keyboard() keyboard_layout = KeyboardLayoutUS(keyboard) led.value = True while True: time.sleep(0.5) if not switch.value: led.value = False keyboard.press(Keycode.F5) keyboard.release_all() print("Switch is on!") time.sleep(1) else: led.value = True print("Switch is off!")
from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode hid = HIDService() advertisement = ProvideServicesAdvertisement(hid) advertisement.complete_name = 'CIRCUITPY KEYBOARD' advertisement.appearance = 961 ble = adafruit_ble.BLERadio() if ble.connected: for c in ble.connections: c.disconnect() ble.start_advertising(advertisement) advertising = True ble_keyboard = Keyboard(hid.devices) button = digitalio.DigitalInOut(board.USR_BTN) button.direction = digitalio.Direction.INPUT button.pull = digitalio.Pull.UP last_value = button.value while True: if last_value != button.value: last_value = button.value print('Button is ' + ('released' if button.value else 'pressed')) if ble.connected: if not button.value: ble_keyboard.press(Keycode.A) else: ble_keyboard.release(Keycode.A)
mouse.move(0, 0, 1) time.sleep(0.01) elif diff < 0: for i in range(-diff): mouse.move(0, 0, -1) time.sleep(0.01) while True: diff = last_encoder_val - encoder.position # encoder clicks since last read last_encoder_val = encoder.position ring_pos = (ring_pos + diff) % len(ring) # position on LED ring hue = colorwheel(encoder.position * 4 % 255) # fun hue change based on pos if not button.value: # button pressed keyboard.press(Keycode.LEFT_SHIFT) scroll(diff) keyboard.release(Keycode.LEFT_SHIFT) for i in range(len(ring)): # spin the rainbow while held pixel_index = (i * 256 // len(ring)) + rainbow_pos ring[i] = colorwheel(pixel_index & 255) ring.show() rainbow_pos = (rainbow_pos + 1) % 256 else: scroll(diff) ring.fill([int(i / 4) for i in hue]) # make it 1/4 dimmer ring[ring_pos] = (255, 255, 255) ring[(ring_pos - 1) % len(ring)] = (67, 67, 67) ring[(ring_pos + 1) % len(ring)] = (67, 67, 67) ring.show()
# 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)
# https://hridaybarot.home.blog/2021/01/31/using-raspberry-pi-pico-has-hid-device-to-control-mouse-and-keyboard/ # # Download or clone this repo: # https://github.com/adafruit/Adafruit_CircuitPython_HID # # In there, there is a folder called adafruit_hid , # copy that folder to the Pico where CircuitPython is already installed. import time import usb_hid from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode key_A = Keycode.A key_Shift = Keycode.SHIFT keyboard = Keyboard(usb_hid.devices) time.sleep(2) print("Sending keys now...") keyboard.press(key_Shift, key_A) keyboard.release(key_Shift, key_A)
# else: # if not button2.value: # #print("Button 2 pressed!") # # channel.write(["", "bproc", "./test.sh"]) # channel.write(["dbput", "dbput", "TESTING", "FROMPORTAL"]) # channel.write(["dbput", "dbput", "TESTING", "TIME:" + str(time.time())]) # button2_pressed = True if mcp is not None: for i in range(pin_count): value = pins[i].value if value != pin_states[i]: # print("Pin " + str(i) + " is " + str(value)) pin_states[i] = value if not value: kbd.press(*pin_keys[i]) else: kbd.release(*pin_keys[i]) point = touch.touch_point if point: # Touch point needs to be rotated, flipped vertically, and halved point = (point[1] // 2), ((480 - point[0]) // 2) for button in buttons: if button.contains(point): button.selected = True elif button.selected: button.selected = False had_point = True elif had_point: for button in buttons:
# has the state changed? if touching and not touch2.value: # we just stopped touching it # read how long it was touched print("touched for", i) if i < threshold: letter_buffer.append('.') else: letter_buffer.append('-') touching = False i = 0 if not touching and touch2.value: # we just started touching it # read how long we were silent print("absent for", i) touching = True i = 0 if not touching and not touch2.value: if i > threshold and letter_buffer: letter = "".join(letter_buffer) letter_buffer = [] print("read", letter) key = morse_code_dict.get(letter) if key: kbd.press(key) kbd.release_all() led.value = touch2.value
btn2.direction = digitalio.Direction.INPUT keyboard = Keyboard(usb_hid.devices) while True: print(btn1.value, btn2.value) keys = [ (btn1, Keycode.A), (btn2, Keycode.B) ] key_press_flags = [ False, False, ] for i, (btn, keycode) in enumerate(keys): if not btn.value: #Press keyboard.press(keycode) key_press_flags[i] = True led.value = True time.sleep(0.5) for i, (btn, keycode) in enumerate(keys): if key_press_flags[i]: keyboard.release(keycode) led.value = False time.sleep(0.1)
# get actions for this icon from config object _cur_actions = touch_deck_config["layers"][ current_layer]["shortcuts"][index][ "actions"] # 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
zoom_mute = digitalio.DigitalInOut(board.GP10 ) zoom_mute.switch_to_input(pull=digitalio.Pull.DOWN) teams_mute.switch_to_input(pull=digitalio.Pull.DOWN) kbd = Keyboard(usb_hid.devices) sleep(1) zoom_mic_status = False teams_mic_status = False while True: if zoom_mute.value == True: if zoom_mic_status == False: kbd.press(Keycode.ALT) kbd.press(Keycode.A) kbd.release_all() zoom_mic_status = True else: if zoom_mic_status == True: kbd.press(Keycode.ALT) kbd.press(Keycode.A) kbd.release_all() zoom_mic_status = False if teams_mute.value == True: if teams_mic_status == False: kbd.press(Keycode.CONTROL) kbd.press(Keycode.SHIFT) kbd.press(Keycode.M)
cap_touches[0] = t0_count > 2 cap_touches[1] = touches[1].raw_value > 3000 cap_touches[2] = touches[2].raw_value > 3000 cap_touches[3] = touches[3].raw_value > 3000 return cap_touches while True: caps = read_caps() print(caps) # light up the matching LED for i,c in enumerate(caps): leds[i].value = c if caps[0]: if ENABLE_KEYBOARD: # Zoom kbd.press(Keycode.ALT, Keycode.V) kbd.release(Keycode.V) time.sleep(0.25) kbd.press(Keycode.A) kbd.release_all() if caps[1]: if ENABLE_KEYBOARD: # Teams # Note that video toggle doesn't work in the web app kbd.press(Keycode.CONTROL, Keycode.SHIFT, Keycode.M) kbd.release(Keycode.M) time.sleep(0.5) kbd.press(Keycode.O) kbd.release_all() if caps[2]: if ENABLE_KEYBOARD:
import time from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode import board import digitalio kbd = Keyboard() # define buttons. these can be any physical switches/buttons, but the values # here work out-of-the-box with a CircuitPlayground Express' A and B buttons. swap = digitalio.DigitalInOut(board.D4) swap.direction = digitalio.Direction.INPUT swap.pull = digitalio.Pull.DOWN search = digitalio.DigitalInOut(board.D5) search.direction = digitalio.Direction.INPUT search.pull = digitalio.Pull.DOWN while True: # press ALT+TAB to swap windows if swap.value: kbd.press(Keycode.ALT, Keycode.TAB) kbd.release_all() # press CTRL+K, which in a web browser will open the search dialog elif search.value: kbd.press(Keycode.CONTROL, Keycode.K) kbd.release_all() time.sleep(0.1)
######################### MAIN LOOP ############################## i = 0 while True: # spin internal LED around! dot[0] = wheel(i) dot.show() # set analog output to 0-3.3V (0-65535 in increments) aout.value = i * 256 # once every 256 ticks, so it doesnt rush by! if i == 0: # Read analog voltage on A1 print("A1: %0.2f" % getVoltage(analog1in)) # Print the temperature print("Temp: %0.1f" % microcontroller.cpu.temperature) # use A2 as capacitive touch to turn on internal LED if touch2.value: print("A2 touched!") # optional! uncomment below & save to have it sent a keypress kbd.press(Keycode.A) kbd.release_all() time.sleep(1) led.value = touch2.value i = (i + 1) % 256 # run from 0 to 255
([255, 2, 151, 104],(Keycode.SIX,)), ([255, 2, 231, 24], (Keycode.SEVEN,)), ([255, 2, 103, 152],(Keycode.EIGHT,)), ([255, 2, 167, 88], (Keycode.NINE,)), ) print("Ready for NEC remote input!") while True: led[0] = (0, 0, 0) # LED off pulses = decoder.read_pulses(pulsein) #print("\tHeard", len(pulses), "Pulses:", pulses) try: code = decoder.decode_bits(pulses, debug=False) print("Decoded:", code) # Reads 4-byte code transmitted by NEC remotes and # sends a matching key command for pairs in infrared_to_key: if pairs[0] == code: led[0] = (0, 100, 0) # flash green print("Matched IR code to keypresses: ", pairs[1]) keyboard.press(*pairs[1]) keyboard.release_all() except adafruit_irremote.IRNECRepeatException: # unusual short code! print("NEC repeat!") except adafruit_irremote.IRDecodeException as e: # failed to decode led[0] = (100, 0, 0) # flash red print("Failed to decode: ", e.args) print("----------------------------")
if (left_right < -0.25): left_pressed = True elif (left_right > 0.25): right_pressed = True if (up_down < -0.25): down_pressed = True elif (up_down > 0.25): up_pressed = True # For each type of key, we press it down, # release it, or leave it in its current state. # if not up_state and up_pressed: if player == 1: keyboard.press(Keycode.UP_ARROW) else: keyboard.press(Keycode.K) keyboard.press(Keycode.W) up_state = True elif up_state and not up_pressed: if player == 1: keyboard.release(Keycode.UP_ARROW) else: keyboard.release(Keycode.K) keyboard.release(Keycode.W) up_state = False if not down_state and down_pressed: if player == 1: keyboard.press(Keycode.DOWN_ARROW)