位元運算

從控制微處理器的需求出發,理解二進位與 Hex、AND/OR/XOR/NOT、位移與遮罩,再把設定、清除、翻轉、讀取及欄位寫入接到硬體暫存器。

今天來複習一下位元運算(Bitwise Operations)。

至於為什麼剛寫完 Git 和 Docker,又突然跳到這裡,那當然也是因為有需要囉。最近有需求去控制微處理器,開始看暫存器的設定,才發現文件和程式裡,常常出現的不是一整排二進位,而是 0x 開頭的數字。

例如 0x1A、0x80,或是更長的 0x40001000。

「電腦不是用 0 和 1 嗎?怎麼看到最後,連英文字母都跑進來了?」

其實沒有換一套硬體,也不是暫存器突然改用十六種狀態。暫存器裡仍然是那些位元,只是我們換了一種比較方便閱讀的寫法。

不過,看得懂數字,只是第一步。真的要設定暫存器時,還會碰到 &、|、^、~,以及往左、往右的位移。

例如,我們只是想把某個功能打開,怎麼確定不會順便改掉其他設定?如果一個模式占了三個位元,又要怎麼把新值放進去?

所以這次先用 Hex,也就是十六進位(Hexadecimal),把位元的表示方式補上,再看這些運算到底怎麼幫我們控制硬體。前面 CI/CD 的坑先放一下,應該還不至於忘記吧。

一、十六進位,到底是在進什麼?

先從我們最熟悉的十進位來看。

十進位有 0 到 9,十個可以放在單一位置上的數字。數到 9 之後,再加 1,就要往左進一位,變成 10。

這裡的 10,意思是「一個十,加上零個一」。

二進位也是相同的規則,只是每個位置只能放 0 或 1。所以數到 1,再加 1,就已經要進位了:

十進位二進位
00
11
210
311
4100
5101

注意,這裡二進位的 10,代表的是十進位的 2,不是十。

那十六進位呢?

它需要十六個符號,但我們平常使用的數字只有 0 到 9,還差六個。於是,就用 A 到 F 接下去:

十進位十六進位的單一位數
0~90~9
10A
11B
12C
13D
14E
15F

所以 A 在這裡不是變數名稱,而是一個代表十進位 10 的數字符號。

數到 F 之後,再加 1,才會往左進一位:

十進位十六進位
14E
15F
1610
1711
1812

嗯,現在三種進位都有自己的 10 了。如果不先說清楚是哪一種,確實很容易各講各的。

前面的 0x,是拿來做什麼的?

在 C 這類語言裡,可以用 0x 告訴編譯器,後面寫的是十六進位整數。例如:

unsigned int a = 26;
unsigned int b = 0x1A;

這兩個變數得到的數值相同,都是十進位的 26。

0x 是表示法的前綴,不是數字內容的一部分;0x1A 和 0x1a 也代表相同的值。GNU C:Integer Constants

為什麼 1A 是 26?把每個位置的意義拆開就知道了:

表示方式寫法位值展開
十進位262 × 10 + 6 = 26
十六進位1A1 × 16 + 10 = 26

再多一位也是一樣:

0x12F=1×162+2×16+15=256+32+15=303\begin{aligned} \mathtt{0x12F} &= 1 \times 16^2 + 2 \times 16 + 15 \\ &= 256 + 32 + 15 \\ &= 303 \end{aligned}

進位改變的是數值的寫法,不是數值本身。 所以不是寫成 Hex 之後,數字就變大,或程式就比較快。

二、為什麼不用十進位就好?

既然 0x1A 和 26 是同一個值,那暫存器直接寫 26,不是更熟悉嗎?

如果只想知道數量,確實可以。但看暫存器時,我們常常在意的不是「這個數字有多大」,而是「哪幾個位元是 1」。

這時候,十六進位就有一個很好用的特性:

一位十六進位,剛好對應四個二進位位元。

原因其實很簡單。四個位元,每個都可以是 0 或 1,總共有 2⁴ = 16 種組合,正好對應 0 到 F。

把它們排在一起:

Hex二進位Hex二進位
0000081000
1000191001
20010A1010
30011B1011
40100C1100
50101D1101
60110E1110
70111F1111

不用急著把整張表背起來。先看右邊那四個位置,從左到右的權重是 8、4、2、1。

例如 1010,就是 8 + 2 = 10,所以對應 A;1101 則是 8 + 4 + 1 = 13,對應 D。

1. 從 Hex 轉成二進位

回到剛才的 0x1A,把每一位分開換掉就好:

四個位元的權重先組成一位 Hex,再依十六進位的位置組成完整數值。 0x1A 的 1 對應 0001,A 對應 1010;每位 Hex 對應四個位元。
四個位元的權重先組成一位 Hex,再依十六進位的位置組成完整數值。

所以 0x1A 對應的 8 位元圖樣,就是 0001 1010。

這裡不需要先算出十進位的 26,再把 26 轉成二進位。四個一組,直接對照就可以了。

2. 從二進位轉回 Hex

反過來也一樣。從最右邊開始,每四個位元分成一組,再各自換成 Hex:

先把每組四位換成 A、6,再合成 0xA6;兩組各自的計算都有畫出來。 1010 和 0110 分別對應 A 和 6,合起來是 0xA6。
先把每組四位換成 A、6,再合成 0xA6;兩組各自的計算都有畫出來。

如果最左邊那一組不足四個位元,在這種非負整數的表示裡,可以補上前導零:

七位元的 101 1010,左側補 0 後才分成兩組;數值仍然是 0x5A。 101 1010 補上前導零成為 0101 1010,再分組換成 0x5A。
七位元的 101 1010,左側補 0 後才分成兩組;數值仍然是 0x5A。

補零只是為了方便分組,沒有改變原本的數值。

3. 暫存器越長,差別越明顯

假設有一份 32 位元的內容:

八位 Hex 分成八組,每組對應四個位元;上下兩排合起來才是完整 32 位。 32 位元 0x00000081。
八位 Hex 分成八組,每組對應四個位元;上下兩排合起來才是完整 32 位。

如果每次都要數前面到底有幾個零,眼睛應該會先提出抗議。

Hex 把四個位元收成一個符號,長度短了很多,又能很容易拆回二進位。這就是它特別適合拿來表示暫存器內容、位址和位元遮罩的原因。

要完整寫出的位元數需要的 Hex 位數
8 bits2 位,例如 0x1A
16 bits4 位,例如 0x001A
32 bits8 位,例如 0x0000001A

不過,寫了幾位 Hex,不會自動決定變數或暫存器的寬度。 0x1A 和 0x0000001A 的數值相同,實際使用多少位元,還是要看資料型別與硬體定義。

三、把它放進暫存器裡看

前面已經能把 0x1A 拆成 0001 1010 了。但這八個位置,和「控制硬體」有什麼關係?

先想一個簡單的需求:我們希望程式能決定某個硬體要不要啟動。

硬體可以準備一個位置,讓程式寫入設定。例如放 1 就啟用,放 0 就停用。這樣一個只能存 0 或 1 的位置,就是一個位元;把好幾個這樣的位置放在一起,就能保存更多設定。

這次要看的控制暫存器,就是硬體提供給程式讀寫設定的地方。程式寫入內容,硬體依照事先定好的規則處理;程式讀回內容,則能查看它允許我們讀取的設定。

另外也有狀態暫存器,用來提供「資料準備好了嗎」「有沒有發生某個事件」等資訊。先知道設定與狀態是不同的事情,後面再看它們的讀寫規則。

1. 八個位元,先找到各自的位置

假設我們設計一個叫做 CTRL 的控制暫存器,裡面有八個位元。

為了能說清楚「想改哪一個」,先替位置編號:最右邊是 bit 0,往左依序是 bit 1、bit 2,一直到 bit 7。 這裡的 bit 4,是從右邊數第五個位置,因為編號從 0 開始。

我們先把 bit 0 定義成啟用開關,取名叫 ENABLE:

  • bit 0 是 1:啟用。
  • bit 0 是 0:停用。

所以,看到 ENABLE = 0,意思是「負責啟用的那一位目前是 0」。ENABLE 是用途的名字,bit 0 是它的位置,0 則是當時放在那裡的內容。

這三件事先對上,接下來才不會看到名字和數字交錯出現,就以為又多了好幾種東西。

2. 不只開關,也可以放一個模式編號

如果硬體有八種模式,只有一個位元就不夠了,因為它只能表示兩種組合:0 和 1。

三個位元則有 2 × 2 × 2 = 8 種組合,從 000 到 111,可以分別表示模式 0~7。因此,我們把 bit 3、2、1 這三個位置合起來使用,取名叫 MODE。

這種由一個或幾個位元共同表示一項設定的部分,叫做欄位(Field)。MODE 占三位,ENABLE 則只占一位。

再加上一個 IRQ_EN,用來決定是否允許中斷。中斷可以先理解成,硬體通知處理器來處理事件的一種方式。這裡只看「允不允許通知」這個開關,還不需要先學完整的中斷流程。

把我們替這個假想裝置訂的規則排在一起:

位元位置名稱本例的規則
bit 7~5Reserved保留位置,本例要求維持 0
bit 4IRQ_EN1 表示允許中斷,0 表示不允許
bit 3~1MODE三個位元合起來表示模式編號 0~7
bit 0ENABLE1 表示啟用,0 表示停用

保留位置不是可以自行拿來增加功能的空格,要依硬體規定處理。這裡要求維持 0,也是這個例子自己訂的規則。

我們先假設這些設定欄位都可以一般讀寫。這不是某顆真實晶片的暫存器,目的是先看懂「一份數字裡,怎麼放不同設定」。

3. 現在才把 0x1A 放進來

0x1A 對應 0001 1010。照著剛才的配置,從右邊開始讀:最右邊的 0 是 ENABLE;接著三位 101 是 MODE;再往左的 1 是 IRQ_EN。

欄位的範圍、位元內容與解讀使用相同顏色對照,保留位元另行標示。 CTRL 的 bit 7~5 是保留位元 000,bit 4 是 IRQ_EN 1,bit 3~1 是 MODE 101,bit 0 是 ENABLE 0。
欄位的範圍、位元內容與解讀使用相同顏色對照,保留位元另行標示。

因此,這份內容表示:

  • ENABLE = 0:功能停用。
  • MODE = 101:這三個位元組成二進位的 5,所以選模式 5。
  • IRQ_EN = 1:允許中斷。
  • 保留位置都是 0,符合本例的要求。

注意,讀 MODE 時,是把它的三個位元合起來看成 101,再解讀成模式編號。不是把整個暫存器的十進位值 26,拿來當模式編號。

同一份位元,既能合起來表示一個數值,也能依照硬體定義,拆成幾個用途不同的欄位。 我們現在關心的是後者。

所以 Hex 幫我們看清楚位元,欄位表才告訴我們位元的意思。換一個暫存器,同樣的 0x1A 就可能代表不同設定。

至於程式要去哪裡讀到這份內容,先留到第九節。接下來先把它放進普通變數,練習怎麼算出新的設定。

途中可展開的補充,會另外處理型別寬度、負數與完整指標寫法。第一次讀可以先沿著主線走,等操作熟悉了再回來核對。

四、只想改一個位元,怎麼辦?

目前是「模式 5、允許中斷、功能停用」。假設現在只想啟用功能,也就是把 bit 0 換成 1,其他設定保留。

那把整份內容換成 0x01 就好了嗎?

綠色是原本要改的 ENABLE;紅色是整份寫入時一起遺失的設定。 原本內容 0x1A、直接寫入 0x01。
綠色是原本要改的 ENABLE;紅色是整份寫入時一起遺失的設定。

不太對。最右邊確實變成 1,但其他位置也一起被換成了 0。模式變成 0,中斷允許也被關掉了。

原因是,0x01 提供的是一整份新內容,不是「只改第一位」的命令。

我們需要的做法是:先拿原本的內容來算,只改目標位置,再把計算結果存回去。

下面使用 C 語法,先建立普通變數:

unsigned int ctrl = 0x1Au;

ctrl 保存這次要練習的數值。unsigned int 是無號整數型別,這裡拿來存非負整數;數字後面的 u 也表示使用無號整數常數。

本例的設定只用到低八位,也就是最右邊八個位元。這不表示 unsigned int 本身只有八位,只是目前要處理的設定都放在這一段。

接下來對 ctrl 的修改,都還只是電腦裡的普通變數,不會真的啟動硬體。

1. 用 OR,把指定位置設成 1

位元 OR,在 C 裡寫成 |。先只看同一個位置的兩個輸入:只要有一個是 1,結果就是 1;兩個都是 0,結果才是 0。

這裡最有用的是兩個效果:

  • 原值和 1 做 OR,一定得到 1。
  • 原值和 0 做 OR,仍然是原值。

所以,想改的位置準備 1,其他位置準備 0,不就能只把那一位設成 1 了嗎?

這份按位置準備好的 0、1 圖樣,就叫做遮罩(Mask)。ENABLE 在 bit 0,因此這次的遮罩是 0x01:

遮罩的 1 選取 bit 0,其他位置的 0 表示這次不選取它們。 ENABLE 遮罩 0x01。
遮罩的 1 選取 bit 0,其他位置的 0 表示這次不選取它們。

遮罩的效果要和運算子一起看。這裡搭配 OR,遮罩為 1 的位置會設成 1,為 0 的位置會保留原值。

把 ctrl 原本的 0x1A 和它做 OR:

OR 讓 bit 0 成為 1;目標欄位與其他位元各自套用的規則分開說明。 原本內容 0x1A、OR 遮罩 0x01、OR 結果 0x1B。
OR 讓 bit 0 成為 1;目標欄位與其他位元各自套用的規則分開說明。

結果是 0x1B。bit 0 變成 1,原本的模式和中斷設定都還在。

先把程式寫完整一點:

ctrl = ctrl | 0x01u;

先算等號右邊,再把結果存回左邊的 ctrl。如果只寫 ctrl | 0x01u,沒有把結果存起來,ctrl 本身不會因此改變。

這種「拿自己來算,再存回自己」的寫法,可以縮成:

ctrl |= 0x01u;

兩行是在說明同一件事,不需要連著執行。之後看到 |=,就把它展開成前面那行來想。

如果 bit 0 本來就是 1,再做一次 OR,仍然是 1。所以這是「確定設成 1」,不是加法,也不是切換狀態。

2. 想清成 0,先準備另一種遮罩

現在 ctrl 是 0x1B。如果又想停用功能,就要把 bit 0 清成 0,其他位置仍然保留。

這次會用到 AND,寫成 &。同一個位置,兩個輸入都必須是 1,結果才是 1。

因此:

  • 原值和 0 做 AND,一定得到 0。
  • 原值和 1 做 AND,仍然是原值。

這是不是剛好和需求接上了?目標位置準備 0,其他位置準備 1,就能只清掉目標。

但我們剛才準備的遮罩 0x01,是目標為 1、其他為 0。要把它整份反過來,會用到 NOT,也就是位元反相,寫成 ~。

先暫時離開 ctrl,用一份獨立的八位元圖樣看反相的意思:

八個位置逐一反相,0 換成 1、1 換成 0,得到低八位的 0x5A。 原本 0xA5、反相後 0x5A。
八個位置逐一反相,0 換成 1、1 換成 0,得到低八位的 0x5A。

0xA5 的每個 0 都換成 1,每個 1 都換成 0,低八位就得到 0x5A。

同樣地,把 ENABLE 遮罩 0000 0001 反過來,低八位就是 1111 1110,也就是 0xFE。這才是清除 bit 0 需要的圖樣。

這裡先觀察低八位。程式裡的 ~ 會依實際運算型別處理更多位元;這件事不影響本例低八位的清除效果,完整的寬度與型別放在下面展開。

為什麼 ~0xA5 有時會看到 0xFFFFFF5A?

前面的圖只畫八位,但常見電腦上的整數運算會使用 32 位。把省略的高位補出來,原本其實還有二十四個 0,它們也會一起反相:

高 24 位由 0x000000 反相成 0xFFFFFF;低八位由 0xA5 反相成 0x5A。 原本 0x000000A5、反相後 0xFFFFFF5A。
高 24 位由 0x000000 反相成 0xFFFFFF;低八位由 0xA5 反相成 0x5A。

所以,低八位是 0x5A,整個 32 位元圖樣則是 0xFFFFFF5A。寫了兩位 Hex,不代表運算只處理八位。

如果要明確保存 32 位元的無號結果,可以使用 <stdint.h> 提供的型別:

#include <stdint.h>

uint32_t value = UINT32_C(0xA5);
uint32_t inverted = (uint32_t)~value;

在提供這個型別的環境裡,uint32_t 是剛好 32 位的無號整數;UINT32_C(...) 用來建立適合至少 32 位無號型別的常數。(uint32_t) 則是型別轉換,讓最後的結果保存成這個型別。

inverted 因而得到 0xFFFFFF5A。如果最後只保存成八位的 uint8_t:

uint8_t inverted8 = (uint8_t)inverted;  /* 0x5A */

就只留下低八位。

另外,對 uint8_t 這類較窄的整數做運算,C 通常會先把它提升成 int。這叫做整數提升(Integer Promotion)。所以,即使來源是八位,也不能直接認為中間運算只有八位。

如果遇到有人把 ~0xA5 印成 -166,又是另一個問題:同一份位元要怎麼解讀。在 int 為 32 位、使用二補數表示負數的環境裡,這個運算的結果是有號 int,數值是 -166。

二補數是常見的有號整數表示方式。在這個 32 位例子裡,最高位為 1 的圖樣,解讀成有號值時,可以用對應的無號值減去 2³²:

解讀方式計算結果
無號值0xFFFFFF5A 的無號解讀4294967130
有號值4294967130 − 2³²−166

這些例子分開說明位元寬度和型別,沒有修改主線的 ctrl。做遮罩時,先記住看三件事:原本的型別、運算時的寬度,以及最後存回的型別。

3. 用 AND 搭配反相遮罩,清掉 bit 0

回到 ctrl = 0x1B,現在有了低八位為 1111 1110 的反相遮罩:

反相遮罩的 bit 0 是 0,用 AND 清除目標位置;其他位置與 1 做 AND 保留。 目前內容 0x1B、反相遮罩 0xFE、AND 結果 0x1A。
反相遮罩的 bit 0 是 0,用 AND 清除目標位置;其他位置與 1 做 AND 保留。

bit 0 遇到 0,會被清掉;其他位置遇到 1,就保留原值。結果回到 0x1A,功能停用,但模式和中斷設定都沒變。

完整寫法是:

ctrl = ctrl & ~0x01u;

~0x01u 先把遮罩反相,再與原本的 ctrl 做 AND,最後把結果存回去。可以縮成:

ctrl &= ~0x01u;

這裡仍然是在說明同一個動作的兩種寫法。

4. AND 也能只讀取某個位置

剛才 AND 用來清除;現在換一個目的:只想知道 IRQ_EN 是不是 1,不想修改 ctrl。

IRQ_EN 在 bit 4,因此準備 0x10,也就是只有 bit 4 是 1 的遮罩。這次保留目標位置,其他位置清成 0:

用 0x10 只留下 bit 4,其餘位置清成 0;結果是 0x10,不是數值 1。 目前內容 0x1A、IRQ 遮罩 0x10、AND 結果 0x10。
用 0x10 只留下 bit 4,其餘位置清成 0;結果是 0x10,不是數值 1。

把計算結果存到另一個變數:

unsigned int irq_bits = ctrl & 0x10u;

此時 irq_bits 是 0x10,ctrl 仍然是原本的 0x1A。圖中其他位置被清掉,指的是這次的計算結果,不是硬體或 ctrl 被改了。

如果只需要判斷有沒有開啟:

if (irq_bits != 0u) {
    /* 目前允許中斷。 */
}

!= 表示不相等。遮罩留下的結果不是 0,就表示那一位是 1。

為什麼不比較「是不是 1」?因為它仍然在 bit 4,數值是 0x10,也就是十進位 16。位元內容是 1,和整個計算結果等於數值 1,是兩件不同的事。

這裡讀的是中斷允許設定,還不是「中斷事件有沒有發生」。要查事件,得看硬體提供的對應狀態。

5. 原本開著就關掉:用 XOR

如果需求是「每做一次,就切換到另一個狀態」,OR 就不夠了。它遇到已經是 1 的位置,會繼續留下 1。

這時可以用 XOR,寫成 ^。同一個位置的兩個輸入不同,結果是 1;相同,結果是 0。

對遮罩來說,就有這兩個效果:和 1 做 XOR 會翻轉,和 0 做 XOR 會保留。

目前的 ctrl 是 0x1A,bit 0 是 0。使用同一份 0x01 遮罩:

第一次 XOR,把 bit 0 從 0 翻成 1,得到 0x1B。 目前內容 0x1A、XOR 遮罩 0x01、第一次結果 0x1B。
第一次 XOR,把 bit 0 從 0 翻成 1,得到 0x1B。

再做一次:

相同遮罩再次 XOR,把 bit 0 從 1 翻回 0,回到 0x1A。 目前內容 0x1B、XOR 遮罩 0x01、第二次結果 0x1A。
相同遮罩再次 XOR,把 bit 0 從 1 翻回 0,回到 0x1A。

程式依序寫成:

ctrl ^= 0x01u;  /* 0x1A → 0x1B */
ctrl ^= 0x01u;  /* 0x1B → 0x1A */

^= 也一樣是拿自己來算,再存回自己。這次兩行都要執行,才能看到翻轉兩次又回到原值。

所以,想確定它開著,用 OR;想換成相反狀態,用 XOR。^ 在 C 裡也不是次方,2 ^ 3 不會算出 8。

把三種雙輸入運算整理一下:

同一位的輸入 a同一位的輸入 ba & ba | ba ^ b
00000
01011
10011
11110

整個數字的位元運算,就是每個位置各自套用這些規則,不會像加法那樣把進位送到旁邊。至於 NOT,只有一個輸入,直接把每一位反相。

到這裡,我們把 ctrl 改了幾次,最後又回到 0x1A。接下來就用這份內容,練習讀出模式編號。

& 和 &&、| 和 ||,為什麼不能混用?

單一的 &、| 是逐位運算;&&、|| 則先判斷整個值為真還是假。在 C 的條件判斷裡,0 是假,非零是真。

例如 0x02 和 0x04 都非零,但它們的 1 在不同位置:

位元 AND 逐位計算得到 0;邏輯 AND 先判斷兩個非零輸入,再得到 1。 0x02 和 0x04 的 1 位於不同位置,位元 AND 得到 0;兩個值都非零,因此邏輯 AND 得到 1。
位元 AND 逐位計算得到 0;邏輯 AND 先判斷兩個非零輸入,再得到 1。

因此,0x02 & 0x04 是 0,0x02 && 0x04 則是 1。前者在比對位置,後者在問「兩邊是不是都為真」。

&& 和 || 還有短路求值:左邊已經能決定整個真假結果時,右邊不會再求值。位元運算的 &、| 沒有這個規則。

同樣地,! 是邏輯 NOT,結果只會是 0 或 1;~ 才是逐位反相。GNU C:Bitwise Logical Operators

五、位移:為什麼取出 MODE,還不是模式編號?

第三節已經知道,MODE 的三位是 101,代表模式 5。但程式不能只靠我們眼睛把那三位挑出來,得真的算一次。

1. 先留下欄位,再看看它還在哪裡

MODE 位於 bit 3~1。先讓這三個位置的遮罩為 1,其他位置為 0,就得到 0x0E:

三個連續的 1 選取 MODE 的 bit 3~1,遮罩是 0x0E。 MODE 遮罩 0x0E。
三個連續的 1 選取 MODE 的 bit 3~1,遮罩是 0x0E。

用剛才學過的 AND,留下這三位:

unsigned int masked_mode = ctrl & 0x0Eu;
AND 只取出欄位,101 仍停在 bit 3~1,所以結果暫時是 0x0A。 目前內容 0x1A、MODE 遮罩 0x0E、AND 結果 0x0A。
AND 只取出欄位,101 仍停在 bit 3~1,所以結果暫時是 0x0A。

masked_mode 是 0x0A,也就是十進位 10。

欸,模式不是 5 嗎?

因為 AND 只把其他位置清掉,留下來的位元還停在原來的位置。101 的最後一位仍然在 bit 1,還沒有搬到 bit 0。

當成整個數值來算時,那兩個 1 還是位於 bit 3、bit 1,權重是 8 和 2,所以得到 10。

2. 右移:讓欄位從 bit 0 開始

C 的右移運算子是 >>。value >> 1 就是把位元整體往右搬一個位置;右邊寫 2,就搬兩個位置。

現在要把 bit 3~1,搬到 bit 2~0,所以右移一位:

unsigned int mode = masked_mode >> 1;
欄位中的 1、0、1 一起右移,對齊到 bit 2~0,才得到模式編號 5。 取出欄位 0x0A、右移一位 0x05。
欄位中的 1、0、1 一起右移,對齊到 bit 2~0,才得到模式編號 5。

這時兩個 1 的權重變成 4 和 1,才得到模式編號 5。欄位裡的 0 也一起移動,不是只有 1 會搬家。

所以讀取這個欄位,完整過程是:AND 留下 bit 3~1,再右移一位,把它對齊到最低位。

剛才刻意分成兩行,是為了能分別觀察中間的 0x0A 和最後的 5。熟悉之後,也可以合成:

unsigned int mode = (ctrl & 0x0Eu) >> 1;

括號裡先取欄位,括號外再移動位置。這是前面兩步的合寫,不是又多一套新的規則。

這些計算都沒有賦值回 ctrl,所以原本的設定仍然是 0x1A。

3. 左移:把 1 搬到需要的位置

另一個方向是左移,寫成 <<。它把位元往左搬,右邊空出的位置補 0。

例如只有 bit 0 是 1 的數值,左移四位:

bit 0 的 1 左移到 bit 4,右邊空出的四位補 0;本圖只顯示低八位。 原本 0x01、左移四位 0x10。
bit 0 的 1 左移到 bit 4,右邊空出的四位補 0;本圖只顯示低八位。

那個 1 就來到 bit 4,得到 0x10。這也正是前面檢查 IRQ_EN 用的遮罩。

所以,知道目標位置,就不必每次從 Hex 心算遮罩:

unsigned int irq_mask = 1u << 4;  /* 0x10 */

1u 從只有 bit 0 為 1 的值開始;<< 4 把它搬到 bit 4。這裡的 4 是位移量,也是目標的位元編號。

那如果下一次想改 bit 2,或是由程式決定要改哪一位呢?總不能每換一個位置,就重新查一次 Hex 吧。

我們可以用變數 n 保存目標的位元編號。寫「bit n」,意思就是「編號為 n 的那個位置」;n 是 0,就指 bit 0,n 是 4,就指 bit 4。編號仍然從最右邊的 0 開始,不是從 1 開始數。

把剛才固定的 4 換成 n,1u << n 就能算出「只有 bit n 是 1」的遮罩:

每一列只有一個 1,往左移動時遮罩加倍;bit 4 是從右邊數第五格。 1u << 0 0x01、1u << 1 0x02、1u << 2 0x04、1u << 3 0x08、1u << 4 0x10、1u << 5 0x20、1u << 6 0x40、1u << 7 0x80。
每一列只有一個 1,往左移動時遮罩加倍;bit 4 是從右邊數第五格。

在合法的位移範圍內,1u << n 的值就是 2ⁿ。例如 n 是 2,得到 0x04;n 是 4,得到 0x10。

注意,這裡是在準備一份遮罩,還沒有修改 ctrl,也沒有讀取 bit n 的內容。準備好之後要做什麼,就能接回前面的 OR、AND 和 XOR。下一節會把它們接在一起。

4. 位移前,先確認範圍

右移時,超出最右邊的內容會被捨去;左移也有整數寬度的邊界,不會一直增加位元。所以位移不是把兩端接起來循環搬動。

位移量必須先確認不是負數,而且小於運算時的位元寬度。 不能先移完,再檢查有沒有超過。

這次主線使用 unsigned int,它至少有 16 位;目前只移動 0~7 個位置,因此範圍放得下。若想移到 bit 31,就要另外確認型別寬度,第七節會補上寫法。

把完整的 32 位邊界畫出來,看哪些內容會消失

位移要看這次正在處理多寬的值。

前面的圖為了方便看,只顯示低八位。現在明確用 32 位元無號值看完整邊界:

32 位分成 bit 31、中間 23 位和低八位;右移時高位補 0、bit 0 移出邊界。 原本(13) 0x0000000D、右移(6) 0x00000006。
32 位分成 bit 31、中間 23 位和低八位;右移時高位補 0、bit 0 移出邊界。

13 的最低位是 1。右移一位時,這個 1 移出最右邊,最高位補 0,留下來的值是 6。

左移也一樣要看邊界:

最高位的 1 超出 32 位邊界,最低位補 0;保留下來的結果是 0x00000002。 原本 0x80000001、左移一位 0x00000002。
最高位的 1 超出 32 位邊界,最低位補 0;保留下來的結果是 0x00000002。

以保留 32 位的無號結果來看,原本 bit 31 的 1 超出範圍,最低位補 0,最後得到 0x00000002。移出去的 1 不會從另一邊跑回來;那是旋轉位元要處理的另一種操作。

對無號值來說,右移 n 位相當於除以 2ⁿ,捨去餘數;左移 n 位在結果放得下時相當於乘以 2ⁿ。超出寬度的部分,就不能再當成普通的無限大整數計算。

如果原本是負數,右移時也一定補 0 嗎?

前面的主線都使用無號值,右移時補 0,稱為邏輯右移。

如果使用有號整數,就還要考慮負數的表示。在常見的二補數表示法裡,最高位參與表示正負;算術右移會把這個符號位複製到左側空出的位置。

例如同一份 32 位圖樣,分別這樣處理:

相同起始圖樣分別進行算術與邏輯右移,差別在 bit 31 移入符號位或 0。 有號 -8 0xFFFFFFF8、算術移後 -4 0xFFFFFFFC、相同無號圖樣 0xFFFFFFF8、邏輯右移後 0x7FFFFFFC。
相同起始圖樣分別進行算術與邏輯右移,差別在 bit 31 移入符號位或 0。

上半部把原本的 -8 做算術右移,結果是 -4;下半部把同一份起始圖樣當成無號值,做邏輯右移,結果是 0x7FFFFFFC。

本篇使用 C11。在這個標準裡,負的有號整數右移由實作定義;GNU C 使用算術右移,不能把它直接當成所有 C 環境都一樣的保證。GNU C:Shifting Makes New Bits

這也是主線先用無號值的原因:先看清楚位置怎麼搬,再另外處理負數。

六、從 bit 0 換成 bit n,運算要怎麼跟著換?

第四節用 0x01 操作 bit 0,剛才又知道,可以用左移算出指定位置的遮罩。現在把這兩件事接起來。

先用 n 決定位置,算出 1u << n,再依需求選 OR、AND 或 XOR。 運算規則沒有變,改變的是遮罩裡那個 1 放在哪裡。

例如 n 是 0,遮罩就是前面的 0x01;n 是 4,則是檢查 IRQ_EN 用的 0x10。所以 bit n 並沒有新增一種位元,只是把原本寫死的位置,換成可以指定的編號。

接著沿用同一份 ctrl。第五節只讀取它,所以目前仍然是 0x1A。這次選 bit 2,準備它的遮罩:

unsigned int n = 2u;
unsigned int mask = 1u << n;  /* 0x04 */

這節先把 n 限定在 0~7,全部只看低八位。n = 2 表示從右邊數第三個位置,mask = 0x04 才是選取那個位置的圖樣。

回頭看第三節的欄位表,bit 2 位在 MODE 裡。因此,這次是在練習改動模式中的一個位元,還不是直接指定整個模式編號。先看清楚單一位置怎麼改,下一節再把整段 MODE 換成想要的值。

以下操作依序進行,每一步都接著上一個結果。

1. 設定與清除 bit n

設定成 1,仍然用 OR:

ctrl |= mask;
用 0x04 設定 bit 2,其他位元透過 OR 0 保留原值。 原本 0x1A、OR 遮罩 0x04、設定後 0x1E。
用 0x04 設定 bit 2,其他位元透過 OR 0 保留原值。

現在是 0x1E,只有 bit 2 被設成 1。MODE 也因此從 101 變成 111,也就是模式 7;啟用與中斷允許設定都保留。

接著清除同一位,用 AND 搭配反相遮罩:

ctrl &= ~mask;
用反相遮罩的低八位 0xFB 清除 bit 2,其他位置保留。 目前內容 0x1E、反相遮罩 0xFB、清除後 0x1A。
用反相遮罩的低八位 0xFB 清除 bit 2,其他位置保留。

結果回到 0x1A。這和第四節的做法相同,只是遮罩由 bit 0 換成 bit 2。

2. 翻轉 bit n

如果要切換目前狀態:

ctrl ^= mask;

bit 2 由 0 變成 1,ctrl 又變成 0x1E。再做一次就會回到 0x1A,但這裡先只做一次,讓它留在 0x1E。

所以 OR、AND、XOR 的用法都沒變;mask 只是把想處理的位置抽出來,方便替換。

3. 讀取 bit n

修改位置之外,讀取也能用同一份遮罩。就像第四節檢查 IRQ_EN,如果只想知道 bit n 是不是 1,可以檢查 AND 結果是否非零:

unsigned int is_set = (ctrl & mask) != 0u;

目前 ctrl & mask 得到 0x04,不是數值 1;比較 != 0u 之後,is_set 才得到 1。若目標位元是 0,則會得到 0。

前面讀 MODE 時,是先 AND 選取欄位,再右移對齊。單一位元也可以照做:

unsigned int bit = (ctrl & mask) >> n;

遮罩只留下 bit n,再右移 n 位,就會得到數值 0 或 1。本例是把 0x04 右移兩位,得到 1。

也常看到另一種順序:先把 bit n 搬到 bit 0,再用 & 1u 留下最低位。下面是前一種讀法的替代寫法,分成兩步看:

unsigned int shifted = ctrl >> n;
unsigned int bit = shifted & 1u;
先追蹤 bit 2 移到 bit 0,再與 0x01 做 AND,只留下數值 0 或 1。 原本 0x1E、右移兩位 0x07、AND 1 結果 0x01。
先追蹤 bit 2 移到 bit 0,再與 0x01 做 AND,只留下數值 0 或 1。

本例先得到 0x07,再和 0x01 做 AND,最後才得到 1。右移會連其他較高的位元也一起搬下來,所以不能省掉最後的 AND。

熟悉之後可以合成 unsigned int bit = (ctrl >> n) & 1u;。這些結果都沒有存回 ctrl,它仍然是 0x1E。

4. 位置、遮罩和動作,現在可以分開看了

把第四節的 bit 0,和現在的 bit n 放在一起:

目的固定操作 bit 0指定操作 bit n
準備遮罩0x01umask = 1u << n
設成 1ctrl |= 0x01uctrl |= mask
清成 0ctrl &= ~0x01uctrl &= ~mask
翻轉ctrl ^= 0x01uctrl ^= mask
取出數值 0 或 1ctrl & 0x01u(ctrl & mask) >> n

表格是在對照不同需求,不能從上到下當成一串指令執行。使用前先確認 n 的範圍,再準備遮罩;要設、清、翻轉或讀取,才決定接下來的運算。

還有,bit n 是位置,讀出的 0 或 1 是那個位置的內容,1u << n 則是選取它的遮罩。 例如 n 是 2,遮罩是 4,讀到的位元內容卻可以是 0 或 1。這三個數字各有自己的用途。

本節剛才把 bit 2 翻成了 1,現在再翻一次:

ctrl ^= mask;  /* 0x1E → 0x1A */

同一個遮罩翻轉兩次,就回到原值。這時 MODE 也從 111 回到 101,也就是模式 5。接下來換一個需求:如果想直接指定「模式 2」,而不是只動其中一位呢?

七、從一個位元,到替換整段 MODE

前一節能選定任意一個位置,設成 1、清成 0,或翻轉。但 MODE 是由 bit 3~1 共同表示的模式編號,要改成模式 2,就得讓整段成為 010。

所以,這次要處理的範圍從「一個位元」,變成「一段欄位」;仍然需要遮罩,只是遮罩要把這三個位置一起選起來。

接著前一節翻轉兩次之後的 ctrl = 0x1A,也就是模式 5。啟用和中斷允許設定都要保留。

1. 從一個 1,變成一整段 1

單一位元從一個 1 開始;欄位則需要一整段連續的 1。

單一位元只要用 n 指定位置;一段欄位則要知道「從哪裡開始」和「占幾位」。用 MODE 來看,替這兩件事取名字:

名稱本例的值意思
w3欄位寬度,占三個位元
p1欄位的起點,最右邊是 bit 1

p 和前面的 n 一樣,都在表示位元位置;另外多了 w,才能決定要選取幾個位置。這裡 p 是 1、w 是 3,所以選的是 bit 1、2、3。

要準備三個連續的 1,可以先算 1u << 3,得到二進位 1000。再減去 1,就變成 0111。

也就是 2³ - 1 = 7。這份 0x07 還沒搬位置,最右邊仍然是 bit 0。

最後再左移 p 位:

先用減 1 建立 w 個連續的 1,再把整段移到起始位置 p。 1 << 3 0x08、減去 1 0x07、再左移一位 0x0E。
先用減 1 建立 w 個連續的 1,再把整段移到起始位置 p。

程式一步一步寫成:

unsigned int w = 3u;
unsigned int p = 1u;
unsigned int low_mask = (1u << w) - 1u;  /* 0x07 */
unsigned int field_mask = low_mask << p; /* 0x0E */

low_mask 決定有幾個連續的 1,field_mask 則是搬到正確位置後的遮罩。這樣就回到 MODE 的 0x0E。

這裡的 p、w 是已知且合法的值。若改成由外部提供,就要在位移前檢查範圍。以本篇限定的低八位來說,要求 1 <= w <= 8,而且 p <= 8 - w。

1u 至少有 16 位,所以這個低八位練習可以先左移八位再減 1;若操作寬度擴大到整個型別,就要另外處理滿寬的情況,本節最後的補充會說明。

遮罩現在準備好了。它和第五節直接對照位置得到的 0x0E 相同,只是這次也知道,怎麼從起點與寬度把它算出來。

2. 先把新模式搬到欄位的位置

模式 2 的三位元表示是 010。單獨寫成數字 2 時,這三位是從 bit 0 開始排列的。

但 MODE 在 bit 3~1,所以得先把新模式左移一位:

unsigned int new_mode = 2u;
unsigned int positioned_mode = new_mode << 1;
新模式的三個位元一起左移到 MODE 欄位,而不只是移動其中的 1。 模式 2 0x02、左移一位 0x04。
新模式的三個位元一起左移到 MODE 欄位,而不只是移動其中的 1。

positioned_mode 得到 0x04。它是「模式 2 放到 MODE 欄位之後的圖樣」,不是把模式改成 4。

3. 為什麼不能直接 OR?

現在只差把它合進去,看起來直接 OR 就好了吧?

紅色標出錯誤的 MODE:舊的 101 與新的 010 做 OR,變成模式 7。 原本內容 0x1A、新模式位置 0x04、直接 OR 結果 0x1E。
紅色標出錯誤的 MODE:舊的 101 與新的 010 做 OR,變成模式 7。

結果卻變成模式 7。

因為 OR 只能讓位置成為 1,不會把舊的 1 清成 0。舊欄位的 101 還在,新值 010 一進來,就混成了 111。

單一的「設成 1」可以直接 OR;替換整段欄位,還得先清掉原本的內容。

4. 清掉舊欄位,再放入新內容

剛才算出的 MODE 遮罩是 0x0E。和清除 bit n 一樣,把遮罩反相,再用 AND;這次遮罩有三個 1,所以會一起清掉三個位置:

unsigned int kept = ctrl & ~0x0Eu;
第一步先用反相遮罩清掉舊 MODE,欄位以外的設定保留。 原本內容 0x1A、反相遮罩 0xF1、清除後 0x10。
第一步先用反相遮罩清掉舊 MODE,欄位以外的設定保留。

kept 得到 0x10。MODE 的三個位置都清成 0,其他設定保留下來。這一步仍然只是算出中間結果,還沒有存回 ctrl。

再把已經搬好位置的 positioned_mode 合進去:

ctrl = kept | positioned_mode;
第二步把新模式 OR 進清好的欄位,得到 MODE 為 2 的 0x14。 清除之後 0x10、新模式位置 0x04、寫入後 0x14。
第二步把新模式 OR 進清好的欄位,得到 MODE 為 2 的 0x14。

最後得到 0x14:模式 2、允許中斷、功能仍然停用。

接著如果再執行 ctrl |= 0x01u,才會變成「模式 2、允許中斷、啟用功能」,值是 0x15。

5. 拆開看懂之後,再把它寫短

前面分成「清欄位」「搬新值」「合起來」,是為了知道每一步得到什麼。

實際寫程式時,可以替固定的位置和遮罩取名字。const 表示這些設定值在這段程式裡不再修改:

const unsigned int MODE_SHIFT = 1u;
const unsigned int MODE_WIDTH = 3u;
const unsigned int MODE_LOW_MASK = (1u << MODE_WIDTH) - 1u;
const unsigned int MODE_MASK = MODE_LOW_MASK << MODE_SHIFT;
unsigned int new_mode = 2u;

unsigned int kept = ctrl & ~MODE_MASK;
unsigned int positioned = (new_mode << MODE_SHIFT) & MODE_MASK;
ctrl = kept | positioned;

MODE_SHIFT 對應剛才的 p,MODE_WIDTH 對應 w。MODE_LOW_MASK 是還沒搬位置的 0x07,MODE_MASK 則是對齊欄位的 0x0E。這份程式是在整理同一個模式替換操作,不需要接著前面的分步寫法再做一次。

計算 positioned 時,最後又做一次 & MODE_MASK,是把新圖樣限制在 MODE 的位置裡,避免多出的位元跑進其他欄位。

但遮掉多出的位元,不等於檢查輸入正確。例如模式 8 的二進位是 1000,根本放不進三位元欄位;遮掉超出部分,也不會自動報錯。

所以要先確定 new_mode 不大於 MODE_LOW_MASK,在本例就是 0~7。真正的硬體如果只提供其中幾種模式,還要符合它的規定。

常見那一長行欄位寫入,怎麼對回剛才的三步?

從相同的原始內容開始,前面的三步可以合成:

ctrl = (ctrl & ~MODE_MASK)
     | ((new_mode << MODE_SHIFT) & MODE_MASK);

左邊是 kept:清掉舊欄位,保留其他設定。右邊是 positioned:把新值搬到正確位置,再限制範圍。中間的 OR 把兩份圖樣合起來,最後才存回 ctrl。

這行沒有增加新運算,只是把中間變數展開了。閱讀時,也可以反過來替左右兩邊取名字,先分開算。

如果要操作 bit 31,或準備一般的 32 位元欄位呢?

主線使用的 1u 是 unsigned int,但這個型別不保證在所有平台都是 32 位。有些嵌入式環境只有 16 位,因此不能直接把 n 換成 31 就假設會成功。

<stdint.h> 在支援的環境裡提供 uint32_t,也就是剛好 32 位的無號整數型別。可以明確寫成:

#include <stdint.h>

uint32_t reg = UINT32_C(0x1A);
unsigned int n = 31u;  /* 必須先確認 n < 32 */
uint32_t mask = (uint32_t)(UINT32_C(1) << n);

UINT32_C(1) 提供適合至少 32 位無號型別的起點,最後保存成 uint32_t。當 n 是 31,就得到 0x80000000。

要準備一段 32 位元範圍內的欄位,可以寫成:

unsigned int p = 1u;
unsigned int w = 3u;
uint32_t field_value = UINT32_C(2);

/* 位移之前先確認:1 <= w < 32,而且 p <= 32 - w。 */
uint32_t low_mask = (uint32_t)((UINT32_C(1) << w) - UINT32_C(1));
uint32_t field_mask = (uint32_t)(low_mask << p);

/* 寫入之前另確認:field_value <= low_mask,而且模式合法。 */
uint32_t kept = reg & ~field_mask;
uint32_t positioned = (field_value << p) & field_mask;
reg = kept | positioned;

這份寫法刻意要求 w 小於 32。如果欄位占滿 32 位,就直接用 UINT32_MAX,也就是 32 位全為 1 的完整遮罩;不能拿 1 << 32 來做。

例如在 unsigned int 為 32 位的環境裡,1u << 32 是未定義行為,不能期待它一定得到 0。此外,較窄的整數在運算前,可能先轉成 int 等型別,這叫做整數提升。位移限制要看提升後的運算寬度,不是光看最後存入的變數。

八、把主線的操作放在一起跑一次

前面看了很多張圖,現在實際把那份 ctrl 算一次。

這支程式操作普通變數,不需要開發板。使用有 C 編譯器的環境即可,下面採用 C11:

建立 bitwise-practice.c:

#include <stdio.h>

int main(void) {
    unsigned int ctrl = 0x1Au;
    const unsigned int ENABLE_MASK = 0x01u;
    const unsigned int IRQ_MASK = 0x10u;
    const unsigned int MODE_SHIFT = 1u;
    const unsigned int MODE_WIDTH = 3u;
    const unsigned int MODE_LOW_MASK = (1u << MODE_WIDTH) - 1u;
    const unsigned int MODE_MASK = MODE_LOW_MASK << MODE_SHIFT;

    printf("initial: 0x%02X\n", ctrl);

    ctrl |= ENABLE_MASK;
    printf("enabled: 0x%02X\n", ctrl);

    ctrl &= ~ENABLE_MASK;
    printf("disabled: 0x%02X\n", ctrl);

    ctrl ^= ENABLE_MASK;
    printf("toggled: 0x%02X\n", ctrl);
    ctrl ^= ENABLE_MASK;
    printf("toggled back: 0x%02X\n", ctrl);

    unsigned int irq_bits = ctrl & IRQ_MASK;
    unsigned int irq_enabled = (irq_bits != 0u);
    printf("IRQ enabled: %u\n", irq_enabled);

    unsigned int masked_mode = ctrl & MODE_MASK;
    printf("masked mode: 0x%02X\n", masked_mode);
    unsigned int mode = masked_mode >> MODE_SHIFT;
    printf("mode: %u\n", mode);

    unsigned int n = 2u;
    unsigned int mask = 1u << n;
    printf("bit %u mask: 0x%02X\n", n, mask);
    ctrl |= mask;
    printf("bit set: 0x%02X\n", ctrl);
    ctrl &= ~mask;
    printf("bit cleared: 0x%02X\n", ctrl);
    ctrl ^= mask;
    printf("bit toggled: 0x%02X\n", ctrl);

    unsigned int bit = (ctrl & mask) >> n;
    unsigned int shifted_bit = (ctrl >> n) & 1u;
    printf("bit %u: %u, shift first: %u\n", n, bit, shifted_bit);
    ctrl ^= mask;
    printf("bit toggled back: 0x%02X\n", ctrl);

    unsigned int new_mode = 2u;
    unsigned int kept = ctrl & ~MODE_MASK;
    unsigned int positioned = (new_mode << MODE_SHIFT) & MODE_MASK;
    ctrl = kept | positioned;
    printf("mode changed: 0x%02X\n", ctrl);

    ctrl |= ENABLE_MASK;
    printf("final: 0x%02X\n", ctrl);
    return 0;
}

編譯後執行,例如:

cc -std=c11 -Wall -Wextra bitwise-practice.c -o bitwise-practice
./bitwise-practice

預期看到:

initial: 0x1A
enabled: 0x1B
disabled: 0x1A
toggled: 0x1B
toggled back: 0x1A
IRQ enabled: 1
masked mode: 0x0A
mode: 5
bit 2 mask: 0x04
bit set: 0x1E
bit cleared: 0x1A
bit toggled: 0x1E
bit 2: 1, shift first: 1
bit toggled back: 0x1A
mode changed: 0x14
final: 0x15

%02X 用大寫 Hex 輸出,至少顯示兩位,不足補 0;%u 則把無號整數印成十進位。前面的 0x 是我們自己寫進輸出字串的文字。

irq_bits != 0u 的比較結果會是 0 或 1。把它存進無號變數 irq_enabled 後,就能用 %u 印出是否啟用。

可以回頭看中間的 masked mode:它是 0x0A,再右移才得到 5。程式實際做的事,正好就是第五節分開看的兩步。

接著把 n 設成 2,確認遮罩是 0x04,依序設定、清除、翻轉,再比較兩種讀取順序。第二次翻轉後,ctrl 回到 0x1A,才繼續替換整段 MODE,每一步都能對回第六、七節。

這份練習最後得到 0x15,代表模式 2、允許中斷、啟用功能。但目前只把普通變數算好了,還沒有把它交給任何硬體。

想一起核對 32 位反相與 bit 31 的遮罩

這是另一支獨立程式,對應前面折疊區的型別與寬度說明。需要提供 uint8_t、uint32_t 的 C 環境:

建立 bitwise-width.c:

#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>

int main(void) {
    uint32_t value = UINT32_C(0xA5);
    uint32_t inverted = (uint32_t)~value;
    uint32_t high_bit = (uint32_t)(UINT32_C(1) << 31);

    printf("NOT32: 0x%08" PRIX32 "\n", inverted);
    printf("NOT8: 0x%02X\n", (unsigned int)(uint8_t)inverted);
    printf("bit 31 mask: 0x%08" PRIX32 "\n", high_bit);
    return 0;
}

用相同的編譯方式執行:

cc -std=c11 -Wall -Wextra bitwise-width.c -o bitwise-width
./bitwise-width

預期輸出:

NOT32: 0xFFFFFF5A
NOT8: 0x5A
bit 31 mask: 0x80000000

<inttypes.h> 的 PRIX32 會提供符合 uint32_t 的 Hex 輸出格式,前面的 08 表示至少補齊八位。它與旁邊的字串在 C 裡會接成同一份格式字串。

第二行先轉成 uint8_t 取低八位,再轉成 unsigned int 配合 %X。這些轉換是為了把運算寬度、保存的結果和輸出型別對好,不是位元反相又多了一種規則。

九、把算好的設定交給硬體

前一節的程式最後得到 ctrl = 0x15,也印出了結果。但這時候開發板上的硬體,還沒有收到任何設定。

第三節的 CTRL 是假想裝置提供的控制暫存器;第四節建立的 ctrl,則是用來練習計算的普通變數。名稱很像,不會讓兩者自動連在一起。

要真的完成「保留其他設定,把模式改成 2,再啟用功能」,就得先找到硬體的 CTRL,讀取它目前的內容,沿用前面的運算,再把結果寫回去。

所以接下來先找位置,再看 C 怎麼透過這個位置讀寫,最後才把整段操作接起來。

1. 位址是位置,值是裡面的內容

先把這兩個東西分開:

  • 位址(Address):要去讀寫哪個位置。
  • 值(Value):從那裡讀到什麼,或準備寫入什麼。

我們之前一直在算的 0x1A、0x15,是值。它們和 CTRL 放在哪個位址,是不同的事情。

假設硬體手冊說,某組周邊的起始位置在 0x40001000,CTRL 位於起點再往後 4 個位元組的地方。那麼:

項目位址或距離
起始位置0x40001000
往後距離0x00000004
CTRL 位址0x40001004

手冊通常把起始位置叫做基底位址(Base Address),從起點往後的距離叫做偏移量(Offset)。

先由基底位址與偏移量找到 CTRL,再從這個位置讀回內容 0x1A。 假想基底位址 0x40001000 加偏移量 0x04,得到 CTRL 位址 0x40001004;從這個位置讀到的內容則是 0x1A。
先由基底位址與偏移量找到 CTRL,再從這個位置讀回內容 0x1A。

這裡有兩層位置:先用位址找到整個 CTRL,再用遮罩選擇 CTRL 裡面的位元。偏移量 0x04 的單位是位元組,表示從基底往後四個位元組;1u << 4 裡的 4 則是位元編號。它們剛好都出現 4,處理的卻是不同事情。

同一組周邊可以有好幾個暫存器,各自放在不同的偏移量。實際位置、可用的讀寫寬度,都要依硬體手冊,不能由程式自行安排。

2. 處理器怎麼把寫入交到正確的硬體?

程式存取普通變數時,通常是在讀寫 RAM,也就是放程式資料的記憶體。

晶片也可以安排某些位址,讓對它們的讀寫直接交給周邊硬體。例如對 0x40001004 寫入 0x15,就交給我們假想裝置的 CTRL 處理。

這種把硬體讀寫介面安排在記憶體位址空間裡的做法,叫做 MMIO(Memory-Mapped I/O,記憶體映射輸入輸出)。

處理器發出寫入要求時,會同時提供「位址」和「資料」。晶片內部依照位址,找到負責接收的周邊,再把資料交給它。這個依位址選出目標的過程,叫做位址解碼。

寫入要求包含位址與資料;位址解碼只選中對應周邊,資料才交給 CTRL 處理。 程式執行寫入,處理器送出位址與資料,晶片依位址找到周邊,再由周邊依暫存器定義處理。
寫入要求包含位址與資料;位址解碼只選中對應周邊,資料才交給 CTRL 處理。

這樣就接上最開始的疑問了:ctrl = 0x15 只是在更新普通變數;對 CTRL 的位址寫入 0x15,才會由對應周邊接收並處理。要讓設定送到硬體,除了算對資料,也要送到它提供的讀寫位置。

那在 C 裡,要怎麼指定「這次要讀寫哪個位置」?

3. C 裡怎麼透過位址讀寫?先用普通變數練習

這裡會遇到指標(Pointer)。先把它想成:保存某個物件位址、讓程式能透過位址找到內容的變數。

先做一個獨立的小例子,用普通變數看清楚「位址」和「透過位址存取」的關係。這段不接著修改前面的 ctrl:

unsigned int number = 0x1Au;
unsigned int *location = &number;
unsigned int copy = *location;
*location = 0x15u;

第一行建立 number,內容是 0x1A。

第二行的 &number 是「取得 number 的位址」;unsigned int *location 則宣告一個指向 unsigned int 的指標,用來保存這個位址。這裡的 & 只有一個對象,和前面兩個數值之間的位元 AND 不同。

第三行的 *location 表示「到 location 指向的位置讀取內容」。讀到的是 number 當時的 0x1A,再把它存進另一個普通變數 copy。

第四行的 *location 出現在等號左邊,意思就變成「把右邊的值寫入那個位置」。因此 number 變成 0x15,copy 仍然是剛才複製到的 0x1A,不會自動跟著變。

先分清楚:宣告裡的 * 用來表示指標型別;之後使用 *location,才是透過指標存取內容。

接到 MMIO 時,也是透過指標讀寫內容,只是目標改成平台指定的硬體位址,而且必須遵守硬體的存取規則。

後面把指向硬體 CTRL 的指標叫做 ctrl_reg。它的角色就像這裡的 location,只是指向的目標換成了硬體介面。

4. 換成硬體位址,還要決定怎麼存取

剛才的 unsigned int *,表示透過指標存取 unsigned int。但硬體允許多寬的讀寫,是它自己的規定,不能只看我們喜歡用哪個 C 型別。

延續第三節的假想裝置,這裡再約定:CTRL 允許八位元讀寫。C 環境提供的 uint8_t 是八位元無號整數型別,宣告在 <stdint.h> 裡,因此這個例子使用指向 uint8_t 的指標。

實際專案通常由廠商標頭檔或 SDK 提供暫存器的存取介面。我們先假設平台已提供指向 CTRL 的 ctrl_reg,型別是 volatile uint8_t *;把假想位址轉成這個指標的完整寫法,放在本節最後的補充。

那多出來的 volatile,又是為了什麼?

普通變數通常由程式修改。如果編譯器認為中間沒有修改,就可能重用上一次讀到的結果,減少重複讀取。

但硬體狀態不一定等我們的程式來改。假設正在等待資料準備完成,硬體可以自己把狀態位元從 0 設成 1。下一次讀取,就需要重新去看當時的內容。

同樣地,對某個硬體位置寫兩次相同的值,也可能代表送出兩次命令,不能因為數字相同,就隨意省略一次。

這就是 MMIO 程式常用到 volatile 的原因:標示這些存取有外部可觀察的意義,讓編譯器依目標平台的 volatile 規則處理。GCC:Volatiles

因此,這裡的 volatile uint8_t * 同時交代兩件事:這個例子透過八位元型別存取,而且指向的內容要依平台的 volatile 規則處理。位址、寬度和存取方式都準備好,接下來才真正讀寫。

5. 讀出目前設定,算好,再寫回

這一次,起點是硬體當時的內容。第八節普通變數裡的 0x15,只是讓我們確認那套計算會得到什麼結果,不能代替這次的讀取。

為了和前面的數字對照,先假設此時硬體 CTRL 也是 0x1A,欄位仍然能一般讀寫,而且這段操作期間沒有其他人修改它。

以下是核心片段,ctrl_reg 已由平台準備好:

unsigned int value = *ctrl_reg;       /* 從硬體讀到 0x1A */
unsigned int kept = value & ~0x0Eu;   /* 清掉舊 MODE,得到 0x10 */
unsigned int positioned = (2u << 1) & 0x0Eu;
value = kept | positioned;           /* 模式 2,得到 0x14 */
value |= 0x01u;                      /* 加上啟用,得到 0x15 */
*ctrl_reg = value;                   /* 現在才寫回硬體 */

第一行透過 *ctrl_reg 讀取 CTRL,再把讀到的八位元數值存進普通的 unsigned int value。接下來的遮罩和位移,就和前面練習相同。

這裡最容易混在一起的,是「本地計算結果變了」和「硬體設定變了」。把兩邊分開看:

完成的動作普通變數 value硬體 CTRL
讀取目前內容0x1A0x1A
算好模式 20x14仍是 0x1A
再加上啟用位元0x15仍是 0x1A
執行 *ctrl_reg = value0x15收到寫入,變成 0x15

中間修改 value 的幾行,都還沒有寫入 CTRL。到了最後一行,處理器才對 ctrl_reg 指向的位置發出寫入,把這次結果交給硬體。

所以,前面學的位元運算沒有換規則;我們只是把「普通變數從哪裡取得內容、算完送去哪裡」接上了硬體。

至於 volatile,它處理的是編譯器如何看待存取,不會讓整段讀取、計算、寫回變成不可分割的動作。剛才暫時假設沒有人在中途修改,下一節就來看,這個假設不成立時會怎樣。

想看完整的 MMIO 指標寫法,再展開這一段

下面把剛才先略過的指標建立也補上,計算步驟沿用正文。位址是本文為了教學自行假設的,只有在支援這份映射的嵌入式平台才有意義,不能當成前面的桌面練習直接執行。

這個假想裝置允許八位元讀寫,設定配置和第三節相同:

#include <stdint.h>

void configure_example_device(void) {
    volatile uint8_t * const ctrl_reg =
        (volatile uint8_t *)(uintptr_t)UINT32_C(0x40001004);

    unsigned int value = *ctrl_reg;
    unsigned int kept = value & ~0x0Eu;
    unsigned int positioned = (2u << 1) & 0x0Eu;
    value = kept | positioned;
    value |= 0x01u;

    *ctrl_reg = value;
}

第一行指標宣告比較長,把每個部分分開看:

寫法在這裡的意思
uint8_t<stdint.h> 提供的八位元無號整數型別,環境需要有這個型別
uint8_t *指向這個型別的指標,透過它做八位元存取
volatile指向的內容要依 volatile 存取規則處理
const ctrl_reg指標本身固定指向同一個位置,並不是內容不能寫
UINT32_C(0x40001004)建立適合至少 32 位無號型別的整數位址常數
(uintptr_t)轉成平台提供的、可容納物件指標轉換結果的無號整數型別
(volatile uint8_t *)再把整數位址轉成這裡要使用的指標型別

這些整數與指標的轉換,需要目標平台與編譯器支援對應的 MMIO 映射;不是只要寫出這個轉型,任何電腦就都能存取那個位置。

建立 ctrl_reg 時,還沒有讀取或寫入硬體。到了 value = *ctrl_reg,才讀到當時的內容。

接著先清除模式欄位,把模式 2 放進去,再設啟用位元。中間幾行都在算普通變數;假設讀到原本的 0x1A,會算出 0x15。最後 *ctrl_reg = value,才把結果寫回硬體。

最後一行會把 value 轉成指標所指向的 uint8_t 再寫入;本例的 0x15 放得下。中間用 unsigned int 計算,不會把最後那次硬體存取改成 unsigned int 寬度。

這裡選八位元型別,是因為假想裝置允許這樣存取。若真實暫存器要求 32 位元存取,就需要相應的型別與對齊方式;不能因為只想改低八位,就自行改用八位元指標。實際產生的硬體存取,也需要目標平台與編譯器提供相應保證。

理解這些關係,是為了看懂 SDK 的介面。實際使用時,優先依照平台已定義好的方式讀寫,就能減少手寫位址和型別的機會。

十、寫回去之前,還要確認哪些事情?

剛才已經完成一次硬體讀寫,但我們先放了兩個條件:CTRL 能一般讀寫,而且中間沒有其他人修改它。

接下來分別拿掉這兩個條件。先看同一個 CTRL 如果被別人改動,為什麼可能蓋掉設定;再看硬體提供專用命令時,寫法能怎麼改;最後才換到回報事件的狀態暫存器,看看寫入的意義如何改變。

1. 同一個 CTRL,讀完之後可能被別人改動

沿用剛才的 CTRL,但先把需求縮小成只啟用 bit 0。上一節的寫法可以拆成:

unsigned int local = *ctrl_reg;  /* 先讀取 */
local = local | 0x01u;           /* 在普通變數裡計算 */
*ctrl_reg = local;              /* 再寫回 */

這就是讀取、修改、寫回(Read-Modify-Write,RMW)。前一節改模式再啟用,也經過相同的三個階段,只是中間多了幾步計算。

熟悉 C 的複合賦值後,上面也可以縮成:

*ctrl_reg |= 0x01u;

這兩段是在說明同一個操作,不必連著執行。縮成一行,仍然要先取得舊內容,不能因此認為整次更新不會被打斷。

第三節提到硬體可以發出中斷通知。處理器收到後,可能暫停主程式,先執行中斷處理程式,處理完再回來繼續。

現在用一組新的起始狀態看問題:CTRL 原本是 0x00。主程式想設定 bit 0,中斷處理程式則想設定 bit 4。假設它剛好在主程式讀完之後執行:

時間由上往下:本地計算時硬體仍是 0x10,最後寫回舊資料才蓋掉 bit 4。 主程式讀到 0x00、中斷設定後 0x10、主程式舊值算 0x01、主程式寫回 0x01。
時間由上往下:本地計算時硬體仍是 0x10,最後寫回舊資料才蓋掉 bit 4。

主程式的 local 是先前複製的 0x00。硬體內容變成 0x10 時,這份普通變數不會自動更新,所以它仍然算出 0x01。最後寫回整份內容,就把 bit 4 蓋掉了。

這和第九節指標練習裡的 copy 一樣:讀到的是當時的值,不是一份會自動追蹤原處內容的連結。

volatile 也無法補上這段空隙。它不會阻止中斷進來,也不會讓「讀到的舊值」自動變新。要避免這種衝突,需要依平台選擇能保護這段操作的做法,例如在適用的情況下暫時禁止相關中斷;若還有其他核心會存取,則需要能處理核心間共享的同步機制。

這些同步方式各有規則,這篇先看清楚問題發生在「讀完到寫回之間」。如果硬體直接提供只改指定位元的命令,也可能省掉軟體先讀再寫的步驟。接下來就看這種介面。

2. 讓硬體接收 SET、CLR、XOR 命令

前面的衝突,是主程式最後把一整份舊內容寫回去。那如果它只告訴硬體「請把 bit 0 設成 1」,其餘位置交給硬體保留呢?

這需要硬體提供對應功能,不能只替指標取個新名字。假設同一個裝置,另外定義了三個專用寫入位置:

  • SET:寫入值為 1 的位置設成 1,其他位置不變。
  • CLR:寫入值為 1 的位置清成 0,其他位置不變。
  • XOR:寫入值為 1 的位置翻轉,其他位置不變;有些晶片也叫 TGL。

沿用「啟用 bit 0」的需求,這次直接把 0x01 寫入 SET,不必先讀回整份 CTRL。假設平台把這個專用位置的指標叫做 ctrl_set:

*ctrl_set = 0x01u;

這一行是在送出選取 bit 0 的遮罩。硬體收到後,才把同一份 CTRL 的 bit 0 設成 1,其他設定保留。Microchip:Registers and Bits

如果接著前面的中斷情境:CTRL 已經被中斷改成 0x10,這時主程式對 SET 寫入 0x01,硬體就會保留 bit 4,再設 bit 0,得到 0x11。主程式沒有拿舊的 0x00 算好整份內容再蓋回去。

這也和第四節直接把 CTRL 整份換成 0x01 不同。寫到 CTRL,提供的是新的設定內容;寫到 SET,提供的是請硬體設定哪些位元的命令。 寫入值相同,目的位址的定義不同,作用也就不同。

這種介面可以避免軟體自己讀取、計算、寫回造成的那段空隙。實際能保證什麼,仍要依晶片對這個介面的規定;例如兩邊同時要求改同一位,就仍要依硬體規則與程式需求安排。

SET、CLR、XOR 也不是每個暫存器都有。先在手冊確認有這些介面,才能使用對應位址;一般 CTRL 不能只靠更換寫入值,就變成 SET。

在 RP2040 手冊裡,對照一組真正的位址

上面是假想 CTRL 的例子。下面改看真正晶片的 GPIO 輸出介面,對照「一般輸出值」和「專用 SET/CLR/XOR」各自的位址;它們也有自己的存取寬度。

GPIO 是通用輸入輸出腳位,程式可以控制腳位的輸出,或讀取輸入訊號。RP2040 的 SIO 周邊提供以下 32 位元暫存器,基底位址為 0xD0000000:

名稱偏移量位址寫入的作用
GPIO_OUT0x100xD0000010設定 GPIO 輸出值
GPIO_OUT_SET0x140xD0000014將寫入值為 1 的對應輸出位元設成 1
GPIO_OUT_CLR0x180xD0000018將寫入值為 1 的對應輸出位元清成 0
GPIO_OUT_XOR0x1C0xD000001C翻轉寫入值為 1 的對應輸出位元

這些定義可以在 RP2040 資料手冊的 SIO 章節找到。這裡的 SET、CLR、XOR 都是對同一份 GPIO 輸出值做操作,而不是三份互不相干的輸出設定。

1u << 2 是 0x04。把它寫入 GPIO_OUT_SET,就要求硬體把 GPIO 輸出值的 bit 2 設成 1。其他輸出位元不變。

輸出值改了,腳位是否真的輸出對應電位,還要看腳位功能選擇、輸出允許等設定。先讀懂這個暫存器,是完成整個周邊設定的一部分。

3. 換到狀態暫存器:寫 1,為什麼反而清除?

剛才看到,寫入也可以表示命令。接下來換到另一個暫存器,看看同一份遮罩還能被怎麼解讀。

第三節說過,中斷允許是設定,硬體有沒有發生事件則是狀態。我們把這次回報事件的位置叫做 STATUS,和剛才保存設定的 CTRL 分開。

某個事件發生時,硬體把 STATUS 的對應位元設成 1,留下「發生過了」的記號。這種記號也常叫做旗標(Flag)。這裡的 bit 0 表示一項事件,不再是 CTRL 的啟用開關。

程式處理完事件,就需要告訴硬體可以清掉記號。有些狀態位元因此被定義成 W1C(Write One to Clear):

  • 寫入 1:清除對應旗標。
  • 寫入 0:不影響對應旗標。

這裡寫的是「請清除哪些位置」的命令,不是在交出一整份新狀態。Microchip:Register Bit Types

假設這個暫存器的有效位元全都是 W1C,其他位置也允許寫 0。目前 bit 2 和 bit 0 是 1,也就是讀到 0x05;我們只想清除 bit 0:

寫入命令不等於新狀態:寫 1 清除 bit 0,寫 0 讓 bit 2 維持原來的 1。 讀到的狀態 0x05、實際寫入 0x01、硬體新狀態 0x04。
寫入命令不等於新狀態:寫 1 清除 bit 0,寫 0 讓 bit 2 維持原來的 1。

假設平台已提供指向這個 STATUS 的 status_reg,這次應該直接寫:

*status_reg = 0x01u;

讓 bit 0 收到清除命令,bit 2 因為收到 0 而保持原狀。最後硬體狀態是 0x04。雖然讀到目前狀態是 0x05,這次送出的卻是「只清 bit 0」的遮罩,不必先拿 0x05 算出一份新狀態再寫回。

如果套用普通變數的寫法,會發生什麼?先沿著「讀到什麼 → 算出什麼 → 寫入造成什麼」來看:

操作方式從 0x05 算出的寫入值W1C 收到後的狀態
直接寫 0x010x01只清 bit 0,留下 0x04
AND 反相遮罩 &= ~0x01u0x04清掉 bit 2,反而留下 0x01
OR 遮罩 |= 0x01u0x05bit 2、bit 0 都被清掉,剩 0x00

所以「AND 搭配反相遮罩能清除位元」說的是運算結果;把這個結果送進 W1C,硬體還會再依命令解讀一次。

真正的暫存器可能混合不同讀寫規則,其他位元也不一定能全部寫 0。要依整份定義準備寫入值,不能把這個例子的直接寫法套到所有狀態暫存器。

4. 先知道讀寫的作用,再選運算

現在把同樣寫入 0x01 的三種情況放在一起:

寫到哪裡本例把寫入值解讀成什麼作用
一般讀寫的 CTRL新的整份設定把設定換成 0x01
CTRL 的 SET 介面要設成 1 的位置只把 CTRL 的 bit 0 設成 1
W1C 的 STATUS要清除的旗標位置只清除 STATUS 的 bit 0 旗標

所以,看真實暫存器時,除了「設定放在哪幾位」,還要一起看「對這個位址讀寫,硬體會怎麼處理」。

如果只能讀,就不能拿來寫設定;如果寫 1 是清除命令,就不能當普通變數修改。有些狀態甚至會在讀取後清除,因此為了查看數字而多讀一次,也可能改變後續結果。手冊把這些規則列成唯讀、一般讀寫、W1C 等存取屬性。

保留位元也要照手冊處理。前面要求它們維持 0,是本文假想裝置的規則;實際晶片如果要求保留原值或寫入特定值,就依它的規定。

讀手冊時,可以先照第九節找到位址與存取寬度,再確認欄位配置和讀寫屬性。確定是一般設定,才安排讀取、修改、寫回與必要的同步;若是命令介面,就依它的規則準備遮罩。

這樣才知道,前面的運算結果應該當成「新的內容」寫回,還是當成「指定哪些位置」的命令送出。

十一、從看懂位元,到知道自己改了什麼

最開始看到 0x1A,可能只覺得又多了一種要背的數字。

但它其實就是 0001 1010 的另一種寫法。把位元的位置和欄位定義對上,就能讀出模式、中斷允許和啟用狀態。

接著才是想改哪裡:OR 可以設成 1,AND 配合反相遮罩可以清成 0,XOR 可以翻轉。想讀一個欄位,就先用 AND 取出,再右移對齊;想換一個欄位,就先清掉舊內容,再放入移好位置的新值。

這些操作先在普通變數裡看清楚,最後再透過正確的讀寫位置,把結果交給硬體。硬體如果把寫入解讀成命令,就要依它的規則重新安排操作。

所以我覺得,這次最重要的,不是看到 Hex 就立刻心算成十進位。

而是先知道,這份位元放了什麼設定,我想改哪一部分,以及寫入之後會發生什麼。

之後再看到一整行位元運算,可以把它拆成幾步,逐一核對保留了哪裡、清除了哪裡、新值放到了哪裡。不需要一開始就把整行公式背起來。

先把這些關係接起來,下次看到一整頁 0x,應該就比較不會想直接把手冊關掉了。

參考資料

完

#學習筆記#十六進位#二進位#微處理器#暫存器#位元運算

客官怎麼看

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

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