jepler · September 4, 2024 22:29
diff --git a/code.py b/code.py
 import array
 import rp2pio
 import board
 import adafruit_pioasm
 import time

 # MIT licensed https://github.com/No0ne/ps2pico/blob/main/LICENSE
 # https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol

 KBD_DATA = board.GP27
 KBD_CLK = board.GP26

 debug_raw = const(True)

 program = adafruit_pioasm.Program("""
 ; from https://raw.githubusercontent.com/PaulW/rp2040-keyboard-converter/main/src/protocols/at-ps2/interface.pio, license: GPLv3
 ; Pins: 0 = data, 1 = clock

 init:
    ; Wait until CLK is high before we continue.  Keyboards seem to pull this LOW briefly
    ; during power on.  This prevents the first bit read being shifted in this scenario.
    wait 1 pin 1

 check:
    ; Wait for incoming data, but jump to bitLoopOut if the Output Shift Register isn't empty
    jmp !osre, bitLoopOut
    jmp pin, check ; Loop back to check if pin high

    ; Receiving Data
    ;    IBM AT:
    ;        ____ 1 _ 2 _ 3 _ 4 _ 5 _ 6 _ 7 _ 8 _ 9 _ A _ B _____
    ;    CLK     \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
    ;        ___     ___ ___ ___ ___ ___ ___ ___ ___ ___ ________
    ;    DAT    \___/___X___X___X___X___X___X___X___X___/
    ;             S   0   1   2   3   4   5   6   7   P   s

    ; Read Start bit
    in pins, 1
    ; Wait for Clock to go High
    wait 1 pin 1

    ; Set x to 9 (to read in 8 x Data bits, 1 x Parity and 1 x Stop bit)
    set x, 9

 bitLoopIn:
    ; Wait for clock signal to go low
    wait 0 pin 1 [1]
    ; Read data pin and store in pins register
    in pins, 1
    ; Wait for clock signal to go high
    wait 1 pin 1
    ; Decrement x and jump back to bitLoopIn if it's not zero
    jmp x--, bitLoopIn

    ; Jump back to check now all data read
    jmp check

 bitLoopOut:
    ; Sending Data
    ;    IBM AT:
    ;        __      _ 1 _ 2 _ 3 _ 4 _ 5 _ 6 _ 7 _ 8 _ 9 _ A __ B ____
    ;    CLK   \____/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/  \_/
    ;        ______     ___ ___ ___ ___ ___ ___ ___ ___ ______     ____
    ;    DAT       \___/___X___X___X___X___X___X___X___X___/  \___/
    ;           H    R   0   1   2   3   4   5   6   7   P   s ACK

    ; Set data pin low and configure pins
    set pins, 0
    set pindirs 2 [14]   ; Set data pin to output mode
    set pindirs 1  [1]   ; Set clock pin to input mode
    ; Set x to 8 (to write out 8 Data Bits and 1 Parity Bit)
    set x, 8

 bitLoopOutLoop:
    ; Wait for clock signal to go low and start sending bit
    wait 0 pin 1 [1]
    out pins, 1
    ; Wait for clock signal to go high
    wait 1 pin 1
    ; Decrement x and jump back to bitLoopOutLoop if it's not zero
    jmp x--, bitLoopOutLoop

    ; Send stop bit
    wait 0 pin 1 [1]
    set pins, 1
    wait 1 pin 1

    ; Wait for ACK to acknowledge
    set pindirs, 0  ; Set data pin to input mode so we can read ACK

    wait 0 pin 0 [1]
    wait 1 pin 0 [5]
 """, build_debuginfo=True)

 program.print_c_program("program")

 cycles_per_bit = 11
 poll_rate_khz = 20_000

 sm = rp2pio.StateMachine(program.assembled,
    first_in_pin = KBD_DATA,
    first_out_pin = KBD_DATA,
    first_set_pin = KBD_DATA,
    jmp_pin = KBD_CLK,
    in_pin_count = 2,
    out_pin_count = 2,
    set_pin_count = 2,
    in_shift_right=True,
    frequency=8_000_000,
    exclusive_pin_use=False,
    auto_pull=True,
    pull_threshold=9,
    auto_push=True,
    push_threshold=11,
    initial_out_pin_direction=0,
    initial_set_pin_direction=0,
    **program.pio_kwargs)

 def parity(x):
    x = x ^ (x >> 4)
    x = x ^ (x >> 2)
    x = x ^ (x >> 1)
    return (x & 1) ^ 1

 def get_kbd_byte():
    sm.readinto(buf, swap=False)
    r = (buf[0] >> 6) & 0xff
    if debug_raw:
        print(f"RAW {r:02x} {buf[0]:016b}")
    return r

 def get_kbd_code():
    val = get_kbd_byte()
    is_extended = (val == 0xe0)
    if is_extended:
        val = get_kbd_byte()

    is_break = (val == 0xf0)
    if is_break:
        val = get_kbd_byte()

    return val | (is_extended << 8) | (is_break << 9)

 def write_cmd(*args):
    for b0 in args:
        p = parity(b0)
        print(b0, p)
        buf[0] = b0 | (parity(b0) << 8)
        print(f"WRITE {b0:08b} {buf[0]:011b}")
        sm.background_write(buf)

 buf = array.array('H', [0])

 #write_cmd(0xed, 0xe0)
 #raise SystemExit()
 write_cmd(0xed, 0xe0)

 offset = sm.offset
 print(f"State machine loaded at {sm.offset}")
 i = 7
 while True:
    pc = sm.pc
    print(f"{pc - offset:2d} [{pc:2d}]", end="\r")
    if sm.in_waiting:
        print(f"{get_kbd_byte():02x}")
    #else:
    #    write_cmd(0xed, i << 5)
    #    i = (i + 1) & 0x7
    #    time.sleep(.5)
    #break
            

 while True:
    code = get_kbd_code()
    print(f"{'BREAK' if code & 0x200 else 'MAKE':5} {code & 0x1ff:03x}")
	import array
	import rp2pio
	import board
	import adafruit_pioasm
	import time

	# MIT licensed https://github.com/No0ne/ps2pico/blob/main/LICENSE
	# https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol

	KBD_DATA = board.GP27
	KBD_CLK = board.GP26

	debug_raw = const(True)

	program = adafruit_pioasm.Program("""
	; from https://raw.githubusercontent.com/PaulW/rp2040-keyboard-converter/main/src/protocols/at-ps2/interface.pio, license: GPLv3
	; Pins: 0 = data, 1 = clock

	init:
	; Wait until CLK is high before we continue. Keyboards seem to pull this LOW briefly
	; during power on. This prevents the first bit read being shifted in this scenario.
	wait 1 pin 1

	check:
	; Wait for incoming data, but jump to bitLoopOut if the Output Shift Register isn't empty
	jmp !osre, bitLoopOut
	jmp pin, check ; Loop back to check if pin high

	; Receiving Data
	; IBM AT:
	; ____ 1 _ 2 _ 3 _ 4 _ 5 _ 6 _ 7 _ 8 _ 9 _ A _ B _____
	; CLK \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
	; ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ________
	; DAT \___/___X___X___X___X___X___X___X___X___/
	; S 0 1 2 3 4 5 6 7 P s

	; Read Start bit
	in pins, 1
	; Wait for Clock to go High
	wait 1 pin 1

	; Set x to 9 (to read in 8 x Data bits, 1 x Parity and 1 x Stop bit)
	set x, 9

	bitLoopIn:
	; Wait for clock signal to go low
	wait 0 pin 1 [1]
	; Read data pin and store in pins register
	in pins, 1
	; Wait for clock signal to go high
	wait 1 pin 1
	; Decrement x and jump back to bitLoopIn if it's not zero
	jmp x--, bitLoopIn

	; Jump back to check now all data read
	jmp check

	bitLoopOut:
	; Sending Data
	; IBM AT:
	; __ _ 1 _ 2 _ 3 _ 4 _ 5 _ 6 _ 7 _ 8 _ 9 _ A __ B ____
	; CLK \____/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
	; ______ ___ ___ ___ ___ ___ ___ ___ ___ ______ ____
	; DAT \___/___X___X___X___X___X___X___X___X___/ \___/
	; H R 0 1 2 3 4 5 6 7 P s ACK

	; Set data pin low and configure pins
	set pins, 0
	set pindirs 2 [14] ; Set data pin to output mode
	set pindirs 1 [1] ; Set clock pin to input mode
	; Set x to 8 (to write out 8 Data Bits and 1 Parity Bit)
	set x, 8

	bitLoopOutLoop:
	; Wait for clock signal to go low and start sending bit
	wait 0 pin 1 [1]
	out pins, 1
	; Wait for clock signal to go high
	wait 1 pin 1
	; Decrement x and jump back to bitLoopOutLoop if it's not zero
	jmp x--, bitLoopOutLoop

	; Send stop bit
	wait 0 pin 1 [1]
	set pins, 1
	wait 1 pin 1

	; Wait for ACK to acknowledge
	set pindirs, 0 ; Set data pin to input mode so we can read ACK

	wait 0 pin 0 [1]
	wait 1 pin 0 [5]
	""", build_debuginfo=True)

	program.print_c_program("program")

	cycles_per_bit = 11
	poll_rate_khz = 20_000

	sm = rp2pio.StateMachine(program.assembled,
	first_in_pin = KBD_DATA,
	first_out_pin = KBD_DATA,
	first_set_pin = KBD_DATA,
	jmp_pin = KBD_CLK,
	in_pin_count = 2,
	out_pin_count = 2,
	set_pin_count = 2,
	in_shift_right=True,
	frequency=8_000_000,
	exclusive_pin_use=False,
	auto_pull=True,
	pull_threshold=9,
	auto_push=True,
	push_threshold=11,
	initial_out_pin_direction=0,
	initial_set_pin_direction=0,
	**program.pio_kwargs)

	def parity(x):
	x = x ^ (x >> 4)
	x = x ^ (x >> 2)
	x = x ^ (x >> 1)
	return (x & 1) ^ 1

	def get_kbd_byte():
	sm.readinto(buf, swap=False)
	r = (buf[0] >> 6) & 0xff
	if debug_raw:
	print(f"RAW {r:02x} {buf[0]:016b}")
	return r

	def get_kbd_code():
	val = get_kbd_byte()
	is_extended = (val == 0xe0)
	if is_extended:
	val = get_kbd_byte()

	is_break = (val == 0xf0)
	if is_break:
	val = get_kbd_byte()

	return val \| (is_extended << 8) \| (is_break << 9)

	def write_cmd(*args):
	for b0 in args:
	p = parity(b0)
	print(b0, p)
	buf[0] = b0 \| (parity(b0) << 8)
	print(f"WRITE {b0:08b} {buf[0]:011b}")
	sm.background_write(buf)

	buf = array.array('H', [0])

	#write_cmd(0xed, 0xe0)
	#raise SystemExit()
	write_cmd(0xed, 0xe0)

	offset = sm.offset
	print(f"State machine loaded at {sm.offset}")
	i = 7
	while True:
	pc = sm.pc
	print(f"{pc - offset:2d} [{pc:2d}]", end="\r")
	if sm.in_waiting:
	print(f"{get_kbd_byte():02x}")
	#else:
	# write_cmd(0xed, i << 5)
	# i = (i + 1) & 0x7
	# time.sleep(.5)
	#break


	while True:
	code = get_kbd_code()
	print(f"{'BREAK' if code & 0x200 else 'MAKE':5} {code & 0x1ff:03x}")