Код:

from machine import Pin
from time import sleep_us, sleep_ms, ticks_ms, ticks_diff

pwrctl  = Pin(15)   # Power control
pullctl = Pin(16)   # USB pullup control (for reliable ACK sampling)
jlclk   = Pin(20)   # Key clock signal (USBDP)
jldat   = Pin(21)   # Key data signal  (USBDM)

pwrctl.init(Pin.OUT, value=0) # power off
pullctl.init(Pin.IN) # do not pull anywhere yet

jldat.init(Pin.IN);jlclk.init(Pin.IN)

#----------------------------------------------------

powerstate = False

def power_off():
    global powerstate

    pwrctl(0)   # Power off
    powerstate = False

def power_on():
    global powerstate

    if powerstate:  # Do a power cycle
        power_off()
        sleep_ms(250)

    pwrctl(1)   # Power on
    powerstate = True

#----------------------------------------------------

def sendkey(key=0x16EF):
    """ Send a key and sample for acknowledge """
    jldat.init(Pin.OUT) ; jlclk.init(Pin.OUT)

    for i in range(16):
        jldat(key & (0x8000 >> i))
        jlclk.off() ; sleep_us(10)
        jlclk.on()  ; sleep_us(10)

    jldat.init(Pin.IN) ; jlclk.init(Pin.IN)
    return not jldat() and not jlclk()  # <- is both D- and D+ low?
    #return jlclk() # <- is D+ high?

def send_usbkey(timeout=1000):
    # Power on
    power_on()

    pullctl.init(Pin.OUT, value=1)  # drive external pullups

    # send the key
    keysent = False
    tstart = ticks_ms()
    while not keysent:
        elapsed = ticks_diff(ticks_ms(), tstart)
        if elapsed >= timeout: break

        keysent = sendkey()

    pullctl.init(Pin.IN)        # disable pullups

    # release the pins, and we're done
    jlclk.init(Pin.IN);jldat.init(Pin.IN)

    if not keysent:
        power_off()

    return keysent, elapsed

Код:

#########################################
# JieLi USB dongle - RP2040 PIO edition #
#########################################
from machine import Pin
from time import sleep_ms, ticks_ms, ticks_diff
import rp2

pwrctl  = Pin(15)   # Power control
pullctl = Pin(16)   # USB pullup control (for reliable ACK sampling)
jlclk   = Pin(20)   # Key clock signal (USBDP)
jldat   = Pin(21)   # Key data signal  (USBDM)

pwrctl.init(Pin.OUT, value=0) # power off
pullctl.init(Pin.IN) # do not pull anywhere yet

#----------------------------------------------------

powerstate = False

def power_off():
    global powerstate

    pwrctl(0)   # Power off
    powerstate = False

def power_on():
    global powerstate

    if powerstate:  # Do a power cycle
        power_off()
        sleep_ms(250)

    pwrctl(1)   # Power on
    powerstate = True

#----------------------------------------------------

@rp2.asm_pio(
    out_init     = rp2.PIO.IN_LOW,
    sideset_init = rp2.PIO.IN_LOW,
    set_init     = (rp2.PIO.IN_LOW, rp2.PIO.IN_LOW),
    out_shiftdir = rp2.PIO.SHIFT_LEFT
)
def usb_key_pio():
    # pull the key value - blocks until it appears
    pull()

    # send 16 bits
    set(pindirs, 3)     # drive pins
    set(x, 15)          # 16 bits
    label("bitloop")    # <-- 10 PIO ticks per output clock
    out(pins, 1)          .side(0) [5-1]   # CLK=0, output to DAT
    jmp(x_dec, "bitloop") .side(1) [5-1]   # CLK=1

    # sample lines
    set(pindirs, 0)     # pins to input
    set(x, 15)          # sample 16 times (for full 32 bits)
    label("samploop")   # <-- 2 PIO ticks per sample  = 32 ticks or 3.2 bits
    in_(pins, 2)        # sample
    jmp(x_dec, "samploop")
    push()              # store the sampling result

usbkeysm = rp2.StateMachine(0, usb_key_pio,
    freq=25000*10,          # 25 kHz clock
    sideset_base=jlclk,     # sideset affects clock
    out_base=jldat,         # 'out' affects data
    set_base=jlclk,         # 'set' affects both clock and data
    in_base=jlclk           # 'in' reads clock and data
)

def send_usbkey(timeout=1000):
    power_on()

    usbkeysm.active(1)
    pullctl.init(Pin.OUT, value=1)  # drive external pullups

    # send the key
    keysent = False
    tstart = ticks_ms()
    while not keysent:
        elapsed = ticks_diff(ticks_ms(), tstart)
        if elapsed >= timeout: break

        usbkeysm.put(0x16EF, 16)
        ret = usbkeysm.get()

        keysent = ret == 0  # <- [D-] and [D+] were low the whole time
        #keysent = (~ret & 0x55555555) == 0  # <- [D+] was high the whole time

    pullctl.init(Pin.IN)        # disable pullups
    usbkeysm.active(0)

    if not keysent:
        power_off()

    return keysent, elapsed

Код:

from machine import Pin
from time import ticks_ms, ticks_diff, sleep_ms
import usbkey2 as juk

key = Pin(24, mode=Pin.IN, pull=Pin.PULL_UP)
led = Pin(25, mode=Pin.OUT, value=0)


presstime = 0
btnlast = False
pressed = False
state = None

def blink(times, delay=100):
    for i in range(times):
        led.toggle()
        sleep_ms(delay)


while True:
    btnstate = not key()
    command = None

    if not pressed:
        if btnstate and btnlast != btnstate:
            presstime = ticks_ms()
            pressed = True
    else:
        if not btnstate and btnlast != btnstate:
            if ticks_diff(ticks_ms(), presstime) >= 50:
                command = 'power_toggle'
            pressed = False
        elif btnstate and ticks_diff(ticks_ms(), presstime) >= 250:
            command = 'usb_key'
            pressed = False

    btnlast = btnstate

    if command == 'power_toggle':
        if state == 'on':
            command = 'power_off'
        else:
            command = 'power_on'

    if command == 'power_off':
        state = 'off'
        juk.power_off()
        led(0)

    elif command == 'power_on':
        state = 'on'
        juk.power_on()
        led(1)
        blink(2)

    elif command == 'usb_key':
        led(0)
        res, elapsed = juk.send_usbkey()

        if not res:
            state = 'off'
            blink(6)
        else:
            state = 'usb-download'
            blink(3)