Single MOSI MISO pin via asm_pio

[JonPark0]

Hello.

Currently I am writing a code for WeMos 4.2 inch e-paper display which uses SSD1683 epd driver.

On the micropython documentation, both MOSI and MISO should be defined to use default SPI class.

Since most of the spi based displays doesn't require MISO communication, I usually just put unused pin to define MISO.

While trying to enhance performance for both communication side and MCU side, I found out that using PIO feature might help this pin defining problem.

Based on these informations, I wrote a basic code. (which looks like the one in below)

I didn't tested yet since it only has minimal function which only can write/read command and data with it, and also because I'm not sure if this is the right way to use pio_asm.

Can anyone please review this code if this is the right way to use pio_asm? It will be so grateful if I can get any advice from here.

from machine import Pin
from rp2 import asm_pio, PIO, StateMachine
from utime import sleep_us, ticks_ms

SDA = Pin(1)
SCL = Pin(2)
CS = Pin(3, Pin.OUT)
DC = Pin(4, Pin.OUT)
RST = Pin(5, Pin.OUT)
BUSY = Pin(6, Pin.IN)

@asm_pio(
    set_init=PIO.OUT_LOW, 
    out_init=PIO.OUT_LOW, 
    in_shiftdir=PIO.SHIFT_LEFT,
    out_shiftdir=PIO.SHIFT_LEFT,
    autopull=True,
    autopush=True,
    push_thresh=8,
    pull_thresh=8)
def ssd1683():
    wrap_target()   # TX Mode
    set(pins, 1)    # SCL Rise
    out(pins, 1)    # Send 1 bit
    set(pins, 0)    # SCL Fall
    wrap()

    label("rx")     # RX Mode
    wrap_target()   
    set(pins, 1)    # SCL Rise
    in_(pins, 1)    # Read 1 bit
    set(pins, 0)    # SCL Fall
    wrap()

# TX Max Frequency is 20MHz
# RX Max Frequency is 2.5MHz
# If you have communication issues, try to reduce the frequency.

disp_tx = StateMachine(0, ssd1683, freq=20_000_000, set_base=SCL, out_base=SDA, out_shift=8)
disp_rx = StateMachine(1, ssd1683, freq=2_500_000, set_base=SCL, in_base=SDA, in_shift=8, jmp_pin=None)

def write_mode(command, data = bytearray()):
    SDA.init(Pin.OUT)   # Configure SDA as Output

    disp_tx.active(1)   # Enable TX State Machine
    DC.value(0)         # Set Command Mode
    CS.value(0)         # Start Operation
    sleep_us(60)
    disp_tx.put(command)
    DC.value(1)         # Set Data Mode
    if data:
        for byte in data:
            disp_tx.put(byte)
    DC.value(0)         # Set Command Mode (Default State)
    CS.value(1)         # Exit Write Mode
    disp_tx.active(0)   # Disable TX State Machine

def read_mode(command, num_bytes=1, timeout_ms=1000):
    rx_data = bytearray()   # Create varaible to store data received
    SDA.init(Pin.OUT)   # Configure SDA as Output

    disp_tx.active(1)   # Enable TX State Machine
    DC.value(0)         # Set Command Mode
    CS.value(0)         # Start Operation
    sleep_us(60)
    disp_tx.put(command)
    disp_tx.active(0)   # Disable TX State Machine

    SDA.init(Pin.IN)    # Configure SDA as Input
    disp_rx.exec("jmp rx")

    disp_rx.active(1)   # Enable RX State Machine
    DC.value(1)         # Set Data Mode
    start_time = ticks_ms()
    for _ in range(num_bytes):
        while disp_rx.rx_fifo() == 0:
            if ticks_ms() - start_time > timeout_ms:
                DC.value(0)         # Set Command Mode (Default State)
                CS.value(1)         # Exit Read Mode
                disp_rx.active(0)   # Disable TX State Machine
                return Exception("ERROR: Progress Exceeded Timeout Limit!")
            pass
        rx_data.append(disp_rx.get())
    DC.value(0)         # Set Command Mode (Default State)
    CS.value(1)         # Exit Read Mode
    disp_rx.active(0)   # Disable TX State Machine
    
    return rx_data      # Return the data received

[mendenm]

you can't do 'jmp rx' as a pushed instruction. The code that compiles that has no idea where 'rx' is. You can make the first thing the state machine does is pull a single value, which can be zero or one, and then either jump to the write or read code based on it. In your case, it might just be easier to make two separate PIO programs, though, and start one state machine with the read program, and the other with the write program, unless you are running out of state machines.