PIO 可程式化輸入輸出

從 PIO 透過 GPIO 與外部裝置收發資料開始,理解 TX/RX、先進先出的 FIFO、移位暫存器與資料路徑,再用內部往返練習拆開 pull、out、in、push、自動搬運與 stall。

今天接著上一篇位元運算,來看 PIO。

前面已經知道,想設定硬體的某個功能,可以先算好位元,再透過對應的暫存器寫進去。

但如果這次的需求,不只是「把一個腳位設成 1」,而是要把一串資料送出去呢?

例如先送一個 0,隔一段時間再送一個 1,每個位元還要配合固定的節奏。難道 CPU 得一直盯著時鐘,時間到了就去改一次腳位?

可以這樣做,但如果它中途還有其他事情要忙,這個節奏就得另外想辦法維持。

所以這次要看的,是能不能把這種工作交給另一組硬體,讓 CPU 準備資料,而它負責依照我們寫好的步驟處理。

至於為什麼又繼續往微處理器走,那當然還是因為前面的需求還沒結束。CI/CD 的坑先放在旁邊,至少我還記得它在那裡。

一、PIO 是什麼?

PIO 是 Programmable I/O,也就是可程式化輸入輸出。這篇說的是 Raspberry Pi 微控制器裡的 PIO,並以 RP2040 為例,使用 Pico SDK 的 C 與 .pio 組合語言寫法。

先不要被「可程式化」嚇到,可以把它理解成:晶片裡有一組專門處理輸入輸出的硬體,我們能替它寫一小段程式,決定什麼時候讀取腳位、輸出資料,或等待某個條件。

真正依序執行這些指令的,叫做狀態機(State Machine,SM)。

它會記住目前執行到哪裡、暫存器裡放了什麼,然後依照指令往下一步走。需要等待時,就留在目前這一步,等條件滿足再繼續。

「所以,是另外一顆 CPU 嗎?」

可以拿「能自己執行一小段程式」來幫助理解,但不能直接把它當成另一顆通用 CPU。PIO 的指令很精簡,主要處理資料移動、腳位、跳躍與等待,不是拿來執行一般的 C 程式。

例如要解析一大段文字、計算複雜公式,還是交給 CPU 比較適合;但如果是照著固定節奏,把位元一個一個送到腳位,PIO 就很適合接手。

這些腳位連到的是外部裝置。例如用 PIO 實作 UART,把資料送給另一塊板子、接收對方傳來的位元,或依照 LED 燈條的時序送出顏色資料。PIO 程式負責安排何時輸出、何時取樣,以及何時等待訊號。RP2040:PIO 應用範例,第 3.6 節

這裡的「CPU 以外」,是指由晶片內另一組硬體執行,不是還要在開發板旁邊多接一顆晶片。

一個 PIO,裡面不只一個狀態機

RP2040 有兩個 PIO 區塊,每個區塊有四個狀態機。每個狀態機都有自己的執行狀態、資料暫存器與 FIFO,但同一區塊的四個狀態機,共用一份能容納 32 條指令的程式記憶體。

所以,PIO 區塊和狀態機,是兩個不同層次。平常說「讓 PIO 跑這段程式」,實際上還會選擇要讓哪個狀態機執行。

這些容量是本篇使用的 RP2040 規格,換成其他晶片時,要再看對應文件。RP2040 資料手冊,第 3 章

精準控制,精準在哪裡?

一般 PIO 指令在沒有額外延遲、也沒有等待的情況下,一個狀態機時脈週期就能完成。配合時脈分頻與指令延遲,就能安排每一步的時間。

這樣 CPU 去做其他事情時,狀態機仍然能繼續跑自己的程式,不必每切換一次腳位,就等 CPU 執行一次寫入。

但這不代表 PIO 永遠不會停。如果程式需要下一筆資料,資料卻還沒送來,它還是可能等待。這正是後面要講的 stall。

先記住這個分工就好:CPU 負責設定與管理,PIO 狀態機依程式控制 GPIO,與外部裝置收發訊號。 需要連續搬資料時,還能由 DMA 在記憶體與 PIO 之間搬運,不必每筆都讓 CPU 親自處理。

二、對外收發的資料,怎麼進出 PIO?

先把完整的路徑分成兩邊:晶片內透過 FIFO 交接資料,晶片外透過 GPIO 傳遞訊號。

要傳送時,CPU 或 DMA 把資料寫進 TX FIFO,狀態機再取出,依照程式安排送到 GPIO,讓外部裝置接收。例如把上一篇出現的 0x1A 排進 TX FIFO,之後由 PIO 一個位元、一個位元地送出去。

要接收時,狀態機從 GPIO 取樣,累積資料後放進 RX FIFO,再由 CPU 讀取,或交給 DMA 搬到記憶體。

把對外的那一端也畫出來:

傳送由 CPU 或 DMA 經 TX FIFO、PIO 狀態機與 GPIO 到外部裝置;接收由外部裝置經 GPIO、PIO 狀態機與 RX FIFO 回到 CPU 或 DMA。
TX 供應待傳送的資料,RX 暫存收到的資料;對外收發由 PIO 控制 GPIO 完成,兩個方向可以分開使用。

TX 是 transmit(傳送),RX 是 receive(接收)。 在這條常見的對外通訊路徑裡,TX 對應準備向外送出的資料,RX 對應從外面收到的資料。

更精確地說,RP2040 的 TX FIFO 定義為系統端 → 狀態機,RX FIFO 定義為狀態機 → 系統端;系統端可以是 CPU,也可以是 DMA。這兩個名稱固定,不會隨著站在哪一側看而交換。外部裝置接的是 GPIO,FIFO 則負責晶片內的資料交接。RP2040:FIFO,第 3.2.3.5 節

PIO 也能只輸出、只接收,或執行不經 FIFO 的腳位控制程式。後面會用「把數字原樣送回 CPU」練習內部搬運,那只是其中一種程式安排。

不過,為什麼不直接用一個暫存器交接,還要多放一個 FIFO?

FIFO:先進去的,先拿出來

FIFO 是 First In, First Out,也就是先進先出。

它是一個有順序的佇列。可以想像成一條通道:新資料從入口推入,最早進入的資料先從另一端取出。 這樣資料的供應端與取用端,不必每一筆都剛好在同一個瞬間交接。

例如原本依序放入 0x1A、0x80、0x05、0x03。現在一邊從右側取出、一邊從左側補入 0xF0,可以把這段過程想像成:新的一筆擠入通道,整排向右推進,最早進入的 0x1A 先從另一端出來。

FIFO 是一條兩端開口的通道,最新的 0xF0 正從左端推入,最早的 0x1A 正從右端取出;中間資料依原本順序向右前進。
把一次寫入與一次讀出,畫成同一段推進動作:左端進一筆,右端先出最早進入的那筆。

圖中的「擠出」是在表現先後順序;實際上要有讀取操作,資料才會離開 FIFO,單純寫入不會把舊資料自動擠掉。

取一次,拿到 0x1A;再取一次,拿到 0x80。0x1A 被取走後,就不再占用佇列的位置。

所以這裡的「讀取」,不是像讀一般變數那樣,連讀三次都得到同一份內容,而是每取一筆,就把最前面的那筆移出佇列。

能排多少筆?

RP2040 的每個狀態機,在預設配置下,有各自獨立的 TX FIFO 和 RX FIFO,每邊都能放四筆 32 位元資料。

注意是四筆,不是四個位元,也不是四個位元組。

CPU 寫入 0x0000001A,會占一筆;寫入 0xFFFFFFFF,也占一筆。前面的零比較多,不會讓它少占一點位置。

佇列誰放進去誰取出來預設容量
TX FIFOCPU 或 DMAPIO 狀態機四筆 32 位元資料
RX FIFOPIO 狀態機CPU 或 DMA四筆 32 位元資料

這樣雙方就有一點緩衝空間。但緩衝終究有限,CPU 一直送、PIO 一直來不及處理,TX FIFO 還是會滿。

至於滿了或空了會發生什麼,要看是哪一邊正在做哪個操作。我們先把資料在 PIO 裡的路走完,再回來看它會停在哪裡。

如果只需要傳送,另一邊的 FIFO 能借來用嗎?

可以。RP2040 支援 FIFO joining,能把同一個狀態機的 FIFO 空間合併,改成單方向的八筆容量。

例如合併給 TX,TX 就能放八筆,但 RX 會停用。這不是兩邊都一起擴充成八筆。

後面的內部往返練習會同時使用兩邊,所以保留 TX、RX 各四筆的配置。Pico SDK:PIO FIFO 設定

三、OSR、ISR、X、Y,又各自在做什麼?

FIFO 是等候交接的地方。但狀態機通常不會每送出一個位元,就重新去 FIFO 拿一整筆資料。

它會先把一筆資料放到 OSR(Output Shift Register,輸出移位暫存器),接著依照指令,一次取出需要的位元。

例如拿到一筆 32 位元的資料後,可以每次移出一個位元,也可以一次移出八個。

「移位」是不是有點熟悉了?前一篇用 >>、<< 看數字怎麼移動,這裡則是硬體直接替我們維護這份待處理的資料。

另一邊的 ISR(Input Shift Register,輸入移位暫存器),則用來累積移進來的位元。累積到準備交出去時,再把內容送進 RX FIFO。

這裡的 ISR 指的是輸入移位暫存器,不是有些程式文件裡用同樣縮寫表示的中斷服務常式。

X 和 Y,是旁邊的暫存空間

除了 OSR 和 ISR,每個狀態機還有 X、Y 兩個工作暫存器,可以保存中間資料,也常拿來放迴圈計數。

這四個暫存器都是 32 位元,但用途不同:

名稱這篇先使用的角色
OSR保存準備移出的資料
X、Y暫存資料,或作為計數等工作用途
ISR累積移入、準備交回的資料

前面的對外傳送路徑,是把 OSR 裡的位元送到 GPIO;接收路徑,則是把 GPIO 取樣的位元移入 ISR。

接著把這些位置和指令接起來,用同一筆資料看每一步從哪裡搬到哪裡。

四、用四條指令,讓數字走一圈

先做一個只在晶片內搬資料的練習:CPU 送進 0x0000001A,PIO 用 X 暫存,再原樣送回 CPU。 這樣可以先追清楚每一條指令的起點與終點,不必同時處理外部裝置的腳位時序,也不需要接 GPIO。

程式使用 Pico SDK 的 pioasm 語法,放在 .pio 檔案裡。先假設狀態機已完成初始化,關閉 autopull、autopush,而且 OSR、ISR 都設定為向右移;初始化的 C 程式後面再補。

狀態機依序執行這四條指令:

pull block
out x, 32
in x, 32
push block

把每條指令接到資料路徑上,就是下面這張圖。我們沿著箭頭,跟著 0x0000001A 走一次:

CPU 寫入 TX FIFO,PIO 透過 pull、out x、in x、push,讓資料依序經過 OSR、X、ISR、RX FIFO,再由 CPU 讀回。
圖中的四段搬運,依序對應下方的 pull、out、in、push。

1. pull:從 TX FIFO 拿到 OSR

CPU 先把 0x0000001A 放進 TX FIFO。接著狀態機執行:

pull block

它會從 TX FIFO 取出最前面的一筆 32 位元資料,放進 OSR。

階段位置內容
執行前TX FIFO[0x0000001A]
執行後TX FIFO[],這筆已取出
執行後OSR0x0000001A

這裡不是「CPU 從 PIO 拉資料」,而是 PIO 把 TX FIFO 的資料拉進 OSR。

如果 TX FIFO 沒有資料,block 就表示停在這裡等。先把這件事記著,後面會看到它其實很有用。

還有,pull 是取出一整筆,放進 OSR,不是把新資料接在 OSR 剩下的內容後面。手動使用時,要自己安排好什麼時候需要換下一筆。

2. out:把 OSR 的位元移到指定位置

接著執行:

out x, 32

意思是從 OSR 移出 32 個位元,寫到 X。

這次剛好整份移完,所以 X 得到 0x0000001A;OSR 的位元移出後補零,內容變成 0。

這裡的 out,是從 OSR 往外移,不一定代表已經送到晶片外面。目的地是 X,資料就還在狀態機裡。

如果寫成 out pins, 1,目的地才是對應的腳位。最後的數字表示移出的位元數,不是想輸出的數值,也不是 GPIO 編號。

3. in:把來源的位元移進 ISR

現在資料在 X,接著執行:

in x, 32

它會取 X 的 32 個位元,移入 ISR。結果 ISR 得到 0x0000001A。

注意,in 的目的地是 ISR,寫在後面的 X 是來源。它和 out x, 32 裡 X 的角色剛好不同。

而且,in x, 32 不會把 X 清掉。它讀取 X 的內容,用來更新 ISR,X 本身仍然保留原值。

這次每次搬完整的 32 位元,所以容易看出數字沒變。如果只移八位,就還要考慮移位方向,以及新資料最後落在 ISR 的哪一段,後面再看。

4. push:把 ISR 交給 RX FIFO

最後執行:

push block

它會把 ISR 的內容,當成一筆 32 位元資料放進 RX FIFO。成功後,ISR 內容與輸入移位計數都會清成 0,準備下一筆。

階段ISRRX FIFO
執行前0x0000001A[]
執行後0x00000000[0x0000001A]

如果 RX FIFO 已經滿了,這個 push block 就得等到有位置,才能完成。

走到這一步,CPU 才能從 RX FIFO 取回 0x0000001A。數字雖然沒變,但已經經過了不同的儲存位置。

把四條指令放在一起看

指令起點終點這次搬多少
pull blockTX FIFOOSR一筆 32 位元資料
out x, 32OSRX32 個位元
in x, 32XISR32 個位元
push blockISRRX FIFO一筆 32 位元資料

所以,pull/push 負責 FIFO 和移位暫存器之間的交接,out/in 則負責移出或移入位元。

out、in 一次可以指定 1~32 個位元;pull、push 則是一整筆 32 位元的 FIFO 交接。這兩個層次不要混在一起。RP2040:PIO 指令集,第 3.4 節

這次讓資料經過 X,是為了示範 out 和 in 怎麼搬資料;也可以用 Y 取代 X。對外收發時,out 可以直接把 OSR 的位元送到腳位,in 也可以直接從腳位移入 ISR,X、Y 有需要才使用。第九節再把這兩條指令接回 GPIO,看真正的對外收發。

五、做完一次之後,怎麼繼續?

剛才只讓一筆資料走完。但 CPU 如果接著送第二筆,總不能每次都重新啟動整個狀態機吧。

我們會希望,執行完 push 之後,回到最前面的 pull,繼續處理下一筆。

這裡就可以使用 wrap。

建立 pio-echo.pio,把程式寫成:

.program pio_echo

.wrap_target
    pull block
    out x, 32
    in x, 32
    push block
.wrap

.program pio_echo 是替這段程式取名字。.wrap_target 標記要回到的位置,.wrap 則標記迴圈最後一條指令的位置。

在這個例子裡,執行完 push block,下一步就回到 pull block:

pull block、out x 32、in x 32、push block 依序執行,完成 push 後由 wrap 返回 pull。
wrap 指定返回的位置,不會重設資料,也不占額外指令週期。

不過,這裡有一個重要的區別:.wrap_target 和 .wrap 是組譯器指示,不是狀態機另外執行的兩條指令。

它們會提供迴圈邊界的設定,讓硬體在這個位置返回。因此,這支程式仍然只有四條指令,返回本身不需要多花一條跳躍指令的週期。

後面使用的 pio_echo_program_get_default_config(offset),會把這些邊界放進狀態機設定。不是只在文字檔裡寫好 .wrap,尚未載入與設定的硬體就會自己知道。

還有,wrap 只是在安排下一條指令的位置,不會順便把 X、Y、OSR、ISR 或 FIFO 全部重設。

例如這裡 ISR 會清空,是前面的 push 做的;X 保留上一筆,是因為沒有其他指令改它。不能把回到程式開頭,理解成整台狀態機重新開機。

六、CPU 這一端,要怎麼配合?

這一節只做一件事:讓 CPU 送出 0x0000001A,交給前面的四條 PIO 指令處理,再讀回同一個數字。

要讓這件事發生,CPU 得先替狀態機準備好程式與設定,最後才開始送資料。我們就沿著下面同一段 C 程式,從第一行走到最後一行。前四步在開始運作前做一次,第五步才是之後每一筆資料都會重複的工作。

以下承接前面的 pio-echo.pio;建置時產生的 pio-echo.pio.h,讓 C 程式能引用那四條指令。標頭檔與 CMake 的完整接法放在本節最後。

// 1. 選好要執行程式的狀態機
PIO pio = pio0;
uint sm = pio_claim_unused_sm(pio, true);

// 2. 把那四條指令載入這個 PIO 區塊
uint offset = pio_add_program(pio, &pio_echo_program);

// 3. 準備執行設定,套用到剛才選好的狀態機
pio_sm_config config = pio_echo_program_get_default_config(offset);
sm_config_set_out_shift(&config, true, false, 32);
sm_config_set_in_shift(&config, true, false, 32);
sm_config_set_fifo_join(&config, PIO_FIFO_JOIN_NONE);
pio_sm_init(pio, sm, offset, &config);

// 4. 啟動狀態機
pio_sm_set_enabled(pio, sm, true);

// 5. 送進一筆資料,再取回一筆結果
pio_sm_put_blocking(pio, sm, 0x0000001Au);
uint32_t received = pio_sm_get_blocking(pio, sm);

1. 先決定:由哪個狀態機執行?

先看程式最前面的兩行。pio0 是第一個 PIO 區塊,我們把它記在 pio;接著 pio_claim_unused_sm(pio, true) 從這個區塊裡取得一個可用的狀態機,把它的編號記在 sm。

因此,pio 和 sm 合起來,指的就是接下來要替我們工作的那個狀態機。 後面初始化、啟動、送資料、收資料,都會使用這同一組值。

例如送資料時的 pio_sm_put_blocking(pio, sm, ...),就是把資料送進這個狀態機的 TX FIFO。這裡先選好它,後面才有明確的交接對象。

到這一步,我們已經選好由誰執行。下一步,要把它準備執行的指令放進去。

2. 再準備:它要執行哪一份程式?

接著看 uint offset = pio_add_program(pio, &pio_echo_program);。

這裡的 pio_echo_program 就是前面那份 .program pio_echo 組譯後的程式,裡面有 pull、out、in、push 四條指令。pio_add_program 把它們載入 pio 代表的 PIO 區塊,再回傳放置的起點,記在 offset。

為什麼要記住起點?因為同一個 PIO 區塊裡的狀態機共用程式記憶體,這份程式會被安排在其中一段空間。稍後要告訴剛才選好的狀態機:從 offset 指向的第一條指令開始執行。

現在兩件事都備齊了:pio、sm 記住執行者,offset 記住這份程式的起點。接下來要準備的,是這個執行者的工作方式。

3. 告訴它怎麼執行,再把設定交給它

程式中間的 pio_sm_config config = ...,建立了一份叫做 config 的設定資料。這份資料由 CPU 準備,寫下狀態機接下來要採用的執行方式。

pio_echo_program_get_default_config(offset) 先依照這份程式的起點,準備好 wrap 邊界。接著三行設定,對應這次練習的三個安排:

  • sm_config_set_out_shift:OSR 向右移,關閉 autopull,移位門檻設為 32。
  • sm_config_set_in_shift:ISR 向右移,關閉 autopush,移位門檻設為 32。
  • sm_config_set_fifo_join:保留 TX、RX 各四筆,讓資料能送進去,也能收回來。

這些設定配合的是前面的四條 PIO 指令:因為程式已經明確寫了 pull、push,這裡先關閉自動搬運,讓每一次 FIFO 交接都由那兩條指令負責。下一節再改成自動搬運。

前面這幾行先把內容寫在 config 裡,接著的 pio_sm_init(pio, sm, offset, &config) 才把它套用到那個狀態機。 這一行把剛才準備的東西接在一起:

傳入的值從哪一步得到這次要告訴硬體的事
pio、sm第一步選好的執行者要設定哪個狀態機
offset第二步載入程式後記下的起點從哪一條指令開始
&config這一步寫好的設定資料採用哪些移位、FIFO 與 wrap 設定

所以,可以把這次初始化讀成一句話:讓剛才選好的那個狀態機,從這份程式的起點,依照這份設定準備執行。

到這裡,它已經知道要執行什麼、從哪裡開始、要怎麼執行。下一步才讓它真正開始跑。Pico SDK:狀態機設定 API

4. 啟動,讓它等第一筆資料

現在才執行 pio_sm_set_enabled(pio, sm, true),啟動剛才準備好的同一個狀態機。

它從 offset 指向的 pull block 開始。此時 CPU 還沒送資料,TX FIFO 是空的,所以狀態機先停在這條指令等待;CPU 則繼續執行下一行 C 程式。

這正是本篇的配合方式:PIO 先準備好接資料,CPU 再把資料送進去。 前四步到這裡就完成了,之後處理下一筆資料時,沿用這個已啟動的狀態機。

5. 送一筆,讓它跑四步,再收回結果

最後兩行,才是 CPU 每次要處理一筆資料時的交接。

先執行 pio_sm_put_blocking(pio, sm, 0x0000001Au)。這仍然使用第一步記下的 pio、sm,把 0x0000001A 放進那個狀態機的 TX FIFO;如果 FIFO 已滿,CPU 就等有空位再放。

資料放進去之後,剛才等在 pull block 的狀態機就能繼續:

  1. pull block:從 TX FIFO 取出這筆資料,放進 OSR。
  2. out x, 32:把 OSR 的 32 位元移到 X。
  3. in x, 32:把 X 的 32 位元移進 ISR。
  4. push block:把 ISR 裡的結果放進 RX FIFO。

這四步由狀態機照著已載入的程式執行。CPU 接下來執行的,是 uint32_t received = pio_sm_get_blocking(pio, sm):從同一個狀態機的 RX FIFO,取出一筆資料存進 received。

如果 CPU 走到 get 時,PIO 還沒把結果放進 RX FIFO,CPU 就先等;如果結果已經在裡面,就能取出。在本篇送一筆、收一筆的安排下,received 會得到剛才送入的 0x0000001A。

把這次交接畫出來,就是下面的順序:

CPU 先 put 到 TX FIFO,PIO 依序完成 pull、out、in、push,CPU 再從 RX FIFO get 回結果。
同一個狀態機持續執行;CPU 每次透過 put 送入,再透過 get 取回。

put 完成,表示資料已經成功寫進 TX FIFO;get 完成,才表示 CPU 已經取到一筆結果。 CPU 與 PIO 可以同時往前走,因此 put 回傳時,資料可能還在 FIFO 裡,也可能已被狀態機取走,不能用它來判斷 PIO 是否做完。

這裡的 blocking 表示 CPU 會在函式裡反覆檢查 FIFO,等條件滿足才返回。第八節再比較 CPU 等待和 PIO stall 各自發生在哪裡。Pico SDK:PIO FIFO 讀寫 API

處理下一筆時,就重複第五步的 put、get。前面的 pio、sm、offset 與 config 都已經完成準備,不必每送一筆就再做一次初始化。

設定裡的 true、false、32,還有 init 的細節

以 sm_config_set_out_shift(&config, true, false, 32) 為例,四個參數依序是:要修改的設定資料、是否向右移、是否啟用 autopull,以及輸出移位計數的門檻。in_shift 的順序相同,但設定的是 ISR 與 autopush。

這次門檻雖然設為 32,autopull、autopush 都是 false,因此仍由程式中的 pull、push 明確交接。wrap 邊界則由產生的 pio_echo_program_get_default_config(offset) 根據指令放置的起點設定。

pio_sm_init 會先停用這個狀態機、套用設定、清空它的 FIFO,重設移位計數等執行狀態,再把執行位置設到指定的起點。這也是為什麼要先初始化,再啟動與送資料。Pico SDK:pio_sm_init 實作

第一步的 pio_claim_unused_sm(pio, true),其中 true 表示一定要取得一個狀態機;若已沒有可用資源,SDK 會觸發 panic。

想在 Pico SDK 專案裡跑一次,完整檔案怎麼放?

這個練習需要 RP2040 開發板,以及已準備好 Pico SDK 的建置環境。它不使用 GPIO,不必接外部電路,也不能當成一般桌面 C 程式直接執行。

在已呼叫 pico_sdk_init() 的專案裡,讓 main.c 和前面的 pio-echo.pio 放在同一個目錄,再加入以下 CMake 設定:

add_executable(pio_echo main.c)

pico_generate_pio_header(pio_echo
    ${CMAKE_CURRENT_LIST_DIR}/pio-echo.pio
)

target_link_libraries(pio_echo pico_stdlib hardware_pio)
pico_enable_stdio_usb(pio_echo 1)
pico_enable_stdio_uart(pio_echo 0)
pico_add_extra_outputs(pio_echo)

pico_generate_pio_header 會在建置時呼叫 pioasm,產生 C 程式要引用的標頭檔,不需要自己手寫 pio-echo.pio.h。

main.c 如下:

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "pio-echo.pio.h"

int main(void) {
    stdio_init_all();

    PIO pio = pio0;
    uint sm = pio_claim_unused_sm(pio, true);
    uint offset = pio_add_program(pio, &pio_echo_program);

    pio_sm_config config = pio_echo_program_get_default_config(offset);
    sm_config_set_out_shift(&config, true, false, 32);
    sm_config_set_in_shift(&config, true, false, 32);
    sm_config_set_fifo_join(&config, PIO_FIFO_JOIN_NONE);

    pio_sm_init(pio, sm, offset, &config);
    pio_sm_set_enabled(pio, sm, true);

    const uint32_t values[] = {
        UINT32_C(0x1A), UINT32_C(0x80), UINT32_C(0x05)
    };

    while (true) {
        for (uint i = 0; i < 3; ++i) {
            pio_sm_put_blocking(pio, sm, values[i]);
            uint32_t received = pio_sm_get_blocking(pio, sm);
            printf("sent: 0x%08" PRIX32 ", received: 0x%08" PRIX32 "\n",
                   values[i], received);
        }
        sleep_ms(1000);
    }
}

依照原本專案的流程建置、燒錄後,開啟開發板的 USB 序列埠。程式會每秒重複一組輸出,預期看到:

sent: 0x0000001A, received: 0x0000001A
sent: 0x00000080, received: 0x00000080
sent: 0x00000005, received: 0x00000005

這裡刻意採用「送一筆、收一筆」。如果改成一直送、最後才收,RX FIFO 滿了之後,可能連帶讓整條路都停下來,後面會說明原因。

建置方式與 API 可以對照 Pico SDK 文件及官方 PIO 範例。

七、每次都 pull、push,能不能自動做?

回頭看剛才的迴圈,每處理一筆資料,要做四件事:

  1. pullTX FIFO → OSR
  2. outOSR → X
  3. inX → ISR
  4. pushISR → RX FIFO

但中間兩步,才是這支程式實際安排的資料操作。前後兩步都是固定的補資料、交資料。

如果硬體能自己記住「已經移出多少位元」,是不是就能在需要時,自動取下一筆?

可以,這就是 autopull。另一邊把 ISR 自動送進 RX FIFO,則叫做 autopush。

1. 硬體看的是移位計數,不是數值

OSR 和 ISR 各有自己的移位計數。

OSR 那邊記錄已經移出了多少位元;ISR 那邊記錄已經移入了多少位元。當計數達到設定的門檻,就能觸發對應的自動搬運。

例如把門檻設成 32:

  • OSR 移出累計 32 位元後,這筆就用完了,可以補下一筆。
  • ISR 移入累計 32 位元後,就把這份結果交到 RX FIFO。

這裡的「用完」不是說數值變成 0。

如果 CPU 傳進來的本來就是 0x00000000,它仍然是一筆有效資料,要照樣處理 32 個位元。反過來,就算 OSR 還有非零位元,設定的門檻到了,也可能要換下一筆。

判斷依據是移位計數和門檻,不是暫存器裡還剩幾個 1。

2. 把四條指令縮成兩條

在這個完整 32 位元往返的例子裡,可以把 pio-echo.pio 改成:

.program pio_echo

.wrap_target
    out x, 32
    in x, 32
.wrap

同時把 C 程式裡的兩行設定改成:

sm_config_set_out_shift(&config, true, true, 32);
sm_config_set_in_shift(&config, true, true, 32);

這次第二個布林值都改成 true,分別啟用 autopull 和 autopush;方向仍然向右,門檻仍然是 32。

兩個檔案都改好後,重新建置並燒錄。只刪掉 .pio 裡的 pull、push,卻沒有開啟自動搬運,資料不會自己找到路。

現在 out x, 32 使用 OSR 裡的資料,硬體負責在需要時從 TX FIFO 補入;in x, 32 一次就達到輸入門檻,硬體會把結果送到 RX FIFO,再清空 ISR 與輸入計數。

因此,CPU 一端仍然是原本的 put、get,預期讀回的數字也相同。省掉的是 PIO 程式裡明確搬運 FIFO 的指令。

資料順暢、沒有 stall 時,這個迴圈可以每兩個狀態機週期處理一筆。剛啟動時的補資料,以及之後等待 FIFO 的時間,則不能直接算成永遠只有兩個週期。

第一條指令就是 out,OSR 最開始哪來的資料?

狀態機重啟後,OSR 的移位計數會被設成 32,表示需要補入資料。啟用 autopull 後,硬體會依門檻判斷並從 TX FIFO 補入,不需要再手動加一個起始 pull。

如果 out 要執行時仍然沒有可用資料,就會先停住。即使這個週期成功補入,RP2040 也不能在同一個週期同時把這份剛補進空 OSR 的資料移出,要到下一個週期才能使用。

穩定運作時,則可能在移出目前資料的同時,補好下一筆;也可能在兩條 out 之間完成補入。

所以 autopull 不只是「在原本指令後面偷偷加一條 pull」。它由硬體配合移位計數管理,精確時序可以看資料手冊第 3.5.4 節。

3. 門檻設成 8,FIFO 就變成八位元了嗎?

不會。門檻決定累積多少位元後交接,不會改變 FIFO 每筆 32 位元的寬度。

例如 TX FIFO 裡放的是 0x1234561A,OSR 向右移,而 autopull 門檻設成 8:

OSR 的 0x1234561A 向右移出低八位 0x1A 到 X;門檻為 8 時,剩下的 0x123456 會在下一筆補入時被取代。
門檻決定何時換下一筆,不會把 FIFO 改成八位元寬。

執行一次 out x, 8,X 得到 0x0000001A,OSR 的輸出計數就達到門檻了。接下來補入新的 FIFO 資料時,原本剩下的 0x123456 會被取代,不會自動拆成另外三筆留著慢慢送。

如果原本想把同一筆 32 位元資料分成四次、每次八位全部送完,就應該把 pull 門檻設成 32。

接收端也要看方向。假設 ISR 原本是 0,向右移,執行 in x, 8,而 X 的低八位是 0x1A:

階段ISR 的內容
移入前0x00000000
移入後0x1A000000

因為 ISR 向右移,新進來的八個位元會放在空出的高八位。若 autopush 門檻是 8,此時送進 RX FIFO 的就是一整筆 0x1A000000。

CPU 想取得這次的八位元數值,可以把讀回結果右移 24 位。這不是 FIFO 把數字改壞了,而是我們得知道位元被放在哪裡。

這也接回前一篇:知道資料寬度、位移方向和欄位位置,才知道讀回來的 Hex 應該怎麼解讀。

八、FIFO 空了或滿了,誰會卡住?

現在終於可以回頭看 stall 了。

它指的是:狀態機目前這條指令還不能完成,所以程式計數器先不往下一條前進,等條件滿足再繼續。

例如程式停在 pull block,原因可能很單純:CPU 還沒送下一筆。

PIO 不需要另外寫一段「一直檢查 FIFO 有沒有資料」的迴圈。這條指令本身就能等。

1. TX FIFO 空了:沒有下一筆可拿

手動版本會停在:

pull block

CPU 後來把資料寫進 TX FIFO,條件滿足,這個 pull 就能完成,接著執行 out。

但在 autopull 版本裡,少了明確的 pull,就要看 out 執行時,OSR 是否已經需要補資料。如果需要補、TX FIFO 又沒有資料,out 就會等待。

所以,TX FIFO 空了,不代表狀態機立刻停止一切工作。 OSR 裡如果仍有這次能使用的資料,就還能繼續移出;程式裡不依賴新輸出資料的指令,也不會只因 TX FIFO 是空的就全部卡住。

關鍵是目前這條指令,需要的資料是否已經準備好。

2. RX FIFO 滿了:結果沒有地方放

手動版本的 push block,會等到 RX FIFO 有空位。

autopush 版本則是在 in 達到門檻、需要把結果交出去時,如果 RX FIFO 已滿,就停在這個交接點。

這時候 CPU 從 RX FIFO 讀走一筆,就騰出一個位置,讓狀態機把待送的結果放進去,再繼續往下執行。

不是 CPU 一讀走,PIO 就從整支程式的第一行重跑。它是完成剛才尚未完成的操作,再接下一條。

3. CPU 等待,和 PIO stall 是不同的事

我們前面的 C 函式也有 blocking。這時候等的是 CPU 呼叫的函式:

正在做的操作無法繼續的條件在哪裡等待
PIO pull blockTX FIFO 空了這個 PIO 狀態機
PIO push blockRX FIFO 滿了這個 PIO 狀態機
CPU pio_sm_put_blockingTX FIFO 滿了CPU 的這次函式呼叫
CPU pio_sm_get_blockingRX FIFO 空了CPU 的這次函式呼叫

Pico SDK 這兩個 blocking 函式,會在 CPU 上反覆檢查 FIFO 狀態,條件滿足才進行讀寫。它們沒有內建逾時,不能把呼叫它們理解成 CPU 已經自動去休眠了。Pico SDK:PIO API

反過來,某個 PIO 狀態機 stall,也不表示整顆微控制器都停止。CPU 和其他狀態機仍可繼續運作,只是後續如果又依賴這個狀態機的結果,也可能跟著等。

如果不想等待,直接用 noblock 就好了嗎?

要先看沒有資料或沒有空間時,自己願意接受什麼結果。

在本篇關閉自動搬運的手動情境裡,pull noblock 如果遇到空的 TX FIFO,會把 X 複製到 OSR,作為替代內容。它不是自動得到一筆新的 CPU 資料。

push noblock 遇到滿的 RX FIFO,則不會成功放入這筆結果,但仍會清空 ISR,這筆資料就遺失了。

CPU 一端也不能直接略過狀態檢查。對滿的 TX FIFO 做一般寫入,硬體不會替你排在第五個位置,而是忽略該次寫入並設定溢位旗標;從空的 RX FIFO 讀取,也不能把結果當成有效資料。

所以選擇不等待,還得安排缺資料、丟資料或重試的處理方式,不是換個名字就解決了流量問題。

4. 為什麼一直送,最後才收,可能永遠等不到最後?

假設我們把前面的練習改成:CPU 先連續送很多筆,全部送完才開始讀回結果。

一開始會正常運作,但 RX FIFO 最多只能放四筆。CPU 不讀,結果慢慢堆滿,PIO 就停在 push block。

PIO 停住之後,也不會繼續往下取得新的 TX 資料。CPU 如果還在送,TX FIFO 最後也會滿,於是 CPU 停在 pio_sm_put_blocking。

這時候就變成:

CPU 因 TX FIFO 滿而等待 PIO 消耗資料,PIO 因 RX FIFO 滿而等待 CPU 讀取結果,形成互相等待。
這個往返練習採用送一筆、讀一筆,避免只送不收塞滿兩個方向。

兩邊都在等對方先動,流程就走不下去了。

所以前面的「送一筆、收一筆」不是隨便安排的。它讓這個往返練習不會因為只送不收,把兩邊的佇列都塞滿。

之後需要持續傳輸時,可以安排交錯讀寫、根據 FIFO 狀態服務兩個方向,或使用中斷、DMA。這次先把原因看清楚,不急著把所有搬資料的方法一起塞進來。

九、那要怎麼真的接到腳位?

前面的內部往返練習,已經把 FIFO 與移位暫存器的交接拆開了。現在回到開頭的用途:讓 PIO 透過 GPIO,真的與外部裝置收發資料。

接到腳位時,out 的目的地改成 GPIO,in 的來源也改成 GPIO;腳位映射與時序則要依外部裝置的需求設定。

把輸出與接收分開畫,會比較清楚:

輸出由 CPU 或 DMA 經 TX FIFO、OSR、GPIO 到外部裝置;接收由外部裝置經 GPIO、ISR、RX FIFO 到 CPU 或 DMA,兩條路都不必經過 X 或 Y。
傳送往外走,接收從外面進來;out 的目的地與 in 的來源都可以是 GPIO。

這時候就不必經過 X、Y,也不一定同時使用 TX 和 RX。只傳送資料的程式,可能完全不需要把同一筆內容再送回 CPU。

例如驅動 LED 燈條時,顏色資料沿 TX 這一列送到外面;接收另一塊板子的 UART 訊息時,取樣結果沿 RX 這一列收進來。兩列可以對應不同的裝置或不同的狀態機,不表示外部裝置會把送出的資料原樣回傳。

out pins, 1:一次送一個位元

假設 OSR 裡放著 0x0000001A,設定向右移,並且已把 OUT 對應到一個輸出腳位。

0x1A 從 bit 0 開始依序輸出 0、1、0、1、1、0、0、0,相鄰兩個 1 維持高電位。
每次移出一位;腳位的電位不一定在每個位元邊界都改變。

每次 out pins, 1,會取出一個位元,更新那個腳位的輸出值。連續八次,才送完上面這八個位元。

如果相鄰兩個位元都是 1,腳位就會持續為高,不會因為「又送了一個 1」就一定多出一次跳變。外部裝置還需要根據約定的時序,知道什麼時候算下一個位元。

這裡的 1 是位元數,不是指定 GPIO 1。實際使用哪個 GPIO,要靠腳位映射設定。

in pins, 1:取樣一次,不是收到完整訊息

另一邊執行 in pins, 1,則是在這一步讀取映射到的輸入腳位,將一個位元移進 ISR。

它不會自己知道 UART 的起始位元在哪裡,也不會只因為設定 autopush,就自動辨認一份通訊協定。何時取樣、要等什麼訊號、每筆資料有幾位,都還是程式與設定要安排的事情。

真的使用 GPIO 時,也要先設定對應的 PIO 功能、輸入輸出方向,以及 IN/OUT 的腳位映射。前面那支內部往返程式沒有做這些設定,不能只把 X 換成 pins,就當成完整的通訊程式。

這也是我們先讓數字在內部走一圈的原因:資料搬對了,再來處理它何時出現在腳位上,會比較容易知道問題出在哪裡。

卡住時,外面的裝置會等嗎?

不一定。

PIO 可以因為 RX FIFO 滿了而停止往下取樣,但外部裝置可能仍然繼續送資料。它後面送來的位元,不會自動排在 PIO 外面等我們有空。

所以,stall 能讓內部資料交接等到條件滿足,卻不保證外部訊號也會一起暫停。如果通訊協定不允許中斷,就要提前安排好資料供應、接收速度,或協定支援的流量控制。

同樣地,輸出時如果資料接不上,停住的位置也會影響腳位上的波形。不能只因為 PIO 的指令時間容易掌握,就認為資料不足時仍然保證連續輸出。

stall 就代表腳位一定完全不動嗎?

本篇沒有其他控制者介入、也沒有 side-set 的簡單情境裡,停在等待資料的指令時,通常會維持先前的輸出設定。

但 PIO 還有 side-set,能在執行指令時額外設定腳位。它即使遇到該指令 stall,也可能立即生效。因此,要判斷等待期間的電位,還是得看具體指令和設定。RP2040:Side-set,第 3.5.1 節

wait 等條件尚未滿足的指令,也會造成 stall。這次主要看 FIFO 的等待,並不是說 PIO 只有這一種停下來的原因。

十、先知道資料在哪裡,再看它為什麼不動

最開始看到 PIO 程式,可能只有幾行,卻幾乎每個字都像新名詞。

把對外通訊的路徑接起來,就比較知道各自負責什麼了:CPU 或 DMA 把資料排進 TX FIFO,OSR 接下準備移出的內容,out pins 把位元送到 GPIO,交給外部裝置;接收時則從 GPIO 用 in pins 累積到 ISR,再交給 RX FIFO,由 CPU 或 DMA 取走。中間那個 0x1A 原樣往返的練習,是用來拆解內部搬運的。

X、Y 是過程中可以使用的暫存空間。wrap 決定做完後回到哪裡,自動 pull/push 則依照移位計數,省掉重複的交接指令。

至於 stall,看起來像卡住,其實經常只是這個流程在說:「我要的資料還沒來」,或「這筆結果還沒有位置放」。

所以我覺得,這次比起先背所有指令,更重要的是知道:現在資料在哪裡,下一步要去哪裡,而那一步正在等誰。

這些看清楚之後,再去看腳位時序,才不會資料還停在 FIFO,就開始懷疑是不是位元順序寫反了。

至於怎麼用 wait 等外部訊號、用 side-set 配合時鐘,以及用 DMA 連續搬資料,就留到後面。先讓這一筆數字順利來回,再慢慢把它接到真正要控制的硬體上。

參考資料

完

#學習筆記#PIO#RP2040#微處理器#FIFO#嵌入式系統

客官怎麼看

看完有話想說,留在這裡。罵我也可以,罵別人更好。

可用 GitHub 登入,或以筆名題字;Email 選填。地區章依網路位置辨識,臺灣可顯示縣市;編號用來區分留言。