ESP32 ULP 协处理器指令

[English]

本文档详细介绍了 ESP32 ULP FSM 协处理器汇编程序使用的指令。

ULP FSM 协处理器有 4 个 16 位通用寄存器,分别标记为 R0、R1、R2、R3,还有一个 8 位计数器寄存器 (stage_cnt) 用来实现循环。可以用特殊指令来访问阶段计数寄存器。

ULP 协处理器可以访问 8 K 字节大小的 RTC_SLOW_MEM 内存区域。内存以 32 位字单位寻址。它还可以访问 RTC_CNTLRTC_IOSENS 外设中的外设寄存器。

所有指令都是 32 位。跳转指令、ALU 指令、外设寄存器和内存访问指令在 1 个周期内执行。与外设(TSENS、ADC 和 I2C)相关的指令所需的周期不同,具体取决于外设操作。

指令语法不区分大小写。无论是寄存器名称还是指令名称,都可以任意混合使用大小写字母。

寻址注意事项

对于 ESP32 ULP FSM 协处理器的 JUMPSTLD 系列指令,地址参数应以如下方式表示(具体取决于使用的地址参数类型):

  • 当地址参数作为标签时,指令中的地址应为 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

    但是,当使用立即数作为 LDST 指令的偏移量时,汇编程序会认为地址参数是字节,并在执行指令前将其转换为 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 位有符号值移动到目标寄存器。

备注

注意,当标签用作立即数时,标签的地址会从字节转换为字。这是因为对于 LDSTJUMP 指令,地址寄存器的值应以字表示,而不以字节表示。更多详细信息请参阅 寻址注意事项

示例:

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 中的值 >= 阈值,则跳转

周期

条件 LTGELEGT:执行需要 2 个周期,获取下一条指令需要 2 个周期。

条件 LEGT 在汇编程序中用一个 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.hsoc/rtc_io_reg.hsoc/sens_reg.hsoc/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)

此文档对您有帮助吗?