ESP32 ULP 协处理器指令
本文档详细介绍了 ESP32 ULP FSM 协处理器汇编程序使用的指令。
ULP FSM 协处理器有 4 个 16 位通用寄存器，分别标记为 R0、R1、R2、R3，还有一个 8 位计数器寄存器 (stage_cnt) 用来实现循环。可以用特殊指令来访问阶段计数寄存器。
ULP 协处理器可以访问 8 K 字节大小的 RTC_SLOW_MEM 内存区域。内存以 32 位字单位寻址。它还可以访问 RTC_CNTL、RTC_IO 和 SENS 外设中的外设寄存器。
所有指令都是 32 位。跳转指令、ALU 指令、外设寄存器和内存访问指令在 1 个周期内执行。与外设（TSENS、ADC 和 I2C）相关的指令所需的周期不同，具体取决于外设操作。
指令语法不区分大小写。无论是寄存器名称还是指令名称，都可以任意混合使用大小写字母。
寻址注意事项
对于 ESP32 ULP FSM 协处理器的 JUMP、ST、LD 系列指令，地址参数应以如下方式表示（具体取决于使用的地址参数类型）：
当地址参数作为标签时，指令中的地址应为 32 位字。
对于示例程序:
entry: NOP NOP NOP NOP loop: MOVE R1, loop JUMP R1
当此程序被汇编和链接时，标签
loop的地址将为 16 字节。然而JUMP指令期望寄存器R1中存储的地址以 32 位字表示。由于这种情况较为常见，汇编程序会在生成MOVE指令时将标签loop的地址从字节转换为字。因此，生成的代码相当于:0000 NOP 0004 NOP 0008 NOP 000c NOP 0010 MOVE R1, 4 0014 JUMP R1
另一种情况是，
MOVE指令的参数不是标签，而是常量。此时汇编程序将 直接使用该常量 ，不进行任何转换:.set val, 0x10 MOVE R1, val
在这种情况下，加载到
R1的值为0x10。但是，当使用立即数作为
LD和ST指令的偏移量时，汇编程序会认为地址参数是字节，并在执行指令前将其转换为 32 位字:ST R1, R2, 4 // offset = 4 bytes; Mem[R2 + 4 / 4] = R1
在这种情况下， R1 中的值存储在 [R2 + offset / 4] 指向的内存位置。
请看以下代码:
.global array array: .long 0 .long 0 .long 0 .long 0 MOVE R1, array MOVE R2, 0x1234 ST R2, R1, 0 // 将 R2 的值写入第一个数组元素， // 即 array[0] ST R2, R1, 4 // 将 R2 的值写入第二个数组元素， //（4 字节偏移量），即 array[1] ADD R1, R1, 2 // 将地址递增 2 个字（8 个字节） ST R2, R1, 0 // 将 R2 的值写入第三个数组元素， // 即 array[2]
指令执行时间注意事项
ULP 协处理器的时钟 RTC_FAST_CLK 通常来自内部的 8 MHz 振荡器。如果应用程序需要获知精确 ULP 时钟频率，可以根据主 XTAL 时钟进行校准:
#include "soc/rtc.h"
// calibrate 8M/256 clock against XTAL, get 8M/256 clock period
uint32_t rtc_8md256_period = rtc_clk_cal(RTC_CAL_8MD256, 100);
uint32_t rtc_fast_freq_hz = 1000000ULL * (1 << RTC_CLK_CAL_FRACT) * 256 / rtc_8md256_period;
ULP 协处理器在获取每个指令时需要一定的时钟周期，执行时同样需要一定的时钟周期，此周期数取决于具体的指令。下文详细列出了每个指令所需的执行时间信息。
指令获取时间：
2 个时钟周期 - ALU 和分支类的指令
4 个时钟周期 - 其他指令
注意，访问 RTC 存储器和 RTC 寄存器时，ULP 协处理器的优先级低于主 CPU。这意味着当主 CPU 与 ULP 访问同一块内存区域时，ULP 协处理器需要等待，主 CPU 会优先访问。
以下是所有指令的详细描述：
NOP - 无操作
语法
NOP
操作数
无
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
不执行任何操作，只增加 PC
示例:
1: NOP
ADD - 做加法运算
语法
ADD Rdst, Rsrc1, Rsrc2
ADD Rdst, Rsrc1, imm
操作数
Rdst - 寄存器 R[0..3]
Rsrc1 - 寄存器 R[0..3]
Rsrc2 - 寄存器 R[0..3]
Imm - 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令将源寄存器与另一个源寄存器中的值相加或与一个 16 位有符号值相加，并将结果存储在目标寄存器中。
示例:
1: ADD R1, R2, R3 // R1 = R2 + R3
2: Add R1, R2, 0x1234 // R1 = R2 + 0x1234
3: .set value1, 0x03 // constant value1=0x03
Add R1, R2, value1 // R1 = R2 + value1
4: .global label // declaration of variable label
add R1, R2, label // R1 = R2 + label
...
label: nop // definition of variable label
SUB - 做减法运算
语法
SUB Rdst, Rsrc1, Rsrc2
SUB Rdst, Rsrc1, imm
操作数
Rdst - 寄存器 R[0..3]
Rsrc1 - 寄存器 R[0..3]
Rsrc2 - 寄存器 R[0..3]
Imm - 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令将两个源寄存器中的值相减，或从一个源寄存器中减去一个 16 位有符号值，并将结果存储到目标寄存器中。
示例:
1: SUB R1, R2, R3 // R1 = R2 - R3
2: sub R1, R2, 0x1234 // R1 = R2 - 0x1234
3: .set value1, 0x03 // constant value1=0x03
SUB R1, R2, value1 // R1 = R2 - value1
4: .global label // declaration of variable label
SUB R1, R2, label // R1 = R2 - label
....
label: nop // definition of variable label
AND - 两个操作数的按位与
语法
AND Rdst, Rsrc1, Rsrc2
AND Rdst, Rsrc1, imm
操作数
Rdst - 寄存器 R[0..3]
Rsrc1 - 寄存器 R[0..3]
Rsrc2 - 寄存器 R[0..3]
Imm - 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令对源寄存器的值和另一个源寄存器的值或一个 16 位有符号值进行按位与操作，并将结果存储到目标寄存器中。
示例:
1: AND R1, R2, R3 // R1 = R2 & R3
2: AND R1, R2, 0x1234 // R1 = R2 & 0x1234
3: .set value1, 0x03 // constant value1=0x03
AND R1, R2, value1 // R1 = R2 & value1
4: .global label // declaration of variable label
AND R1, R2, label // R1 = R2 & label
...
label: nop // definition of variable label
OR - 两个操作数的按位或
语法
OR Rdst, Rsrc1, Rsrc2
OR Rdst, Rsrc1, imm
操作数
Rdst - 寄存器 R[0..3]
Rsrc1 - 寄存器 R[0..3]
Rsrc2 - 寄存器 R[0..3]
Imm - 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令对源寄存器的值和另一个源寄存器的值或一个 16 位有符号值进行按位或操作，并将结果存储到目标寄存器中。
示例:
1: OR R1, R2, R3 // R1 = R2 || R3
2: OR R1, R2, 0x1234 // R1 = R2 || 0x1234
3: .set value1, 0x03 // constant value1=0x03
OR R1, R2, value1 // R1 = R2 || value1
4: .global label // declaration of variable label
OR R1, R2, label // R1 = R2 || label
...
label: nop // definition of variable label
LSH - 逻辑左移
语法
LSH Rdst, Rsrc1, Rsrc2
LSH Rdst, Rsrc1, imm
操作数
Rdst - 寄存器 R[0..3]
Rsrc1 - 寄存器 R[0..3]
Rsrc2 - 寄存器 R[0..3]
Imm - 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令对源寄存器进行逻辑左移，移动的位数由另一个源寄存器或一个16位有符号值确定，并将结果存储到目标寄存器中。
备注
大于 15 位的移位操作结果不确定。
示例:
1: LSH R1, R2, R3 // R1 = R2 << R3
2: LSH R1, R2, 0x03 // R1 = R2 << 0x03
3: .set value1, 0x03 // constant value1=0x03
LSH R1, R2, value1 // R1 = R2 << value1
4: .global label // declaration of variable label
LSH R1, R2, label // R1 = R2 << label
...
label: nop // definition of variable label
RSH - 逻辑右移
语法
RSH Rdst, Rsrc1, Rsrc2
RSH Rdst, Rsrc1, imm
操作数
Rdst - 寄存器 R[0..3]
Rsrc1 - 寄存器 R[0..3]
Rsrc2 - 寄存器 R[0..3]
Imm - 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令对源寄存器进行逻辑右移，移动的位数由另一个源寄存器或一个 16 位有符号值确定，并将结果存储到目标寄存器中。
备注
大于 15 位的移位操作结果未定义。
示例:
1: RSH R1, R2, R3 // R1 = R2 >> R3
2: RSH R1, R2, 0x03 // R1 = R2 >> 0x03
3: .set value1, 0x03 // constant value1=0x03
RSH R1, R2, value1 // R1 = R2 >> value1
4: .global label // declaration of variable label
RSH R1, R2, label // R1 = R2 >> label
label: nop // definition of variable label
MOVE – 移动到寄存器
语法
MOVE Rdst, Rsrc
MOVE Rdst, imm
操作数
Rdst – 寄存器 R[0..3]
Rsrc – 寄存器 R[0..3]
Imm – 16 位有符号值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令将源寄存器的值或一个 16 位有符号值移动到目标寄存器。
备注
注意，当标签用作立即数时，标签的地址会从字节转换为字。这是因为对于 LD、ST 和 JUMP 指令，地址寄存器的值应以字表示，而不以字节表示。更多详细信息请参阅 寻址注意事项。
示例:
1: MOVE R1, R2 // R1 = R2
2: MOVE R1, 0x03 // R1 = 0x03
3: .set value1, 0x03 // constant value1=0x03
MOVE R1, value1 // R1 = value1
4: .global label // declaration of label
MOVE R1, label // R1 = address_of(label) / 4
...
label: nop // definition of label
ST – 将数据存储到内存中
语法
ST Rsrc, Rdst, offset
操作数
Rsrc – 寄存器 R[0..3]，保存要存储的 16 位值
Rdst – 寄存器 R[0..3]，目标地址，以 32 位字为单位
Offset – 13 位有符号值，以字节表示
周期
执行需要 4 个周期，获取下一条指令需要 4 个周期
描述
该指令将 Rsrc 的 16 位值存储到目标内存地址 [Rdst + offset] 中，存储的数据占目标内存中一个字的低半部分，而高半部分由当前程序计数器 PC 的值（以字为单位，左移 5 位）与 Rdst（0..3）进行逻辑“或”运算:
Mem[Rdst + offset / 4]{31:0} = {PC[10:0], 3'b0, Rdst, Rsrc[15:0]}应用程序可以使用高 16 位来确定 ULP 程序中的哪条指令将某个特定的字写入了内存。
备注
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 寻址注意事项。
示例:
1: ST R1, R2, 0x12 // MEM[R2 + 0x12 / 4] = R1
2: .data // Data section definition
Addr1: .word 123 // Define label Addr1 16 bit
.set offs, 0x00 // Define constant offs
.text // Text section definition
MOVE R1, 1 // R1 = 1
MOVE R2, Addr1 // R2 = Addr1
ST R1, R2, offs // MEM[R2 + 0 / 4] = R1
// MEM[Addr1 + 0] will be 32'h600001
LD – 从内存中加载数据
语法
LD Rdst, Rsrc, offset
操作数
Rdst – 寄存器 R[0..3]，目标寄存器
Rsrc – 寄存器 R[0..3]，保存目标地址，以 32 位字为单位
Offset – 13 位有符号值，以字节为单位的偏移量
周期
执行需要 4 个周期，获取下一条指令需要 4 个周期
描述
该指令将地址为 [Rsrc + offset / 4] 的内存中的 16 位低半字加载到目标寄存器 Rdst 中:
Rdst[15:0] = Mem[Rsrc + offset / 4][15:0]
备注
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。详情请参阅 寻址注意事项。
示例:
1: LD R1, R2, 0x12 // R1 = MEM[R2 + 0x12 / 4]
2: .data // Data section definition
Addr1: .word 123 // Define label Addr1 16 bit
.set offs, 0x00 // Define constant offs
.text // Text section definition
MOVE R1, 1 // R1 = 1
MOVE R2, Addr1 // R2 = Addr1 / 4 (address of label is converted into words)
LD R1, R2, offs // R1 = MEM[R2 + 0]
// R1 will be 123
JUMP – 跳转到绝对地址
语法
JUMP Rdst
JUMP ImmAddr
JUMP Rdst, Condition
JUMP ImmAddr, Condition
操作数
Rdst – 寄存器 R[0..3] 包含要跳转到的地址（以 32 位字表示）
ImmAddr – 13 位地址（以字节表示），对齐为 4 字节
Condition： - EQ – 如果最后的 ALU 操作结果为零，则跳转 - OV – 如果最后的 ALU 设置了溢出 flag，则跳转
周期
执行需要 2 个周期，获取下一条指令需要 2 个周期。
描述
该指令跳转到指定的地址。既可以无条件跳转，也可以基于 ALU flag 跳转。
示例:
1: JUMP R1 // Jump to address in R1 (address in R1 is in 32-bit words)
2: JUMP 0x120, EQ // Jump to address 0x120 (in bytes) if ALU result is zero
3: JUMP label // Jump to label
...
label: nop // Definition of label
4: .global label // Declaration of global label
MOVE R1, label // R1 = label (value loaded into R1 is in words)
JUMP R1 // Jump to label
...
label: nop // Definition of label
JUMPR – 跳转到相对偏移（条件基于 R0）
语法
JUMPR Step, Threshold, Condition
操作数
Step – 相对于当前位置的偏移量，以字节为单位
Threshold – 分支条件的阈值
- Condition：
EQ (等于) – 如果 R0 中的值 == 阈值，则跳转
LT (小于) – 如果 R0 中的值 < 阈值，则跳转
LE (小于或等于) – 如果 R0 中的值 <= 阈值，则跳转
GT (大于) – 如果 R0 中的值 > 阈值，则跳转
GE (大于或等于) – 如果 R0 中的值 >= 阈值，则跳转
周期
条件 LT，GE，LE 和 GT：执行需要 2 个周期，获取下一条指令需要 2 个周期。
条件 LE 和 GT 在汇编程序中用一个 JUMPR 指令实现:
// JUMPR target, threshold, GT 的实现为：
JUMPR target, threshold+1, GE
// JUMPR target, threshold, LE 的实现为：
JUMPR target, threshold + 1, LT
条件 EQ 在汇编程序中用两个 JUMPR 指令实现:
// JUMPR target, threshold, EQ 的实现为：
JUMPR next, threshold + 1, GE
JUMPR target, threshold, GE
next:
描述
如果条件为真，该指令会跳转到相对地址。条件是指 R0 寄存器的值和阈值的比较结果。
示例:
1:pos: JUMPR 16, 20, GE // Jump to address (position + 16 bytes) if value in R0 >= 20
2: // Down counting loop using R0 register
MOVE R0, 16 // load 16 into R0
label: SUB R0, R0, 1 // R0--
NOP // do something
JUMPR label, 1, GE // jump to label if R0 >= 1
JUMPS – 跳转到相对地址（条件基于阶段数）
语法
JUMPS 步骤, 阈值, 条件
操作数
步骤 – 相对于当前位置的偏移，以字节为单位
阈值 – 分支条件的阈值
- 条件：
EQ (等于) – 如果 stage_cnt == 阈值，则跳转
LT (小于) – 如果 stage_cnt < 阈值，则跳转
LE (小于或等于) - 如果 stage_cnt <= 阈值，则跳转
GT (大于) – 如果 stage_cnt > 阈值，则跳转
GE (大于或等于) — 如果 stage_cnt >= 阈值，则跳转
周期
条件 LE, LT, GE：执行需要 2 个周期，获取下一条指令需要 2 个周期。
条件 EQ, GT 在汇编程序中用两个 JUMPS 指令实现:
// JUMPS target, threshold, EQ 的实现为：
JUMPS next, threshold, LT
JUMPS target, threshold, LE
next:
// JUMPS target, threshold, GT 的实现为:
JUMPS next, threshold, LE
JUMPS target, threshold, GE
next:
因此，执行时间取决于所用分支：要么执行 2 个周期 + 获取 2 个周期，要么执行 4 个周期 + 获取 4 个周期。
描述
如果条件为真，指令将跳转到相对地址。条件是计数寄存器的值和阈值的比较结果。
示例:
1:pos: JUMPS 16, 20, EQ // Jump to (position + 16 bytes) if stage_cnt == 20
2: // Up counting loop using stage count register
STAGE_RST // set stage_cnt to 0
label: STAGE_INC 1 // stage_cnt++
NOP // do something
JUMPS label, 16, LT // jump to label if stage_cnt < 16
STAGE_RST – 重置阶段计数寄存器
语法
STAGE_RST
操作数
无操作数
描述
该指令将阶段计数寄存器设置为 0
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
示例:
1: STAGE_RST // 重置阶段计数寄存器
STAGE_INC – 增加阶段计数寄存器
语法
STAGE_INC 值
操作数
值 – 8 位值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期。
描述
该指令将给定值增加到阶段计数寄存
示例:
1: STAGE_INC 10 // stage_cnt += 10
2: // Up counting loop example:
STAGE_RST // set stage_cnt to 0
label: STAGE_INC 1 // stage_cnt++
NOP // do something
JUMPS label, 16, LT // jump to label if stage_cnt < 16
STAGE_DEC – 减少阶段计数寄存器
语法
STAGE_DEC 值
操作数
值 – 8 位值
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令从阶段计数寄存器中减去给定值
示例:
1: STAGE_DEC 10 // stage_cnt -= 10;
2: // Down counting loop example
STAGE_RST // set stage_cnt to 0
STAGE_INC 16 // increment stage_cnt to 16
label: STAGE_DEC 1 // stage_cnt--;
NOP // do something
JUMPS label, 0, GT // jump to label if stage_cnt > 0
HALT – 结束程序
语法
HALT
操作数
无操作数
周期
执行需要 2 个周期
描述
该指令会停止 ULP 协处理器并重新启动 ULP 唤醒定时器（如果定时器已启用）
示例:
1: HALT // Halt the coprocessor
WAKE – 唤醒芯片
语法
WAKE
操作数
无操作数
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令从 ULP 协处理器向 RTC 控制器发送一个中断。
如果 SoC 处于深度睡眠模式并启用了 ULP 唤醒，会唤醒 SoC。
如果 SoC 不处在深度睡眠模式，并且在 RTC_CNTL_INT_ENA_REG 寄存器中设置了 ULP 中断位 (RTC_CNTL_ULP_CP_INT_ENA)，则会触发 RTC 中断。
备注
注意，在使用 WAKE 指令前，ULP 程序可能需要等待 RTC 控制器就绪，才能唤醒主 CPU。此信息通过 RTC_CNTL_LOW_POWER_ST_REG 寄存器的 RTC_CNTL_RDY_FOR_WAKEUP 位来指示。当 RTC_CNTL_RDY_FOR_WAKEUP 为零时，执行 WAKE 指令唤醒无效。如果希望在主 CPU 不处于睡眠模式时使用 WAKE 指令，可以用 RTC_CNTL_LOW_POWER_ST_REG 的 RTC_CNTL_MAIN_STATE_IN_IDLE 位（位 27）来检查主 CPU 状态，确定其处于正常模式还是睡眠模式。
示例:
1: is_rdy_for_wakeup: // Read RTC_CNTL_RDY_FOR_WAKEUP bit
READ_RTC_FIELD(RTC_CNTL_LOW_POWER_ST_REG, RTC_CNTL_RDY_FOR_WAKEUP)
AND r0, r0, 1
JUMP is_rdy_for_wakeup, eq // Retry until the bit is set
WAKE // Trigger wake up
REG_WR 0x006, 24, 24, 0 // Stop ULP timer (clear RTC_CNTL_ULP_CP_SLP_TIMER_EN)
HALT // Stop the ULP program
// After these instructions, SoC will wake up,
// and ULP will not run again until started by the main program.
1: check_wakeup: // Read RTC_CNTL_RDY_FOR_WAKEUP and RTC_CNTL_MAIN_STATE_IN_IDLE bit
READ_RTC_REG(RTC_CNTL_LOW_POWER_ST_REG, 27, 1)
MOVE r1, r0 // Copy result in to r1
READ_RTC_FIELD(RTC_CNTL_LOW_POWER_ST_REG, RTC_CNTL_RDY_FOR_WAKEUP)
OR r0, r0, r1
JUMP check_wakeup, eq // Retry until either of the bit are set
WAKE // Trigger wake up
HALT // Stop the ULP program
SLEEP – 设置 ULP 唤醒计时器周期
语法
SLEEP sleep_reg
操作数
sleep_reg – 0..4，选择一个
SENS_ULP_CP_SLEEP_CYCx_REG寄存器
周期
执行需要 2 个周期，获取下一条指令需要 4 个周期
描述
该指令决定 ULP 唤醒计时器使用哪一个
SENS_ULP_CP_SLEEP_CYCx_REG(x = 0..4) 寄存器值作为唤醒周期。默认情况下，使用SENS_ULP_CP_SLEEP_CYC0_REG的值
示例:
1: SLEEP 1 // Use period set in SENS_ULP_CP_SLEEP_CYC1_REG
2: .set sleep_reg, 4 // Set constant
SLEEP sleep_reg // Use period set in SENS_ULP_CP_SLEEP_CYC4_REG
WAIT – 等待一定的周期数
语法
WAIT Cycles
操作数
Cycles – 等待的周期数
周期
执行需要 (2 + Cycles) 个周期，获取下一条指令需要 4 个周期
描述
该指令指示延迟一定的周期数。
示例:
1: WAIT 10 // Do nothing for 10 cycles
2: .set wait_cnt, 10 // Set a constant
WAIT wait_cnt // wait for 10 cycles
ADC – 使用 ADC 进行测量
语法
ADC Rdst, Sar_sel, Mux
ADC Rdst, Sar_sel, Mux, 0 — 形式已弃用
操作数
Rdst – 目标寄存器 R[0..3]，结果将存储到此寄存器
Sar_sel – 选择 ADC：0 = SARADC1，1 = SARADC2
Mux - 启用 ADC 通道，通道号为 [Mux-1]。如果传递了 Mux 值 1，会使用 ADC 通道 0。
周期
执行需要
23 + max(1, SAR_AMP_WAIT1) + max(1, SAR_AMP_WAIT2) + max(1, SAR_AMP_WAIT3) + SARx_SAMPLE_CYCLE + SARx_SAMPLE_BIT个周期，获取下一条指令需要 4 个周期
描述
该指令通过 ADC 进行测量
示例
1: ADC R1, 0, 1 // Measure value using ADC1 channel 0 and store result into R1
I2C_RD - 从 I2C 从机中读取单字节
语法
I2C_RD Sub_addr, High, Low, Slave_sel
操作数
Sub_addr – 要从 I2C 从机中读取的地址
High*, *Low — 定义要读取的位的范围。[High, Low] 以外的位会被屏蔽
Slave_sel - 要使用的 I2C 从机地址的索引
周期
执行时间主要取决于 I2C 通信时间。获取下一条指令需要 4 个周期
描述
I2C_RD指令从索引为Slave_sel的 I2C 从机读取一个字节。从机地址（格式为 7 位）必须预先设置到寄存器字段SENS_I2C_SLAVE_ADDRx中，其中x == Slave_sel。 8 位读取结果存储到R0寄存器。
示例:
1: I2C_RD 0x10, 7, 0, 0 // Read byte from sub-address 0x10 of slave with address set in SENS_I2C_SLAVE_ADDR0
I2C_WR - 向 I2C 从机写入单字节
语法
I2C_WR Sub_addr, Value, High, Low, Slave_sel
操作数
Sub_addr – I2C 从机内要写入的地址
Value – 要写入的 8 位值
High, Low — 定义要写入的位范围。[High, Low] 范围外的位会被屏蔽
Slave_sel - 要使用的 I2C 从机地址的索引
周期
执行时间主要取决于 I2C 通信时间。获取下一条指令需要 4 个周期
描述
I2C_WR指令向索引为Slave_sel的 I2C 从机地址写入一个字节。从机地址（格式为 7 位）必须预先设置到寄存器字段SENS_I2C_SLAVE_ADDRx中，其中x == Slave_sel。
示例:
1: I2C_WR 0x20, 0x33, 7, 0, 1 // Write byte 0x33 to sub-address 0x20 of slave with address set in SENS_I2C_SLAVE_ADDR1.
REG_RD – 从外设寄存器读取
语法
REG_RD Addr, High, Low
操作数
Addr – 寄存器地址，以 32 位字为单位
High – 寄存器结束位号
Low – 寄存器起始位号
周期
执行需要 4 个周期，获取下一条指令需要 4 个周期
描述
该指令从外设寄存器读取最多 16 位到一个通用寄存器：
R0 = REG[Addr][High:Low]。
该指令可以访问 RTC_CNTL、RTC_IO、SENS 和 RTC_I2C 外设中的寄存器。从 ULP 中看到的寄存器地址可以根据 DPORT 总线上相同寄存器的地址计算得出，如下所示:
addr_ulp = (addr_dport - DR_REG_RTCCNTL_BASE) / 4
示例:
1: REG_RD 0x120, 7, 4 // load 4 bits: R0 = {12'b0, REG[0x120][7:4]}
REG_WR – 写入外设寄存器
语法
REG_WR Addr, High, Low, Data
操作数
Addr – 寄存器地址，以 32 位字为单位
High – 寄存器结束位号
Low – 寄存器起始位号
Data – 要写入的值，8 位
周期
执行需要 8 个周期，获取下一条指令需要 4 个周期
描述
该指令将一个立即数的最多 8 位写入到外设寄存器中：
REG[Addr][High:Low] = data。此指令可以访问 RTC_CNTL、RTC_IO、SENS 和 RTC_I2C 外设中的寄存器。从 ULP 看到的寄存器地址可以根据 DPORT 总线上同一寄存器的地址计算得出，如下所示:
addr_ulp = (addr_dport - DR_REG_RTCCNTL_BASE) / 4
示例:
1: REG_WR 0x120, 7, 0, 0x10 // set 8 bits: REG[0x120][7:0] = 0x10
方便的外设寄存器访问宏
ULP 源文件在进入汇编程序之前先通过 C 预处理器，因此可以使用某些宏来方便地访问外设寄存器。
一些现有的宏定义在 soc/soc_ulp.h 头文件中，这些宏允许通过的名称访问外设寄存器的字段。可以通过这些宏使用的外设寄存器名称定义在 soc/rtc_cntl_reg.h、soc/rtc_io_reg.h、soc/sens_reg.h 和 soc/rtc_i2c_reg.h 中。
- READ_RTC_REG(rtc_reg, low_bit, bit_width)
将 rtc_reg[low_bit + bit_width - 1 : low_bit] 中的数读到 R0，最多 16 位。如:
#include "soc/soc_ulp.h" #include "soc/rtc_cntl_reg.h" /* 将 RTC_CNTL_TIME0_REG 的低 16 位读入 R0 */ READ_RTC_REG(RTC_CNTL_TIME0_REG, 0, 16)
- READ_RTC_FIELD(rtc_reg, field)
将 rtc_reg 的一个字段读取到 R0，最多 16 位。如:
#include "soc/soc_ulp.h" #include "soc/sens_reg.h" /* 将 SENS_SAR_SLAVE_ADDR3_REG 的 8 位 SENS_TSENS_OUT 字段读入 R0 */ READ_RTC_FIELD(SENS_SAR_SLAVE_ADDR3_REG, SENS_TSENS_OUT)
- WRITE_RTC_REG(rtc_reg, low_bit, bit_width, value)
将立即数写入 rtc_reg[low_bit + bit_width - 1 : low_bit]，最多 8 位。如:
#include "soc/soc_ulp.h" #include "soc/rtc_io_reg.h" /* 设置 RTC_GPIO_OUT_W1TS_REG 中 RTC_GPIO_OUT_DATA_W1TS 字段的 BIT(2) */ WRITE_RTC_REG(RTC_GPIO_OUT_W1TS_REG, RTC_GPIO_OUT_DATA_W1TS_S + 2, 1, 1)
- WRITE_RTC_FIELD(rtc_reg, field, value)
将立即数写入 rtc_reg 的一个字段，最多 8 位。如:
#include "soc/soc_ulp.h" #include "soc/rtc_cntl_reg.h" /* 将 RTC_CNTL_STATE0_REG 的 RTC_CNTL_ULP_CP_SLP_TIMER_EN 字段设置为 0 */ WRITE_RTC_FIELD(RTC_CNTL_STATE0_REG, RTC_CNTL_ULP_CP_SLP_TIMER_EN, 0)