{IDF_TARGET_NAME} ULP 协处理器指令
=================================================
:link_to_translation:`en:[English]`
本文档详细介绍了 {IDF_TARGET_NAME} 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）相关的指令所需的周期不同，具体取决于外设操作。
指令语法不区分大小写。无论是寄存器名称还是指令名称，都可以任意混合使用大小写字母。
.. _ulp-fsm-addressing:
寻址注意事项
-----------------
对于 {IDF_TARGET_NAME} 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 会优先访问。
.. only:: esp32s2 or esp32s3
ESP32 ULP 和 {IDF_TARGET_NAME} ULP 指令集的区别
-----------------------------------------------------------------------
与 ESP32 ULP FSM 协处理器相比，{IDF_TARGET_NAME} ULP FSM 协处理器具有扩展的指令集。{IDF_TARGET_NAME} ULP FSM 与 ESP32 ULP FSM 二进制不兼容，但在重新构建后，ESP32 ULP FSM 的汇编程序应能在 {IDF_TARGET_NAME} ULP FSM 上运行。
添加到 {IDF_TARGET_NAME} ULP FSM 的新指令包括：``LDL``、``LDH``、``STL``、``STH``、``ST32``、``STO``、``STI``、``STI32``。
以下是所有指令的详细描述：
**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位有符号值确定，并将结果存储到目标寄存器中。
.. note::
大于 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 位有符号值确定，并将结果存储到目标寄存器中。
.. note::
大于 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 位有符号值移动到目标寄存器。
.. note::
注意，当标签用作立即数时，标签的地址会从字节转换为字。这是因为对于 ``LD``、``ST`` 和 ``JUMP`` 指令，地址寄存器的值应以字表示，而不以字节表示。更多详细信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
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 程序中的哪条指令将某个特定的字写入了内存。
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
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
.. only:: esp32s2 or esp32s3
**STL** – 将数据存储到 32 位内存的低 16 位
----------------------------------------------------------------
**语法**
**STL** **Rsrc, Rdst, offset, Label**
**操作数**
- **Rsrc** – 寄存器 R[0..3]，保存要存储的 16 位值
- **Rdst** – 寄存器 R[0..3]，目标地址，以 32 位字为单位
- **Offset** – 11 位有符号值，以字节为单位的偏移
- **Label** – 用户定义的 2 位无符号值
**周期**
执行需要 4 个周期，获取下一条指令需要 4 个周期
**描述**
该指令将 Rsrc 的 16 位值存储到地址为 [Rdst + offset / 4] 的内存的低半字中::
Mem[Rdst + offset / 4]{15:0} = {Rsrc[15:0]}
Mem[Rdst + offset / 4]{15:0} = {Label[1:0],Rsrc[13:0]}
``ST`` 和 ``STL`` 命令可以互换使用，以保持对早期版本 ULP 核的向后兼容性。
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
1: STL 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
STL R1, R2, offs // MEM[R2 + 0 / 4] = R1
// MEM[Addr1 + 0] will be 32'hxxxx0001
3:
MOVE R1, 1 // R1 = 1
STL R1, R2, 0x12, 1 // MEM[R2 + 0x12 / 4] = 0xxxxx4001
**STH** – 将数据存储到 32 位内存的高 16 位
------------------------------------------------------------
**语法**
**STH** **Rsrc, Rdst, offset, Label**
**操作数**
- **Rsrc** – 寄存器 R[0..3]，保存要存储的 16 位值
- **Rdst** – 寄存器 R[0..3]，目标地址，以 32 位字为单位
- **Offset** – 11 位有符号值，以字节为单位的偏移
- **Label** – 用户定义的 2 位无符号值
**周期**
执行需要 4 个周期，获取下一条指令需要 4 个周期
**描述**
该指令将 Rsrc 的 16 位值存储到地址为 [Rdst + offset / 4] 的内存的高半字中::
Mem[Rdst + offset / 4]{31:16} = {Rsrc[15:0]}
Mem[Rdst + offset / 4]{31:16} = {Label[1:0],Rsrc[13:0]}
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
1: STH R1, R2, 0x12 // MEM[R2 + 0x12 / 4][31:16] = 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
STH R1, R2, offs // MEM[R2 + 0 / 4] = R1
// MEM[Addr1 + 0] will be 32'h0001xxxx
3:
MOVE R1, 1 // R1 = 1
STH R1, R2, 0x12, 1 // MEM[R2 + 0x12 / 4] 0x4001xxxx
**ST32** – 将 32 位数据存储到 32 位内存
---------------------------------------------------
**语法**
**ST32** **Rsrc, Rdst, offset, Label**
**操作数**
- **Rsrc** – 寄存器 R[0..3]，保存要存储的 16 位值
- **Rdst** – 寄存器 R[0..3]，目标地址，以 32 位字为单位
- **Offset** – 11 位有符号值，以字节为单位的偏移
- **Label** – 用户定义的 2 位无符号值
**周期**
执行需要 4 个周期，获取下一条指令需要 4 个周期
**描述**
该指令将 PC 的 11 位值，标签值和 Rsrc 的 16 位值存储到地址为 [Rdst + offset / 4] 的 32 位内存中::
Mem[Rdst + offset / 4]{31:0} = {PC[10:0],0[2:0],Label[1:0],Rsrc[15:0]}
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
1: ST32 R1, R2, 0x12, 0 // MEM[R2 + 0x12 / 4][31:0] = {PC[10:0],0[2:0],Label[1:0],Rsrc[15:0]}
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
ST32 R1, R2, offs, 1 // MEM[R2 + 0] = {PC[10:0],0[2:0],Label[1:0],Rsrc[15:0]}
// MEM[Addr1 + 0] will be 32'h00010001
**STO** – 设置自动递增操作的偏移值
-------------------------------------------------------
**语法**
**STO** **offset**
**操作数**
- **Offset** – 11 位有符号值，以字节为单位的偏移
**周期**
执行需要 4 个周期，获取下一条指令需要 4 个周期
**描述**
该指令将 16 位值设置到偏移寄存器::
offset = value / 4
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
1: STO 0x12 // Offset = 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
STO offs // Offset = 0x00
**STI** – 将数据存储到 32 位内存中，并自动递增预定义地址偏移
-------------------------------------------------------------------------------------------
**语法**
**STI** **Rsrc, Rdst, Label**
**操作数**
- **Rsrc** – 寄存器 R[0..3]，保存要存储的 16 位值
- **Rdst** – 寄存器 R[0..3]，目标地址，以 32 位字为单位
- **Label** – 用户定义的 2 位无符号值
**周期**
执行需要 4 个周期，获取下一条指令需要 4 个周期
**描述**
该指令将 Rsrc 的 16 位值存储到地址为 [Rdst + offset / 4] 的内存的低半字和高半字中。
当 STI 指令被调用两次时，会自增偏移量。请确保在执行 STI 指令之前，执行 ``STO`` 指令来设置该偏移值::
Mem[Rdst + offset / 4]{15:0/31:16} = {Rsrc[15:0]}
Mem[Rdst + offset / 4]{15:0/31:16} = {Label[1:0],Rsrc[13:0]}
**示例**::
1: STO 4 // Set offset to 4
STI R1, R2 // MEM[R2 + 4 / 4][15:0] = R1
STI R1, R2 // MEM[R2 + 4 / 4][31:16] = R1
// offset += (1 * 4) //offset is incremented by 1 word
STI R1, R2 // MEM[R2 + 8 / 4][15:0] = R1
STI R1, R2 // MEM[R2 + 8 / 4][31:16] = R1
**STI32** – 将 32 位数据存储到 32 位内存中，并自动递增地址偏移
-----------------------------------------------------------------------------------------
**语法**
**STI32** **Rsrc, Rdst, Label**
**操作数**
- **Rsrc** – 寄存器 R[0..3]，保存要存储的 16 位值
- **Rdst** – 寄存器 R[0..3]，目标地址，以 32 位字为单位
- **Label** – 用户定义的 2 位无符号值
**周期**
执行需要 4 个周期，获取下一条指令需要 4 个周期
**描述**
该指令将 PC 的 11 位值，标签值和 Rsrc 的 16 位值存储到地址为 [Rdst + offset / 4] 的 32 位内存中。
每次调用 STI32 指令时，偏移值都会自动增加。确保在执行 STI32 指令之前，执行 ``STO`` 指令来设置偏移值::
Mem[Rdst + offset / 4]{31:0} = {PC[10:0],0[2:0],Label[1:0],Rsrc[15:0]}
**示例**::
1: STO 0x12
STI32 R1, R2, 0 // MEM[R2 + 0x12 / 4][31:0] = {PC[10:0],0[2:0],Label[1:0],Rsrc[15:0]}
// offset += (1 * 4) //offset is incremented by 1 word
STI32 R1, R2, 0 // MEM[R2 + 0x16 / 4][31:0] = {PC[10:0],0[2:0],Label[1:0],Rsrc[15:0]}
**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]
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。详情请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
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
.. only:: esp32s2 or esp32s3
**LDL** – 从 32 位内存的低半字中加载数据
-------------------------------------------------
**语法**
**LDL** **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]
``LD`` 和 ``LDL`` 命令可以互换使用，以保持对早期版本 ULP 核的向后兼容性。
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
1: LDL 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)
LDL R1, R2, offs // R1 = MEM[R2 + 0]
// R1 will be 123
**LDH** – 从 32 位内存的高半字加载数据
--------------------------------------------------------------
**语法**
**LDH** **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]
.. note::
注意，以字节为单位指定的偏移量会在执行前被转换为 32 位字偏移量。更多信息请参阅 :ref:`ulp-fsm-addressing`。
**示例**::
1: LDH R1, R2, 0x12 // R1 = MEM[R2 + 0x12 / 4]
2: .data // Data section definition
Addr1: .word 0x12345678 // 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)
LDH R1, R2, offs // R1 = MEM[R2 + 0]
// R1 will be 0x1234
**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 中的值 >= 阈值，则跳转
**周期**
.. only:: esp32
条件 **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:
.. only:: esp32s2 or esp32s3
条件 **EQ**，**GT** 和 **LT**：执行需要 2 个周期，获取下一条指令需要 2 个周期。
条件 **LE** 和 **GE** 在汇编程序中使用两个 **JUMPR** 指令实现::
// JUMPR target, threshold, LE is implemented as:
JUMPR target, threshold, EQ
JUMPR target, threshold, LT
// JUMPR target, threshold, GE is implemented as:
JUMPR target, threshold, EQ
JUMPR target, threshold, GT
因此，执行时间取决于所用分支：要么执行 2 个周期 + 获取 2 个周期，要么执行 4 个周期 + 获取 4 个周期。
**描述**
如果条件为真，该指令会跳转到相对地址。条件是指 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 >= 阈值，则跳转
**周期**
.. only:: esp32
条件 **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 个周期。
.. only:: esp32s2 or esp32s3
执行需要 2 个周期，获取下一条指令需要 2 个周期。
**描述**
如果条件为真，指令将跳转到相对地址。条件是计数寄存器的值和阈值的比较结果。
**示例**::
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 中断。
.. note::
注意，在使用 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
.. only:: esp32
**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
.. only:: not esp32
**TSENS** – 使用温度传感器进行测量
--------------------------------------------
**语法**
- **TSENS** **Rdst, Wait_Delay**
**操作数**
- **Rdst** – 目标寄存器 R[0..3]，结果将存储到此寄存器
- **Wait_Delay** – 执行测量所需的周期数
**周期**
执行需要（2 + **Wait_Delay** + 3 * TSENS_CLK）个周期，获取下一条指令需要 4 个周期
**描述**
该指令使用 TSENS 进行测量，并将结果存储到通用寄存器
**示例**::
1: TSENS R1, 1000 // Measure temperature sensor for 1000 cycles,
// and store result to R1
**ADC** – 使用 ADC 进行测量
---------------------------------
**语法**
- **ADC** **Rdst, Sar_sel, Mux**
- **ADC** **Rdst, Sar_sel, Mux, 0** — 形式已弃用
**操作数**
- **Rdst** – 目标寄存器 R[0..3]，结果将存储到此寄存器
- **Sar_sel** – 选择 ADC：0 = SARADC1，1 = SARADC2
.. only:: esp32
- **Mux** - 启用 ADC 通道，通道号为 [Mux-1]。如果传递了 Mux 值 1，会使用 ADC 通道 0。
.. only:: esp32s2 or esp32s3
- **Mux** - 选择的 PAD，SARADC Pad[Mux-1] 被启用。如果传递了 Mux 值 1，会使用 ADC pad 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 进行测量
.. only:: esp32
**示例** ::
1: ADC R1, 0, 1 // Measure value using ADC1 channel 0 and store result into R1
.. only:: esp32s2 or esp32s3
**示例** ::
1: ADC R1, 0, 1 // Measure value using ADC1 pad 2 and store result into R1
.. only:: esp32
**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]``。
.. only:: esp32
该指令可以访问 RTC_CNTL、RTC_IO、SENS 和 RTC_I2C 外设中的寄存器。从 ULP 中看到的寄存器地址可以根据 DPORT 总线上相同寄存器的地址计算得出，如下所示::
addr_ulp = (addr_dport - DR_REG_RTCCNTL_BASE) / 4
.. only:: esp32s2 or esp32s3
该指令可以访问 RTC_CNTL、RTC_IO、SENS 和 RTC_I2C 外设中的寄存器。从 ULP 看到的寄存器地址可以根据 PeriBUS1 总线上相同寄存器的地址计算得出，如下所示::
addr_ulp = (addr_peribus1 - 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``。
.. only:: esp32
此指令可以访问 RTC_CNTL、RTC_IO、SENS 和 RTC_I2C 外设中的寄存器。从 ULP 看到的寄存器地址可以根据 DPORT 总线上同一寄存器的地址计算得出，如下所示::
addr_ulp = (addr_dport - DR_REG_RTCCNTL_BASE) / 4
.. only:: esp32s2 or esp32s3
此指令可以访问 RTC_CNTL 、 RTC_IO 、 SENS 和 RTC_I2C 外设中的寄存器。从 ULP 看到的寄存器地址可以根据 PeriBUS1 上同一寄存器的地址按如下方式计算::
addr_ulp = (addr_peribus1 - 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)