prettyprint

顯示具有 Raspberry Pi pico 標籤的文章。 顯示所有文章
顯示具有 Raspberry Pi pico 標籤的文章。 顯示所有文章

2022年11月15日 星期二

Raspberry Pi Pico PIO(Programmable IO) Episode 5: IR-Receiver(VS1838B)

 本篇文章介紹使用Raspberry Pi Pico PIO功能,製作一個IR 遙控器接收器,並用來控制伺服馬達。


一、使用材料:

  1. Raspberry Pi Pico
  2. VS1838B IR 接收器
  3. SG90 MicroServo
二、紅外線協定使用Samsung IR protocol:
Start bits: 4.5ms burst pulse + 4.5ms space
32 bits data(Address + command): logical "0": 590us burst pulse + 590us space; 
                                                        logical "1": 590us burst pulse + 1690us space
stop bits: 590us burst pulse + 590us space

三、VS1838B Datasheet:

burst pulse: output level LOW
space : output leve HIGH

四、Raspberry Pi Pico PIO說明:
1.設定StateMachine clock cycle週期為10us。

2. StateMachine程式碼:
  • 確定start bits: 4.5ms burst pulse + 4.5ms space
  • 每個bit 取樣點:650us > 560us 
  • IR發送器發送data bits為LSB first,所以設定shift right,且autopush=false

五、成果影片:


六、程式碼
  • PIO
; IR protocol:
; start bits: 4.5ms burst pulse + 4.5 ms space
; 32 bits data: logical "0": 590us burst pulse+590us space, logical "1": 590us burst pulse+1690us space
; stop bits: 590us burst pulse + 590us space
; StateMachine clock cycle period=10us 
.program samsung_ir_receiver
.wrap_target
start:
set x, 31                   ; 32*14=4480(us)   
start_burst:
jmp pin start
jmp x--, start_burst [12]

wait 1 pin 0                ; 10us
set x, 31                   ; 32*14=4480us
start_space:
in pins, 1
mov y, isr
jmp !y  start
jmp pin start_space [10]

mov isr, NULL

set x, 31
bit_loop:
wait 1 pin 0
nop [31]
nop [31] 
in pins, 1 
wait 0 pin 0
jmp x--, bit_loop
push
irq 0

wait 1 pin 0
wait_stop:
jmp pin, wait_stop

.wrap
  • ir-receiver.c
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "IR-receiver.h"
#include "hardware/clocks.h"
#include "hardware/pwm.h"

#define IR_PIN  15
#define PWM_PIN 16

int angle=0;
int slice, pwm_ch;

void setServoAngle(int ang) {
    uint16_t top_count = (uint16_t)(ang/0.09 + 1500);  // angle 0: 1.5 ms duty
    pwm_set_chan_level(slice, pwm_ch, top_count);

}
void ir_irq_handle() {
    if (pio_interrupt_get(pio0, 0)) {
        pio_interrupt_clear(pio0, 0);
        uint32_t code = pio_sm_get(pio0, 0);
        
        switch (code) {
            case 0xf8070707:    
                angle += 2;
                if (angle > 90) angle = 90;
                break;
            case 0xf40b0707:
                angle -= 2;
                if (angle < -90) angle = -90;
                break;
            case 0xed120707:
                angle = 90;
                break;
            case 0xef100707:
                angle = 0;
                break;
        }
        setServoAngle(angle);
    }

}

void ir_receiver_pio_init(PIO pio, uint sm, uint pin, uint32_t freq) {
    uint offset = pio_add_program(pio, &samsung_ir_receiver_program);
    pio_sm_config c = samsung_ir_receiver_program_get_default_config(offset);
    pio_gpio_init(pio, pin);
    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false);
    float div = clock_get_hz(clk_sys)/freq;
    sm_config_set_clkdiv(&c, div);
    sm_config_set_in_pins(&c, pin);
    sm_config_set_in_shift(&c, true, false,32);
    sm_config_set_jmp_pin(&c, pin);
    // set interrupt 
    pio_set_irq0_source_enabled(pio, pis_interrupt0, true);
    irq_add_shared_handler(PIO0_IRQ_0, ir_irq_handle, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
    irq_set_enabled(PIO0_IRQ_0, true);
    
    pio_sm_init(pio, sm, offset, &c);
    pio_sm_set_enabled(pio, sm, true);

}

int main()
{
    stdio_init_all();
    gpio_init(IR_PIN);
    gpio_set_dir(IR_PIN, false);
    gpio_disable_pulls(IR_PIN);
    ir_receiver_pio_init(pio0, 0, IR_PIN, 100000);  // set StateMachine clock sycle period=10us

    // set Servo pwm
    gpio_set_function(PWM_PIN, GPIO_FUNC_PWM);
    slice = pwm_gpio_to_slice_num(PWM_PIN);
    pwm_ch = pwm_gpio_to_channel(PWM_PIN);
    pwm_config c = pwm_get_default_config();
    pwm_config_set_clkdiv(&c, 125);  // 20ms period, steps 20000, clkdiv = 125 
    pwm_config_set_wrap(&c, 20000);
    pwm_config_set_phase_correct(&c, false);
    pwm_init(slice, &c, true);    
    
    setServoAngle(0);
    
    while(true) {
        tight_loop_contents();
    }
    return 0;
}

2022年11月9日 星期三

Raspberry Pi Pico PIO(Programmable IO) Episode 4: I2S audio (Play WAVE File In SDCard from MAX98357A DAC)

本篇文章探討Raspberry Pi Pico 使用PIO功能,模擬I2S界面,連接MAX98357A DAC播放Wave聲音檔。 開發界面使用VSCode + C-SDK。



一、PIO與MAX98357A I2S界面對應

根據MAX98357A  datasheet可支援16、24、32bit, 8kHz, 16kHz, 32kHz, 44.1kHz,
48kHz, 88.2kHz取樣速率。分成左右兩聲道。

若是檔案為單聲道時,則左右聲道播放相同內容。

根據Datasheet 16與32 bit的時間脈序如下圖所示,因此24bit時為後補0成為32bit再送出給MAX98357A。


根據以上分析,PIO 程式碼分成mono與streo兩段,分別處理。 

  • 使用pio side-set pin 輸出LRCLK與BCLK。 bit0:BCLK, bit1:LRCLK
  • Mono audio

根據上圖每輸出1bit,pio StateMachine使用4 clock cycle。 因為register ISR未使用,因此可用來當scratch register用,第9行先將OSR存在ISR中,第19行相同內容輸出到右聲道。單聲道時autopull=false。

  • Stereo audio

每輸出1bit,pio StateMachine 使用2 clock cycles,使用autopull=true


 PIO 程式開始時將bits per sample存到scratch register y。

 
PIO StateMachine clock frequency = 取樣速率*(每個bit的clock cycle數)*取樣位元數*2
註:   2: 為左右聲道



二、SDCard code:

使用no-OS-FatFS-SD-SPI-RPi-Pico程式碼。

三、PIO DMA:

將檔案讀取的資料透過DMA直接送PIO StateMachin TX_FIFO中:


 

四、成果影片



五、原始程式碼:

 1. PIO

;=====  mono ====== 
; 4 pio clock cycles for 1 bit
.program i2s_pio_dma_mono
.side_set 2
loop1:
out pins, 1 side 0b00 [1]
jmp x--, loop1 side 0b01 [1]
out pins, 1 side 0b10
mov osr, isr side 0b10   ;isr as scratch register, the same output for right channel

mov x, y side 0b11 [1]
loop2:
out pins, 1  side 0b10 [1]
jmp x--, loop2 side 0b11 [1]
out pins, 1  side 0b00

public entry_point_m:
pull side 0b00
mov isr, osr side 0b01
mov x,y side 0b01

;=====  stereo ====== 
; 2 pio clock cycles for 1 bit
.program i2s_pio_dma_stereo
.side_set 2
loop1:
out pins, 1 side 0b00
jmp x--, loop1 side 0b01
out pins, 1 side 0b10

mov x, y side 0b11
loop2:
out pins, 1 side 0b10
jmp x--, loop2 side 0b11
out pins, 1  side 0b00

public entry_point_s:
mov x,y side 0b01

2. main.c
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/dma.h"
#include "hardware/pio.h"
#include "sd_card.h"
#include "ff.h"
#include "pio_dma.h"
#include "hardware/clocks.h"


uint8_t f_buf0[4010], f_buf1[4010]; //double buffer 
uint8_t *file_ptr = f_buf0;
uint8_t *fifo_ptr = f_buf1;
uint8_t *temp_ptr=NULL;
bool read_flag=true;

uint byte_trans_count=0;
uint MAX_BYTE_TRANS=4000;

struct i2s_pio_dma_param_t {
    //for pio
    pio_program_t program;
    uint8_t bitsPerSample;
    uint8_t offset;
    uint8_t entry_point;
    uint8_t bitInsCycles; // 4 pio clock cycles for mono, 2 pio clocks for stereo
    //for dma
    int chan_num;
    uint8_t dma_size;
} i2s_pio_dma_param;

struct wave_file_header_t {
    char blockID[4];
    uint32_t totalSize;
    char typeHeader[4];
    char fmt[4];
    uint32_t headerLen;
    uint16_t typeOfFormat;
    uint16_t numbeOfChannel;
    uint32_t sampleRate;
    uint32_t byteRate;
    uint16_t blockAlign;
    uint16_t bitsPerSample;
    char dataHeader[4];
    uint32_t dataSize;
} wave_file_header;


void trans_wav();


void i2s_pio_init(PIO pio, uint sm, uint sideset_base, uint out_base, uint numberOfChannels, uint bitsPerSample, uint freq) {
    uint offset = 0;
    pio_sm_config c;
    if (numberOfChannels == 1) {
        offset = pio_add_program(pio, &i2s_pio_dma_mono_program);
        c = i2s_pio_dma_mono_program_get_default_config(offset);
        i2s_pio_dma_param.program = i2s_pio_dma_mono_program;
        i2s_pio_dma_param.entry_point = i2s_pio_dma_mono_offset_entry_point_m;
        sm_config_set_out_shift(&c, false, false, bitsPerSample);
    } else {
        offset = pio_add_program(pio, &i2s_pio_dma_stereo_program);
        c = i2s_pio_dma_stereo_program_get_default_config(offset);
        i2s_pio_dma_param.program = i2s_pio_dma_stereo_program;
        i2s_pio_dma_param.entry_point = i2s_pio_dma_stereo_offset_entry_point_s;
        sm_config_set_out_shift(&c, false, true, bitsPerSample);
    }
    i2s_pio_dma_param.offset = offset;
    i2s_pio_dma_param.bitsPerSample = bitsPerSample;
    pio_gpio_init(pio, out_base);
    pio_gpio_init(pio, sideset_base);
    pio_gpio_init(pio, sideset_base+1);
    pio_sm_set_consecutive_pindirs(pio, sm, sideset_base, 2, true);
    pio_sm_set_consecutive_pindirs(pio, sm, out_base, 1, true);
    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);
    sm_config_set_out_pins(&c, out_base, 1);
    sm_config_set_sideset_pins(&c, sideset_base);
    float div = clock_get_hz(clk_sys)/freq;
    sm_config_set_clkdiv(&c, div);
    pio_sm_init(pio, sm, offset, &c);
}

void i2s_pio_enable(PIO pio, uint sm) {
    dma_channel_set_irq1_enabled(i2s_pio_dma_param.chan_num, true);
    pio_sm_set_enabled(pio, sm, true);
    pio_sm_exec(pio, sm, pio_encode_set(pio_y, i2s_pio_dma_param.bitsPerSample-2));
    pio_sm_exec(pio, sm, pio_encode_jmp(i2s_pio_dma_param.offset+i2s_pio_dma_param.entry_point));
}

void i2s_reset(PIO pio, uint sm) {
    pio_sm_drain_tx_fifo(pio, sm);
    pio_sm_set_enabled(pio, sm, false);

    pio_remove_program(pio, &i2s_pio_dma_param.program, i2s_pio_dma_param.offset);
    pio_clear_instruction_memory(pio);

    dma_channel_unclaim(i2s_pio_dma_param.chan_num);
    irq_set_enabled(DMA_IRQ_1,false);
    irq_remove_handler(DMA_IRQ_1, trans_wav);
    dma_channel_set_irq1_enabled(i2s_pio_dma_param.chan_num, false);
}

void i2s_pio_dma_init(PIO pio, uint sm) {
    i2s_pio_dma_param.chan_num = dma_claim_unused_channel(true);
    dma_channel_config c = dma_channel_get_default_config(i2s_pio_dma_param.chan_num);
    channel_config_set_write_increment(&c, false);
    channel_config_set_read_increment(&c, true);
    channel_config_set_dreq(&c, pio_get_dreq(pio, sm, true));
    channel_config_set_transfer_data_size(&c, i2s_pio_dma_param.dma_size); //DMA_SIZE_8,16,32
    dma_channel_acknowledge_irq1(i2s_pio_dma_param.chan_num);  // clear channel interrupt(ints1)
    dma_channel_set_irq1_enabled(i2s_pio_dma_param.chan_num, true); // enable irq1 (inte1)
    irq_add_shared_handler(DMA_IRQ_1, trans_wav, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
    irq_set_enabled(DMA_IRQ_1, true);
    dma_channel_configure(i2s_pio_dma_param.chan_num, &c, (void*) (PIO0_BASE+PIO_TXF0_OFFSET), 
             fifo_ptr, MAX_BYTE_TRANS>> i2s_pio_dma_param.dma_size, false); //DMA_SIZE_8 or 16 or 32
}

void trans_wav() {
    if (dma_channel_get_irq1_status(i2s_pio_dma_param.chan_num)) {
        dma_channel_acknowledge_irq1(i2s_pio_dma_param.chan_num);
        temp_ptr = file_ptr;
        file_ptr=fifo_ptr;
        fifo_ptr=temp_ptr;
        
        dma_channel_set_trans_count(i2s_pio_dma_param.chan_num, byte_trans_count >> i2s_pio_dma_param.dma_size, false);
        dma_channel_set_read_addr(i2s_pio_dma_param.chan_num, fifo_ptr,true);
        
        read_flag=true;
        if (byte_trans_count < MAX_BYTE_TRANS) {
            dma_channel_set_irq1_enabled(i2s_pio_dma_param.chan_num, false);
        }
    }
}

void i2s_init() {
    i2s_pio_dma_param.bitInsCycles=2;
    if (wave_file_header.numbeOfChannel == 1) i2s_pio_dma_param.bitInsCycles=4;
    uint freq = wave_file_header.sampleRate*i2s_pio_dma_param.bitInsCycles*wave_file_header.bitsPerSample*2;
    i2s_pio_dma_param.dma_size = wave_file_header.bitsPerSample >> 4; // DMA_SIZE_8, 16, 32

    i2s_pio_dma_init(pio0, 0);
    i2s_pio_init(pio0, 0, 16, 18, wave_file_header.numbeOfChannel,wave_file_header.bitsPerSample, freq);
    i2s_pio_enable(pio0, 0);
}

void playWave(char* fn) {
    printf("%s\n", fn);
    FRESULT fr;
    uint br;
    FIL pfile;
    fr = f_open(&pfile, fn, FA_READ);
    if (fr != FR_OK) {
        printf("open file error\n");
        return;
    }
    f_read(&pfile, &wave_file_header, 44, &br);
    if (fr != FR_OK) {
        printf("open file error\n");
        return;
    }

    i2s_init();

    f_read(&pfile, fifo_ptr, MAX_BYTE_TRANS, &byte_trans_count);
    read_flag=true;

    dma_channel_set_trans_count(i2s_pio_dma_param.chan_num, byte_trans_count >> i2s_pio_dma_param.dma_size, false);
    dma_channel_set_read_addr(i2s_pio_dma_param.chan_num, fifo_ptr,true);

    while (1) {
        if (read_flag) {
            read_flag=false;
            f_read(&pfile, file_ptr, MAX_BYTE_TRANS, &byte_trans_count);
            if (byte_trans_count < MAX_BYTE_TRANS) {
                f_close(&pfile);
                i2s_reset(pio0,0);
                break;
            }
        }
        
    }
}
int main()
{
    FRESULT fr;
    FATFS fs;

    stdio_init_all();
    
    if (!sd_init_driver()) {
        printf("SD Initial Error\n");
        return 0;
    }
    fr = f_mount(&fs, "0:", 1);
    if (fr != FR_OK) {
        printf("bool read_flag=true;mount error\n");
        return 0;
    }
    
    playWave(demo1.wav");
    playWave("demo2.wav");
    

    while(true) {
        tight_loop_contents();
    }

    return 0;
}


3. CMakeLists.txt

  # Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)
set(PICO_SDK_PATH "/your-path/pico/pico-sdk")
set(PICO_BOARD pico CACHE STRING "Board type")
# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)
if (PICO_SDK_VERSION_STRING VERSION_LESS "1.4.0")
  message(FATAL_ERROR "Raspberry Pi Pico SDK version 1.3.0 (or later) required. Your version is ${PICO_SDK_VERSION_STRING}")
endif()
project(pio_dma C CXX ASM)
# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()
# Add executable. Default name is the project name, version 0.1

add_executable(pio_dma main.c )
pico_set_program_name(pio_dma "pio_dma")
pico_set_program_version(pio_dma "0.1")
pico_enable_stdio_uart(pio_dma 1)
pico_enable_stdio_usb(pio_dma 0)
# Add the standard library to the build
target_link_libraries(pio_dma
        pico_stdlib)
# Add the standard include files to the build
target_include_directories(pio_dma PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
  ${CMAKE_CURRENT_LIST_DIR}/.. # for our common lwipopts or any other standard includes, if required
)
# Add any user requested libraries
target_link_libraries(pio_dma
        hardware_dma
        hardware_pio
        FatFs_SPI
        )
# Tell CMake where to find other source code
add_subdirectory(FatFs_SPI build)
pico_add_extra_outputs(pio_dma)
# Enable usb output, disable uart output
pico_enable_stdio_usb(${PROJECT_NAME} 0)
pico_enable_stdio_uart(${PROJECT_NAME} 1)


2022年10月1日 星期六

Raspberry Pi Pico PIO(Programmable IO) Episode 1: 4x4 matrix keypad

一、Raspberry PIO簡述: 

Raspberry Pi pico比較獨特的是具有PIO(programmable IO),相當於具有8小型的專門處理IO的處理器,分為兩個PIO區塊,每個區塊有4個StateMachine,其架構如下圖所示:

(PIO block, 取自RP2040 datasheet)
  1. 每個PIO block的4個StateMachine共用32 Instructions 的Instruction Memory,雖然小但也夠用。
  2. 每個StateMachine有4個32 bits output FIFO與4個32 bits input FIFO,有可結合成單一方向的8個32 bits FIFO。
  3. 有兩個通用32 bits register: X and Y
  4. ISR 與OSR: input shift register and output shift register
  5. Clock Div: 可除頻1~65536。

(StateMachine, 取自RP2040 datasheet)
指令集:
(取自RP2040 datasheet)


二、4x4 Keypad:


腳位從左到右為pin1~pin8,pin1~4同一時間只能有一個腳位設為High,當pin1為high時,按下key 1,則pin5輸出為hight。

三、實做Raspberry Pi Pico PIO:

使用MicroPython程式語言來實作。
4x4 keypad與raspberry pi pico腳位接線如上圖所示。

pin 1~4同時間只能有一個腳位為高電位,使用PIO1 block的StateMachine(4) set(pins,4)指令達成需求,程式碼如下:

@rp2.asm_pio(set_init=(rp2.PIO.OUT_LOW,rp2.PIO.OUT_LOW,rp2.PIO.OUT_LOW,rp2.PIO.OUT_LOW))
def scanRowHigh():
    wrap_target()
    set(pins, 1) [3] # each pin is high for at least 8 cycles (1+3+1+1+1+1)
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    set(pins, 2) [3] 
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    set(pins, 4) [3] 
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    set(pins, 8) [3]
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    wrap()

smr = rp2.StateMachine(4, scanRowHigh, freq=2000, set_base=Pin(2), in_base=col1pin)
smr.active(1)

第一行(1,4,7,*)鍵按下時,則pin5為高電位,使用PIO0 StateMachine(0) 的指令jmp(pin, "which_row")來判斷是否有按鍵按下。若有按鍵按下則使用in_(pins,4)來讀取GPIO2~5是那一個pin是高電位,則可判斷是那一個按鍵按下。接下來觸發irq,使用指令irq(rel(0))輸出按鍵內容。最後等待按鍵釋放(wait(0, pin, 0)。第二行按鍵使用PIO0 StateMachine(1) ,第三行按鍵使用PIO0 StateMachine(2),第四行按鍵使用PIO0 StateMachine(3)。程式碼如下所示。

@rp2.asm_pio()
def keypad():
    wrap_target()
    label("start")
    jmp(pin, "which_row") 
    jmp("start")
    label("which_row")
    in_(pins,4)
    push() 
    irq(rel(0)) [31] #wait for button bounce(at least 30ms: (32+32)*0.5ms)
    label("delay")
    nop() [31]
    jmp(pin, "delay") # wait for key to be released
    wrap()
    
def getkeyvalue(sm):
    row=-1
    if sm == rp2.StateMachine(0):
        row=0
    elif sm == rp2.StateMachine(1):
        row=1
    elif sm == rp2.StateMachine(2):
        row=2
    elif sm == rp2.StateMachine(3):
        row=3
    
    while sm.rx_fifo() :
        term = sm.get()
        for i in range(4):
            if term >> i == 1:
                print(keyvalues[row][i])
                break;

keyvalues=[["1","4","7","*"],
           ["2","5","8","0"],
           ["3","6","9","#"],
           ["A","B","C","D"]]

col1pin=Pin(6, Pin.IN, Pin.PULL_DOWN)
col2pin=Pin(7, Pin.IN, Pin.PULL_DOWN)
col3pin=Pin(8, Pin.IN, Pin.PULL_DOWN)
col4pin=Pin(9, Pin.IN, Pin.PULL_DOWN)

smc1=rp2.StateMachine(0, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col1pin)
smc2=rp2.StateMachine(1, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col2pin)
smc3=rp2.StateMachine(2, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col3pin)
smc4=rp2.StateMachine(3, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col4pin)

smc1.irq(getkeyvalue)
smc2.irq(getkeyvalue)
smc3.irq(getkeyvalue)
smc4.irq(getkeyvalue)
smc1.active(1)
smc2.active(1)
smc3.active(1)
smc4.active(1)

四、成果影片:


五、完整程式碼:

第二個程式碼為修正第二版,程式碼更簡潔。
👉第一版
from machine import Pin
import rp2

@rp2.asm_pio(set_init=(rp2.PIO.OUT_LOW,rp2.PIO.OUT_LOW,rp2.PIO.OUT_LOW,rp2.PIO.OUT_LOW))
def scanRowHigh():
    wrap_target()
    set(pins, 1) [3] 
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    set(pins, 2) [3] 
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    set(pins, 4) [3] 
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    set(pins, 8) [3]
    wait(0,pin,0)
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3) 
    wrap()
    
@rp2.asm_pio()
def keypad():
    wrap_target()
    label("start")
    jmp(pin, "which_row") 
    jmp("start")
    label("which_row")
    in_(pins,4)
    push() 
    irq(rel(0)) [31] 
    label("delay")
    nop() [31]
    jmp(pin, "delay") # wait for key to be released
    wrap()
    
def getkeyvalue(sm):
    row=-1
    if sm == rp2.StateMachine(0):
        row=0
    elif sm == rp2.StateMachine(1):
        row=1
    elif sm == rp2.StateMachine(2):
        row=2
    elif sm == rp2.StateMachine(3):
        row=3
    
    while sm.rx_fifo() :
        term = sm.get()
        for i in range(4):
            if term >> i == 1:
                print(keyvalues[row][i])
                break;

keyvalues=[["1","4","7","*"],
           ["2","5","8","0"],
           ["3","6","9","#"],
           ["A","B","C","D"]]

col1pin=Pin(6, Pin.IN, Pin.PULL_DOWN)
col2pin=Pin(7, Pin.IN, Pin.PULL_DOWN)
col3pin=Pin(8, Pin.IN, Pin.PULL_DOWN)
col4pin=Pin(9, Pin.IN, Pin.PULL_DOWN)

smc1=rp2.StateMachine(0, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col1pin)
smc2=rp2.StateMachine(1, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col2pin)
smc3=rp2.StateMachine(2, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col3pin)
smc4=rp2.StateMachine(3, keypad, freq=2000,  in_base=Pin(2),jmp_pin=col4pin)

smr = rp2.StateMachine(4, scanRowHigh, freq=2000, set_base=Pin(2), in_base=col1pin)
smr.active(1)

smc1.irq(getkeyvalue)
smc2.irq(getkeyvalue)
smc3.irq(getkeyvalue)
smc4.irq(getkeyvalue)
smc1.active(1)
smc2.active(1)
smc3.active(1)
smc4.active(1)
👉第二版
from machine import Pin
import rp2

@rp2.asm_pio(set_init=(rp2.PIO.OUT_LOW,)*4)
def keypad():
    wrap_target()
    label("set_row_1")
    set(pins, 1) [31]  #set row_1 High and wait for button bounce
    set(x,0x1)
    in_(pins,4)
    mov(y, isr)
    jmp(not_y,"set_row_2")
    jmp("rx_fifo")
    
    label("set_row_2")
    set(pins, 2) [31]
    set(x,0x2)
    in_(pins,4)
    mov(y, isr)
    jmp(not_y,"set_row_3")
    jmp("rx_fifo")
    
    label("set_row_3")
    set(pins, 4) [31]
    set(x,0x4)
    in_(pins,4)
    mov(y, isr)
    jmp(not_y,"set_row_4")
    jmp("rx_fifo")
    
    label("set_row_4")
    set(pins, 8) [31]
    set(x,0x8)
    in_(pins,4)
    mov(y, isr)
    jmp(not_y,"set_row_1")
  
    
    label("rx_fifo")
    push()              #push y(col) 
    in_(x,4)[2]
    push()              #and then x(row)
    irq(rel(0))
    
    wait(0,pin,0)  # check whether key is released
    wait(0,pin,1)
    wait(0,pin,2)
    wait(0,pin,3)
    wrap()   # total 31 instructions
    
keys=[["1","2","3","A"],
      ["4","5","6","B"],
      ["7","8","9","C"],
      ["*","0","#","D"]]

def keypad_irq(sm):
    y=sm.get()
    x=sm.get()
    for i in range(4):
        if x >> i == 1:
            break;
    for j in range(4):
        if y >> j == 1:
            break;
    print(keys[i][j])
    
smkeypad=rp2.StateMachine(0, keypad, freq=2000, set_base=Pin(2), in_base=Pin(6))
smkeypad.irq(keypad_irq)
smkeypad.active(1)