/**
 * @file LKS32MC09x_User_Manual_v1.19
 * @brief 从手册创建的头文件
 * @details 基于文件 LKS32MC09x_User_Manual_v1.19.pdf
 * @note 本文件由自动化系统创建，请勿手动修改
 * @date 2025-11-13 10:56:02
 * @version 1.19
 */
#ifndef __LKS32MC09X_USER_MANUAL_V1_19__
#define __LKS32MC09X_USER_MANUAL_V1_19__
#include "stdint.h"

/* SYST_CSR 控制和状态寄存器 */
#define SYST_CSR_FLAG_BIT    BIT16 // [16] SysTick定时器计数器回零标志位，读清除。 0:没有回零 1:发生回零
#define SYST_CSR_CLKSRC_BIT  BIT2  // [2] SysTick定时器时钟选择信号。默认为0。 0:CPU时钟/8 1:CPU时钟
#define SYST_CSR_TICKINT_BIT BIT1  // [1] SysTick定时器中断使能信号。默认为0。 0:关闭 1:使能
#define SYST_CSR_ENABLE_BIT  BIT0  // [0] SysTick定时器使能信号。默认为0。 0:关闭 1:使能

/* SYST_RVR 重载值寄存器 */
#define SYST_RVR_RELOAD_POS  0                                                   // SYST_RVR_RELOAD起始位
#define SYST_RVR_RELOAD_MASK (uint32_t)(0xFFFFFF << SYST_RVR_RELOAD_POS)         // SYST_RVR_RELOAD位掩码
#define SYST_RVR_RELOAD(x)   (uint32_t)(((x) & 0xFFFFFF) << SYST_RVR_RELOAD_POS) // [23:0] SysTick定时器周期寄存器，定时器在0RELOAD之间计数。默认为0。

/* SYST_CVR 当前值寄存器 */
#define SYST_CVR_CURRENT_POS  0                                                    // SYST_CVR_CURRENT起始位
#define SYST_CVR_CURRENT_MASK (uint32_t)(0xFFFFFF << SYST_CVR_CURRENT_POS)         // SYST_CVR_CURRENT位掩码
#define SYST_CVR_CURRENT(x)   (uint32_t)(((x) & 0xFFFFFF) << SYST_CVR_CURRENT_POS) // [23:0] 读取该寄存器，返回SysTick定时器内部计数值，默认为0。对该寄存器写入任何值，将复位内部计数值，同时清除SYST_CSR.FLAG。

/* SYS_AFE_ADC ADC原始数据寄存器 */
#define SYS_AFE_ADC_ADC_RAW_D_POS  0                                                      // SYS_AFE_ADC_ADC_RAW_D起始位
#define SYS_AFE_ADC_ADC_RAW_D_MASK (uint32_t)(0xFFF << SYS_AFE_ADC_ADC_RAW_D_POS)         // SYS_AFE_ADC_ADC_RAW_D位掩码
#define SYS_AFE_ADC_ADC_RAW_D(x)   (uint32_t)(((x) & 0xFFF) << SYS_AFE_ADC_ADC_RAW_D_POS) // [11:0] ADC输出的原始数据

/* SYS_AFE_INFO 芯片版本信息寄存器 */
#define SYS_AFE_INFO_Series_POS   8                                                    // SYS_AFE_INFO_Series起始位
#define SYS_AFE_INFO_Series_MASK  (uint32_t)(0xFF << SYS_AFE_INFO_Series_POS)          // SYS_AFE_INFO_Series位掩码
#define SYS_AFE_INFO_Series(x)    (uint32_t)(((x) & 0xFF) << SYS_AFE_INFO_Series_POS)  // [15:8] 芯片型号信息，固定为0x04
#define SYS_AFE_INFO_Version_POS  0                                                    // SYS_AFE_INFO_Version起始位
#define SYS_AFE_INFO_Version_MASK (uint32_t)(0xFF << SYS_AFE_INFO_Version_POS)         // SYS_AFE_INFO_Version位掩码
#define SYS_AFE_INFO_Version(x)   (uint32_t)(((x) & 0xFF) << SYS_AFE_INFO_Version_POS) // [7:0] 芯片版本信息

/* SYS_AFE_DBG AFE调试寄存器 */
#define SYS_AFE_DBG_PWR_WEAK_BIT BIT15 // [15] 供电低于掉电监测阈值

/* SYS_AFE_REG0 模拟配置寄存器0 */
#define SYS_AFE_REG0_ADC_OPA_MODE_BIT BIT15                                                // [15] ADC和运放模式 0: ADC量程为+/-3.6V；运放输出的共模电压为1.8V，因此理论上运放输出的最大信号是+/-3.6V，但考虑到共模电压的分布特性，建议运放的最大信号小于+/-3.4V。IO口输入的ADC最大信号可到3.6V。用于电源电压为5V的应用。 1: ADC量程为+/-3.3V；运放输出的共模电压为1.6V，因此理论上运放输出的最大信号是+/-3.2V，但考虑到共模电压的分布特性，建议运放的最大信号小于+/-3.0V。IO口输入的ADC最大信号可到3.3V。用于电源电压为3.3V的应用。
#define SYS_AFE_REG0_PVDSEL_POS       13                                                   // SYS_AFE_REG0_PVDSEL起始位
#define SYS_AFE_REG0_PVDSEL_MASK      (uint32_t)(0x3 << SYS_AFE_REG0_PVDSEL_POS)           // SYS_AFE_REG0_PVDSEL位掩码
#define SYS_AFE_REG0_PVDSEL(x)        (uint32_t)(((x) & 0x3) << SYS_AFE_REG0_PVDSEL_POS)   // [14:13] 掉电检测阈值Vth选择 00:4.0V 01:3.74V 10:3.49V 11:2.8V 精度为100 mV 以上阈值为VSR_PDT=0，即选择低功耗基准源VBGP时的设定值；如果VSR_PDT=1，选择DAC输出作为基准，则阈值相应调整为Vth\*DAC0_OUT/VBGP
#define SYS_AFE_REG0_VSR_PDT_BIT      BIT12                                                // [12] 掉电检测基准源选择 0:选择VBGP 1:选择DAC输出
#define SYS_AFE_REG0_PD_PDT_BIT       BIT11                                                // [11] 掉电检测电路开关 0:开启 1:关闭
#define SYS_AFE_REG0_OPA_ST_BIT       BIT10                                                // [10] OPA 内部IP/IN短接以测试零漂 0:OPA正常工作模式 1:OPA内部IP/IN短接，并与芯片外部断开连接
#define SYS_AFE_REG0_IT_OPA_POS       8                                                    // SYS_AFE_REG0_IT_OPA起始位
#define SYS_AFE_REG0_IT_OPA_MASK      (uint32_t)(0x3 << SYS_AFE_REG0_IT_OPA_POS)           // SYS_AFE_REG0_IT_OPA位掩码
#define SYS_AFE_REG0_IT_OPA(x)        (uint32_t)(((x) & 0x3) << SYS_AFE_REG0_IT_OPA_POS)   // [9:8] OPA偏置电流调节 00:×1 01:×1.2 10:×1.5 11:×2
#define SYS_AFE_REG0_RES_OPA3_POS     6                                                    // SYS_AFE_REG0_RES_OPA3起始位
#define SYS_AFE_REG0_RES_OPA3_MASK    (uint32_t)(0x3 << SYS_AFE_REG0_RES_OPA3_POS)         // SYS_AFE_REG0_RES_OPA3位掩码
#define SYS_AFE_REG0_RES_OPA3(x)      (uint32_t)(((x) & 0x3) << SYS_AFE_REG0_RES_OPA3_POS) // [7:6] 运放3反馈电阻 00: 660k:20k 01: 640k:40k 10: 320k:40k 11:160k:40k
#define SYS_AFE_REG0_RES_OPA2_POS     4                                                    // SYS_AFE_REG0_RES_OPA2起始位
#define SYS_AFE_REG0_RES_OPA2_MASK    (uint32_t)(0x3 << SYS_AFE_REG0_RES_OPA2_POS)         // SYS_AFE_REG0_RES_OPA2位掩码
#define SYS_AFE_REG0_RES_OPA2(x)      (uint32_t)(((x) & 0x3) << SYS_AFE_REG0_RES_OPA2_POS) // [5:4] 运放2反馈电阻 00: 660k:20k 01: 640k:40k 10: 320k:40k 11:160k:40k
#define SYS_AFE_REG0_RES_OPA1_POS     2                                                    // SYS_AFE_REG0_RES_OPA1起始位
#define SYS_AFE_REG0_RES_OPA1_MASK    (uint32_t)(0x3 << SYS_AFE_REG0_RES_OPA1_POS)         // SYS_AFE_REG0_RES_OPA1位掩码
#define SYS_AFE_REG0_RES_OPA1(x)      (uint32_t)(((x) & 0x3) << SYS_AFE_REG0_RES_OPA1_POS) // [3:2] 运放1反馈电阻 00: 660k:20k 01: 640k:40k 10: 320k:40k 11:160k:40k
#define SYS_AFE_REG0_RES_OPA0_POS     0                                                    // SYS_AFE_REG0_RES_OPA0起始位
#define SYS_AFE_REG0_RES_OPA0_MASK    (uint32_t)(0x3 << SYS_AFE_REG0_RES_OPA0_POS)         // SYS_AFE_REG0_RES_OPA0位掩码
#define SYS_AFE_REG0_RES_OPA0(x)      (uint32_t)(((x) & 0x3) << SYS_AFE_REG0_RES_OPA0_POS) // [1:0] 运放0反馈电阻 00: 660k:20k 01: 640k:40k 10: 320k:40k 11:160k:40k 对应的OPA增益分别为: 00:33倍 01:16倍 10:8倍 11:4倍 使用660k:20k增益设置时，IT_OPA需设置为2b’10，即x1.5倍的电流.

/* SYS_AFE_REG1 模拟配置寄存器1 */
#define SYS_AFE_REG1_OPA3PDN_BIT   BIT15                                              // [15] OPA3开关 0:关闭 1:使能
#define SYS_AFE_REG1_OPA2PDN_BIT   BIT14                                              // [14] OPA2开关 0:关闭 1:使能
#define SYS_AFE_REG1_OPA1PDN_BIT   BIT13                                              // [13] OPA1开关 0:关闭 1:使能
#define SYS_AFE_REG1_OPA0PDN_BIT   BIT12                                              // [12] OPA0开关 0:关闭 1:使能
#define SYS_AFE_REG1_BGPPD_BIT     BIT11                                              // [11] BandGap开关 此寄存器配置为1，且芯片通过休眠指令进入休眠后BandGap会被硬件切换至低功耗模式。 只配置BGPPD=1，不会立即关闭RCH时钟。 如配置BGPPD=0，芯片休眠后BandGap不会被硬件切换至低功耗模式 0:开启 1:关闭
#define SYS_AFE_REG1_RCHPD_BIT     BIT10                                              // [10] 8MHz RCH时钟开关，此寄存器配置为1，且芯片通过休眠指令进入休眠后RCH会被硬件关闭。 只配置RCHPD=1，不会立即关闭RCH时钟。 如配置RCHPD=0，芯片休眠后RCH时钟不会被关闭 0:开启 1:关闭
#define SYS_AFE_REG1_XTAL_FLT_BIT  BIT9                                               // [9] 晶振低通滤波关闭 1:关闭 0:打开
#define SYS_AFE_REG1_LDOOUT_EN_BIT BIT8                                               // [8] 0:不输出 1:使能1.5V LDO输出到IO P0_0
#define SYS_AFE_REG1_DAC1_GAIN_BIT BIT7                                               // [7] 8BIT DAC量程选择 0:满量程为3V; 1:满量程为1.2V
#define SYS_AFE_REG1_DAC0_GAIN_BIT BIT6                                               // [6] 12BIT DAC量程选择 0:满量程为4.76V; 1:满量程为1.2V
#define SYS_AFE_REG1_XTAL_SCHT_BIT BIT4                                               // [4] 晶振选择反相器或者施密特 1:反相器 0:施密特
#define SYS_AFE_REG1_SW_RES_POS    1                                                  // SYS_AFE_REG1_SW_RES起始位
#define SYS_AFE_REG1_SW_RES_MASK   (uint32_t)(0x7 << SYS_AFE_REG1_SW_RES_POS)         // SYS_AFE_REG1_SW_RES位掩码
#define SYS_AFE_REG1_SW_RES(x)     (uint32_t)(((x) & 0x7) << SYS_AFE_REG1_SW_RES_POS) // [3:1] SW电压测量时片内电阻阻值选择 000:不使用 111:46 ohm 011:60 ohm 101:67 ohm 110:86 ohm 001:100 ohm 010:150 ohm 100:200 ohm
#define SYS_AFE_REG1_CMP_FT_BIT    BIT0                                               // [0] 1: 比较器延迟为:15ns(pos)，32ns(neg) 0:比较器延迟为:92ns(pos)，320ns(neg)

/* SYS_AFE_REG2 模拟配置寄存器2 */
#define SYS_AFE_REG2_SW_RES_EN_BIT      BIT15                                                     // [15] 使能测量反电动势，使能后OPAx_IP端通过测量电阻下拉到地，通常，此时OPAx_IN端通过外围电路接地。 测量电阻连接至哪一个OPA，由SW_RES_OPA进行选择。 测量电阻阻值，由SYS_AFE_REG2.SW_RES进行选择。 0:断开反电动势测量电阻 1:连接反电动势测量电阻
#define SYS_AFE_REG2_SW_RES_OPA_POS     13                                                        // SYS_AFE_REG2_SW_RES_OPA起始位
#define SYS_AFE_REG2_SW_RES_OPA_MASK    (uint32_t)(0x3 << SYS_AFE_REG2_SW_RES_OPA_POS)            // SYS_AFE_REG2_SW_RES_OPA位掩码
#define SYS_AFE_REG2_SW_RES_OPA(x)      (uint32_t)(((x) & 0x3) << SYS_AFE_REG2_SW_RES_OPA_POS)    // [14:13] 测量反电动势的零温度系数电阻连接关系 00:接到OPA0正输入端 01:接到OPA1正输入端 10:接到OPA2正输入端 11:接到OPA3正输入端
#define SYS_AFE_REG2_BEMFMID_OUTEN_POS  10                                                        // SYS_AFE_REG2_BEMFMID_OUTEN起始位
#define SYS_AFE_REG2_BEMFMID_OUTEN_MASK (uint32_t)(0x3 << SYS_AFE_REG2_BEMFMID_OUTEN_POS)         // SYS_AFE_REG2_BEMFMID_OUTEN位掩码
#define SYS_AFE_REG2_BEMFMID_OUTEN(x)   (uint32_t)(((x) & 0x3) << SYS_AFE_REG2_BEMFMID_OUTEN_POS) // [11:10] 使能比较器三个正输入端中点信号到输出 00:不输出 01:输出比较器0的中点信号到IO 10:输出比较器1的中点信号到IO 11:禁止
#define SYS_AFE_REG2_XTAL_RSEL_BIT      BIT8                                                      // [8] 晶体起振电路电阻调节 0:P端电阻维持原值 1: P端电阻增加一倍
#define SYS_AFE_REG2_DAC1_OUT_EN_BIT    BIT7                                                      // [7] 使能DAC1输出到IO 0:不输出 1:使能输出到IO P0.0
#define SYS_AFE_REG2_DAC0_OUT_EN_BIT    BIT6                                                      // [6] 使能DAC0输出到IO 0:不输出 1:使能输出到IO P0.0
#define SYS_AFE_REG2_VREF_OUT_EN_BIT    BIT5                                                      // [5] 使能VREF输出到IO 0:不输出 1:使能输出到IO P0.0
#define SYS_AFE_REG2_OPAOUT_EN_POS      0                                                         // SYS_AFE_REG2_OPAOUT_EN起始位
#define SYS_AFE_REG2_OPAOUT_EN_MASK     (uint32_t)(0xF << SYS_AFE_REG2_OPAOUT_EN_POS)             // SYS_AFE_REG2_OPAOUT_EN位掩码
#define SYS_AFE_REG2_OPAOUT_EN(x)       (uint32_t)(((x) & 0xF) << SYS_AFE_REG2_OPAOUT_EN_POS)     // [3:0] 使能_OPAx输出信号送至IO口，或使能OPAx_OUT输出信号送至CMP。 0000:不输出到IO，输出OPA0_OUT正端到OPA_OUT_CMP; 0001:不输出到IO，输出OPA1_OUT正端到OPA_OUT_CMP; 0010:不输出到IO，输出OPA2_OUT正端到OPA_OUT_CMP; 0011:不输出到IO，输出OPA3_OUT正端到OPA_OUT_CMP; 0100:不输出到IO，输出OPA0_OUT负端到OPA_OUT_CMP; 0101:不输出到IO，输出OPA1_OUT负端到OPA_OUT_CMP; 0110:不输出到IO，输出OPA2_OUT负端到OPA_OUT_CMP; 0111:不输出到IO，输出OPA3_OUT负端到OPA_OUT_CMP; 1000:输出OPA0_OUT正端到IO P2.7口，同时输出OPA0_OUT正端到OPA_OUT_CMP; 1001:输出OPA1_OUT正端到IO P2.7口，同时输出OPA1_OUT正端到OPA_OUT_CMP; 1010:输出OPA2_OUT正端到IO P2.7口，同时输出OPA2_OUT正端到OPA_OUT_CMP; 1011:输出OPA3_OUT正端到IO P2.7口，同时输出OPA3_OUT正端到OPA_OUT_CMP; 1100:输出OPA0_OUT负端到IO P2.7口，同时输出OPA0_OUT负端到OPA_OUT_CMP; 1101:输出OPA1_OUT负端到IO P2.7口，同时输出OPA1_OUT负端到OPA_OUT_CMP; 1110:输出OPA2_OUT负端到IO P2.7口，同时输出OPA2_OUT负端到OPA_OUT_CMP; 1111:输出OPA3_OUT负端到IO P2.7口，同时输出OPA3_OUT负端到OPA_OUT_CMP; 即OPAOUT_EN[3]控制是否将OPAx输出到IO，OPAOUT_EN[2:0]选择OPAx 输出到OPA_OUT_CMP

/* SYS_AFE_REG3 模拟配置寄存器3 */
#define SYS_AFE_REG3_CMP1_SELP_POS   12                                                    // SYS_AFE_REG3_CMP1_SELP起始位
#define SYS_AFE_REG3_CMP1_SELP_MASK  (uint32_t)(0xF << SYS_AFE_REG3_CMP1_SELP_POS)         // SYS_AFE_REG3_CMP1_SELP位掩码
#define SYS_AFE_REG3_CMP1_SELP(x)    (uint32_t)(((x) & 0xF) << SYS_AFE_REG3_CMP1_SELP_POS) // [15:12] 比较器1正端信号选择 0000: OPA2_IP 0001: OPA3_IP 0010: OPA2_OUTP, OPA2差分输出正端 0011: OPA3_OUTP, OPA3差分输出正端 0100: CMP1_IP0 0101: CMP1_IP1 0110: CMP1_IP2 0111: CMP1_IP3 1000: 未连接 1001: DAC1_OUT 1010: OPA_OUT_CMP 1011: CMP0_IP1 1100: CMP0_IP2 1101: CMP0_IP3
#define SYS_AFE_REG3_CMP0_SELP_POS   8                                                     // SYS_AFE_REG3_CMP0_SELP起始位
#define SYS_AFE_REG3_CMP0_SELP_MASK  (uint32_t)(0xF << SYS_AFE_REG3_CMP0_SELP_POS)         // SYS_AFE_REG3_CMP0_SELP位掩码
#define SYS_AFE_REG3_CMP0_SELP(x)    (uint32_t)(((x) & 0xF) << SYS_AFE_REG3_CMP0_SELP_POS) // [11:8] 比较器0正端信号选择 0000: OPA0_IP 0001: OPA1_IP 0010: OPA0_OUTP, OPA0差分输出正端 0011: OPA1_OUTP, OPA1差分输出正端 0100: CMP0_IP0 0101: CMP0_IP1 0110: IP_CMP0_IP2 0111: IP_CMP0_IP3 1000: IP_CMP0_IP4 1001: DAC0_OUT 1010: OUT_OPA_CMP 1011: IP_CMP1_IP1 1100: IP_CMP1_IP2 1101: IP_CMP1_IP3
#define SYS_AFE_REG3_CMP_HYS_ENN_BIT BIT7                                                  // [7] 比较器回差选择 0:20mv 1:0mv
#define SYS_AFE_REG3_CMP1_SELN_POS   4                                                     // SYS_AFE_REG3_CMP1_SELN起始位
#define SYS_AFE_REG3_CMP1_SELN_MASK  (uint32_t)(0x7 << SYS_AFE_REG3_CMP1_SELN_POS)         // SYS_AFE_REG3_CMP1_SELN位掩码
#define SYS_AFE_REG3_CMP1_SELN(x)    (uint32_t)(((x) & 0x7) << SYS_AFE_REG3_CMP1_SELN_POS) // [6:4] 比较器1信号负端选择 000: 连IN_CMP1 001: 连VBGP 010: 连DAC1 OUT 011: 连 DAC0 OUT 100: 连HS_MID1（中性点的电阻阻值增加为约30k）
#define SYS_AFE_REG3_CMP0_SELN_POS   0                                                     // SYS_AFE_REG3_CMP0_SELN起始位
#define SYS_AFE_REG3_CMP0_SELN_MASK  (uint32_t)(0x7 << SYS_AFE_REG3_CMP0_SELN_POS)         // SYS_AFE_REG3_CMP0_SELN位掩码
#define SYS_AFE_REG3_CMP0_SELN(x)    (uint32_t)(((x) & 0x7) << SYS_AFE_REG3_CMP0_SELN_POS) // [2:0] 比较器0信号负端选择 000: 连IN_CMP0 001: 连VBGP 010: 连DAC1 OUT 011: 连 DAC0 OUT 100: 连HS_MID0（中性点的电阻阻值增加为约30k）

/* SYS_AFE_REG4 模拟配置寄存器4 */
#define SYS_AFE_REG4_ADC_OPAHF_BIT BIT12 // [12] ADC测量运放通道半波使能 正常情况下ADC采样的是OPA输出的差分信号。 OPAHFLF_EN置’1’后， ADC采集的是运放的输出的正端单端信号与芯片地的差值。
#define SYS_AFE_REG4_REF2VDD_BIT   BIT4  // [4] 使用外部输入电源作为ADC REF 1: 使用外部输入电源作为ADC REF，此时GAIN_REF配置无效; 0: 使用默认内部REF作为ADC基准

/* SYS_AFE_REG5 模拟配置寄存器5 */
#define SYS_AFE_REG5_RSTSEL_POS  8                                                  // SYS_AFE_REG5_RSTSEL起始位
#define SYS_AFE_REG5_RSTSEL_MASK (uint32_t)(0x3 << SYS_AFE_REG5_RSTSEL_POS)         // SYS_AFE_REG5_RSTSEL位掩码
#define SYS_AFE_REG5_RSTSEL(x)   (uint32_t)(((x) & 0x3) << SYS_AFE_REG5_RSTSEL_POS) // [9:8] 电源复位阈值Vth选择 00: 2.30V 01: 2.00V 10: 2.70V 11: 3.00V
#define SYS_AFE_REG5_CMP1PDN_BIT BIT7                                               // [7] 比较器1开关 0:关闭 1:使能
#define SYS_AFE_REG5_CMP0PDN_BIT BIT6                                               // [6] 比较器0开关 0:关闭 1:使能
#define SYS_AFE_REG5_PLLPDN_BIT  BIT5                                               // [5] PLL开关 0:关闭 1:使能
#define SYS_AFE_REG5_XTALPDN_BIT BIT4                                               // [4] 晶体起振电路开关 0:关闭 1:使能
#define SYS_AFE_REG5_TMPPDN_BIT  BIT3                                               // [3] 温度传感器开关 0:关闭 1:使能
#define SYS_AFE_REG5_DAC1PDN_BIT BIT2                                               // [2] 8BIT DAC开关 0:关闭 1:使能
#define SYS_AFE_REG5_DAC0PDN_BIT BIT1                                               // [1] 12BIT DAC开关 0:关闭 1:使能

/* SYS_AFE_REG7 模拟配置寄存器7 */
#define SYS_AFE_REG7_ADCPDN_BIT    BIT9                                                 // [9] ADC使能位 0:关闭 1:使能
#define SYS_AFE_REG7_SHAPDN_BIT    BIT8                                                 // [8] ADC采样保持电路使能位 0:关闭 1:使能
#define SYS_AFE_REG7_PLL_FREQ_POS  4                                                    // SYS_AFE_REG7_PLL_FREQ起始位
#define SYS_AFE_REG7_PLL_FREQ_MASK (uint32_t)(0x7 << SYS_AFE_REG7_PLL_FREQ_POS)         // SYS_AFE_REG7_PLL_FREQ位掩码
#define SYS_AFE_REG7_PLL_FREQ(x)   (uint32_t)(((x) & 0x7) << SYS_AFE_REG7_PLL_FREQ_POS) // [6:4] PLL输出频率选择 MCU时钟和ADC时钟分别为: 000:96MHz，32MHz 001:96MHz，16MHz 010:72MHz，24MHz 011:72MHz，12MHz 100:64MHz，64/3MHz 101:64MHz，32MHz 110:64MHz，32/3MHz 111:64MHz，16MHz

/* SYS_AFE_DAC_CTRL DAC控制寄存器 */
#define SYS_AFE_DAC_CTRL_DAC0_STEP_POS        4                                                         // SYS_AFE_DAC_CTRL_DAC0_STEP起始位
#define SYS_AFE_DAC_CTRL_DAC0_STEP_MASK       (uint32_t)(0x7 << SYS_AFE_DAC_CTRL_DAC0_STEP_POS)         // SYS_AFE_DAC_CTRL_DAC0_STEP位掩码
#define SYS_AFE_DAC_CTRL_DAC0_STEP(x)         (uint32_t)(((x) & 0x7) << SYS_AFE_DAC_CTRL_DAC0_STEP_POS) // [6:4] SYS_AFE_DAC0步进值，3bit有符号数，范围-4~3
#define SYS_AFE_DAC_CTRL_TIMER2_TRIG_DAC0_BIT BIT2                                                      // [2] TIMER2过零事件触发DAC0步进使能，高有效
#define SYS_AFE_DAC_CTRL_TIMER1_TRIG_DAC0_BIT BIT1                                                      // [1] TIMER1过零事件触发DAC0步进使能，高有效
#define SYS_AFE_DAC_CTRL_TIMER0_TRIG_DAC0_BIT BIT0                                                      // [0] TIMER0过零事件触发DAC0步进使能，高有效

/* SYS_AFE_DAC0 DAC0数字量寄存器 */
#define SYS_AFE_DAC0_DAC_IN_POS  0                                                    // SYS_AFE_DAC0_DAC_IN起始位
#define SYS_AFE_DAC0_DAC_IN_MASK (uint32_t)(0xFFF << SYS_AFE_DAC0_DAC_IN_POS)         // SYS_AFE_DAC0_DAC_IN位掩码
#define SYS_AFE_DAC0_DAC_IN(x)   (uint32_t)(((x) & 0xFFF) << SYS_AFE_DAC0_DAC_IN_POS) // [11:0] DAC0待转换的数字量输入

/* SYS_AFE_DAC1 DAC1数字量寄存器 */
#define SYS_AFE_DAC1_DAC_IN_POS  0                                                   // SYS_AFE_DAC1_DAC_IN起始位
#define SYS_AFE_DAC1_DAC_IN_MASK (uint32_t)(0xFF << SYS_AFE_DAC1_DAC_IN_POS)         // SYS_AFE_DAC1_DAC_IN位掩码
#define SYS_AFE_DAC1_DAC_IN(x)   (uint32_t)(((x) & 0xFF) << SYS_AFE_DAC1_DAC_IN_POS) // [7:0] DAC1待转换的数字量输入

/* SYS_AFE_DAC0_AMC DAC0增益校正寄存器 */
#define SYS_AFE_DAC0_AMC_AMC_POS  0                                                     // SYS_AFE_DAC0_AMC_AMC起始位
#define SYS_AFE_DAC0_AMC_AMC_MASK (uint32_t)(0x3FF << SYS_AFE_DAC0_AMC_AMC_POS)         // SYS_AFE_DAC0_AMC_AMC位掩码
#define SYS_AFE_DAC0_AMC_AMC(x)   (uint32_t)(((x) & 0x3FF) << SYS_AFE_DAC0_AMC_AMC_POS) // [9:0] DAC0增益校正值，10bit无符号定点数，B[9]为整数，B[8:0]为小数

/* SYS_AFE_DAC0_DC DAC0直流偏置寄存器 */
#define SYS_AFE_DAC0_DC_DC_POS  0                                                   // SYS_AFE_DAC0_DC_DC起始位
#define SYS_AFE_DAC0_DC_DC_MASK (uint32_t)(0x3FF << SYS_AFE_DAC0_DC_DC_POS)         // SYS_AFE_DAC0_DC_DC位掩码
#define SYS_AFE_DAC0_DC_DC(x)   (uint32_t)(((x) & 0x3FF) << SYS_AFE_DAC0_DC_DC_POS) // [9:0] DAC0直流偏置，10bit有符号数，B[9]为符号位

/* SYS_AFE_DAC1_AMC DAC1增益校正寄存器 */
#define SYS_AFE_DAC1_AMC_AMC_POS  0                                                     // SYS_AFE_DAC1_AMC_AMC起始位
#define SYS_AFE_DAC1_AMC_AMC_MASK (uint32_t)(0x3FF << SYS_AFE_DAC1_AMC_AMC_POS)         // SYS_AFE_DAC1_AMC_AMC位掩码
#define SYS_AFE_DAC1_AMC_AMC(x)   (uint32_t)(((x) & 0x3FF) << SYS_AFE_DAC1_AMC_AMC_POS) // [9:0] DAC1增益校正值，10bit无符号定点数，B[9]为整数，B[8:0]为小数

/* SYS_AFE_DAC1_DC DAC1直流偏置寄存器 */
#define SYS_AFE_DAC1_DC_DC_POS  0                                                   // SYS_AFE_DAC1_DC_DC起始位
#define SYS_AFE_DAC1_DC_DC_MASK (uint32_t)(0x3FF << SYS_AFE_DAC1_DC_DC_POS)         // SYS_AFE_DAC1_DC_DC位掩码
#define SYS_AFE_DAC1_DC_DC(x)   (uint32_t)(((x) & 0x3FF) << SYS_AFE_DAC1_DC_DC_POS) // [9:0] DAC1直流偏置，10bit有符号数，B[9]为符号位

/* SYS_CLK_CFG 时钟控制寄存器 */
#define SYS_CLK_CFG_HSE_FAILED_BIT BIT13                                               // [13] 晶振时钟在被开启后是否停振过 如果晶振有停振情况，则该位置位，即使晶体后续恢复振荡，仍保持记录为1。写1清零
#define SYS_CLK_CFG_HSE_FAIL_BIT   BIT12                                               // [12] 晶振时钟当前是否已经停振 0:外部晶体当前正常工作 1:外部晶体当前已经停振
#define SYS_CLK_CFG_CLK_SEL_POS    8                                                   // SYS_CLK_CFG_CLK_SEL起始位
#define SYS_CLK_CFG_CLK_SEL_MASK   (uint32_t)(0x3 << SYS_CLK_CFG_CLK_SEL_POS)          // SYS_CLK_CFG_CLK_SEL位掩码
#define SYS_CLK_CFG_CLK_SEL(x)     (uint32_t)(((x) & 0x3) << SYS_CLK_CFG_CLK_SEL_POS)  // [9:8] 系统时钟MCLK的来源选择信号。默认选择HRC 0: HRC 1: PLL 2: LRC 3:保留 注意，PLL/XTAL在上电后默认开启，需要软件来关闭。
#define SYS_CLK_CFG_CLK_DIV_POS    0                                                   // SYS_CLK_CFG_CLK_DIV起始位
#define SYS_CLK_CFG_CLK_DIV_MASK   (uint32_t)(0xFF << SYS_CLK_CFG_CLK_DIV_POS)         // SYS_CLK_CFG_CLK_DIV位掩码
#define SYS_CLK_CFG_CLK_DIV(x)     (uint32_t)(((x) & 0xFF) << SYS_CLK_CFG_CLK_DIV_POS) // [7:0] PLL输出分频控制，默认为 0x00: 1/8分频 0x01: 1/8分频 0x11: 1/4分频 0x55: 1/2分频 0xFF: 1/1分频 不推荐其它配置值。

/* SYS_IO_CFG IO控制寄存器 */
#define SYS_IO_CFG_SWDMUX_BIT BIT6 // [6] SWD复用控制信号，默认配置为SWD 0:P2.13复用为SWCLK，P2.0 复用为SWDIO 1:P2.13, P2.0作为正常GPIO使用
#define SYS_IO_CFG_RST_IO_BIT BIT5 // [5] RSTn/P0.2复用控制信号，默认配置为RSTn 0:RSTn 1:P0.2 注意，上电后默认是RSTn，后续软件可使能此位，RSTn功能失效

/* SYS_DBG_CFG Debug控制寄存器 */
#define SYS_DBG_CFG_SW_IRQ_TRIG_POS   16                                                        // SYS_DBG_CFG_SW_IRQ_TRIG起始位
#define SYS_DBG_CFG_SW_IRQ_TRIG_MASK  (uint32_t)(0xFFFF << SYS_DBG_CFG_SW_IRQ_TRIG_POS)         // SYS_DBG_CFG_SW_IRQ_TRIG位掩码
#define SYS_DBG_CFG_SW_IRQ_TRIG(x)    (uint32_t)(((x) & 0xFFFF) << SYS_DBG_CFG_SW_IRQ_TRIG_POS) // [31:16] 向此位段写入0x5AA5 触发软件中断，SW_IRQ置1
#define SYS_DBG_CFG_SW_IRQ_BIT        BIT15                                                     // [15] 软件中断标志，对应中断号38，写1清零。
#define SYS_DBG_CFG_SFT_RST_PERI_BIT  BIT14                                                     // [14] Debug软复位是否复位除Flash/SYS_AFE以外的外设寄存器
#define SYS_DBG_CFG_DBG_TIM2_STOP_BIT BIT10                                                     // [10] 调试模式下CPU halt状态TIMER2停止 1:TIMER2在CPU halt状态时停止计数 0:TIMER2在CPU halt状态时继续计数
#define SYS_DBG_CFG_DBG_TIM1_STOP_BIT BIT9                                                      // [9] 调试模式下CPU halt状态TIMER1停止 1:TIMER1在CPU halt状态时停止计数 0:TIMER1在CPU halt状态时继续计数
#define SYS_DBG_CFG_DBG_TIM0_STOP_BIT BIT8                                                      // [8] 调试模式下CPU halt状态TIMER0停止 1:TIMER0在CPU halt状态时停止计数 0:TIMER0在CPU halt状态时继续计数
#define SYS_DBG_CFG_DBG_IWDG_STOP_BIT BIT5                                                      // [5] 调试模式下CPU halt状态独立看门狗停止 1:独立看门狗在CPU halt状态时停止计数 0:独立看门狗在CPU halt状态时继续计数
#define SYS_DBG_CFG_DBG_STOP_BIT      BIT1                                                      // [1] 调试STOP(DEEPSLEEP)模式 0: (FCLK=Off, HCLK=Off) 在STOP模式下，时钟管理模块关闭HCLK和FCLK，即处理器时钟和所有外设时钟。 当退出STOP模式时，时钟管理模块不经历复位，并保持原有配置，可以恢复到STOP模式前的时钟设置。在STOP模式中，所有外设寄存器均保持，因此退出后无需重新配置。 1: (FCLK=On, HCLK=On) 如果设置DBG_STOP为1，进入STOP模式后HCLK和FCLK均不被关闭。 通过设置SCB-\>SCR = (1UL\<\<2)，然后使用__WFI()/___WFE()指令进入STOP模式。
#define SYS_DBG_CFG_DBG_SLP_BIT       BIT0                                                      // [0] 调试睡眠(SLEEP)模式 0: (FCLK=On, HCLK=Off) 在睡眠模式中，FCLK作为所有外设时钟，不关闭； HCLK作为CPU时钟，被关闭。 在睡眠模式中，只有CPU时钟被暂时挂起，而所有外设包括系统时钟管理模块均保持原有配置状态。因此退出睡眠模式时，软件无需重新配置外设寄存器。 1: (FCLK=On, HCLK=On) 如果配置DBG_SLP为1，则当进入睡眠模式时，HCLK不会关闭。 通过__WFI()/___WFE()指令可以令处理器进入睡眠模式

/* SYS_CLK_DIV0 外设时钟分频寄存器0 */
#define SYS_CLK_DIV0_DIV0_POS  0                                                   // SYS_CLK_DIV0_DIV0起始位
#define SYS_CLK_DIV0_DIV0_MASK (uint32_t)(0xFFFF << SYS_CLK_DIV0_DIV0_POS)         // SYS_CLK_DIV0_DIV0位掩码
#define SYS_CLK_DIV0_DIV0(x)   (uint32_t)(((x) & 0xFFFF) << SYS_CLK_DIV0_DIV0_POS) // [15:0] I2C工作时钟=MCLK/(CLK_DIV0+1)。其中MCLK由SYS_CLK_CFG分频系数决定

/* SYS_CLK_DIV1 外设时钟分频寄存器1 */
#define SYS_CLK_DIV1_DIV1_POS  0                                                   // SYS_CLK_DIV1_DIV1起始位
#define SYS_CLK_DIV1_DIV1_MASK (uint32_t)(0xFFFF << SYS_CLK_DIV1_DIV1_POS)         // SYS_CLK_DIV1_DIV1位掩码
#define SYS_CLK_DIV1_DIV1(x)   (uint32_t)(((x) & 0xFFFF) << SYS_CLK_DIV1_DIV1_POS) // [15:0] SPI工作时钟=MCLK/(CLK_DIV0+1)。其中MCLK由SYS_CLK_CFG分频系数决定

/* SYS_CLK_DIV2 外设时钟分频寄存器2 */
#define SYS_CLK_DIV2_DIV2_POS  0                                                   // SYS_CLK_DIV2_DIV2起始位
#define SYS_CLK_DIV2_DIV2_MASK (uint32_t)(0xFFFF << SYS_CLK_DIV2_DIV2_POS)         // SYS_CLK_DIV2_DIV2位掩码
#define SYS_CLK_DIV2_DIV2(x)   (uint32_t)(((x) & 0xFFFF) << SYS_CLK_DIV2_DIV2_POS) // [15:0] UART工作时钟=MCLK/(CLK_DIV2+1)。UART0/UART1共享此分频配置，波特率根据UART波特率寄存器进一步分频，其中MCLK由SYS_CLK_CFG分频系数决定。

/* SYS_CLK_FEN 外设时钟门控寄存器 */
#define SYS_CLK_FEN_CL0_CLK_EN_BIT    BIT21 // [21] CL0模块时钟控制信号，默认关闭CL0模块时钟 1:使能CL0模块时钟 0:关闭CL0模块时钟
#define SYS_CLK_FEN_SIF0_CLK_EN_BIT   BIT20 // [20] SIF0模块时钟控制信号，默认关闭SIF0模块时钟 1:使能SIF0模块时钟 0:关闭SIF0模块时钟
#define SYS_CLK_FEN_DSP0_CLK_EN_BIT   BIT17 // [17] DSP0模块时钟控制信号，默认关闭DSP0模块时钟 1:使能DSP0模块时钟 0:关闭DSP0模块时钟
#define SYS_CLK_FEN_CRC0_CLK_EN_BIT   BIT16 // [16] CRC0模块时钟控制信号，默认关闭CRC0模块时钟 1:使能CRC0模块时钟 0:关闭CRC0模块时钟
#define SYS_CLK_FEN_UART2_CLK_EN_BIT  BIT14 // [14] UART2模块时钟控制信号，默认关闭UART2模块时钟 1:使能UART2模块时钟 0:关闭UART2模块时钟
#define SYS_CLK_FEN_UART1_CLK_EN_BIT  BIT13 // [13] UART1模块时钟控制信号，默认关闭UART1模块时钟 1:使能UART1模块时钟 0:关闭UART1模块时钟
#define SYS_CLK_FEN_UART0_CLK_EN_BIT  BIT12 // [12] UART0模块时钟控制信号，默认关闭UART0模块时钟 1:使能UART0模块时钟 0:关闭UART0模块时钟
#define SYS_CLK_FEN_GPIO_CLK_EN_BIT   BIT11 // [11] GPIO模块时钟控制信号，默认关闭GPIO模块时钟 1:使能GPIO模块时钟 0:关闭GPIO模块时钟
#define SYS_CLK_FEN_MCPWM0_CLK_EN_BIT BIT10 // [10] MCPWM0模块时钟控制信号，默认关闭MCPWM0模块时钟 1:使能MCPWM0模块时钟 0:关闭MCPWM0模块时钟
#define SYS_CLK_FEN_QEP0_CLK_EN_BIT   BIT8  // [8] QEP0模块时钟控制信号，默认关闭QEP0模块时钟 1:使能QEP0模块时钟 0:关闭QEP0模块时钟
#define SYS_CLK_FEN_TIMER2_CLK_EN_BIT BIT6  // [6] TIMER2模块时钟控制信号，默认关闭TIMER2模块时钟 1:使能TIMER2模块时钟 0:关闭TIMER2模块时钟
#define SYS_CLK_FEN_TIMER1_CLK_EN_BIT BIT5  // [5] TIMER1模块时钟控制信号，默认关闭TIMER1模块时钟 1:使能TIMER1模块时钟 0:关闭TIMER1模块时钟
#define SYS_CLK_FEN_TIMER0_CLK_EN_BIT BIT4  // [4] TIMER0模块时钟控制信号，默认关闭TIMER0模块时钟 1:使能TIMER0模块时钟 0:关闭TIMER0模块时钟
#define SYS_CLK_FEN_HALL0_CLK_EN_BIT  BIT3  // [3] HALL0模块时钟控制信号，默认关闭HALL0模块时钟 1:使能HALL0模块时钟 0:关闭HALL0模块时钟
#define SYS_CLK_FEN_CMP_CLK_EN_BIT    BIT2  // [2] CMP模块时钟控制信号，默认关闭CMP模块时钟 1:使能CMP模块时钟 0:关闭CMP模块时钟
#define SYS_CLK_FEN_I2C0_CLK_EN_BIT   BIT1  // [1] I2C0模块时钟控制信号，默认关闭I2C0模块时钟 1:使能I2C0模块时钟 0:关闭I2C0模块时钟
#define SYS_CLK_FEN_SPI0_CLK_EN_BIT   BIT0  // [0] SPI0模块时钟控制信号，默认关闭SPI0模块时钟 1:使能SPI0模块时钟 0:关闭SPI0模块时钟

/* SYS_SFT_RST 软复位寄存器 */
#define SYS_SFT_RST_EEPROM_SFT_RST_BIT BIT26 // [26] EEPROM模块软复位信号，默认不复位EEPROM模块 1:复位EEPROM模块 0:释放EEPROM模块
#define SYS_SFT_RST_ADC1_SFT_RST_BIT   BIT23 // [23] ADC1数字接口模块软复位信号，默认不复位ADC1模块 1:复位ADC1数字接口模块 0:释放ADC1数字接口模块
#define SYS_SFT_RST_ADC0_SFT_RST_BIT   BIT22 // [22] ADC0数字接口模块软复位信号，默认不复位ADC0模块 1:复位ADC0数字接口模块 0:释放ADC0数字接口模块
#define SYS_SFT_RST_CL0_SFT_RST_BIT    BIT21 // [21] CL0模块软复位信号，默认不复位CL0模块 1:复位CL0模块 0:释放CL0模块
#define SYS_SFT_RST_SIF0_SFT_RST_BIT   BIT20 // [20] SIF0模块软复位信号，默认不复位SIF0模块 1:复位SIF0模块 0:释放SIF0模块
#define SYS_SFT_RST_DMA0_SFT_RST_BIT   BIT18 // [18] DMA0模块软复位信号，默认不复位DMA0模块 1:复位DMA0模块 0:释放DMA0模块
#define SYS_SFT_RST_DSP0_SFT_RST_BIT   BIT17 // [17] DSP0模块软复位信号，默认不复位DSP0模块 1:复位DSP0模块 0:释放DSP0模块
#define SYS_SFT_RST_CRC0_SFT_RST_BIT   BIT16 // [16] CRC0数字接口模块软复位信号，默认不复位CRC0模块 1:复位CRC0数字接口模块 0:释放CRC0数字接口模块
#define SYS_SFT_RST_UART2_SFT_RST_BIT  BIT14 // [14] UART1模块软复位信号，默认不复位UART1模块 1:复位UART1模块 0:释放UART1模块
#define SYS_SFT_RST_UART1_SFT_RST_BIT  BIT13 // [13] UART1模块软复位信号，默认不复位UART1模块 1:复位UART1模块 0:释放UART1模块
#define SYS_SFT_RST_UART0_SFT_RST_BIT  BIT12 // [12] UART0模块软复位信号，默认不复位UART0模块 1:复位UART0模块 0:释放UART0模块
#define SYS_SFT_RST_GPIO_SFT_RST_BIT   BIT11 // [11] GPIO模块软复位信号，默认不复位GPIO模块 1:复位GPIO模块 0:释放GPIO模块
#define SYS_SFT_RST_MCPWM0_SFT_RST_BIT BIT10 // [10] MCPWM0模块软复位信号，默认不复位MCPWM0模块 1:复位MCPWM0模块 0:释放MCPWM0模块
#define SYS_SFT_RST_QEP1_SFT_RST_BIT   BIT9  // [9] QEP1模块软复位信号，默认不复位QEP1模块 1:复位QEP1模块 0:释放QEP1模块
#define SYS_SFT_RST_QEP0_SFT_RST_BIT   BIT8  // [8] QEP0模块软复位信号，默认不复位QEP0模块 1:复位QEP0模块 0:释放QEP0模块
#define SYS_SFT_RST_TIMER2_SFT_RST_BIT BIT6  // [6] TIMER2模块软复位信号，默认不复位TIMER2模块 1:复位TIMER2模块 0:释放TIMER2模块
#define SYS_SFT_RST_TIMER1_SFT_RST_BIT BIT5  // [5] TIMER1模块软复位信号，默认不复位TIMER1模块 1:复位TIMER1模块 0:释放TIMER1模块
#define SYS_SFT_RST_TIMER0_SFT_RST_BIT BIT4  // [4] TIMER0模块软复位信号，默认不复位TIMER0模块 1:复位TIMER0模块 0:释放TIMER0模块
#define SYS_SFT_RST_HALL0_SFT_RST_BIT  BIT3  // [3] HALL0模块软复位信号，默认不复位HALL0模块 1:复位HALL0模块 0:释放HALL0模块
#define SYS_SFT_RST_CMP_SFT_RST_BIT    BIT2  // [2] CMP模块软复位信号，默认不复位CMP模块 1:复位CMP模块 0:释放CMP模块
#define SYS_SFT_RST_I2C0_SFT_RST_BIT   BIT1  // [1] I2C0模块软复位信号，默认不复位I2C0模块 1:复位I2C0模块 0:释放I2C0模块
#define SYS_SFT_RST_SPI0_SFT_RST_BIT   BIT0  // [0] SPI0模块软复位信号，默认不复位SPI0模块 1:复位SPI0模块 0:释放SPI0模块

/* SYS_PROTECT 写保护寄存器 */
#define SYS_PROTECT_PSW_POS  0                                                 // SYS_PROTECT_PSW起始位
#define SYS_PROTECT_PSW_MASK (uint32_t)(0xFFFF << SYS_PROTECT_PSW_POS)         // SYS_PROTECT_PSW位掩码
#define SYS_PROTECT_PSW(x)   (uint32_t)(((x) & 0xFFFF) << SYS_PROTECT_PSW_POS) // [15:0] 除SYS_AFE_DAC0、SYS_AFE_DAC0_AMC、SYS_AFE_DAC0_DC、 SYS_AFE_DAC1、SYS_AFE_DAC1_AMC、SYS_AFE_DAC1_DC外，其他系统寄存器(SYS_开头的寄存器，包括时钟复位管理以及模拟寄存器)受写保护，写入前需先写入密码解除写保护 写入0x7A83，解除写保护，使能寄存器写操作 写入其它值，开启写保护，禁止寄存器写操作 读回恒为0

/* SYS_IF 系统中断标志寄存器 */
#define SYS_IF_PWR_WK_BIT      BIT1 // [1] 电源过低中断标志，只读，高有效。
#define SYS_IF_NMI_TIMEOUT_BIT BIT0 // [0] NMI定时中断标志，写1清零，高有效。

/* SYS_RAM_LOCK RAM锁定寄存器 */
#define SYS_RAM_LOCK_PSW_POS  8                                                    // SYS_RAM_LOCK_PSW起始位
#define SYS_RAM_LOCK_PSW_MASK (uint32_t)(0xFFFFFF << SYS_RAM_LOCK_PSW_POS)         // SYS_RAM_LOCK_PSW位掩码
#define SYS_RAM_LOCK_PSW(x)   (uint32_t)(((x) & 0xFFFFFF) << SYS_RAM_LOCK_PSW_POS) // [31:8] 只有在[31:8]写入0x5a6b7c的同时，才能改写[7:0]
#define SYS_RAM_LOCK_L7K_BIT  BIT7                                                 // [7] 0x1C00~0x1FFF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L6K_BIT  BIT6                                                 // [6] 0x1800~0x1BFF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L5K_BIT  BIT5                                                 // [5] 0x1400~0x17FF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L4K_BIT  BIT4                                                 // [4] 0x1000~0x13FF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L3K_BIT  BIT3                                                 // [3] 0x0C00~0x0FFF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L2K_BIT  BIT2                                                 // [2] 0x0800~0x0BFF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L1K_BIT  BIT1                                                 // [1] 0x0400~0x07FF RAM空间写入锁定 0:允许改写 1:不允许改写
#define SYS_RAM_LOCK_L0K_BIT  BIT0                                                 // [0] 0x0000~0x03FF RAM空间写入锁定 0:允许改写 1:不允许改写

/* SYS_FLSE 擦除保护寄存器 */
#define SYS_FLSE_FLSE_POS  0                                               // SYS_FLSE_FLSE起始位
#define SYS_FLSE_FLSE_MASK (uint32_t)(0xFFFF << SYS_FLSE_FLSE_POS)         // SYS_FLSE_FLSE位掩码
#define SYS_FLSE_FLSE(x)   (uint32_t)(((x) & 0xFFFF) << SYS_FLSE_FLSE_POS) // [15:0] FLASH擦除保护寄存器。本寄存器写入0x8FCA，FLASH的擦除功能才能最终生效。写入其他值，FLASH的擦除功能均无法生效。为防止误擦除，建议不使用擦除功能时，不生效此寄存器。

/* SYS_FLSP 编程保护寄存器 */
#define SYS_FLSP_FLSP_POS  0                                               // SYS_FLSP_FLSP起始位
#define SYS_FLSP_FLSP_MASK (uint32_t)(0xFFFF << SYS_FLSP_FLSP_POS)         // SYS_FLSP_FLSP位掩码
#define SYS_FLSP_FLSP(x)   (uint32_t)(((x) & 0xFFFF) << SYS_FLSP_FLSP_POS) // [15:0] FLASH编程保护寄存器。本寄存器写入0x8F35，FLASH的编程功能才能最终生效。写入其他值，FLASH的编程功能均无法生效。为防止误编程，建议不使用编程功能时，不生效此寄存器。

/* FLASH在线升级(IAP) */

/* FLASH_CFG 配置寄存器（推荐先读回，按或/与方式修改） */
#define FLASH_CFG_ERS_EN_BIT   BIT31                                         // [31] FLASH擦除使能。默认为0。 0:关闭擦除 1:开启擦除
#define FLASH_CFG_PRG_EN_BIT   BIT27                                         // [27] FLASH编程使能。默认为0。 0:关闭编程 1:开启编程
#define FLASH_CFG_ADR_INC_BIT  BIT23                                         // [23] FLASH地址递增使能。默认为0。 0:关闭递增使能 1:开启递增使能 当执行FLASH连续读写访问时，可以开启此功能减少对地址的操作。
#define FLASH_CFG_PREF_BIT     BIT19                                         // [19] FLASH预取加速使能。默认为0。 0:关闭加速 1:开启加速
#define FLASH_CFG_ERS_TYPE_BIT BIT15                                         // [15] FLASH擦除类型选择。默认为0。 0:Sector 1:Full
#define FLASH_CFG_REGION_BIT   BIT11                                         // [11] 访问FLASH区域选择。默认为0。 0:MAIN 1:NVR
#define FLASH_CFG_WAIT_BIT     BIT7                                          // [7] 读取FLASH数据，等待开关。默认为0。 0:读取，等待一个周期 1:读取，等待两个周期 向[10:7]写入0xA，WAIT为0；写入其他值WAIT为1
#define FLASH_CFG_TBS_POS      0                                             // FLASH_CFG_TBS起始位
#define FLASH_CFG_TBS_MASK     (uint32_t)(0x7F << FLASH_CFG_TBS_POS)         // FLASH_CFG_TBS位掩码
#define FLASH_CFG_TBS(x)       (uint32_t)(((x) & 0x7F) << FLASH_CFG_TBS_POS) // [6:0] 编程/擦除时间基数寄存器,默认值为0x60。只能配成如下几个值 0x60:96MHz系统频率下，FLASH编程/擦除时间基数配置值。 0x47:72Mhz系统频率下，FLASH编程/擦除时间基数配置值。 0x30:48Mhz系统频率下，FLASH编程/擦除时间基数配置值。 0x17:24Mhz系统频率下，FLASH编程/擦除时间基数配置值。

/* FLASH_ADDR 地址寄存器 */
#define FLASH_ADDR_ADDR_POS  0                                                 // FLASH_ADDR_ADDR起始位
#define FLASH_ADDR_ADDR_MASK (uint32_t)(0x7FFF << FLASH_ADDR_ADDR_POS)         // FLASH_ADDR_ADDR位掩码
#define FLASH_ADDR_ADDR(x)   (uint32_t)(((x) & 0x7FFF) << FLASH_ADDR_ADDR_POS) // [14:0] 地址寄存器。读/写/擦除操作对应的地址寄存器。因按照WORD操作，最低两位会被FLASH控制器忽略。 执行擦除操作时，需要根据擦除类型，地址需要对齐。一个Sector是512-Byte。若执行Sector擦除，地址需要是512的整数倍（若带偏移，偏移量会被忽略）。全芯片擦除，不会参考这个寄存器的值

/* FLASH_WDATA 写数据寄存器 */
#define FLASH_WDATA_WDATA_POS  0                                                       // FLASH_WDATA_WDATA起始位
#define FLASH_WDATA_WDATA_MASK (uint32_t)(0xFFFFFFFF << FLASH_WDATA_WDATA_POS)         // FLASH_WDATA_WDATA位掩码
#define FLASH_WDATA_WDATA(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_WDATA_WDATA_POS) // [31:0] 执行写入操作，写入FLASH的值

/* FLASH_RDATA 读数据寄存器 */
#define FLASH_RDATA_RDATA_POS  0                                                       // FLASH_RDATA_RDATA起始位
#define FLASH_RDATA_RDATA_MASK (uint32_t)(0xFFFFFFFF << FLASH_RDATA_RDATA_POS)         // FLASH_RDATA_RDATA位掩码
#define FLASH_RDATA_RDATA(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_RDATA_RDATA_POS) // [31:0] 执行读取操作，读出FLASH的值

/* FLASH_ERASE 擦除控制寄存器 */
#define FLASH_ERASE_ERASE_POS  0                                                       // FLASH_ERASE_ERASE起始位
#define FLASH_ERASE_ERASE_MASK (uint32_t)(0xFFFFFFFF << FLASH_ERASE_ERASE_POS)         // FLASH_ERASE_ERASE位掩码
#define FLASH_ERASE_ERASE(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_ERASE_ERASE_POS) // [31:0] 写入0x7654DCBA，触发擦除操作

/* FLASH_PROTECT 保护状态寄存器 */
#define FLASH_PROTECT_PROTECT_POS  0                                                           // FLASH_PROTECT_PROTECT起始位
#define FLASH_PROTECT_PROTECT_MASK (uint32_t)(0xFFFFFFFF << FLASH_PROTECT_PROTECT_POS)         // FLASH_PROTECT_PROTECT位掩码
#define FLASH_PROTECT_PROTECT(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_PROTECT_PROTECT_POS) // [31:0] 读取该寄存器，更新加密/解密状态读取返回值无参考意义。

/* FLASH_READY */
#define FLASH_READY_READY_BIT BIT0 // [0] 1:FLASH处于Idle状态；0:FLASH处于Busy状态

/* FLASH_SIZE容量寄存器 */
#define FLASH_SIZE_FLS_SIZE_POS    6                                                  // FLASH_SIZE_FLS_SIZE起始位
#define FLASH_SIZE_FLS_SIZE_MASK   (uint32_t)(0x3 << FLASH_SIZE_FLS_SIZE_POS)         // FLASH_SIZE_FLS_SIZE位掩码
#define FLASH_SIZE_FLS_SIZE(x)     (uint32_t)(((x) & 0x3) << FLASH_SIZE_FLS_SIZE_POS) // [7:6] FLASH容量寄存器，仅可读 0:32KB 1:64KB 2:保留 3:128KB
#define FLASH_SIZE_LIB_PRESENT_BIT BIT1                                               // [1] Flash存在不可读、可执行的库区域
#define FLASH_SIZE_ROM_PRESENT_BIT BIT0                                               // [0] Flash存在可读、可执行、但禁止擦除的ROM区域

/* FLASH_NCFG 配置寄存器（推荐先读回，按或/与方式修改） */
#define FLASH_NCFG_ERS_EN_BIT   BIT31                                          // [31] FLASH擦除使能。默认为0。 0:关闭擦除 1:开启擦除
#define FLASH_NCFG_PRG_EN_BIT   BIT27                                          // [27] FLASH编程使能。默认为0。 0:关闭编程 1:开启编程
#define FLASH_NCFG_ADR_INC_BIT  BIT23                                          // [23] FLASH地址递增使能。默认为0。此寄存器，只能读取不能修改。 0:关闭递增使能 1:开启递增使能 当执行FLASH连续读写访问时，可以开启此功能减少对地址的操作。
#define FLASH_NCFG_PREF_BIT     BIT19                                          // [19] FLASH预取加速使能。默认为0。 0:关闭加速 1:开启加速
#define FLASH_NCFG_ERS_TYPE_BIT BIT15                                          // [15] FLASH擦除类型选择。默认为0。此寄存器，只能读取不能修改。 0:Sector 1:FULL
#define FLASH_NCFG_REGION_BIT   BIT11                                          // [11] 访问FLASH区域选择。默认为0。修改此寄存器，无论写入值是0还是1，最终，只能被强制写成1。 0:MAIN 1:NVR
#define FLASH_NCFG_WAIT_BIT     BIT7                                           // [7] 读取FLASH数据，等待开关。默认为1。此寄存器，只能读取不能修改。 0:读取，等待一个周期 1:读取，等待两个周期
#define FLASH_NCFG_TBS_POS      0                                              // FLASH_NCFG_TBS起始位
#define FLASH_NCFG_TBS_MASK     (uint32_t)(0x7F << FLASH_NCFG_TBS_POS)         // FLASH_NCFG_TBS位掩码
#define FLASH_NCFG_TBS(x)       (uint32_t)(((x) & 0x7F) << FLASH_NCFG_TBS_POS) // [6:0] 编程/擦除时间基数寄存器,默认值为0x60。此寄存器，只能读取不能修改。 0x60:96MHz系统频率下，FLASH编程/擦除时间基数配置值。 0x47:72Mhz系统频率下，FLASH编程/擦除时间基数配置值。 0x30:48Mhz系统频率下，FLASH编程/擦除时间基数配置值。 0x17:24Mhz系统频率下，FLASH编程/擦除时间基数配置值。

/* FLASH_NADDR 地址寄存器 */
#define FLASH_NADDR_ADDR_POS  0                                                  // FLASH_NADDR_ADDR起始位
#define FLASH_NADDR_ADDR_MASK (uint32_t)(0x7FFF << FLASH_NADDR_ADDR_POS)         // FLASH_NADDR_ADDR位掩码
#define FLASH_NADDR_ADDR(x)   (uint32_t)(((x) & 0x7FFF) << FLASH_NADDR_ADDR_POS) // [14:0] 地址寄存器。读/写/擦除操作对应的地址寄存器。因按照WORD操作，最低两位会被FLASH控制器忽略。 执行擦除操作时，需要根据擦除类型，地址需要对齐。一个Sector是512-Byte。若执行Sector擦除，地址需要是512的整数倍（若带偏移，偏移量会被忽略）。全芯片擦除，不会参考这个寄存器的值

/* FLASH_NWDATA写数据寄存器 */
#define FLASH_NWDATA_WDATA_POS  0                                                        // FLASH_NWDATA_WDATA起始位
#define FLASH_NWDATA_WDATA_MASK (uint32_t)(0xFFFFFFFF << FLASH_NWDATA_WDATA_POS)         // FLASH_NWDATA_WDATA位掩码
#define FLASH_NWDATA_WDATA(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_NWDATA_WDATA_POS) // [31:0] 执行写入操作，写入FLASH的值

/* FLASH_NRDATA读数据寄存器 */
#define FLASH_NRDATA_RDATA_POS  0                                                        // FLASH_NRDATA_RDATA起始位
#define FLASH_NRDATA_RDATA_MASK (uint32_t)(0xFFFFFFFF << FLASH_NRDATA_RDATA_POS)         // FLASH_NRDATA_RDATA位掩码
#define FLASH_NRDATA_RDATA(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_NRDATA_RDATA_POS) // [31:0] 执行读取操作，读出FLASH的值

/* FLASH_NERASE擦除控制寄存器 */
#define FLASH_NERASE_ERASE_POS  0                                                        // FLASH_NERASE_ERASE起始位
#define FLASH_NERASE_ERASE_MASK (uint32_t)(0xFFFFFFFF << FLASH_NERASE_ERASE_POS)         // FLASH_NERASE_ERASE位掩码
#define FLASH_NERASE_ERASE(x)   (uint32_t)(((x) & 0xFFFFFFFF) << FLASH_NERASE_ERASE_POS) // [31:0] 写入0x7654DCBA，触发擦除操作

/* FLASH_NKEY密钥寄存器 */
#define FLASH_NKEY_KEY_POS  0                                             // FLASH_NKEY_KEY起始位
#define FLASH_NKEY_KEY_MASK (uint32_t)(0xF << FLASH_NKEY_KEY_POS)         // FLASH_NKEY_KEY位掩码
#define FLASH_NKEY_KEY(x)   (uint32_t)(((x) & 0xF) << FLASH_NKEY_KEY_POS) // [3:0] 当FLASH处于保护状态时，无法通过SWD读取，编程和擦除FLASH。此时，用户可以对此寄存器写入特殊值（0x0000_000F），使能开关，配置FLASH_NCFG/NADDR/NWDATA/NRDATA/NERASE寄存器，对NVR Sector 2进行读取，编程和擦除。

/* FLASH_EPSM Main区域Sector擦除保护寄存器 */
#define FLASH_EPSM_EPS_255_248_BIT BIT31 // [31] Main区域Sector 248~255擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_247_240_BIT BIT30 // [30] Main区域Sector 247~240擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_239_232_BIT BIT29 // [29] Main区域Sector 239~232擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_231_224_BIT BIT28 // [28] Main区域Sector 231~224擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_223_216_BIT BIT27 // [27] Main区域Sector 223~216擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_215_208_BIT BIT26 // [26] Main区域Sector 215~208擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_207_200_BIT BIT25 // [25] Main区域Sector 207~200擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_199_192_BIT BIT24 // [24] Main区域Sector 199_192擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_191_184_BIT BIT23 // [23] Main区域Sector 191_184擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_183_176_BIT BIT22 // [22] Main区域Sector 183_176擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_175_168_BIT BIT21 // [21] Main区域Sector 175_168擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_167_160_BIT BIT20 // [20] Main区域Sector 167_160擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_159_152_BIT BIT19 // [19] Main区域Sector 159_152擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_151_144_BIT BIT18 // [18] Main区域Sector 151_144擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_143_136_BIT BIT17 // [17] Main区域Sector 143_136擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_135_128_BIT BIT16 // [16] Main区域Sector 135_128擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_127_120_BIT BIT15 // [15] Main区域Sector 127_120擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_119_112_BIT BIT14 // [14] Main区域Sector 119_112擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_111_104_BIT BIT13 // [13] Main区域Sector 111_104擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_103_96_BIT  BIT12 // [12] Main区域Sector 103_96擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_95_88_BIT   BIT11 // [11] Main区域Sector 95_88擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_87_80_BIT   BIT10 // [10] Main区域Sector 87_80擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_79_72_BIT   BIT9  // [9] Main区域Sector 79_72擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_71_64_BIT   BIT8  // [8] Main区域Sector 71_64擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_63_56_BIT   BIT7  // [7] Main区域Sector 62_56擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_55_48_BIT   BIT6  // [6] Main区域Sector 55_48擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_47_40_BIT   BIT5  // [5] Main区域Sector 47_40擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_39_32_BIT   BIT4  // [4] Main区域Sector 39_32擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_31_24_BIT   BIT3  // [3] Main区域Sector 31_24擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_23_16_BIT   BIT2  // [2] Main区域Sector 23_16擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_15_8_BIT    BIT1  // [1] Main区域Sector 8~15擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSM_EPS_7_0_BIT     BIT0  // [0] Main区域Sector 0~7擦除保护，0:可擦除，1:不可擦除

/* FLASH_EPSN NVR区域Sector擦除保护寄存器 */
#define FLASH_EPSN_EPS_14_BIT BIT14 // [14] NVR区域Sector 14擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_13_BIT BIT13 // [13] NVR区域Sector 13擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_12_BIT BIT12 // [12] NVR区域Sector 12擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_11_BIT BIT11 // [11] NVR区域Sector 11擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_10_BIT BIT10 // [10] NVR区域Sector 10擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_9_BIT  BIT9  // [9] NVR区域Sector 9擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_8_BIT  BIT8  // [8] NVR区域Sector 8擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_7_BIT  BIT7  // [7] NVR区域Sector 7擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_6_BIT  BIT6  // [6] NVR区域Sector 6擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_5_BIT  BIT5  // [5] NVR区域Sector 5擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_4_BIT  BIT4  // [4] NVR区域Sector 4擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_3_BIT  BIT3  // [3] NVR区域Sector 3擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_2_BIT  BIT2  // [2] NVR区域Sector 2擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_1_BIT  BIT1  // [1] NVR区域Sector 1擦除保护，0:可擦除，1:不可擦除
#define FLASH_EPSN_EPS_0_BIT  BIT0  // [0] NVR区域Sector 0擦除保护，0:可擦除，1:不可擦除

/* FLASH_LIB_ADDR 库代码区域寄存器 */
#define FLASH_LIB_ADDR_LIB_END_SEC_POS    8                                                            // FLASH_LIB_ADDR_LIB_END_SEC起始位
#define FLASH_LIB_ADDR_LIB_END_SEC_MASK   (uint32_t)(0xFF << FLASH_LIB_ADDR_LIB_END_SEC_POS)           // FLASH_LIB_ADDR_LIB_END_SEC位掩码
#define FLASH_LIB_ADDR_LIB_END_SEC(x)     (uint32_t)(((x) & 0xFF) << FLASH_LIB_ADDR_LIB_END_SEC_POS)   // [15:8] 库代码终止Sector，0~255对应Sector 0~255
#define FLASH_LIB_ADDR_LIB_START_SEC_POS  0                                                            // FLASH_LIB_ADDR_LIB_START_SEC起始位
#define FLASH_LIB_ADDR_LIB_START_SEC_MASK (uint32_t)(0xFF << FLASH_LIB_ADDR_LIB_START_SEC_POS)         // FLASH_LIB_ADDR_LIB_START_SEC位掩码
#define FLASH_LIB_ADDR_LIB_START_SEC(x)   (uint32_t)(((x) & 0xFF) << FLASH_LIB_ADDR_LIB_START_SEC_POS) // [7:0] 库代码起始Sector，0~255对应Sector 0~255

/* SPI0_CFG SPI控制寄存器 */
#define SPI0_CFG_DUPLEX_POS  6                                              // SPI0_CFG_DUPLEX起始位
#define SPI0_CFG_DUPLEX_MASK (uint32_t)(0x3 << SPI0_CFG_DUPLEX_POS)         // SPI0_CFG_DUPLEX位掩码
#define SPI0_CFG_DUPLEX(x)   (uint32_t)(((x) & 0x3) << SPI0_CFG_DUPLEX_POS) // [7:6] 半双工模式设置 0X:关闭半双工模式 10:开启半双工模式，仅发送 11:开启半双工模式，仅接收
#define SPI0_CFG_CS_BIT      BIT5                                           // [5] SPI从设备下，片选信号来源。默认值为1。 0:Slave模式下，片选信号恒为有效值--0 1:Slave模式下，片选信号来自Master设备
#define SPI0_CFG_MS_BIT      BIT4                                           // [4] SPI主从模式选择。默认值为0。 0:Slave模式 1:Master模式
#define SPI0_CFG_CPHA_BIT    BIT3                                           // [3] SPI相位选择。默认值为0。 0:Phase为0 1:Phase为1
#define SPI0_CFG_CPOL_BIT    BIT2                                           // [2] SPI极性选择。默认值为0。 0:Polarity为0 1:Polarity为1
#define SPI0_CFG_ENDIAN_BIT  BIT1                                           // [1] SPI模块传输顺序。默认值为0。 0:MSB，高位先传输 1:LSB，低位先传输
#define SPI0_CFG_EN_BIT      BIT0                                           // [0] SPI模块使能信号。默认值为0。 0:关闭SPI模块 1:开启SPI模块

/* SPI0_IE SPI中断寄存器 */
#define SPI0_IE_IE_BIT         BIT7 // [7] SPI中断使能开关。默认值为0。 0:关闭SPI中断 1:使能SPI中断
#define SPI0_IE_CMPLT_IE_BIT   BIT6 // [6] SPI传输，完成事件中断使能信号。 0:屏蔽此中断源 1:使能此中断源
#define SPI0_IE_AB_IE_BIT      BIT5 // [5] SPI传输，异常事件中断使能信号。 0:屏蔽此中断源 1:使能此中断源
#define SPI0_IE_OV_IE_BIT      BIT4 // [4] SPI传输，溢出事件中断使能信号。默认值为0。 0:屏蔽此中断源 1:使能此中断源
#define SPI0_IE_TRANS_TRIG_BIT BIT3 // [3] 传输触发选择。 1:外部触发 0:内部自动执行。仅主模式有效
#define SPI0_IE_CMPLT_IF_BIT   BIT2 // [2] SPI传输，完成事件。高电平有效，写1清除。
#define SPI0_IE_AB_IF_BIT      BIT1 // [1] SPI传输，异常事件。Slave模式下，传输未完成，发生片选信号无效事件。高电平有效，写1清除。
#define SPI0_IE_OV_IF_BIT      BIT0 // [0] SPI传输，溢出事件。前次接收的旧数据没有被取得走，本次接收的新数据已经到达。 高电平有效，写1清除。

/* SPI0_BAUD SPI波特率寄存器 */
#define SPI0_BAUD_TRANS_MODE_BIT BIT15                                           // [15] SPI数据搬移方式。默认为0，DMA方式。 0:SPI接口支持DMA搬移数据到SPI接口，完成发送和接收。 1:SPI接口支持MCU搬移数据到SPI接口，完成发送和接收。
#define SPI0_BAUD_BAUD_POS       0                                               // SPI0_BAUD_BAUD起始位
#define SPI0_BAUD_BAUD_MASK      (uint32_t)(0xFFF << SPI0_BAUD_BAUD_POS)         // SPI0_BAUD_BAUD位掩码
#define SPI0_BAUD_BAUD(x)        (uint32_t)(((x) & 0xFFF) << SPI0_BAUD_BAUD_POS) // [11:0] SPI传输波特率配置，SPI实际传输速度计算公式为: SPI传输速度 = 系统时钟 / (2\*(BAUD + 1)) 切记，BAUD的配置值不能小于3。

/* SPI0_TXDATA SPI数据发送寄存器 */
#define SPI0_TXDATA_TX_DATA_POS  0                                                     // SPI0_TXDATA_TX_DATA起始位
#define SPI0_TXDATA_TX_DATA_MASK (uint32_t)(0xFFFF << SPI0_TXDATA_TX_DATA_POS)         // SPI0_TXDATA_TX_DATA位掩码
#define SPI0_TXDATA_TX_DATA(x)   (uint32_t)(((x) & 0xFFFF) << SPI0_TXDATA_TX_DATA_POS) // [15:0] SPI数据发送寄存器

/* SPI0_RXDATA SPI数据接收寄存器 */
#define SPI0_RXDATA_RX_DATA_POS  0                                                     // SPI0_RXDATA_RX_DATA起始位
#define SPI0_RXDATA_RX_DATA_MASK (uint32_t)(0xFFFF << SPI0_RXDATA_RX_DATA_POS)         // SPI0_RXDATA_RX_DATA位掩码
#define SPI0_RXDATA_RX_DATA(x)   (uint32_t)(((x) & 0xFFFF) << SPI0_RXDATA_RX_DATA_POS) // [15:0] SPI数据接收寄存器

/* SPI0_SIZE SPI数据传输长度寄存器 */
#define SPI0_SIZE_BITSIZE_POS  0                                                 // SPI0_SIZE_BITSIZE起始位
#define SPI0_SIZE_BITSIZE_MASK (uint32_t)(0x1F << SPI0_SIZE_BITSIZE_POS)         // SPI0_SIZE_BITSIZE位掩码
#define SPI0_SIZE_BITSIZE(x)   (uint32_t)(((x) & 0x1F) << SPI0_SIZE_BITSIZE_POS) // [4:0] 字节长度寄存器。 0x00:非法值 0x07:非法值 0x08:8-Bit 0x09:9-Bit … 0x0E:14-Bit 0x0F:15-Bit 0x10:16-Bit

/* I2C0_ADDR 地址寄存器 */
#define I2C0_ADDR_ADDR_CMP_BIT BIT7                                           // [7] I2C硬件地址比较使能开关，默认值为0。 0:关闭 1:开启
#define I2C0_ADDR_ADDR_POS     0                                              // I2C0_ADDR_ADDR起始位
#define I2C0_ADDR_ADDR_MASK    (uint32_t)(0x7F << I2C0_ADDR_ADDR_POS)         // I2C0_ADDR_ADDR位掩码
#define I2C0_ADDR_ADDR(x)      (uint32_t)(((x) & 0x7F) << I2C0_ADDR_ADDR_POS) // [6:0] 主模式下，用于配置需要进行通信的从机地址； 从模式下，用于配置该节点的从机地址；

/* I2C0_CFG 系统控制寄存器 */
#define I2C0_CFG_IE_BIT         BIT7 // [7] I2C中断使能信号。默认值为0。 1:使能I2C中断 0:关闭I2C中断
#define I2C0_CFG_TC_IE_BIT      BIT6 // [6] I2C数据传输完成中断使能信号。默认值为0。 1:使能此中断源 0:屏蔽此中断源
#define I2C0_CFG_BUS_ERR_IE_BIT BIT5 // [5] I2C总线错误事件中断使能信号。默认值为0。 1:使能此中断源 0:屏蔽此中断源
#define I2C0_CFG_STOP_IE_BIT    BIT4 // [4] I2CSTOP事件中断使能信号。默认值为0。 1:使能此中断源 0:屏蔽此中断源
#define I2C0_CFG_MST_MODE_BIT   BIT1 // [1] I2C主模式使能信号。默认值为0。 1:使能主模式 0:关闭主模式
#define I2C0_CFG_SLV_MODE_BIT   BIT0 // [0] I2C从模式使能信号。默认值为0。 1:使能从模式 0:关闭从模式

/* I2C0_SCR 状态控制寄存器 */
#define I2C0_SCR_STT_ERR_BIT    BIT7 // [7] 总线错误状态标志位，用于主模式发送/主模式接收，写0清除。 0:无START/STOP总线错误 1:有START/STOP总线错误
#define I2C0_SCR_LOST_ARB_BIT   BIT6 // [6] 总线仲裁丢失状态标志位，用于主模式发送/主模式接收，发生总线仲裁丢失事件将此位置1，无中断事件产生，在字节完成中断中需查此位。 总线上任何START事件将导致硬件清除此位。 0:无总线仲裁丢失错误发生 1:有总线仲裁丢失错误发生
#define I2C0_SCR_STOP_EVT_BIT   BIT5 // [5] STOP事件状态标志位，用于主模式发送/从模式发送/主模式接收/从模式接收。写0清除。 0:无STOP事件 1:有STOP事件
#define I2C0_SCR_BYTE_CMPLT_BIT BIT4 // [4] 下一字节ACK位。若作为发送方，无须配置此位。若作为接收方（主/从模式接收）， 0:字节接收完成，向发送方返回NACK，表示我方不能接收更多数据 1:字节接收完成，向发送方返回ACK，表示我方可以继续接收数据
#define I2C0_SCR_ADDR_DATA_BIT  BIT3 // [3] 地址字节标志位，用于从模式。START后，从机收到的第一个字节为地址字节，此位是状态位。写0清除。 0:收到的不是地址字节。 1:收到的是地址字节。
#define I2C0_SCR_DATA_DIR_BIT   BIT2 // [2] 发送或接收控制位，主模式发送/从模式发送，此位置1，触发发送，硬件自动清零；主模式接收/从模式接收，此位置0，等待接收。 0:接收 1:触发发送
#define I2C0_SCR_RX_ACK_BIT     BIT1 // [1] 接收响应标志位，用于主模式发送/从模式发送。此位是我方作为发送方，收到的接收方反馈。我方收到此反馈后，可对该位写0来执行清零操作。 0:发送数据后，接收到ACK响应。 1:发送数据后，接收到NACK响应。
#define I2C0_SCR_Done_BIT       BIT0 // [0] 传输完成状态标志位，用于主模式发送/从模式发送/主模式接收/从模式接收。写0清除。 0:传输未完成 1:传输已完成

/* I2C0_DATA 数据寄存器 */
#define I2C0_DATA_DATA_POS  0                                              // I2C0_DATA_DATA起始位
#define I2C0_DATA_DATA_MASK (uint32_t)(0xFF << I2C0_DATA_DATA_POS)         // I2C0_DATA_DATA位掩码
#define I2C0_DATA_DATA(x)   (uint32_t)(((x) & 0xFF) << I2C0_DATA_DATA_POS) // [7:0] 数据寄存器，用于主模式发送/从模式发送/主模式接收/从模式接收。发送方，写入发送数据；接收方，读取接收数据。注意，地址数据也是数据，主模式只能将要发送地址数据写入此寄存器。

/* I2C0_MSCR 主模式寄存器 */
#define I2C0_MSCR_BUSY_BIT      BIT3 // [3] I2C总线，闲忙状态。 0:空闲。 1:忙碌。
#define I2C0_MSCR_MST_CHECK_BIT BIT2 // [2] 主模式争抢总线标志位。争抢到总线，置1；STOP事件或者发生总线冲突本模块释放总线，置0。
#define I2C0_MSCR_RESTART_BIT   BIT1 // [1] 再次触发START事件，写1有效。发送START完毕，硬件清0。I2C_CFG[1]置1，才能实现写1操作。
#define I2C0_MSCR_START_BIT     BIT0 // [0] 触发START事件并发送地址数据至总线，写1有效。I2C_CFG[1]置1，才能实现写1操作。

/* I2C0_BCR I2C传输控制寄存器 */
#define I2C0_BCR_BURST_NACK_BIT     BIT7 // [7] I2C传输，NACK事件中断使能信号。 1:使能此中断源 0:屏蔽此中断源
#define I2C0_BCR_BURST_ADDR_CMP_BIT BIT6 // [6] I2C传输，硬件地址匹配中断使能信号。 1:使能此中断源 0:屏蔽此中断源
#define I2C0_BCR_BUSRT_EN_BIT       BIT5 // [5] I2C多数据传输使能，需要采用DMA方式。 1:使能 0:关闭
#define I2C0_BCR_SLV_DMA_PREF_BIT   BIT4 // [4] I2C多数据传输。从模式执行DMA方式发送，触发硬件预取第一个字节。硬件自动清零。 1:使能 0:关闭

/* I2C0_BSIZE I2C传输长度寄存器 */
#define I2C0_BSIZE_SIZE_POS  0                                               // I2C0_BSIZE_SIZE起始位
#define I2C0_BSIZE_SIZE_MASK (uint32_t)(0x1F << I2C0_BSIZE_SIZE_POS)         // I2C0_BSIZE_SIZE位掩码
#define I2C0_BSIZE_SIZE(x)   (uint32_t)(((x) & 0x1F) << I2C0_BSIZE_SIZE_POS) // [4:0] I I2C数据传输长度寄存器，用于多字节传输。 实际传输字节数 = B[3:0]+ 1

/* CMP_IE 中断使能寄存器 */
#define CMP_IE_CMP1_RE_BIT BIT9 // [9] 比较器1 DMA请求使能，高有效
#define CMP_IE_CMP0_RE_BIT BIT8 // [8] 比较器0 DMA请求使能，高有效
#define CMP_IE_CMP1_IE_BIT BIT1 // [1] 比较器1中断使能，高有效
#define CMP_IE_CMP0_IE_BIT BIT0 // [0] 比较器0中断使能，高有效

/* CMP_IF 中断标志寄存器 */
#define CMP_IF_CMP1_IF_BIT BIT1 // [1] 比较器1中断标志，高有效，写1清零
#define CMP_IF_CMP0_IF_BIT BIT0 // [0] 比较器0中断标志，高有效，写1清零

/* CMP_TCLK 分频时钟控制寄存器 */
#define CMP_TCLK_COMM_DIV_POS        24                                                     // CMP_TCLK_COMM_DIV起始位
#define CMP_TCLK_COMM_DIV_MASK       (uint32_t)(0x7 << CMP_TCLK_COMM_DIV_POS)               // CMP_TCLK_COMM_DIV位掩码
#define CMP_TCLK_COMM_DIV(x)         (uint32_t)(((x) & 0x7) << CMP_TCLK_COMM_DIV_POS)       // [26:24] 比较器0/1共用滤波时钟分频系数，影响进入比较器中断的时间，最大支持到4
#define CMP_TCLK_FIL1_CLK_DIV16_POS  12                                                     // CMP_TCLK_FIL1_CLK_DIV16起始位
#define CMP_TCLK_FIL1_CLK_DIV16_MASK (uint32_t)(0xF << CMP_TCLK_FIL1_CLK_DIV16_POS)         // CMP_TCLK_FIL1_CLK_DIV16位掩码
#define CMP_TCLK_FIL1_CLK_DIV16(x)   (uint32_t)(((x) & 0xF) << CMP_TCLK_FIL1_CLK_DIV16_POS) // [15:12] 比较器1滤波时钟分频，基于MCLK进行1~16分频，影响进入比较器中断的时间
#define CMP_TCLK_CLK1_EN_BIT         BIT11                                                  // [11] 比较器1滤波时钟使能，高有效
#define CMP_TCLK_FIL1_CLK_DIV2_POS   8                                                      // CMP_TCLK_FIL1_CLK_DIV2起始位
#define CMP_TCLK_FIL1_CLK_DIV2_MASK  (uint32_t)(0x7 << CMP_TCLK_FIL1_CLK_DIV2_POS)          // CMP_TCLK_FIL1_CLK_DIV2位掩码
#define CMP_TCLK_FIL1_CLK_DIV2(x)    (uint32_t)(((x) & 0x7) << CMP_TCLK_FIL1_CLK_DIV2_POS)  // [10:8] 比较器1滤波时钟分频 0:1分频 1:2分频 2:4分频 3:8分频 4:16分频 5:32分频, 6:64分频 7:128分频
#define CMP_TCLK_FIL0_CLK_DIV16_POS  4                                                      // CMP_TCLK_FIL0_CLK_DIV16起始位
#define CMP_TCLK_FIL0_CLK_DIV16_MASK (uint32_t)(0xF << CMP_TCLK_FIL0_CLK_DIV16_POS)         // CMP_TCLK_FIL0_CLK_DIV16位掩码
#define CMP_TCLK_FIL0_CLK_DIV16(x)   (uint32_t)(((x) & 0xF) << CMP_TCLK_FIL0_CLK_DIV16_POS) // [7:4] 比较器0滤波时钟分频，基于MCLK进行1~16分频，影响进入比较器中断的时间
#define CMP_TCLK_CLK0_EN_BIT         BIT3                                                   // [3] 比较器0滤波时钟使能，高有效
#define CMP_TCLK_FIL0_CLK_DIV2_POS   0                                                      // CMP_TCLK_FIL0_CLK_DIV2起始位
#define CMP_TCLK_FIL0_CLK_DIV2_MASK  (uint32_t)(0x7 << CMP_TCLK_FIL0_CLK_DIV2_POS)          // CMP_TCLK_FIL0_CLK_DIV2位掩码
#define CMP_TCLK_FIL0_CLK_DIV2(x)    (uint32_t)(((x) & 0x7) << CMP_TCLK_FIL0_CLK_DIV2_POS)  // [2:0] 比较器0滤波时钟分频 0:1分频 1:2分频 2:4分频 3:8分频 4:16分频 5:32分频, 6:64分频 7:128分频

/* CMP_CFG 控制寄存器 */
#define CMP_CFG_CMP1_W_PWM_POL_BIT BIT7 // [7] 比较器1开窗PWM信号极性选择，在CMP_BLCWIN1使能情况下使用
#define CMP_CFG_CMP1_IRQ_TRIG_BIT  BIT6 // [6] 比较器1中断触发类型，0:电平触发，1:边沿触发
#define CMP_CFG_CMP1_IN_EN_BIT     BIT5 // [5] 比较器1信号输入使能
#define CMP_CFG_CMP1_POL_BIT       BIT4 // [4] 比较器1极性选择，0:高电平有效；1:低电平有效
#define CMP_CFG_CMP0_W_PWM_POL_BIT BIT3 // [3] 比较器0开窗PWM信号极性选择，在CMP_BLCWIN0使能情况下使用
#define CMP_CFG_CMP0_IRQ_TRIG_BIT  BIT2 // [2] 比较器0中断触发类型，0:电平触发，1:边沿触发
#define CMP_CFG_CMP0_IN_EN_BIT     BIT1 // [1] 比较器0信号输入使能
#define CMP_CFG_CMP0_POL_BIT       BIT0 // [0] 比较器0极性选择，0:高电平有效；1:低电平有效

/* CMP_BLCWIN 开窗控制寄存器 */
#define CMP_BLCWIN_CMP1_CHN3P_WIN_EN_BIT BIT7 // [7] 使用MCPWM模块CHN3_P通道输出的P管开关控制信号作为比较器1开窗使能
#define CMP_BLCWIN_CMP1_CHN2P_WIN_EN_BIT BIT6 // [6] 使用MCPWM模块CHN2_P通道输出的P管开关控制信号作为比较器1开窗使能
#define CMP_BLCWIN_CMP1_CHN1P_WIN_EN_BIT BIT5 // [5] 使用MCPWM模块CHN1_P通道输出的P管开关控制信号作为比较器1开窗使能
#define CMP_BLCWIN_CMP1_CHN0P_WIN_EN_BIT BIT4 // [4] 使用MCPWM模块CHN0_P通道输出的P管开关控制信号作为比较器1开窗使能
#define CMP_BLCWIN_CMP0_CHN3P_WIN_EN_BIT BIT3 // [3] 使用MCPWM模块CHN3_P通道输出的P管开关控制信号作为比较器0开窗使能
#define CMP_BLCWIN_CMP0_CHN2P_WIN_EN_BIT BIT2 // [2] 使用MCPWM模块CHN2_P通道输出的P管开关控制信号作为比较器0开窗使能
#define CMP_BLCWIN_CMP0_CHN1P_WIN_EN_BIT BIT1 // [1] 使用MCPWM模块CHN1_P通道输出的P管开关控制信号作为比较器0开窗使能
#define CMP_BLCWIN_CMP0_CHN0P_WIN_EN_BIT BIT0 // [0] 使用MCPWM模块CHN0_P通道输出的P管开关控制信号作为比较器0开窗使能

/* CMP_DATA 输出数据寄存器 */
#define CMP_DATA_CMP1_FLT_DATA_BIT BIT9 // [9] 比较器1经过滤波后的信号
#define CMP_DATA_CMP0_FLT_DATA_BIT BIT8 // [8] 比较器0经过滤波后的信号
#define CMP_DATA_CMP1_RAW_DATA_BIT BIT1 // [1] 比较器1原始输出信号，直接来自模拟比较器1
#define CMP_DATA_CMP0_RAW_DATA_BIT BIT0 // [0] 比较器0原始输出信号，直接来自模拟比较器0

/* HALL0_CFG HALL模块配置寄存器 */
#define HALL0_CFG_SW_IE_BIT    BIT30                                               // [30] 软件触发HALL信号变化中断使能，高电平有效。当SW_IE=1时，软件向HALL_INFO.SW_IF写1，可以手动产生HALL信号变化中断，并令HALL_INFO.CHG_IF置位。
#define HALL0_CFG_OV_IE_BIT    BIT29                                               // [29] HALL计数器溢出中断使能开关。默认关闭。 0: 关闭 1: 使能
#define HALL0_CFG_CHG_IE_BIT   BIT28                                               // [28] HALL信号变化中断使能开关。默认关闭。 0: 关闭 1: 使能
#define HALL0_CFG_OV_RE_BIT    BIT26                                               // [26] HALL计数器溢出DMA请求使能开关。默认关闭。 0: 关闭 1: 使能
#define HALL0_CFG_CHG_RE_BIT   BIT25                                               // [25] HALL信号变化DMA请求使能开关。默认关闭。 0: 关闭 1: 使能
#define HALL0_CFG_HALL_EN_BIT  BIT24                                               // [24] HALL模块使能开关。默认关闭。 0: 关闭 1: 使能
#define HALL0_CFG_FIL_75_BIT   BIT20                                               // [20] 7/5滤波开关（连续采样7次，5次值一致）。默认关闭。 0: 关闭 1: 使能
#define HALL0_CFG_CLK_DIV_POS  16                                                  // HALL0_CFG_CLK_DIV起始位
#define HALL0_CFG_CLK_DIV_MASK (uint32_t)(0x3 << HALL0_CFG_CLK_DIV_POS)            // HALL0_CFG_CLK_DIV位掩码
#define HALL0_CFG_CLK_DIV(x)   (uint32_t)(((x) & 0x3) << HALL0_CFG_CLK_DIV_POS)    // [17:16] HALL时钟分频系数。默认不分频。 00:不分频 01:2分频 10:4分频 11:8分频
#define HALL0_CFG_FIL_LEN_POS  0                                                   // HALL0_CFG_FIL_LEN起始位
#define HALL0_CFG_FIL_LEN_MASK (uint32_t)(0x7FFF << HALL0_CFG_FIL_LEN_POS)         // HALL0_CFG_FIL_LEN位掩码
#define HALL0_CFG_FIL_LEN(x)   (uint32_t)(((x) & 0x7FFF) << HALL0_CFG_FIL_LEN_POS) // [14:0] 滤波宽度，低于对应脉冲宽度的信号将被硬件自动过滤掉。滤波宽度的计算公式为[14:0]+ 1。

/* HALL0_INFO HALL模块信息寄存器 */
#define HALL0_INFO_SW_IF_BIT     BIT18                                              // [18] 软件触发HALL信号变化中断。写1触发，自动清零。
#define HALL0_INFO_OV_IF_BIT     BIT17                                              // [17] HALL计数器溢出事件标志，写1清空
#define HALL0_INFO_CHG_IF_BIT    BIT16                                              // [16] HALL信号变化事件标志，写1清空
#define HALL0_INFO_RAW_DATA_POS  8                                                  // HALL0_INFO_RAW_DATA起始位
#define HALL0_INFO_RAW_DATA_MASK (uint32_t)(0x7 << HALL0_INFO_RAW_DATA_POS)         // HALL0_INFO_RAW_DATA位掩码
#define HALL0_INFO_RAW_DATA(x)   (uint32_t)(((x) & 0x7) << HALL0_INFO_RAW_DATA_POS) // [10:8] HALL值，未滤波结果
#define HALL0_INFO_FLT_DATA_POS  0                                                  // HALL0_INFO_FLT_DATA起始位
#define HALL0_INFO_FLT_DATA_MASK (uint32_t)(0x7 << HALL0_INFO_FLT_DATA_POS)         // HALL0_INFO_FLT_DATA位掩码
#define HALL0_INFO_FLT_DATA(x)   (uint32_t)(((x) & 0x7) << HALL0_INFO_FLT_DATA_POS) // [2:0] HALL值，滤波结果

/* HALL0_WIDTH HALL宽度计数值寄存器 */
#define HALL0_WIDTH_CAP_CNT_POS  0                                                       // HALL0_WIDTH_CAP_CNT起始位
#define HALL0_WIDTH_CAP_CNT_MASK (uint32_t)(0xFFFFFF << HALL0_WIDTH_CAP_CNT_POS)         // HALL0_WIDTH_CAP_CNT位掩码
#define HALL0_WIDTH_CAP_CNT(x)   (uint32_t)(((x) & 0xFFFFFF) << HALL0_WIDTH_CAP_CNT_POS) // [23:0] HALL 宽度计数器值

/* HALL0_TH HALL模块计数器门限值寄存器 */
#define HALL0_TH_TH_POS  0                                               // HALL0_TH_TH起始位
#define HALL0_TH_TH_MASK (uint32_t)(0xFFFFFF << HALL0_TH_TH_POS)         // HALL0_TH_TH位掩码
#define HALL0_TH_TH(x)   (uint32_t)(((x) & 0xFFFFFF) << HALL0_TH_TH_POS) // [23:0] HALL计数器门限值

/* HALL0_CNT HALL计数寄存器 */
#define HALL0_CNT_CNT_POS  0                                                 // HALL0_CNT_CNT起始位
#define HALL0_CNT_CNT_MASK (uint32_t)(0xFFFFFF << HALL0_CNT_CNT_POS)         // HALL0_CNT_CNT位掩码
#define HALL0_CNT_CNT(x)   (uint32_t)(((x) & 0xFFFFFF) << HALL0_CNT_CNT_POS) // [23:0] HALL计数值，写入任意值可清零

/* ADC0_DAT0 */
#define ADC0_DAT0_DAT0_POS  0                                                // ADC0_DAT0_DAT0起始位
#define ADC0_DAT0_DAT0_MASK (uint32_t)(0xFFFF << ADC0_DAT0_DAT0_POS)         // ADC0_DAT0_DAT0位掩码
#define ADC0_DAT0_DAT0(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT0_DAT0_POS) // [15:0] ADC0第0次采样数据

/* ADC0_DAT1 */
#define ADC0_DAT1_DAT1_POS  0                                                // ADC0_DAT1_DAT1起始位
#define ADC0_DAT1_DAT1_MASK (uint32_t)(0xFFFF << ADC0_DAT1_DAT1_POS)         // ADC0_DAT1_DAT1位掩码
#define ADC0_DAT1_DAT1(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT1_DAT1_POS) // [15:0] ADC0第1次采样数据

/* ADC0_DAT2 */
#define ADC0_DAT2_DAT2_POS  0                                                // ADC0_DAT2_DAT2起始位
#define ADC0_DAT2_DAT2_MASK (uint32_t)(0xFFFF << ADC0_DAT2_DAT2_POS)         // ADC0_DAT2_DAT2位掩码
#define ADC0_DAT2_DAT2(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT2_DAT2_POS) // [15:0] ADC0第2次采样数据

/* ADC0_DAT3 */
#define ADC0_DAT3_DAT3_POS  0                                                // ADC0_DAT3_DAT3起始位
#define ADC0_DAT3_DAT3_MASK (uint32_t)(0xFFFF << ADC0_DAT3_DAT3_POS)         // ADC0_DAT3_DAT3位掩码
#define ADC0_DAT3_DAT3(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT3_DAT3_POS) // [15:0] ADC0第3次采样数据

/* ADC0_DAT4 */
#define ADC0_DAT4_DAT4_POS  0                                                // ADC0_DAT4_DAT4起始位
#define ADC0_DAT4_DAT4_MASK (uint32_t)(0xFFFF << ADC0_DAT4_DAT4_POS)         // ADC0_DAT4_DAT4位掩码
#define ADC0_DAT4_DAT4(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT4_DAT4_POS) // [15:0] ADC0第4次采样数据

/* ADC0_DAT5 */
#define ADC0_DAT5_DAT5_POS  0                                                // ADC0_DAT5_DAT5起始位
#define ADC0_DAT5_DAT5_MASK (uint32_t)(0xFFFF << ADC0_DAT5_DAT5_POS)         // ADC0_DAT5_DAT5位掩码
#define ADC0_DAT5_DAT5(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT5_DAT5_POS) // [15:0] ADC0第5次采样数据

/* ADC0_DAT6 */
#define ADC0_DAT6_DAT6_POS  0                                                // ADC0_DAT6_DAT6起始位
#define ADC0_DAT6_DAT6_MASK (uint32_t)(0xFFFF << ADC0_DAT6_DAT6_POS)         // ADC0_DAT6_DAT6位掩码
#define ADC0_DAT6_DAT6(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT6_DAT6_POS) // [15:0] ADC0第6次采样数据/第5次空闲采样数据

/* ADC0_DAT7 */
#define ADC0_DAT7_DAT7_POS  0                                                // ADC0_DAT7_DAT7起始位
#define ADC0_DAT7_DAT7_MASK (uint32_t)(0xFFFF << ADC0_DAT7_DAT7_POS)         // ADC0_DAT7_DAT7位掩码
#define ADC0_DAT7_DAT7(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT7_DAT7_POS) // [15:0] ADC0第7次采样数据/第4次空闲采样数据

/* ADC0_DAT8 */
#define ADC0_DAT8_DAT8_POS  0                                                // ADC0_DAT8_DAT8起始位
#define ADC0_DAT8_DAT8_MASK (uint32_t)(0xFFFF << ADC0_DAT8_DAT8_POS)         // ADC0_DAT8_DAT8位掩码
#define ADC0_DAT8_DAT8(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT8_DAT8_POS) // [15:0] ADC0第8次采样数据/第3次空闲采样数据

/* ADC0_DAT9 */
#define ADC0_DAT9_DAT9_POS  0                                                // ADC0_DAT9_DAT9起始位
#define ADC0_DAT9_DAT9_MASK (uint32_t)(0xFFFF << ADC0_DAT9_DAT9_POS)         // ADC0_DAT9_DAT9位掩码
#define ADC0_DAT9_DAT9(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT9_DAT9_POS) // [15:0] ADC0第9次采样数据/第2次空闲采样数据

/* ADC0_DAT10 */
#define ADC0_DAT10_DAT10_POS  0                                                  // ADC0_DAT10_DAT10起始位
#define ADC0_DAT10_DAT10_MASK (uint32_t)(0xFFFF << ADC0_DAT10_DAT10_POS)         // ADC0_DAT10_DAT10位掩码
#define ADC0_DAT10_DAT10(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT10_DAT10_POS) // [15:0] ADC0第10次采样数据/第1次空闲采样数据

/* ADC0_DAT11 */
#define ADC0_DAT11_DAT11_POS  0                                                  // ADC0_DAT11_DAT11起始位
#define ADC0_DAT11_DAT11_MASK (uint32_t)(0xFFFF << ADC0_DAT11_DAT11_POS)         // ADC0_DAT11_DAT11位掩码
#define ADC0_DAT11_DAT11(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DAT11_DAT11_POS) // [15:0] ADC0第11次采样数据/第0次空闲采样数据

/* ADC0_CHN0 */
#define ADC0_CHN0_PDS3_POS  12                                            // ADC0_CHN0_PDS3起始位
#define ADC0_CHN0_PDS3_MASK (uint32_t)(0xF << ADC0_CHN0_PDS3_POS)         // ADC0_CHN0_PDS3位掩码
#define ADC0_CHN0_PDS3(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN0_PDS3_POS) // [15:12] ADC0第3次采样正端输入信号选择
#define ADC0_CHN0_PDS2_POS  8                                             // ADC0_CHN0_PDS2起始位
#define ADC0_CHN0_PDS2_MASK (uint32_t)(0xF << ADC0_CHN0_PDS2_POS)         // ADC0_CHN0_PDS2位掩码
#define ADC0_CHN0_PDS2(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN0_PDS2_POS) // [11:8] ADC0第2次采样正端输入信号选择
#define ADC0_CHN0_PDS1_POS  4                                             // ADC0_CHN0_PDS1起始位
#define ADC0_CHN0_PDS1_MASK (uint32_t)(0xF << ADC0_CHN0_PDS1_POS)         // ADC0_CHN0_PDS1位掩码
#define ADC0_CHN0_PDS1(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN0_PDS1_POS) // [7:4] ADC0第1次采样正端输入信号选择
#define ADC0_CHN0_PDS0_POS  0                                             // ADC0_CHN0_PDS0起始位
#define ADC0_CHN0_PDS0_MASK (uint32_t)(0xF << ADC0_CHN0_PDS0_POS)         // ADC0_CHN0_PDS0位掩码
#define ADC0_CHN0_PDS0(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN0_PDS0_POS) // [3:0] ADC0第0次采样正端输入信号选择

/* ADC0_CHN1 */
#define ADC0_CHN1_PDS7_POS  12                                            // ADC0_CHN1_PDS7起始位
#define ADC0_CHN1_PDS7_MASK (uint32_t)(0xF << ADC0_CHN1_PDS7_POS)         // ADC0_CHN1_PDS7位掩码
#define ADC0_CHN1_PDS7(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN1_PDS7_POS) // [15:12] ADC0第7次采样正端输入信号选择 或第4次空闲采样正端输入信号选择
#define ADC0_CHN1_PDS6_POS  8                                             // ADC0_CHN1_PDS6起始位
#define ADC0_CHN1_PDS6_MASK (uint32_t)(0xF << ADC0_CHN1_PDS6_POS)         // ADC0_CHN1_PDS6位掩码
#define ADC0_CHN1_PDS6(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN1_PDS6_POS) // [11:8] ADC0第6次采样正端输入信号选择 或第5次空闲采样正端输入信号选择
#define ADC0_CHN1_PDS5_POS  4                                             // ADC0_CHN1_PDS5起始位
#define ADC0_CHN1_PDS5_MASK (uint32_t)(0xF << ADC0_CHN1_PDS5_POS)         // ADC0_CHN1_PDS5位掩码
#define ADC0_CHN1_PDS5(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN1_PDS5_POS) // [7:4] ADC0第5次采样正端输入信号选择
#define ADC0_CHN1_PDS4_POS  0                                             // ADC0_CHN1_PDS4起始位
#define ADC0_CHN1_PDS4_MASK (uint32_t)(0xF << ADC0_CHN1_PDS4_POS)         // ADC0_CHN1_PDS4位掩码
#define ADC0_CHN1_PDS4(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN1_PDS4_POS) // [3:0] ADC0第4次采样正端输入信号选择

/* ADC0_CHN2 */
#define ADC0_CHN2_PDS11_POS  12                                             // ADC0_CHN2_PDS11起始位
#define ADC0_CHN2_PDS11_MASK (uint32_t)(0xF << ADC0_CHN2_PDS11_POS)         // ADC0_CHN2_PDS11位掩码
#define ADC0_CHN2_PDS11(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN2_PDS11_POS) // [15:12] ADC0第11次常规采样正端输入信号选择 或第0次空闲采样正端输入信号选择
#define ADC0_CHN2_PDS10_POS  8                                              // ADC0_CHN2_PDS10起始位
#define ADC0_CHN2_PDS10_MASK (uint32_t)(0xF << ADC0_CHN2_PDS10_POS)         // ADC0_CHN2_PDS10位掩码
#define ADC0_CHN2_PDS10(x)   (uint32_t)(((x) & 0xF) << ADC0_CHN2_PDS10_POS) // [11:8] ADC0第10次采样正端输入信号选择 或第1次空闲采样正端输入信号选择
#define ADC0_CHN2_PDS9_POS   4                                              // ADC0_CHN2_PDS9起始位
#define ADC0_CHN2_PDS9_MASK  (uint32_t)(0xF << ADC0_CHN2_PDS9_POS)          // ADC0_CHN2_PDS9位掩码
#define ADC0_CHN2_PDS9(x)    (uint32_t)(((x) & 0xF) << ADC0_CHN2_PDS9_POS)  // [7:4] ADC0第9次采样正端输入信号选择 或第2次空闲采样正端输入信号选择
#define ADC0_CHN2_PDS8_POS   0                                              // ADC0_CHN2_PDS8起始位
#define ADC0_CHN2_PDS8_MASK  (uint32_t)(0xF << ADC0_CHN2_PDS8_POS)          // ADC0_CHN2_PDS8位掩码
#define ADC0_CHN2_PDS8(x)    (uint32_t)(((x) & 0xF) << ADC0_CHN2_PDS8_POS)  // [3:0] ADC0第8次采样正端输入信号选择 或第3次空闲采样正端输入信号选择

/* ADC0_CHNT */
#define ADC0_CHNT_IS1_POS  8                                            // ADC0_CHNT_IS1起始位
#define ADC0_CHNT_IS1_MASK (uint32_t)(0xF << ADC0_CHNT_IS1_POS)         // ADC0_CHNT_IS1位掩码
#define ADC0_CHNT_IS1(x)   (uint32_t)(((x) & 0xF) << ADC0_CHNT_IS1_POS) // [11:8] 空闲采样次数
#define ADC0_CHNT_S2_POS   4                                            // ADC0_CHNT_S2起始位
#define ADC0_CHNT_S2_MASK  (uint32_t)(0xF << ADC0_CHNT_S2_POS)          // ADC0_CHNT_S2位掩码
#define ADC0_CHNT_S2(x)    (uint32_t)(((x) & 0xF) << ADC0_CHNT_S2_POS)  // [7:4] 第二段常规采样次数
#define ADC0_CHNT_S1_POS   0                                            // ADC0_CHNT_S1起始位
#define ADC0_CHNT_S1_MASK  (uint32_t)(0xF << ADC0_CHNT_S1_POS)          // ADC0_CHNT_S1位掩码
#define ADC0_CHNT_S1(x)    (uint32_t)(((x) & 0xF) << ADC0_CHNT_S1_POS)  // [3:0] 第一段常规采样次数

/* ADC0_GAIN */
#define ADC0_GAIN_DG11_BIT BIT11 // [11] DAT11增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG10_BIT BIT10 // [10] DAT10增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG9_BIT  BIT9  // [9] DAT9增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG8_BIT  BIT8  // [8] DAT8增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG7_BIT  BIT7  // [7] DAT7增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG6_BIT  BIT6  // [6] DAT6增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG5_BIT  BIT5  // [5] DAT5增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG4_BIT  BIT4  // [4] DAT4增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG3_BIT  BIT3  // [3] DAT3增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG2_BIT  BIT2  // [2] DAT2增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG1_BIT  BIT1  // [1] DAT1增益选择，0:±3.6V量程，1:±5V量程
#define ADC0_GAIN_DG0_BIT  BIT0  // [0] DAT0增益选择，0:±3.6V量程，1:±5V量程

/* ADC0_CFG */
#define ADC0_CFG_NSMP_BIT       BIT12                                        // [12] 0:单段采样，1:两段采样
#define ADC0_CFG_FSM_RS_BIT     BIT11                                        // [11] 状态机复位控制信号。软件写入1产生复位，将ADC内部状态机回到初始状态，完成后自动回到0。该复位控制，不影响ADC其它寄存器的配置值。 读取该位返回ADC当前状态，1表示ADC目前正在采样转换工作中，0表示空闲。
#define ADC0_CFG_DATA_ALIGN_BIT BIT10                                        // [10] ADC_DAT对齐方式 0:左对齐，右端补4’h0， 1:右对齐，左端补4bit符号位
#define ADC0_CFG_IDLE_PRI_BIT   BIT9                                         // [9] 空闲触发优先级 0:空闲触发优先级低于常规触发 1:空闲触发优先级高于常规触发
#define ADC0_CFG_CSMP_BIT       BIT8                                         // [8] 连续采样模式 0:不开启 1:开启连续采样模式，触发到来后，ADC即开始采样转换，完成所有信号的转换后，无需等待触发立即从第0个信号开始新一轮的采样转换
#define ADC0_CFG_TCNT_POS       4                                            // ADC0_CFG_TCNT起始位
#define ADC0_CFG_TCNT_MASK      (uint32_t)(0xF << ADC0_CFG_TCNT_POS)         // ADC0_CFG_TCNT位掩码
#define ADC0_CFG_TCNT(x)        (uint32_t)(((x) & 0xF) << ADC0_CFG_TCNT_POS) // [7:4] 触发一次采样所需的事件数。 0:表示需要发生1次事件才能触发一次采样 1:表示需要发生2次事件才能触发一次采样 …… 15:表示需要发生16次事件才能触发一次采样
#define ADC0_CFG_TROVS_BIT      BIT3                                         // [3] 过采样触发模式 0:一次触发即连续过采样多次至OVSR，并将数据平均后存入，可以配置采样多个通道，每个通道都采样OVSR次后才进行下一个通道的采样。 1:一次触发只进行一次采样转换，需要OVSR次触发才完成足够数据的采集并进行平均，而后存入数据寄存器。受到累加器个数限制，在此种配置下，ADC0_CHNT只能配置采样一个通道。
#define ADC0_CFG_OVSR_POS       0                                            // ADC0_CFG_OVSR起始位
#define ADC0_CFG_OVSR_MASK      (uint32_t)(0x7 << ADC0_CFG_OVSR_POS)         // ADC0_CFG_OVSR位掩码
#define ADC0_CFG_OVSR(x)        (uint32_t)(((x) & 0x7) << ADC0_CFG_OVSR_POS) // [2:0] 过采样率 0:1，默认1次采样即存入数据 1:2次采后存入数据 2:4次采样后存入数据 3:8次采样后存入数据 4:16次采样后存入数据 5:32次采样后存入数据 6:64次采样后存入数据 7:128次采样后存入数据

/* ADC0_TRIG */
#define ADC0_TRIG_CL_T3_IEN_BIT        BIT27 // [27] CL_OUTPUT[3]触发ADC空闲采样使能，高有效
#define ADC0_TRIG_CL_T2_IEN_BIT        BIT26 // [26] CL_OUTPUT[2]触发ADC空闲采样使能，高有效
#define ADC0_TRIG_CL_T1_IEN_BIT        BIT25 // [25] CL_OUTPUT[1]触发ADC空闲采样使能，高有效
#define ADC0_TRIG_CL_T0_IEN_BIT        BIT24 // [24] CL_OUTPUT[0]触发ADC空闲采样使能，高有效
#define ADC0_TRIG_UTIMER2_CMP1_IEN_BIT BIT23 // [23] TIMER1比较/捕获事件1触发ADC空闲采样使能，高有效
#define ADC0_TRIG_UTIMER2_CMP0_IEN_BIT BIT22 // [22] TIMER1比较/捕获事件0触发ADC空闲采样使能，高有效
#define ADC0_TRIG_UTIMER0_CMP1_IEN_BIT BIT21 // [21] TIMER0比较/捕获事件1触发ADC空闲采样使能，高有效
#define ADC0_TRIG_UTIMER0_CMP0_IEN_BIT BIT20 // [20] TIMER0比较/捕获事件0触发ADC空闲采样使能，高有效
#define ADC0_TRIG_MCPWM_T3_IEN_BIT     BIT19 // [19] MCPWM0 T3事件触发ADC空闲采样使能，高有效
#define ADC0_TRIG_MCPWM_T2_IEN_BIT     BIT18 // [18] MCPWM0 T2事件触发ADC空闲采样使能，高有效
#define ADC0_TRIG_MCPWM_T1_IEN_BIT     BIT17 // [17] MCPWM0 T1事件触发ADC空闲采样使能，高有效
#define ADC0_TRIG_MCPWM_T0_IEN_BIT     BIT16 // [16] MCPWM0 T0事件触发ADC空闲采样使能，高有效
#define ADC0_TRIG_CL_T3_NEN_BIT        BIT11 // [11] CL_OUTPUT[3]触发ADC常规采样使能，高有效
#define ADC0_TRIG_CL_T2_NEN_BIT        BIT10 // [10] CL_OUTPUT[2]触发ADC常规采样使能，高有效
#define ADC0_TRIG_CL_T1_NEN_BIT        BIT9  // [9] CL_OUTPUT[1]触发ADC常规采样使能，高有效
#define ADC0_TRIG_CL_T0_NEN_BIT        BIT8  // [8] CL_OUTPUT[0]触发ADC常规采样使能，高有效
#define ADC0_TRIG_UTIMER2_CMP1_EN_BIT  BIT7  // [7] TIMER1比较/捕获事件1触发ADC常规采样使能，高有效
#define ADC0_TRIG_UTIMER2_CMP0_EN_BIT  BIT6  // [6] TIMER1比较/捕获事件0触发ADC常规采样使能，高有效
#define ADC0_TRIG_UTIMER0_CMP1_EN_BIT  BIT5  // [5] TIMER0比较/捕获事件1触发ADC常规采样使能，高有效
#define ADC0_TRIG_UTIMER0_CMP0_EN_BIT  BIT4  // [4] TIMER0比较/捕获事件0触发ADC常规采样使能，高有效
#define ADC0_TRIG_MCPWM_T3_NEN_BIT     BIT3  // [3] MCPWM0 T3事件触发ADC常规采样使能，高有效
#define ADC0_TRIG_MCPWM_T2_NEN_BIT     BIT2  // [2] MCPWM0 T2事件触发ADC常规采样使能，高有效
#define ADC0_TRIG_MCPWM_T1_NEN_BIT     BIT1  // [1] MCPWM0 T1事件触发ADC常规采样使能，高有效
#define ADC0_TRIG_MCPWM_T0_NEN_BIT     BIT0  // [0] MCPWM0 T0事件触发ADC常规采样使能，高有效

/* ADC0_SWT */
#define ADC0_SWT_SWT_POS  0                                              // ADC0_SWT_SWT起始位
#define ADC0_SWT_SWT_MASK (uint32_t)(0xFFFF << ADC0_SWT_SWT_POS)         // ADC0_SWT_SWT位掩码
#define ADC0_SWT_SWT(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_SWT_SWT_POS) // [15:0] 写入数据为0x5AA5时，产生一次常规触发 写入数据位0xF00F时，产生一次空闲触发

/* ADC0_DC0 */
#define ADC0_DC0_DC_OFFSET_POS  0                                                    // ADC0_DC0_DC_OFFSET起始位
#define ADC0_DC0_DC_OFFSET_MASK (uint32_t)(0xFFFF << ADC0_DC0_DC_OFFSET_POS)         // ADC0_DC0_DC_OFFSET位掩码
#define ADC0_DC0_DC_OFFSET(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DC0_DC_OFFSET_POS) // [15:0] ADC采样电路DC offset

/* ADC0_AMC0 */
#define ADC0_AMC0_AMC_POS  0                                              // ADC0_AMC0_AMC起始位
#define ADC0_AMC0_AMC_MASK (uint32_t)(0x3FF << ADC0_AMC0_AMC_POS)         // ADC0_AMC0_AMC位掩码
#define ADC0_AMC0_AMC(x)   (uint32_t)(((x) & 0x3FF) << ADC0_AMC0_AMC_POS) // [9:0] ADC 采样电路增益校正系数

/* ADC0_DC1 */
#define ADC0_DC1_DC_OFFSET_POS  0                                                    // ADC0_DC1_DC_OFFSET起始位
#define ADC0_DC1_DC_OFFSET_MASK (uint32_t)(0xFFFF << ADC0_DC1_DC_OFFSET_POS)         // ADC0_DC1_DC_OFFSET位掩码
#define ADC0_DC1_DC_OFFSET(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_DC1_DC_OFFSET_POS) // [15:0] ADC采样电路DC offset

/* ADC0_AMC1 */
#define ADC0_AMC1_AM_CALI_POS  0                                                  // ADC0_AMC1_AM_CALI起始位
#define ADC0_AMC1_AM_CALI_MASK (uint32_t)(0x3FF << ADC0_AMC1_AM_CALI_POS)         // ADC0_AMC1_AM_CALI位掩码
#define ADC0_AMC1_AM_CALI(x)   (uint32_t)(((x) & 0x3FF) << ADC0_AMC1_AM_CALI_POS) // [9:0] ADC 采样电路增益校正系数

/* ADC0_IE */
#define ADC0_IE_ISF_RE_BIT  BIT15 // [15] 空闲采样完成DMA请求使能
#define ADC0_IE_HERR_RE_BIT BIT14 // [14] 硬件触发发生在非空闲状态DMA请求使能
#define ADC0_IE_SERR_RE_BIT BIT13 // [13] 软件触发发生在非空闲状态DMA请求使能
#define ADC0_IE_AWD0_RE_BIT BIT10 // [10] 阈值监测0超限DMA请求使能
#define ADC0_IE_SF2_RE_BIT  BIT9  // [9] 第二段采样完成DMA请求使能
#define ADC0_IE_SF1_RE_BIT  BIT8  // [8] 第一段采样完成DMA请求使能
#define ADC0_IE_ISF_IE_BIT  BIT7  // [7] 空闲采样完成中断使能
#define ADC0_IE_HERR_IE_BIT BIT6  // [6] 硬件触发发生在非空闲状态中断使能
#define ADC0_IE_SERR_IE_BIT BIT5  // [5] 软件触发发生在非空闲状态中断使能
#define ADC0_IE_AWD0_IE_BIT BIT2  // [2] 阈值监测0超限中断使能
#define ADC0_IE_SF2_IE_BIT  BIT1  // [1] 第二段常规采样完成中断使能
#define ADC0_IE_SF1_IE_BIT  BIT0  // [0] 第一段常规采样完成中断使能

/* ADC0_IF */
#define ADC0_IF_ISF_IF_BIT  BIT7 // [7] 空闲采样完成中断标志
#define ADC0_IF_HERR_IF_BIT BIT6 // [6] 硬件触发发生在非空闲状态中断标志
#define ADC0_IF_SERR_IF_BIT BIT5 // [5] 软件触发发生在非空闲状态中断标志
#define ADC0_IF_AWD0_IF_BIT BIT2 // [2] 阈值监测0超限中断标志
#define ADC0_IF_SF2_IF_BIT  BIT1 // [1] 第二段常规采样完成中断标志
#define ADC0_IF_SF1_IF_BIT  BIT0 // [0] 第一段常规采样完成中断标志

/* ADC0_LTH */
#define ADC0_LTH_LTH_POS  0                                             // ADC0_LTH_LTH起始位
#define ADC0_LTH_LTH_MASK (uint32_t)(0xFFF << ADC0_LTH_LTH_POS)         // ADC0_LTH_LTH位掩码
#define ADC0_LTH_LTH(x)   (uint32_t)(((x) & 0xFFF) << ADC0_LTH_LTH_POS) // [11:0] ADC模拟看门狗0下阈值

/* ADC0_HTH */
#define ADC0_HTH_HTH_POS  0                                             // ADC0_HTH_HTH起始位
#define ADC0_HTH_HTH_MASK (uint32_t)(0xFFF << ADC0_HTH_HTH_POS)         // ADC0_HTH_HTH位掩码
#define ADC0_HTH_HTH(x)   (uint32_t)(((x) & 0xFFF) << ADC0_HTH_HTH_POS) // [11:0] ADC模拟看门狗0上阈值

/* ADC0_GEN */
#define ADC0_GEN_GEN_POS  0                                              // ADC0_GEN_GEN起始位
#define ADC0_GEN_GEN_MASK (uint32_t)(0xFFFF << ADC0_GEN_GEN_POS)         // ADC0_GEN_GEN位掩码
#define ADC0_GEN_GEN(x)   (uint32_t)(((x) & 0xFFFF) << ADC0_GEN_GEN_POS) // [15:0] ADC模拟看门狗0对应使能位 BIT0: DAT0看门狗监测使能 BIT1: DAT1看门狗监测使能 …… BIT7: DAT13看门狗监测使能

/* ADC1_DAT0 */
#define ADC1_DAT0_DAT0_POS  0                                                // ADC1_DAT0_DAT0起始位
#define ADC1_DAT0_DAT0_MASK (uint32_t)(0xFFFF << ADC1_DAT0_DAT0_POS)         // ADC1_DAT0_DAT0位掩码
#define ADC1_DAT0_DAT0(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT0_DAT0_POS) // [15:0] ADC1第0次采样数据

/* ADC1_DAT1 */
#define ADC1_DAT1_DAT1_POS  0                                                // ADC1_DAT1_DAT1起始位
#define ADC1_DAT1_DAT1_MASK (uint32_t)(0xFFFF << ADC1_DAT1_DAT1_POS)         // ADC1_DAT1_DAT1位掩码
#define ADC1_DAT1_DAT1(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT1_DAT1_POS) // [15:0] ADC1第1次采样数据

/* ADC1_DAT2 */
#define ADC1_DAT2_DAT2_POS  0                                                // ADC1_DAT2_DAT2起始位
#define ADC1_DAT2_DAT2_MASK (uint32_t)(0xFFFF << ADC1_DAT2_DAT2_POS)         // ADC1_DAT2_DAT2位掩码
#define ADC1_DAT2_DAT2(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT2_DAT2_POS) // [15:0] ADC1第2次采样数据

/* ADC1_DAT3 */
#define ADC1_DAT3_DAT3_POS  0                                                // ADC1_DAT3_DAT3起始位
#define ADC1_DAT3_DAT3_MASK (uint32_t)(0xFFFF << ADC1_DAT3_DAT3_POS)         // ADC1_DAT3_DAT3位掩码
#define ADC1_DAT3_DAT3(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT3_DAT3_POS) // [15:0] ADC1第3次采样数据

/* ADC1_DAT4 */
#define ADC1_DAT4_DAT4_POS  0                                                // ADC1_DAT4_DAT4起始位
#define ADC1_DAT4_DAT4_MASK (uint32_t)(0xFFFF << ADC1_DAT4_DAT4_POS)         // ADC1_DAT4_DAT4位掩码
#define ADC1_DAT4_DAT4(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT4_DAT4_POS) // [15:0] ADC1第4次采样数据

/* ADC1_DAT5 */
#define ADC1_DAT5_DAT5_POS  0                                                // ADC1_DAT5_DAT5起始位
#define ADC1_DAT5_DAT5_MASK (uint32_t)(0xFFFF << ADC1_DAT5_DAT5_POS)         // ADC1_DAT5_DAT5位掩码
#define ADC1_DAT5_DAT5(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT5_DAT5_POS) // [15:0] ADC1第5次采样数据

/* ADC1_DAT6 */
#define ADC1_DAT6_DAT6_POS  0                                                // ADC1_DAT6_DAT6起始位
#define ADC1_DAT6_DAT6_MASK (uint32_t)(0xFFFF << ADC1_DAT6_DAT6_POS)         // ADC1_DAT6_DAT6位掩码
#define ADC1_DAT6_DAT6(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT6_DAT6_POS) // [15:0] ADC1第6次采样数据

/* ADC1_DAT7 */
#define ADC1_DAT7_DAT7_POS  0                                                // ADC1_DAT7_DAT7起始位
#define ADC1_DAT7_DAT7_MASK (uint32_t)(0xFFFF << ADC1_DAT7_DAT7_POS)         // ADC1_DAT7_DAT7位掩码
#define ADC1_DAT7_DAT7(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DAT7_DAT7_POS) // [15:0] ADC1第7次采样数据

/* ADC1_CHN0 */
#define ADC1_CHN0_PDS3_POS  12                                            // ADC1_CHN0_PDS3起始位
#define ADC1_CHN0_PDS3_MASK (uint32_t)(0xF << ADC1_CHN0_PDS3_POS)         // ADC1_CHN0_PDS3位掩码
#define ADC1_CHN0_PDS3(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN0_PDS3_POS) // [15:12] ADC1第3次采样正端输入信号选择
#define ADC1_CHN0_PDS2_POS  8                                             // ADC1_CHN0_PDS2起始位
#define ADC1_CHN0_PDS2_MASK (uint32_t)(0xF << ADC1_CHN0_PDS2_POS)         // ADC1_CHN0_PDS2位掩码
#define ADC1_CHN0_PDS2(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN0_PDS2_POS) // [11:8] ADC1第2次采样正端输入信号选择
#define ADC1_CHN0_PDS1_POS  4                                             // ADC1_CHN0_PDS1起始位
#define ADC1_CHN0_PDS1_MASK (uint32_t)(0xF << ADC1_CHN0_PDS1_POS)         // ADC1_CHN0_PDS1位掩码
#define ADC1_CHN0_PDS1(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN0_PDS1_POS) // [7:4] ADC1第1次采样正端输入信号选择
#define ADC1_CHN0_PDS0_POS  0                                             // ADC1_CHN0_PDS0起始位
#define ADC1_CHN0_PDS0_MASK (uint32_t)(0xF << ADC1_CHN0_PDS0_POS)         // ADC1_CHN0_PDS0位掩码
#define ADC1_CHN0_PDS0(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN0_PDS0_POS) // [3:0] ADC1第0次采样正端输入信号选择

/* ADC1_CHN1 */
#define ADC1_CHN1_PDS7_POS  12                                            // ADC1_CHN1_PDS7起始位
#define ADC1_CHN1_PDS7_MASK (uint32_t)(0xF << ADC1_CHN1_PDS7_POS)         // ADC1_CHN1_PDS7位掩码
#define ADC1_CHN1_PDS7(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN1_PDS7_POS) // [15:12] ADC1第7次采样正端输入信号选择
#define ADC1_CHN1_PDS6_POS  8                                             // ADC1_CHN1_PDS6起始位
#define ADC1_CHN1_PDS6_MASK (uint32_t)(0xF << ADC1_CHN1_PDS6_POS)         // ADC1_CHN1_PDS6位掩码
#define ADC1_CHN1_PDS6(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN1_PDS6_POS) // [11:8] ADC1第6次采样正端输入信号选择
#define ADC1_CHN1_PDS5_POS  4                                             // ADC1_CHN1_PDS5起始位
#define ADC1_CHN1_PDS5_MASK (uint32_t)(0xF << ADC1_CHN1_PDS5_POS)         // ADC1_CHN1_PDS5位掩码
#define ADC1_CHN1_PDS5(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN1_PDS5_POS) // [7:4] ADC1第5次采样正端输入信号选择
#define ADC1_CHN1_PDS4_POS  0                                             // ADC1_CHN1_PDS4起始位
#define ADC1_CHN1_PDS4_MASK (uint32_t)(0xF << ADC1_CHN1_PDS4_POS)         // ADC1_CHN1_PDS4位掩码
#define ADC1_CHN1_PDS4(x)   (uint32_t)(((x) & 0xF) << ADC1_CHN1_PDS4_POS) // [3:0] ADC1第4次采样正端输入信号选择

/* ADC1_CHNT */
#define ADC1_CHNT_S2_POS  4                                           // ADC1_CHNT_S2起始位
#define ADC1_CHNT_S2_MASK (uint32_t)(0xF << ADC1_CHNT_S2_POS)         // ADC1_CHNT_S2位掩码
#define ADC1_CHNT_S2(x)   (uint32_t)(((x) & 0xF) << ADC1_CHNT_S2_POS) // [7:4] 第二段常规采样次数
#define ADC1_CHNT_S1_POS  0                                           // ADC1_CHNT_S1起始位
#define ADC1_CHNT_S1_MASK (uint32_t)(0xF << ADC1_CHNT_S1_POS)         // ADC1_CHNT_S1位掩码
#define ADC1_CHNT_S1(x)   (uint32_t)(((x) & 0xF) << ADC1_CHNT_S1_POS) // [3:0] 第一段常规采样次数

/* ADC1_GAIN */
#define ADC1_GAIN_DG7_BIT BIT7 // [7] DAT7增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG6_BIT BIT6 // [6] DAT6增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG5_BIT BIT5 // [5] DAT5增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG4_BIT BIT4 // [4] DAT4增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG3_BIT BIT3 // [3] DAT3增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG2_BIT BIT2 // [2] DAT2增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG1_BIT BIT1 // [1] DAT1增益选择，0:±3.6V量程，1:±5V量程
#define ADC1_GAIN_DG0_BIT BIT0 // [0] DAT0增益选择，0:±3.6V量程，1:±5V量程

/* ADC1_CFG */
#define ADC1_CFG_NSMP_BIT       BIT12                                        // [12] 0:单段采样，1:两段采样
#define ADC1_CFG_FSM_RS_BIT     BIT11                                        // [11] 状态机复位控制信号。软件写入1产生复位，将ADC内部状态机回到初始状态，完成后自动回到0。该复位控制，不影响ADC其它寄存器的配置值。 读取该位返回ADC当前状态，1表示ADC目前正在采样转换工作中，0表示空闲。
#define ADC1_CFG_DATA_ALIGN_BIT BIT10                                        // [10] ADC_DAT对齐方式 0:左对齐，右端补4’h0， 1:右对齐，左端补4bit符号位
#define ADC1_CFG_CSMP_BIT       BIT8                                         // [8] 连续采样模式 0:不开启 1:开启连续采样模式，触发到来后，ADC即开始采样转换，完成所有信号的转换后，无需等待触发立即从第0个信号开始新一轮的采样转换
#define ADC1_CFG_TCNT_POS       4                                            // ADC1_CFG_TCNT起始位
#define ADC1_CFG_TCNT_MASK      (uint32_t)(0xF << ADC1_CFG_TCNT_POS)         // ADC1_CFG_TCNT位掩码
#define ADC1_CFG_TCNT(x)        (uint32_t)(((x) & 0xF) << ADC1_CFG_TCNT_POS) // [7:4] 触发一次采样所需的事件数。 0:表示需要发生1次事件才能触发一次采样 1:表示需要发生2次事件才能触发一次采样 …… 15:表示需要发生16次事件才能触发一次采样

/* ADC1_TRIG */
#define ADC1_TRIG_CL_NT3_EN_BIT       BIT11 // [11] CL_OUTPUT[3]触发ADC常规采样使能，高有效
#define ADC1_TRIG_CL_NT2_EN_BIT       BIT10 // [10] CL_OUTPUT[2]触发ADC常规采样使能，高有效
#define ADC1_TRIG_CL_NT1_EN_BIT       BIT9  // [9] CL_OUTPUT[1]触发ADC常规采样使能，高有效
#define ADC1_TRIG_CL_NT0_EN_BIT       BIT8  // [8] CL_OUTPUT[0]触发ADC常规采样使能，高有效
#define ADC1_TRIG_UTIMER1_CMP1_EN_BIT BIT7  // [7] TIMER1比较事件1触发ADC常规采样使能，高有效
#define ADC1_TRIG_UTIMER1_CMP0_EN_BIT BIT6  // [6] TIMER1比较事件0触发ADC常规采样使能，高有效
#define ADC1_TRIG_UTIMER0_CMP1_EN_BIT BIT5  // [5] TIMER0比较事件1触发ADC常规采样使能，高有效
#define ADC1_TRIG_UTIMER0_CMP0_EN_BIT BIT4  // [4] TIMER0比较事件0触发ADC常规采样使能，高有效
#define ADC1_TRIG_MCPWM0_T3_EN_BIT    BIT3  // [3] MCPWM0 T3事件触发ADC常规采样使能，高有效
#define ADC1_TRIG_MCPWM0_T2_EN_BIT    BIT2  // [2] MCPWM0 T2事件触发ADC常规采样使能，高有效
#define ADC1_TRIG_MCPWM0_T1_EN_BIT    BIT1  // [1] MCPWM0 T1事件触发ADC常规采样使能，高有效
#define ADC1_TRIG_MCPWM0_T0_EN_BIT    BIT0  // [0] MCPWM0 T0事件触发ADC常规采样使能，高有效

/* ADC1_SWT */
#define ADC1_SWT_SWT_POS  0                                              // ADC1_SWT_SWT起始位
#define ADC1_SWT_SWT_MASK (uint32_t)(0xFFFF << ADC1_SWT_SWT_POS)         // ADC1_SWT_SWT位掩码
#define ADC1_SWT_SWT(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_SWT_SWT_POS) // [15:0] 写入数据为0x5AA5时，产生一次常规触发

/* ADC1_DC0 */
#define ADC1_DC0_DC_OFFSET_POS  0                                                    // ADC1_DC0_DC_OFFSET起始位
#define ADC1_DC0_DC_OFFSET_MASK (uint32_t)(0xFFFF << ADC1_DC0_DC_OFFSET_POS)         // ADC1_DC0_DC_OFFSET位掩码
#define ADC1_DC0_DC_OFFSET(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DC0_DC_OFFSET_POS) // [15:0] ADC采样电路DC offset

/* ADC1_AMC0 */
#define ADC1_AMC0_AMC_POS  0                                              // ADC1_AMC0_AMC起始位
#define ADC1_AMC0_AMC_MASK (uint32_t)(0x3FF << ADC1_AMC0_AMC_POS)         // ADC1_AMC0_AMC位掩码
#define ADC1_AMC0_AMC(x)   (uint32_t)(((x) & 0x3FF) << ADC1_AMC0_AMC_POS) // [9:0] ADC 采样电路增益校正系数

/* ADC1_DC1 */
#define ADC1_DC1_DC_OFFSET_POS  0                                                    // ADC1_DC1_DC_OFFSET起始位
#define ADC1_DC1_DC_OFFSET_MASK (uint32_t)(0xFFFF << ADC1_DC1_DC_OFFSET_POS)         // ADC1_DC1_DC_OFFSET位掩码
#define ADC1_DC1_DC_OFFSET(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_DC1_DC_OFFSET_POS) // [15:0] ADC采样电路DC offset

/* ADC1_AMC1 */
#define ADC1_AMC1_AM_CALI_POS  0                                                  // ADC1_AMC1_AM_CALI起始位
#define ADC1_AMC1_AM_CALI_MASK (uint32_t)(0x3FF << ADC1_AMC1_AM_CALI_POS)         // ADC1_AMC1_AM_CALI位掩码
#define ADC1_AMC1_AM_CALI(x)   (uint32_t)(((x) & 0x3FF) << ADC1_AMC1_AM_CALI_POS) // [9:0] ADC 采样电路增益校正系数

/* ADC1_IE */
#define ADC1_IE_HERR_RE_BIT BIT14 // [14] 硬件触发发生在非空闲状态DMA请求使能
#define ADC1_IE_SERR_RE_BIT BIT13 // [13] 软件触发发生在非空闲状态DMA请求使能
#define ADC1_IE_AWD0_RE_BIT BIT10 // [10] 阈值监测0超限DMA请求使能
#define ADC1_IE_SF2_RE_BIT  BIT9  // [9] 第二段采样完成DMA请求使能
#define ADC1_IE_SF1_RE_BIT  BIT8  // [8] 第一段采样完成DMA请求使能
#define ADC1_IE_HERR_IE_BIT BIT6  // [6] 硬件触发发生在非空闲状态中断使能
#define ADC1_IE_SERR_IE_BIT BIT5  // [5] 软件触发发生在非空闲状态中断使能
#define ADC1_IE_AWD0_IE_BIT BIT2  // [2] 阈值监测0超限中断使能
#define ADC1_IE_SF2_IE_BIT  BIT1  // [1] 第二段常规采样完成中断使能
#define ADC1_IE_SF1_IE_BIT  BIT0  // [0] 第一段常规采样完成中断使能

/* ADC1_IF */
#define ADC1_IF_HERR_IF_BIT BIT6 // [6] 硬件触发发生在非空闲状态中断标志
#define ADC1_IF_SERR_IF_BIT BIT5 // [5] 软件触发发生在非空闲状态中断标志
#define ADC1_IF_AWD0_IF_BIT BIT2 // [2] 阈值监测0超限中断标志
#define ADC1_IF_SF2_IF_BIT  BIT1 // [1] 第二段常规采样完成中断标志
#define ADC1_IF_SF1_IF_BIT  BIT0 // [0] 第一段常规采样完成中断标志

/* ADC1_LTH */
#define ADC1_LTH_LTH_POS  0                                             // ADC1_LTH_LTH起始位
#define ADC1_LTH_LTH_MASK (uint32_t)(0xFFF << ADC1_LTH_LTH_POS)         // ADC1_LTH_LTH位掩码
#define ADC1_LTH_LTH(x)   (uint32_t)(((x) & 0xFFF) << ADC1_LTH_LTH_POS) // [11:0] ADC模拟看门狗0下阈值

/* ADC1_HTH */
#define ADC1_HTH_HTH_POS  0                                             // ADC1_HTH_HTH起始位
#define ADC1_HTH_HTH_MASK (uint32_t)(0xFFF << ADC1_HTH_HTH_POS)         // ADC1_HTH_HTH位掩码
#define ADC1_HTH_HTH(x)   (uint32_t)(((x) & 0xFFF) << ADC1_HTH_HTH_POS) // [11:0] ADC模拟看门狗0上阈值

/* ADC1_GEN */
#define ADC1_GEN_GEN_POS  0                                              // ADC1_GEN_GEN起始位
#define ADC1_GEN_GEN_MASK (uint32_t)(0xFFFF << ADC1_GEN_GEN_POS)         // ADC1_GEN_GEN位掩码
#define ADC1_GEN_GEN(x)   (uint32_t)(((x) & 0xFFFF) << ADC1_GEN_GEN_POS) // [15:0] ADC模拟看门狗0对应使能位 BIT0: DAT0看门狗监测使能 BIT1: DAT1看门狗监测使能 …… BIT13: DAT13看门狗监测使能 BIT14: IDAT0看门狗监测使能 BIT15: IDAT1看门狗监测使能

/* TIMER0_CFG0 TIMER0通道0配置寄存器 */
#define TIMER0_CFG0_TRIGGER_MODE_POS  9                                                       // TIMER0_CFG0_TRIGGER_MODE起始位
#define TIMER0_CFG0_TRIGGER_MODE_MASK (uint32_t)(0x3 << TIMER0_CFG0_TRIGGER_MODE_POS)         // TIMER0_CFG0_TRIGGER_MODE位掩码
#define TIMER0_CFG0_TRIGGER_MODE(x)   (uint32_t)(((x) & 0x3) << TIMER0_CFG0_TRIGGER_MODE_POS) // [10:9] 用于选择递增计数时触发还是递减计数的时候触发adc采样。默认值是0x0。 0x1:递增计数时触发 0x2:递减计数时触发 其他的值则意味着递增和递减时都能触发ADC采样
#define TIMER0_CFG0_CAP_CLR_EN_BIT    BIT8                                                    // [8] 当发生CAP捕获事件时，清零TIMERx_CNT，高有效
#define TIMER0_CFG0_SRC_POS           4                                                       // TIMER0_CFG0_SRC起始位
#define TIMER0_CFG0_SRC_MASK          (uint32_t)(0xF << TIMER0_CFG0_SRC_POS)                  // TIMER0_CFG0_SRC位掩码
#define TIMER0_CFG0_SRC(x)            (uint32_t)(((x) & 0xF) << TIMER0_CFG0_SRC_POS)          // [7:4] TIMER捕获模式通道0信号来源。默认为0x0。 0x0: TIMER通道0，来自芯片GPIO（参见Datasheet及应用配置） 0x1: TIMER通道1，来自芯片GPIO（参见Datasheet及应用配置） 0x2: CLU0输出 0x3: CLU1输出 0x4: CLU2输出 0x5: CLU3输出 0x6: 比较器0的输出 0x7: 比较器1的输出 0x9: TIMER通道0和1的异或 0xA: LRC时钟
#define TIMER0_CFG0_CH_POL_BIT        BIT3                                                    // [3] TIMER通道0在比较模式下的输出极性控制:当计数器CNT\<CMP0时的输出值。时的输出值。
#define TIMER0_CFG0_CH_MODE_BIT       BIT2                                                    // [2] TIMER通道0的工作模式选择，默认值为0。 0: 比较模式。输出方波，在TIMER通道0计数器计数值等于0或等于TIMER比较捕获寄存器值时，IO发生翻转。 1: 捕获模式。当TIMER通道0输入信号发生捕获事件时，将计数器计数值存入TIMER通道0比较捕获寄存器。
#define TIMER0_CFG0_CH_FE_CAP_EN_BIT  BIT1                                                    // [1] TIMER通道0下降沿捕获事件使能。1:使能；0:关闭。 TIMER通道0输入信号发生10跳变被视为捕获事件。下降沿事件使能可以与上升沿事件使能并存。
#define TIMER0_CFG0_CH_RE_CAP_EN_BIT  BIT0                                                    // [0] TIMER通道0上升沿捕获事件使能。1:使能；0:关闭。 TIMER通道0输入信号发生01跳变被视为捕获事件。上升沿事件使能可以与下降沿事件使能并存。

/* TIMER0_CFG1 TIMER0通道1配置寄存器 */
#define TIMER0_CFG1_TRIGGER_MODE_POS  9                                                       // TIMER0_CFG1_TRIGGER_MODE起始位
#define TIMER0_CFG1_TRIGGER_MODE_MASK (uint32_t)(0x3 << TIMER0_CFG1_TRIGGER_MODE_POS)         // TIMER0_CFG1_TRIGGER_MODE位掩码
#define TIMER0_CFG1_TRIGGER_MODE(x)   (uint32_t)(((x) & 0x3) << TIMER0_CFG1_TRIGGER_MODE_POS) // [10:9] 用于选择递增计数时触发还是递减计数的时候触发adc采样。默认值是0x0。 0x1:递增计数时触发 0x2:递减计数时触发 其他的值则意味着递增和递减时都能触发ADC采样
#define TIMER0_CFG1_CAP_CLR_EN_BIT    BIT8                                                    // [8] 当发生CAP1捕获事件时，清零TIMERx_CNT，高有效
#define TIMER0_CFG1_SRC_POS           4                                                       // TIMER0_CFG1_SRC起始位
#define TIMER0_CFG1_SRC_MASK          (uint32_t)(0xF << TIMER0_CFG1_SRC_POS)                  // TIMER0_CFG1_SRC位掩码
#define TIMER0_CFG1_SRC(x)            (uint32_t)(((x) & 0xF) << TIMER0_CFG1_SRC_POS)          // [7:4] TIMER捕获模式通道1信号来源。默认为0x1。 0x0: TIMER通道0，来自芯片GPIO（参见Datasheet及应用配置） 0x1: TIMER通道1，来自芯片GPIO（参见Datasheet及应用配置） 0x2: CLU0输出 0x3: CLU1输出 0x4: CLU2输出 0x5: CLU3输出 0x6: 比较器0的输出 0x7: 比较器1的输出 0x9: TIMER通道0和1的异或 0xA: LRC时钟
#define TIMER0_CFG1_CH_POL_BIT        BIT3                                                    // [3] TIMER通道1在比较模式下的输出极性控制，当计数器CNT\<CMP1时的输出值。
#define TIMER0_CFG1_CH_MODE_BIT       BIT2                                                    // [2] TIMER通道1的工作模式选择，默认值为0。 0: 比较模式。输出方波，在TIMER通道1计数器计数值等于0或等于TIMER比较捕获寄存器值时，IO发生翻转。 1: 捕获模式。当TIMER通道1输入信号发生捕获事件时，将计数器计数值存入TIMER通道1比较捕获寄存器。
#define TIMER0_CFG1_CH_FE_CAP_EN_BIT  BIT1                                                    // [1] TIMER通道1下降沿捕获事件使能。1:使能；0:关闭。 TIMER通道1输入信号发生10跳变被视为捕获事件。下降沿事件使能可以与上升沿事件使能并存。
#define TIMER0_CFG1_CH_RE_CAP_EN_BIT  BIT0                                                    // [0] TIMER通道1上升沿捕获事件使能。1:使能；0:关闭。 TIMER通道1输入信号发生01跳变被视为捕获事件。上升沿事件使能可以与下降沿事件使能并存。

/* TIMER0_CFG2 TIMER0配置寄存器2 */
#define TIMER0_CFG2_EN_BIT       BIT15                                              // [15] TIMER模块整体使能，高有效
#define TIMER0_CFG2_RTE_BIT      BIT14                                              // [14] 单次触发模式下是否可以在一个周期内再次触发 0:不使能再次触发，即一个单次计数周期内发生的单次触发信号被忽略； 1:使能再次触发，即一个单次计数周期内发生的单次触发信号会令TIMERx_CNT重置重新开始一个周期的计数
#define TIMER0_CFG2_CMP1TMIN_BIT BIT12                                              // [12] 当RL_EN=1时，使用CMP1作为TMIN。 TMIN为TIMER 最小计数值寄存器。只有当TIMERx_CNT\>= TMIN时，外部重置事件才会将TIMERx_CNT清零。如果TIMERx_CNT\< TMIN，则等到TIMERx_CNT= TMIN时TIMERx_CNT清零。
#define TIMER0_CFG2_SHADOW_BIT   BIT10                                              // [10] 0: 不启用影子寄存器，软件写入TH/CMP0/CMP1时直接更新对应的影子寄存器 1: 启用影子寄存器，软件写入TH/CMP0/CMP1时进仅仅更新预装载值，当TIMER发生过零事件时才将预装载值写入影子寄存器
#define TIMER0_CFG2_ONE_TRIG_BIT BIT9                                               // [9] 单次发送模式，此位需要在TIMER比较模式下使用，且EN需设置为0 ETON为0时，软件向ONE_TRIG写1触发TIMER发送一个周期的特定占空比的脉冲，TIMER计数一个周期后停止。此位在TIMER计数的当前周期内读为1，TIMER停止后，自动清零。 ETON为1时，即使软件配置ONE_TRIG=1，也需要等待外部事件触发，TIMER计数一个周期后停止。ONE_TRIG位在外部触发TIMER计数一个周期停止后不被硬件清零。
#define TIMER0_CFG2_CENTER_BIT   BIT8                                               // [8] 中心计数模式使能 0: TIMER向上从0计数至TH，然后回0，或TIMER向下从TH计数至0，然后回到TH 1: TIMER向上从0计数至TH，然后向下计数至0
#define TIMER0_CFG2_DIR_BIT      BIT7                                               // [7] 0: 0-\>TH递增计数，1:TH-\>递减计数 此位在CENTER=1时只读，用于指示当前计数方向
#define TIMER0_CFG2_CLK_DIV_POS  4                                                  // TIMER0_CFG2_CLK_DIV起始位
#define TIMER0_CFG2_CLK_DIV_MASK (uint32_t)(0x7 << TIMER0_CFG2_CLK_DIV_POS)         // TIMER0_CFG2_CLK_DIV位掩码
#define TIMER0_CFG2_CLK_DIV(x)   (uint32_t)(((x) & 0x7) << TIMER0_CFG2_CLK_DIV_POS) // [6:4] TIMERx_CNT频率配置，计数器计数频率是系统主时钟频率的2CLK_DIV分频。默认值为0，不分频。 0: 1分频 1: 2分频 2: 4分频 3: 8分频 4: 16分频 5: 32分频 6: 64分频 7: 128分频
#define TIMER0_CFG2_ETON_BIT     BIT3                                               // [3] TIMERx_CNT外部启动使能 0: 自动运行 1:等待外部事件触发计数，外部触发信号根据TIMER0_EVT.EVT_SRC进行选择 需要注意的是，使用外部触发也需要设置TIMERx_CFG.EN=1，除非是外部信号进行的单次触发，即TIMERx_CFG.ONE_TRIG=1。
#define TIMER0_CFG2_GATE_EN_BIT  BIT2                                               // [2] TIMER暂停使能 0:不暂停 1:当外部信号为低时，TIMER暂停计数，外部信号根据TIMERx_EVT.EVT_SRC进行选择
#define TIMER0_CFG2_RL_EN_BIT    BIT1                                               // [1] TIMER重装使能 0:禁用外部事件重装，TIMER向上计数至TH回0，或向下计数值0回到TH 1:使能外部事件重装，重装信号根据TIMER0_EVT.EVT_SRC进行选择，当向上计数时，发生外部事件，TIMER重装为0,；当向下计数时，发生外部事件，TIMER重装为TH。
#define TIMER0_CFG2_XCLK_EN_BIT  BIT0                                               // [0] TIMER 时钟源 0: 芯片内部时钟 1: 外部时钟，时钟源根据TIMER0_EVT.EVT_SRC进行选择，当使用外部时钟时，CLK_DIV不再起作用，即时钟不再进行分频

/* TIMER0_TH TIMER0门限寄存器 */
#define TIMER0_TH_TH_POS  0                                              // TIMER0_TH_TH起始位
#define TIMER0_TH_TH_MASK (uint32_t)(0xFFFF << TIMER0_TH_TH_POS)         // TIMER0_TH_TH位掩码
#define TIMER0_TH_TH(x)   (uint32_t)(((x) & 0xFFFF) << TIMER0_TH_TH_POS) // [15:0] TIMER 计数器计数门限。向上计数从0计数到TH值后回0，或向下计数从TH计数到0后回到TH

/* TIMER0_CNT TIMER0计数寄存器 */
#define TIMER0_CNT_CNT_POS  0                                                // TIMER0_CNT_CNT起始位
#define TIMER0_CNT_CNT_MASK (uint32_t)(0xFFFF << TIMER0_CNT_CNT_POS)         // TIMER0_CNT_CNT位掩码
#define TIMER0_CNT_CNT(x)   (uint32_t)(((x) & 0xFFFF) << TIMER0_CNT_CNT_POS) // [15:0] TIMER 0计数器当前计数值。写操作可以写入新的计数值。

/* TIMER0_CMP0 TIMER0通道0比较捕获寄存器 */
#define TIMER0_CMP0_CMP0_POS  0                                                  // TIMER0_CMP0_CMP0起始位
#define TIMER0_CMP0_CMP0_MASK (uint32_t)(0xFFFF << TIMER0_CMP0_CMP0_POS)         // TIMER0_CMP0_CMP0位掩码
#define TIMER0_CMP0_CMP0(x)   (uint32_t)(((x) & 0xFFFF) << TIMER0_CMP0_CMP0_POS) // [15:0] TIMER 通道0工作在比较模式时，当计数器计数值等于CMP0时，发生比较事件。 TIMER 通道0工作在捕获模式时，发生捕获事件时的计数器计数值存入CMP0寄存器。

/* TIMER0_CMP1 TIMER0通道1比较捕获寄存器 */
#define TIMER0_CMP1_CMP1_POS  0                                                  // TIMER0_CMP1_CMP1起始位
#define TIMER0_CMP1_CMP1_MASK (uint32_t)(0xFFFF << TIMER0_CMP1_CMP1_POS)         // TIMER0_CMP1_CMP1位掩码
#define TIMER0_CMP1_CMP1(x)   (uint32_t)(((x) & 0xFFFF) << TIMER0_CMP1_CMP1_POS) // [15:0] TIMER 通道1工作在比较模式时，当计数器计数值等于CMP1时，发生比较事件。 TIMER 通道1工作在捕获模式时，发生捕获事件时的计数器计数值存入CMP1寄存器。

/* TIMER0_EVT TIMER0外部事件选择寄存器 */
#define TIMER0_EVT_EVT_TH_POS   4                                                 // TIMER0_EVT_EVT_TH起始位
#define TIMER0_EVT_EVT_TH_MASK  (uint32_t)(0xF << TIMER0_EVT_EVT_TH_POS)          // TIMER0_EVT_EVT_TH位掩码
#define TIMER0_EVT_EVT_TH(x)    (uint32_t)(((x) & 0xF) << TIMER0_EVT_EVT_TH_POS)  // [7:4] 外部事件发生次数阈值，配合TIMERx_CFG.RL_EN使用。 外部事件发生EVT_TH次后产生效果（当EVT_TH=0时，1次即生效）。可配置的外部事件发生次数阈值范围是0~15。 特别地，当设置TIMERx_CFG.CMP1TMIN=1，且TIMERx_CNT\<TIMERx_CMP1时，即使此前发生的外部事件已达到EVT_TH设定次数，TIMERx_CNT重置也会延迟生效，即TIMERx_CNT会继续计数到TIMERx_CMP1后归零。此时TIMERx_CMP1作为重置最小计数值TMIN使用。 EVT_TH在一个TIMER周期后自动清零，即一个TIMER周期的外部事件不累积至下一个周期。
#define TIMER0_EVT_EVT_SRC_POS  0                                                 // TIMER0_EVT_EVT_SRC起始位
#define TIMER0_EVT_EVT_SRC_MASK (uint32_t)(0xF << TIMER0_EVT_EVT_SRC_POS)         // TIMER0_EVT_EVT_SRC位掩码
#define TIMER0_EVT_EVT_SRC(x)   (uint32_t)(((x) & 0xF) << TIMER0_EVT_EVT_SRC_POS) // [3:0] TIMER外部事件选择寄存器，本寄存器需要配合TIMER0_CFG.ETON，TIMER0_CFG.GATE_EN，TIMER0_CFG.RL_EN，TIMER0_CFG.XCLK_EN使用。 通常4个设置位不同时使用。 当设置ETON=1时，根据本寄存器选择触发TIMER计数的事件。 需要注意的是，TIMER自身的比较事件无法触发TIMER进行计数。当ETON=1时，触发信号的上升沿触发TIMER开始计数，用作触发源的TIMER需要工作在比较模式，无须从外部输入信号至TIMER通道 0:不可用 1:不可用 2:TIMER1 通道0比较/捕获事件 3:TIMER1 通道1比较/捕获事件 4:TIMER2 通道0比较/捕获事件 5:TIMER2 通道1比较/捕获事件 6:不可用 7:不可用 8:CLU0输出上升沿 9:CLU1输出上升沿 10:CLU2输出上升沿 11:CLU3输出上升沿 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件 当GATE_EN=1，且外部信号为高时TIMER计数，外部信号为低时，TIMER暂停，当GATE_EN=1时，TIMER使用对应外部信号的电平信号作为计数门控。GATE_EN仅支持配合0~11的外部事件使用，当EVT_SRC选择为0~7时，外部信号为TIMER通道输入信号经过对应TIMER滤波后的信号，作为门控信号的TIMER通道需要配置为输入使能 0:TIMER0 通道0滤波后输入信号 1:TIMER0 通道1滤波后输入信号 2:TIMER1 通道0滤波后输入信号 3:TIMER1 通道1滤波后输入信号 4:TIMER2 通道0滤波后输入信号 5:TIMER2 通道1滤波后输入信号 6:不可用 7:不可用 8:CLU0输出信号 9:CLU1输出信号 10:CLU2输出信号 11:CLU3输出信号 当RL_EN为高时，TIMER使用外部信号作为重装载信号 作为重装载信号的TIMER通道需要配置为输入使能 0:TIMER0 通道0比较/捕获事件 1:TIMER0 通道1比较/捕获事件 2:TIMER1 通道0比较/捕获事件 3:TIMER1 通道1比较/捕获事件 4:TIMER2 通道0比较/捕获事件 5:TIMER2 通道1比较/捕获事件 6:不可用 7:不可用 8:CLU0输出 9:CLU1输出 10:CLU2输出 11:CLU3输出 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件 当XCLK_EN为高时，TIMER使用外部信号作为TIMER外部时钟，TIMER在时钟上升沿进行计数动作。如果使用TIMER通道作为外部时钟，通道信号受到对应TIMER滤波设置影响。 0:TIMER0 通道0输入信号 1:TIMER0 通道1输入信号 2:TIMER1 通道0输入信号 3:TIMER1 通道1输入信号 4:TIMER2 通道0输入信号 5:TIMER2 通道1输入信号 6:不可用 7:不可用 8:CLU0输出 9:CLU1输出 10:CLU2输出 11:CLU3输出 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件

/* TIMER0_FLT TIMER0滤波控制寄存器 */
#define TIMER0_FLT_FLT_POS  0                                              // TIMER0_FLT_FLT起始位
#define TIMER0_FLT_FLT_MASK (uint32_t)(0xFF << TIMER0_FLT_FLT_POS)         // TIMER0_FLT_FLT位掩码
#define TIMER0_FLT_FLT(x)   (uint32_t)(((x) & 0xFF) << TIMER0_FLT_FLT_POS) // [7:0] 通道0/1信号滤波宽度选择。取值范围0~255。 FLT为0时，不对通道进行滤波。 FLT不为0时，对通道信号进行滤波:滤波宽度为FLT×8。当通道信号电平稳定超过FLT×8个系统时钟周期宽度时，滤波器输出更新；否则，滤波器保持当前的输出不变。

/* TIMER0_IE TIMER0中断使能寄存器 */
#define TIMER0_IE_FAIL_RE_BIT BIT11 // [11] TIMER FAIL事件 DMA请求使能，高电平有效。
#define TIMER0_IE_ZC_RE_BIT   BIT10 // [10] TIMER CNT过0 DMA请求使能，高电平有效。
#define TIMER0_IE_CH1_RE_BIT  BIT9  // [9] TIMER通道1比较/捕获 DMA请求使能，高电平有效。
#define TIMER0_IE_CH0_RE_BIT  BIT8  // [8] TIMER通道0比较/捕获 DMA请求使能，高电平有效。
#define TIMER0_IE_FAIL_IE_BIT BIT3  // [3] TIMER FAIL事件中断使能，高电平有效。
#define TIMER0_IE_ZC_IE_BIT   BIT2  // [2] TIMER CNT过0中断使能，高电平有效。
#define TIMER0_IE_CH1_IE_BIT  BIT1  // [1] TIMER通道1比较/捕获中断使能，高电平有效。
#define TIMER0_IE_CH0_IE_BIT  BIT0  // [0] TIMER通道0比较/捕获中断使能，高电平有效。

/* TIMER0_IF TIMER0中断标志寄存器 */
#define TIMER0_IF_FAIL_IF_BIT BIT3 // [3] TIMER Fail事件中断标志。高电平有效，写1清0
#define TIMER0_IF_ZC_IF_BIT   BIT2 // [2] TIMER CNT过0中断标志。高电平有效，写1清0
#define TIMER0_IF_CH1_IF_BIT  BIT1 // [1] TIMER通道1比较/捕获中断标志。高电平有效，写1清0
#define TIMER0_IF_CH0_IF_BIT  BIT0 // [0] TIMER通道0比较/捕获中断标志。高电平有效，写1清0

/* TIMER0_IO TIMER0 IO控制寄存器 */
#define TIMER0_IO_CH1_DEFAULT_BIT BIT9 // [9] 发生Fail事件MOE清零后，CH1通道输出值
#define TIMER0_IO_CH0_DEFAULT_BIT BIT8 // [8] 发生Fail事件MOE清零后，CH0通道输出值
#define TIMER0_IO_HALT_PRT_BIT    BIT7 // [7] MCU进入HALT状态，TIMER输出值选择。 1:正常输出；0:输出CH1_DEFAULT和CH0_DEFAULT。
#define TIMER0_IO_MOE_BIT         BIT6 // [6] TIMER通道0/1输出使能 1:输出正常信号 0:输出CH0_DEFAULT和CH1_DEFAULT默认值 TIMER0_IF.FAIL_IF变1将触发MOE变成0，通道输出默认值。 若要恢复输出正常信号，需要先将FAIL_IF清零，然后软件设置MOE=1。无论TIMER工作在何种模式下，只有在MOE置为1之后，TIMER通道0/1才能输出正常信号。
#define TIMER0_IO_FAIL_SEL_BIT    BIT2 // [2] FAIL信号选择 0:TIMER0_FAIL，来自GPIO 1:CLU0输出
#define TIMER0_IO_FAIL_POL_BIT    BIT1 // [1] FAIL信号极性 0:高电平FAIL 1:低电平FAIL
#define TIMER0_IO_FAIL_EN_BIT     BIT0 // [0] FAIL信号使能 0:禁用FAIL 1:使能FAIL

/* TIMER1_CFG0 TIMER1通道0配置寄存器 */
#define TIMER1_CFG0_TRIGGER_MODE_POS  9                                                       // TIMER1_CFG0_TRIGGER_MODE起始位
#define TIMER1_CFG0_TRIGGER_MODE_MASK (uint32_t)(0x3 << TIMER1_CFG0_TRIGGER_MODE_POS)         // TIMER1_CFG0_TRIGGER_MODE位掩码
#define TIMER1_CFG0_TRIGGER_MODE(x)   (uint32_t)(((x) & 0x3) << TIMER1_CFG0_TRIGGER_MODE_POS) // [10:9] 用于选择递增计数时触发还是递减计数的时候触发adc采样。默认值是0x0。 0x1:递增计数时触发 0x2:递减计数时触发 其他的值则意味着递增和递减时都能触发ADC采样
#define TIMER1_CFG0_CAP_CLR_EN_BIT    BIT8                                                    // [8] 当发生CAP捕获事件时，清零TIMERx_CNT，高有效
#define TIMER1_CFG0_SRC_POS           4                                                       // TIMER1_CFG0_SRC起始位
#define TIMER1_CFG0_SRC_MASK          (uint32_t)(0xF << TIMER1_CFG0_SRC_POS)                  // TIMER1_CFG0_SRC位掩码
#define TIMER1_CFG0_SRC(x)            (uint32_t)(((x) & 0xF) << TIMER1_CFG0_SRC_POS)          // [7:4] TIMER捕获模式通道0信号来源。默认为0x0。 0x0: TIMER通道0，来自芯片GPIO（参见Datasheet及应用配置） 0x1: TIMER通道1，来自芯片GPIO（参见Datasheet及应用配置） 0x2: CLU0输出 0x3: CLU1输出 0x4: CLU2输出 0x5: CLU3输出 0x6: 比较器0的输出 0x7: 比较器1的输出 0x9: TIMER通道0和1的异或 0xA: LRC时钟
#define TIMER1_CFG0_CH_POL_BIT        BIT3                                                    // [3] TIMER通道0在比较模式下的输出极性控制:当计数器TIMERx_CNT\<TIMERx_CMP0时的输出值。时的输出值。
#define TIMER1_CFG0_CH_MODE_BIT       BIT2                                                    // [2] TIMER通道0的工作模式选择，默认值为0。 0: 比较模式。输出方波，在TIMER通道0计数器计数值等于0或等于TIMER比较捕获寄存器值时，IO发生翻转。 1: 捕获模式。当TIMER通道0输入信号发生捕获事件时，将计数器计数值存入TIMER通道0比较捕获寄存器。
#define TIMER1_CFG0_CH_FE_CAP_EN_BIT  BIT1                                                    // [1] TIMER通道0下降沿捕获事件使能。1:使能；0:关闭。 TIMER通道0输入信号发生10跳变被视为捕获事件。下降沿事件使能可以与上升沿事件使能并存。
#define TIMER1_CFG0_CH_RE_CAP_EN_BIT  BIT0                                                    // [0] TIMER通道0上升沿捕获事件使能。1:使能；0:关闭。 TIMER通道0输入信号发生01跳变被视为捕获事件。上升沿事件使能可以与下降沿事件使能并存。

/* TIMER1_CFG1 TIMER1通道1配置寄存器 */
#define TIMER1_CFG1_TRIGGER_MODE_POS  9                                                       // TIMER1_CFG1_TRIGGER_MODE起始位
#define TIMER1_CFG1_TRIGGER_MODE_MASK (uint32_t)(0x3 << TIMER1_CFG1_TRIGGER_MODE_POS)         // TIMER1_CFG1_TRIGGER_MODE位掩码
#define TIMER1_CFG1_TRIGGER_MODE(x)   (uint32_t)(((x) & 0x3) << TIMER1_CFG1_TRIGGER_MODE_POS) // [10:9] 用于选择递增计数时触发还是递减计数的时候触发adc采样。默认值是0x0。 0x1:递增计数时触发 0x2:递减计数时触发 其他的值则意味着递增和递减时都能触发ADC采样
#define TIMER1_CFG1_CAP_CLR_EN_BIT    BIT8                                                    // [8] 当发生CAP1捕获事件时，清零TIMERx_CNT，高有效
#define TIMER1_CFG1_SRC_POS           4                                                       // TIMER1_CFG1_SRC起始位
#define TIMER1_CFG1_SRC_MASK          (uint32_t)(0xF << TIMER1_CFG1_SRC_POS)                  // TIMER1_CFG1_SRC位掩码
#define TIMER1_CFG1_SRC(x)            (uint32_t)(((x) & 0xF) << TIMER1_CFG1_SRC_POS)          // [7:4] TIMER捕获模式通道1信号来源。默认为0x1。 0x0: TIMER通道0，来自芯片GPIO（参见Datasheet及应用配置） 0x1: TIMER通道1，来自芯片GPIO（参见Datasheet及应用配置） 0x2: CLU0输出 0x3: CLU1输出 0x4: CLU2输出 0x5: CLU3输出 0x6: 比较器0的输出 0x7: 比较器1的输出 0x9: TIMER通道0和1的异或 0xA: LRC时钟
#define TIMER1_CFG1_CH_POL_BIT        BIT3                                                    // [3] TIMER通道1在比较模式下的输出极性控制，当计数器CNT\<CMP1时的输出值。
#define TIMER1_CFG1_CH_MODE_BIT       BIT2                                                    // [2] TIMER通道1的工作模式选择，默认值为0。 0: 比较模式。输出方波，在TIMER通道1计数器计数值等于0或等于TIMER比较捕获寄存器值时，IO发生翻转。 1: 捕获模式。当TIMER通道1输入信号发生捕获事件时，将计数器计数值存入TIMER通道1比较捕获寄存器。
#define TIMER1_CFG1_CH_FE_CAP_EN_BIT  BIT1                                                    // [1] TIMER通道1下降沿捕获事件使能。1:使能；0:关闭。 TIMER通道1输入信号发生10跳变被视为捕获事件。下降沿事件使能可以与上升沿事件使能并存。
#define TIMER1_CFG1_CH_RE_CAP_EN_BIT  BIT0                                                    // [0] TIMER通道1上升沿捕获事件使能。1:使能；0:关闭。 TIMER通道1输入信号发生01跳变被视为捕获事件。上升沿事件使能可以与下降沿事件使能并存。

/* TIMER1_CFG2 TIMER1配置寄存器2 */
#define TIMER1_CFG2_EN_BIT       BIT15                                              // [15] TIMER模块整体使能，高有效
#define TIMER1_CFG2_RTE_BIT      BIT14                                              // [14] 单次触发模式下是否可以在一个周期内再次触发 0:不使能再次触发，即一个单次计数周期内发生的单次触发信号被忽略； 1:使能再次触发，即一个单次计数周期内发生的单次触发信号会令TIMERx_CNT重置重新开始一个周期的计数
#define TIMER1_CFG2_CMP1TMIN_BIT BIT12                                              // [12] 当RL_EN=1时，使用CMP1作为TMIN。 TMIN为TIMER 最小计数值寄存器。只有当TIMERx_CNT\>= TMIN时，外部重置事件才会将TIMERx_CNT清零。如果TIMERx_CNT\< TMIN，则等到TIMERx_CNT= TMIN时TIMERx_CNT清零。
#define TIMER1_CFG2_SHADOW_BIT   BIT10                                              // [10] 0: 不启用影子寄存器，软件写入TH/CMP0/CMP1时直接更新对应的影子寄存器 1: 启用影子寄存器，软件写入TH/CMP0/CMP1时进仅仅更新预装载值，当TIMER发生过零事件时才将预装载值写入影子寄存器
#define TIMER1_CFG2_ONE_TRIG_BIT BIT9                                               // [9] 单次发送模式，此位需要在TIMER比较模式下使用，且EN需设置为0 ETON为0时，软件向ONE_TRIG写1触发TIMER发送一个周期的特定占空比的脉冲，TIMER计数一个周期后停止。此位在TIMER计数的当前周期内读为1，TIMER停止后，自动清零。 ETON为1时，即使软件配置ONE_TRIG=1，也需要等待外部事件触发，TIMER计数一个周期后停止。ONE_TRIG位在外部触发TIMER计数一个周期停止后不被硬件清零。
#define TIMER1_CFG2_CENTER_BIT   BIT8                                               // [8] 中心计数模式使能 0: TIMER向上从0计数至TH，然后回0，或TIMER向下从TH计数至0，然后回到TH 1: TIMER向上从0计数至TH，然后向下计数至0
#define TIMER1_CFG2_DIR_BIT      BIT7                                               // [7] 0: 0-\>TH递增计数，1:TH-\>递减计数 此位在CENTER=1时只读，用于指示当前计数方向
#define TIMER1_CFG2_CLK_DIV_POS  4                                                  // TIMER1_CFG2_CLK_DIV起始位
#define TIMER1_CFG2_CLK_DIV_MASK (uint32_t)(0x7 << TIMER1_CFG2_CLK_DIV_POS)         // TIMER1_CFG2_CLK_DIV位掩码
#define TIMER1_CFG2_CLK_DIV(x)   (uint32_t)(((x) & 0x7) << TIMER1_CFG2_CLK_DIV_POS) // [6:4] TIMERx_CNT频率配置，计数器计数频率是系统主时钟频率的2CLK_DIV分频。默认值为0，不分频。 0: 1分频 1: 2分频 2: 4分频 3: 8分频 4: 16分频 5: 32分频 6: 64分频 7: 128分频
#define TIMER1_CFG2_ETON_BIT     BIT3                                               // [3] TIMERx_CNT外部启动使能 0: 自动运行 1:等待外部事件触发计数，外部触发信号根据TIMERx_EVT.EVT_SRC进行选择 需要注意的是，使用外部触发也需要设置TIMERx_CFG.EN=1，除非是外部信号进行的单次触发，即TIMERx_CFG.ONE_TRIG=1。
#define TIMER1_CFG2_GATE_EN_BIT  BIT2                                               // [2] TIMER暂停使能 0:不暂停 1:当外部信号为低时，TIMER暂停计数，外部信号根据TIMERx_EVT.EVT_SRC进行选择
#define TIMER1_CFG2_RL_EN_BIT    BIT1                                               // [1] TIMER重装使能 0:禁用外部事件重装，TIMER向上计数至TH回0，或向下计数值0回到TH 1:使能外部事件重装，重装信号根据TIMERx_EVT.EVT_SRC进行选择，当向上计数时，发生外部事件，TIMER重装为0,；当向下计数时，发生外部事件，TIMER重装为TH。
#define TIMER1_CFG2_XCLK_EN_BIT  BIT0                                               // [0] TIMER 时钟源 0: 芯片内部时钟 1: 外部时钟，时钟源根据TIMER0_EVT.EVT_SRC进行选择，当使用外部时钟时，CLK_DIV不再起作用，即时钟不再进行分频

/* TIMER1_TH TIMER1门限寄存器 */
#define TIMER1_TH_TH_POS  0                                              // TIMER1_TH_TH起始位
#define TIMER1_TH_TH_MASK (uint32_t)(0xFFFF << TIMER1_TH_TH_POS)         // TIMER1_TH_TH位掩码
#define TIMER1_TH_TH(x)   (uint32_t)(((x) & 0xFFFF) << TIMER1_TH_TH_POS) // [15:0] TIMER 计数器计数门限。向上计数从0计数到TH值后回0，或向下计数从TH计数到0后回到TH

/* TIMER1_CNT TIMER1计数寄存器 */
#define TIMER1_CNT_CNT_POS  0                                                // TIMER1_CNT_CNT起始位
#define TIMER1_CNT_CNT_MASK (uint32_t)(0xFFFF << TIMER1_CNT_CNT_POS)         // TIMER1_CNT_CNT位掩码
#define TIMER1_CNT_CNT(x)   (uint32_t)(((x) & 0xFFFF) << TIMER1_CNT_CNT_POS) // [15:0] TIMER 0计数器当前计数值。写操作可以写入新的计数值。

/* TIMER1_CMP0 TIMER1通道0比较捕获寄存器 */
#define TIMER1_CMP0_CMP0_POS  0                                                  // TIMER1_CMP0_CMP0起始位
#define TIMER1_CMP0_CMP0_MASK (uint32_t)(0xFFFF << TIMER1_CMP0_CMP0_POS)         // TIMER1_CMP0_CMP0位掩码
#define TIMER1_CMP0_CMP0(x)   (uint32_t)(((x) & 0xFFFF) << TIMER1_CMP0_CMP0_POS) // [15:0] TIMER 通道0工作在比较模式时，当计数器计数值等于CMP0时，发生比较事件。 TIMER 通道0工作在捕获模式时，发生捕获事件时的计数器计数值存入CMP0寄存器。

/* TIMER1_CMP1 TIMER1通道1比较捕获寄存器 */
#define TIMER1_CMP1_CMP1_POS  0                                                  // TIMER1_CMP1_CMP1起始位
#define TIMER1_CMP1_CMP1_MASK (uint32_t)(0xFFFF << TIMER1_CMP1_CMP1_POS)         // TIMER1_CMP1_CMP1位掩码
#define TIMER1_CMP1_CMP1(x)   (uint32_t)(((x) & 0xFFFF) << TIMER1_CMP1_CMP1_POS) // [15:0] TIMER 通道1工作在比较模式时，当计数器计数值等于CMP1时，发生比较事件。 TIMER 通道1工作在捕获模式时，发生捕获事件时的计数器计数值存入CMP1寄存器。

/* TIMER1_EVT TIMER1外部事件选择寄存器 */
#define TIMER1_EVT_EVT_TH_POS   4                                                 // TIMER1_EVT_EVT_TH起始位
#define TIMER1_EVT_EVT_TH_MASK  (uint32_t)(0xF << TIMER1_EVT_EVT_TH_POS)          // TIMER1_EVT_EVT_TH位掩码
#define TIMER1_EVT_EVT_TH(x)    (uint32_t)(((x) & 0xF) << TIMER1_EVT_EVT_TH_POS)  // [7:4] 外部事件发生次数阈值，配合TIMERx_CFG.RL_EN使用。 外部事件发生EVT_TH次后产生效果（当EVT_TH=0时，1次即生效）。可配置的外部事件发生次数阈值范围是0~15。 特别地，当设置TIMERx_CFG.CMP1TMIN=1，且TIMERx_CNT\<TIMERx_CMP1时，即使此前发生的外部事件已达到EVT_TH设定次数，TIMERx_CNT重置也会延迟生效，即TIMERx_CNT会继续计数到TIMERx_CMP1后归零。此时TIMERx_CMP1作为重置最小计数值TMIN使用。 EVT_TH在一个TIMER周期后自动清零，即一个TIMER周期的外部事件不累积至下一个周期。
#define TIMER1_EVT_EVT_SRC_POS  0                                                 // TIMER1_EVT_EVT_SRC起始位
#define TIMER1_EVT_EVT_SRC_MASK (uint32_t)(0xF << TIMER1_EVT_EVT_SRC_POS)         // TIMER1_EVT_EVT_SRC位掩码
#define TIMER1_EVT_EVT_SRC(x)   (uint32_t)(((x) & 0xF) << TIMER1_EVT_EVT_SRC_POS) // [3:0] TIMER外部事件选择寄存器，本寄存器需要配合TIMER1_CFG.ETON，TIMER1_CFG.GATE_EN，TIMER1_CFG.RL_EN，TIMER1_CFG.XCLK_EN使用。 通常4个设置位不同时使用。 当设置ETON=1时，根据本寄存器选择触发TIMER计数的事件。 需要注意的是，TIMER自身的比较事件无法触发TIMER进行计数。当ETON=1时，触发信号的上升沿触发TIMER开始计数，用作触发源的TIMER需要工作在比较模式，无须从外部输入信号至TIMER通道 0:TIMER0 通道0比较/捕获事件 1:TIMER0 通道1比较/捕获事件 2:不可用 3:不可用 4:TIMER2 通道0比较/捕获事件 5:TIMER2 通道1比较/捕获事件 6:不可用 7:不可用 8:CLU0输出上升沿 9:CLU1输出上升沿 10:CLU2输出上升沿 11:CLU3输出上升沿 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件 当GATE_EN=1，且外部信号为高时TIMER计数，外部信号为低时，TIMER暂停，当GATE_EN=1时，TIMER使用对应外部信号的电平信号作为计数门控。GATE_EN仅支持配合0~11的外部事件使用，当EVT_SRC选择为0~7时，外部信号为TIMER通道输入信号经过对应TIMER滤波后的信号，作为门控信号的TIMER通道需要配置为输入使能 0:TIMER0 通道0滤波后输入信号 1:TIMER0 通道1滤波后输入信号 2:TIMER1 通道0滤波后输入信号 3:TIMER1 通道1滤波后输入信号 4:TIMER2 通道0滤波后输入信号 5:TIMER2 通道1滤波后输入信号 6:CLU0输出信号 7:CLU1输出信号 8:CLU2输出信号 9:CLU3输出信号 当RL_EN为高时，TIMER使用外部信号作为重装载信号 作为重装载信号的TIMER通道需要配置为输入使能 0:TIMER0 通道0比较/捕获事件 1:TIMER0 通道1比较/捕获事件 2:TIMER1 通道0比较/捕获事件 3:TIMER1 通道1比较/捕获事件 4:TIMER2 通道0比较/捕获事件 5:TIMER2 通道1比较/捕获事件 6:CLU0输出 7:CLU1输出 8:CLU2输出 9:CLU3输出 10:MCPWM TADC[0]比较事件 11:MCPWM TADC[1]比较事件 12:MCPWM TADC[2]比较事件 13:MCPWM TADC[3]比较事件 当XCLK_EN为高时，TIMER使用外部信号作为TIMER外部时钟，TIMER在时钟上升沿进行计数动作。如果使用TIMER通道作为外部时钟，通道信号受到对应TIMER滤波设置影响。 0:TIMER0 通道0输入信号 1:TIMER0 通道1输入信号 2:TIMER1 通道0输入信号 3:TIMER1 通道1输入信号 4:TIMER2 通道0输入信号 5:TIMER2 通道1输入信号 6:CLU0输出 7:CLU1输出 8:CLU2输出 9:CLU3输出 10:MCPWM TADC[0]比较事件 11:MCPWM TADC[1]比较事件 12:MCPWM TADC[2]比较事件 13:MCPWM TADC[3]比较事件

/* TIMER1_FLT TIMER1滤波控制寄存器 */
#define TIMER1_FLT_FLT_POS  0                                              // TIMER1_FLT_FLT起始位
#define TIMER1_FLT_FLT_MASK (uint32_t)(0xFF << TIMER1_FLT_FLT_POS)         // TIMER1_FLT_FLT位掩码
#define TIMER1_FLT_FLT(x)   (uint32_t)(((x) & 0xFF) << TIMER1_FLT_FLT_POS) // [7:0] 通道0/1信号滤波宽度选择。取值范围0~255。 FLT为0时，不对通道进行滤波。 FLT不为0时，对通道信号进行滤波:滤波宽度为FLT×8。当通道信号电平稳定超过FLT×8个系统时钟周期宽度时，滤波器输出更新；否则，滤波器保持当前的输出不变。

/* TIMER1_IE TIMER1中断使能寄存器 */
#define TIMER1_IE_FAIL_RE_BIT BIT11 // [11] TIMER FAIL事件 DMA请求使能，高电平有效。
#define TIMER1_IE_ZC_RE_BIT   BIT10 // [10] TIMER CNT过0 DMA请求使能，高电平有效。
#define TIMER1_IE_CH1_RE_BIT  BIT9  // [9] TIMER通道1比较/捕获 DMA请求使能，高电平有效。
#define TIMER1_IE_CH0_RE_BIT  BIT8  // [8] TIMER通道0比较/捕获 DMA请求使能，高电平有效。
#define TIMER1_IE_FAIL_IE_BIT BIT3  // [3] TIMER FAIL事件中断使能，高电平有效。
#define TIMER1_IE_ZC_IE_BIT   BIT2  // [2] TIMER CNT过0中断使能，高电平有效。
#define TIMER1_IE_CH1_IE_BIT  BIT1  // [1] TIMER通道1比较/捕获中断使能，高电平有效。
#define TIMER1_IE_CH0_IE_BIT  BIT0  // [0] TIMER通道0比较/捕获中断使能，高电平有效。

/* TIMER1_IF TIMER1中断标志寄存器 */
#define TIMER1_IF_FAIL_IF_BIT BIT3 // [3] TIMER Fail事件中断标志。高电平有效，写1清0
#define TIMER1_IF_ZC_IF_BIT   BIT2 // [2] TIMER CNT过0中断标志。高电平有效，写1清0
#define TIMER1_IF_CH1_IF_BIT  BIT1 // [1] TIMER通道1比较/捕获中断标志。高电平有效，写1清0
#define TIMER1_IF_CH0_IF_BIT  BIT0 // [0] TIMER通道0比较/捕获中断标志。高电平有效，写1清0

/* TIMER1_IO TIMER1 IO控制寄存器 */
#define TIMER1_IO_CH1_DEFAULT_BIT BIT9 // [9] 发生Fail事件MOE清零后，CH1通道输出值
#define TIMER1_IO_CH0_DEFAULT_BIT BIT8 // [8] 发生Fail事件MOE清零后，CH0通道输出值
#define TIMER1_IO_HALT_PRT_BIT    BIT7 // [7] MCU进入HALT状态，TIMER输出值选择。 1:正常输出；0:输出CH1_DEFAULT和CH0_DEFAULT。
#define TIMER1_IO_MOE_BIT         BIT6 // [6] TIMER通道0/1输出使能 1:输出正常信号 0:输出CH0_DEFAULT和CH1_DEFAULT默认值 TIMER0_IF.FAIL_IF变1将触发MOE变成0，通道输出默认值。 若要恢复输出正常信号，需要先将FAIL_IF清零，然后软件设置MOE=1。无论TIMER工作在何种模式下，只有在MOE置为1之后，TIMER通道0/1才能输出正常信号。
#define TIMER1_IO_FAIL_SEL_BIT    BIT2 // [2] FAIL信号选择 0:TIMER0_FAIL，来自GPIO 1:CLU0输出
#define TIMER1_IO_FAIL_POL_BIT    BIT1 // [1] FAIL信号极性 0:高电平FAIL 1:低电平FAIL
#define TIMER1_IO_FAIL_EN_BIT     BIT0 // [0] FAIL信号使能 0:禁用FAIL 1:使能FAIL

/* TIMER2_CFG0 TIMER2通道0配置寄存器 */
#define TIMER2_CFG0_TRIGGER_MODE_POS  9                                                       // TIMER2_CFG0_TRIGGER_MODE起始位
#define TIMER2_CFG0_TRIGGER_MODE_MASK (uint32_t)(0x3 << TIMER2_CFG0_TRIGGER_MODE_POS)         // TIMER2_CFG0_TRIGGER_MODE位掩码
#define TIMER2_CFG0_TRIGGER_MODE(x)   (uint32_t)(((x) & 0x3) << TIMER2_CFG0_TRIGGER_MODE_POS) // [10:9] 用于选择递增计数时触发还是递减计数的时候触发adc采样。默认值是0x0。 0x1:递增计数时触发 0x2:递减计数时触发 其他的值则意味着递增和递减时都能触发ADC采样
#define TIMER2_CFG0_CAP_CLR_EN_BIT    BIT8                                                    // [8] 当发生CAP捕获事件时，清零TIMERx_CNT，高有效
#define TIMER2_CFG0_SRC_POS           4                                                       // TIMER2_CFG0_SRC起始位
#define TIMER2_CFG0_SRC_MASK          (uint32_t)(0xF << TIMER2_CFG0_SRC_POS)                  // TIMER2_CFG0_SRC位掩码
#define TIMER2_CFG0_SRC(x)            (uint32_t)(((x) & 0xF) << TIMER2_CFG0_SRC_POS)          // [7:4] TIMER捕获模式通道0信号来源。默认为0x0。 0x0: TIMER通道0，来自芯片GPIO（参见Datasheet及应用配置） 0x1: TIMER通道1，来自芯片GPIO（参见Datasheet及应用配置） 0x2: CLU0输出 0x3: CLU1输出 0x4: CLU2输出 0x5: CLU3输出 0x6: 比较器0的输出 0x7: 比较器1的输出 0x9: TIMER通道0和1的异或 0xA: LRC时钟
#define TIMER2_CFG0_CH_POL_BIT        BIT3                                                    // [3] TIMER通道0在比较模式下的输出极性控制:当计数器CNT\<CMP0时的输出值。时的输出值。
#define TIMER2_CFG0_CH_MODE_BIT       BIT2                                                    // [2] TIMER通道0的工作模式选择，默认值为0。 0: 比较模式。输出方波，在TIMER通道0计数器计数值等于0或等于TIMER比较捕获寄存器值时，IO发生翻转。 1: 捕获模式。当TIMER通道0输入信号发生捕获事件时，将计数器计数值存入TIMER通道0比较捕获寄存器。
#define TIMER2_CFG0_CH_FE_CAP_EN_BIT  BIT1                                                    // [1] TIMER通道0下降沿捕获事件使能。1:使能；0:关闭。 TIMER通道0输入信号发生10跳变被视为捕获事件。下降沿事件使能可以与上升沿事件使能并存。
#define TIMER2_CFG0_CH_RE_CAP_EN_BIT  BIT0                                                    // [0] TIMER通道0上升沿捕获事件使能。1:使能；0:关闭。 TIMER通道0输入信号发生01跳变被视为捕获事件。上升沿事件使能可以与下降沿事件使能并存。

/* TIMER2_CFG1 TIMER2通道1配置寄存器 */
#define TIMER2_CFG1_CAP_CLR_EN_BIT   BIT8                                           // [8] 当发生CAP1捕获事件时，清零TIMERx_CNT，高有效
#define TIMER2_CFG1_SRC_POS          4                                              // TIMER2_CFG1_SRC起始位
#define TIMER2_CFG1_SRC_MASK         (uint32_t)(0xF << TIMER2_CFG1_SRC_POS)         // TIMER2_CFG1_SRC位掩码
#define TIMER2_CFG1_SRC(x)           (uint32_t)(((x) & 0xF) << TIMER2_CFG1_SRC_POS) // [7:4] TIMER捕获模式通道1信号来源。默认为0x1。 0x0: TIMER通道0，来自芯片GPIO（参见Datasheet及应用配置） 0x1: TIMER通道1，来自芯片GPIO（参见Datasheet及应用配置） 0x2: CLU0输出 0x3: CLU1输出 0x4: CLU2输出 0x5: CLU3输出 0x6: 比较器0的输出 0x7: 比较器1的输出 0x9: TIMER通道0和1的异或 0xA: LRC时钟
#define TIMER2_CFG1_CH_POL_BIT       BIT3                                           // [3] TIMER通道1在比较模式下的输出极性控制，当计数器CNT\<CMP1时的输出值。
#define TIMER2_CFG1_CH_MODE_BIT      BIT2                                           // [2] TIMER通道1的工作模式选择，默认值为0。 0: 比较模式。输出方波，在TIMER通道1计数器计数值等于0或等于TIMER比较捕获寄存器值时，IO发生翻转。 1: 捕获模式。当TIMER通道1输入信号发生捕获事件时，将计数器计数值存入TIMER通道1比较捕获寄存器。
#define TIMER2_CFG1_CH_FE_CAP_EN_BIT BIT1                                           // [1] TIMER通道1下降沿捕获事件使能。1:使能；0:关闭。 TIMER通道1输入信号发生10跳变被视为捕获事件。下降沿事件使能可以与上升沿事件使能并存。
#define TIMER2_CFG1_CH_RE_CAP_EN_BIT BIT0                                           // [0] TIMER通道1上升沿捕获事件使能。1:使能；0:关闭。 TIMER通道1输入信号发生01跳变被视为捕获事件。上升沿事件使能可以与下降沿事件使能并存。

/* TIMER2_CFG2 TIMER2配置寄存器2 */
#define TIMER2_CFG2_EN_BIT       BIT15                                              // [15] TIMER模块整体使能，高有效
#define TIMER2_CFG2_RTE_BIT      BIT14                                              // [14] 单次触发模式下是否可以在一个周期内再次触发 0:不使能再次触发，即一个单次计数周期内发生的单次触发信号被忽略； 1:使能再次触发，即一个单次计数周期内发生的单次触发信号会令TIMERx_CNT重置重新开始一个周期的计数
#define TIMER2_CFG2_CMP1TMIN_BIT BIT12                                              // [12] 当RL_EN=1时，使用CMP1作为TMIN。 TMIN为TIMER 最小计数值寄存器。只有当TIMERx_CNT\>= TMIN时，外部重置事件才会将TIMERx_CNT清零。如果TIMERx_CNT\< TMIN，则等到TIMERx_CNT= TMIN时TIMERx_CNT清零。
#define TIMER2_CFG2_ONE_TRIG_BIT BIT9                                               // [9] 单次发送模式，此位需要在TIMER比较模式下使用，且EN需设置为0 ETON为0时，软件向ONE_TRIG写1触发TIMER发送一个周期的特定占空比的脉冲，TIMER计数一个周期后停止。此位在TIMER计数的当前周期内读为1，TIMER停止后，自动清零。 ETON为1时，即使软件配置ONE_TRIG=1，也需要等待外部事件触发，TIMER计数一个周期后停止。ONE_TRIG位在外部触发TIMER计数一个周期停止后不被硬件清零。
#define TIMER2_CFG2_CENTER_BIT   BIT8                                               // [8] 中心计数模式使能 0: TIMER向上从0计数至TH，然后回0，或TIMER向下从TH计数至0，然后回到TH 1: TIMER向上从0计数至TH，然后向下计数至0
#define TIMER2_CFG2_DIR_BIT      BIT7                                               // [7] 0: 0-\>TH递增计数，1:TH-\>递减计数 此位在CENTER=1时只读，用于指示当前计数方向
#define TIMER2_CFG2_CLK_DIV_POS  4                                                  // TIMER2_CFG2_CLK_DIV起始位
#define TIMER2_CFG2_CLK_DIV_MASK (uint32_t)(0x7 << TIMER2_CFG2_CLK_DIV_POS)         // TIMER2_CFG2_CLK_DIV位掩码
#define TIMER2_CFG2_CLK_DIV(x)   (uint32_t)(((x) & 0x7) << TIMER2_CFG2_CLK_DIV_POS) // [6:4] TIMERx_CNT频率配置，计数器计数频率是系统主时钟频率的2CLK_DIV分频。默认值为0，不分频。 0: 1分频 1: 2分频 2: 4分频 3: 8分频 4: 16分频 5: 32分频 6: 64分频 7: 128分频
#define TIMER2_CFG2_ETON_BIT     BIT3                                               // [3] TIMERx_CNT外部启动使能 0: 自动运行 1:等待外部事件触发计数，外部触发信号根据TIMERx_EVT.EVT_SRC进行选择 需要注意的是，使用外部触发也需要设置TIMERx_CFG.EN=1，除非是外部信号进行的单次触发，即TIMERx_CFG.ONE_TRIG=1。
#define TIMER2_CFG2_GATE_EN_BIT  BIT2                                               // [2] TIMER暂停使能 0:不暂停 1:当外部信号为低时，TIMER暂停计数，外部信号根据TIMERx_EVT.EVT_SRC进行选择
#define TIMER2_CFG2_RL_EN_BIT    BIT1                                               // [1] TIMER重装使能 0:禁用外部事件重装，TIMER向上计数至TH回0，或向下计数值0回到TH 1:使能外部事件重装，重装信号根据TIMER0_EVT.EVT_SRC进行选择，当向上计数时，发生外部事件，TIMER重装为0,；当向下计数时，发生外部事件，TIMER重装为TH。
#define TIMER2_CFG2_XCLK_EN_BIT  BIT0                                               // [0] TIMER 时钟源 0: 芯片内部时钟 1: 外部时钟，时钟源根据TIMER0_EVT.EVT_SRC进行选择，当使用外部时钟时，CLK_DIV不再起作用，即时钟不再进行分频

/* TIMER2_TH TIMER2门限寄存器 */
#define TIMER2_TH_TH_POS  0                                                  // TIMER2_TH_TH起始位
#define TIMER2_TH_TH_MASK (uint32_t)(0xFFFFFFFF << TIMER2_TH_TH_POS)         // TIMER2_TH_TH位掩码
#define TIMER2_TH_TH(x)   (uint32_t)(((x) & 0xFFFFFFFF) << TIMER2_TH_TH_POS) // [31:0] TIMERx_CNT计数门限。向上计数从0计数到TH值后回0，或向下计数从TH计数到0后回到TH

/* TIMER2_CNT TIMER2计数寄存器 */
#define TIMER2_CNT_CNT_POS  0                                                    // TIMER2_CNT_CNT起始位
#define TIMER2_CNT_CNT_MASK (uint32_t)(0xFFFFFFFF << TIMER2_CNT_CNT_POS)         // TIMER2_CNT_CNT位掩码
#define TIMER2_CNT_CNT(x)   (uint32_t)(((x) & 0xFFFFFFFF) << TIMER2_CNT_CNT_POS) // [31:0] TIMER2计数器当前计数值。写操作可以写入新的计数值。

/* TIMER2_CMP0 TIMER2通道0比较捕获寄存器 */
#define TIMER2_CMP0_CMP0_POS  0                                                      // TIMER2_CMP0_CMP0起始位
#define TIMER2_CMP0_CMP0_MASK (uint32_t)(0xFFFFFFFF << TIMER2_CMP0_CMP0_POS)         // TIMER2_CMP0_CMP0位掩码
#define TIMER2_CMP0_CMP0(x)   (uint32_t)(((x) & 0xFFFFFFFF) << TIMER2_CMP0_CMP0_POS) // [31:0] Time通道0工作在比较模式时，当计数器计数值等于CMP0时，发生比较事件。 TIMER通道0工作在捕获模式时，发生捕获事件时的计数器计数值存入CMP0寄存器。

/* TIMER2_CMP1 TIMER2通道1比较捕获寄存器 */
#define TIMER2_CMP1_CMP1_POS  0                                                      // TIMER2_CMP1_CMP1起始位
#define TIMER2_CMP1_CMP1_MASK (uint32_t)(0xFFFFFFFF << TIMER2_CMP1_CMP1_POS)         // TIMER2_CMP1_CMP1位掩码
#define TIMER2_CMP1_CMP1(x)   (uint32_t)(((x) & 0xFFFFFFFF) << TIMER2_CMP1_CMP1_POS) // [31:0] TIMER通道1工作在比较模式时，当计数器计数值等于CMP1时，发生比较事件。 TIMER通道1工作在捕获模式时，发生捕获事件时的计数器计数值存入CMP1寄存器。

/* TIMER2_EVT TIMER2外部事件选择寄存器 */
#define TIMER2_EVT_EVT_TH_POS   4                                                 // TIMER2_EVT_EVT_TH起始位
#define TIMER2_EVT_EVT_TH_MASK  (uint32_t)(0xF << TIMER2_EVT_EVT_TH_POS)          // TIMER2_EVT_EVT_TH位掩码
#define TIMER2_EVT_EVT_TH(x)    (uint32_t)(((x) & 0xF) << TIMER2_EVT_EVT_TH_POS)  // [7:4] 外部事件发生次数阈值，配合TIMERx_CFG.RL_EN使用。 外部事件发生EVT_TH次后产生效果（当EVT_TH=0时，1次即生效）。可配置的外部事件发生次数阈值范围是0~15。 特别地，当设置TIMERx_CFG.CMP1TMIN=1，且TIMERx_CNT\<TIMERx_CMP1时，即使此前发生的外部事件已达到EVT_TH设定次数，TIMERx_CNT重置也会延迟生效，即TIMERx_CNT会继续计数到TIMERx_CMP1后归零。此时TIMERx_CMP1作为重置最小计数值TMIN使用。 EVT_TH在一个TIMER周期后自动清零，即一个TIMER周期的外部事件不累积至下一个周期。
#define TIMER2_EVT_EVT_SRC_POS  0                                                 // TIMER2_EVT_EVT_SRC起始位
#define TIMER2_EVT_EVT_SRC_MASK (uint32_t)(0xF << TIMER2_EVT_EVT_SRC_POS)         // TIMER2_EVT_EVT_SRC位掩码
#define TIMER2_EVT_EVT_SRC(x)   (uint32_t)(((x) & 0xF) << TIMER2_EVT_EVT_SRC_POS) // [3:0] TIMER外部事件选择寄存器，本寄存器需要配合TIMER2_CFG.ETON，TIMER2_CFG.GATE_EN，TIMER2_CFG.RL_EN，TIMER2_CFG.XCLK_EN使用。 通常4个设置位不同时使用。 当设置ETON=1时，根据本寄存器选择触发TIMER计数的事件。 需要注意的是，TIMER自身的比较事件无法触发TIMER进行计数。当ETON=1时，触发信号的上升沿触发TIMER开始计数，用作触发源的TIMER需要工作在比较模式，无须从外部输入信号至TIMER通道 0:TIMER0 通道0比较/捕获事件 1:TIMER0 通道1比较/捕获事件 2:TIMER1 通道0比较/捕获事件 3:TIMER1 通道1比较/捕获事件 4:不可用 5:不可用 6:不可用 7:不可用 8:CLU0输出上升沿 9:CLU1输出上升沿 10:CLU2输出上升沿 11:CLU3输出上升沿 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件 当GATE_EN=1，且外部信号为高时TIMER计数，外部信号为低时，TIMER暂停，当GATE_EN=1时，TIMER使用对应外部信号的电平信号作为计数门控。GATE_EN仅支持配合0~11的外部事件使用，当EVT_SRC选择为0~7时，外部信号为TIMER通道输入信号经过对应TIMER滤波后的信号，作为门控信号的TIMER通道需要配置为输入使能 0:TIMER0 通道0滤波后输入信号 1:TIMER0 通道1滤波后输入信号 2:TIMER1 通道0滤波后输入信号 3:TIMER1 通道1滤波后输入信号 4:TIMER2 通道0滤波后输入信号 5:TIMER2 通道1滤波后输入信号 6:不可用 7:不可用 8:CLU0输出信号 9:CLU1输出信号 10:CLU2输出信号 11:CLU3输出信号 当RL_EN为高时，TIMER使用外部信号作为重装载信号 作为重装载信号的TIMER通道需要配置为输入使能 0:TIMER0 通道0比较/捕获事件 1:TIMER0 通道1比较/捕获事件 2:TIMER1 通道0比较/捕获事件 3:TIMER1 通道1比较/捕获事件 4:TIMER2 通道0比较/捕获事件 5:TIMER2 通道1比较/捕获事件 6:不可用 7:不可用 8:CLU0输出 9:CLU1输出 10:CLU2输出 11:CLU3输出 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件 当XCLK_EN为高时，TIMER使用外部信号作为TIMER外部时钟，TIMER在时钟上升沿进行计数动作。如果使用TIMER通道作为外部时钟，通道信号受到对应TIMER滤波设置影响。 0:TIMER0 通道0输入信号 1:TIMER0 通道1输入信号 2:TIMER1 通道0输入信号 3:TIMER1 通道1输入信号 4:TIMER2 通道0输入信号 5:TIMER2 通道1输入信号 6:不可用 7:不可用 8:CLU0输出 9:CLU1输出 10:CLU2输出 11:CLU3输出 12:MCPWM TADC[0]比较事件 13:MCPWM TADC[1]比较事件 14:MCPWM TADC[2]比较事件 15:MCPWM TADC[3]比较事件

/* TIMER2_FLT TIMER2滤波控制寄存器 */
#define TIMER2_FLT_FLT_POS  0                                              // TIMER2_FLT_FLT起始位
#define TIMER2_FLT_FLT_MASK (uint32_t)(0xFF << TIMER2_FLT_FLT_POS)         // TIMER2_FLT_FLT位掩码
#define TIMER2_FLT_FLT(x)   (uint32_t)(((x) & 0xFF) << TIMER2_FLT_FLT_POS) // [7:0] 通道0/1信号滤波宽度选择。取值范围0~255。 FLT为0时，不对通道进行滤波。 FLT不为0时，对通道信号进行滤波:滤波宽度为FLT×8。当通道信号电平稳定超过FLT×8个系统时钟周期宽度时，滤波器输出更新；否则，滤波器保持当前的输出不变。

/* TIMER2_IE TIMER2中断使能寄存器 */
#define TIMER2_IE_ZC_RE_BIT  BIT10 // [10] TIMER CNT过0 DMA请求使能，高电平有效。
#define TIMER2_IE_CH1_RE_BIT BIT9  // [9] TIMER通道1比较/捕获 DMA请求使能，高电平有效。
#define TIMER2_IE_CH0_RE_BIT BIT8  // [8] TIMER通道0比较/捕获 DMA请求使能，高电平有效。
#define TIMER2_IE_ZC_IE_BIT  BIT2  // [2] TIMER CNT过0中断使能，高电平有效。
#define TIMER2_IE_CH1_IE_BIT BIT1  // [1] TIMER通道1比较/捕获中断使能，高电平有效。
#define TIMER2_IE_CH0_IE_BIT BIT0  // [0] TIMER通道0比较/捕获中断使能，高电平有效。

/* TIMER2_IF TIMER2中断标志寄存器 */
#define TIMER2_IF_ZC_IF_BIT  BIT2 // [2] TIMER CNT过0中断标志。高电平有效，写1清0
#define TIMER2_IF_CH1_IF_BIT BIT1 // [1] TIMER通道1比较/捕获中断标志。高电平有效，写1清0
#define TIMER2_IF_CH0_IF_BIT BIT0 // [0] TIMER通道0比较/捕获中断标志。高电平有效，写1清0

/* QEP0_CFG QEP0配置寄存器 */
#define QEP0_CFG_FLT_POS       16                                           // QEP0_CFG_FLT起始位
#define QEP0_CFG_FLT_MASK      (uint32_t)(0xFF << QEP0_CFG_FLT_POS)         // QEP0_CFG_FLT位掩码
#define QEP0_CFG_FLT(x)        (uint32_t)(((x) & 0xFF) << QEP0_CFG_FLT_POS) // [23:16] 编码器的滤波系数 编码器滤波宽度选择。取值范围0~15。 FLT为0时，不对通道进行滤波。 FLT不为0时，对通道信号进行滤波:滤波宽度为FLT×8。当通道信号电平稳定超过FLT×8个系统时钟周期宽度时，滤波器输出更新；否则，滤波器保持当前的输出不变。
#define QEP0_CFG_EN_BIT        BIT15                                        // [15] QEP模块整体使能
#define QEP0_CFG_FE_CNT_EN_BIT BIT10                                        // [10] CCW+SIGN/CCW+CW两种模式下，是否在下降沿进行计数（上升沿总是计数）
#define QEP0_CFG_MODE_POS      8                                            // QEP0_CFG_MODE起始位
#define QEP0_CFG_MODE_MASK     (uint32_t)(0x3 << QEP0_CFG_MODE_POS)         // QEP0_CFG_MODE位掩码
#define QEP0_CFG_MODE(x)       (uint32_t)(((x) & 0x3) << QEP0_CFG_MODE_POS) // [9:8] 编码器模式选择 00:counting on T1， 01:counting on T1 & T2 以上两种模式都为正交编码信号计数模式 10:CCW+SIGN，符号加脉冲信号计数模式 11:CCW+CW，CCW+CW双脉冲信号计数模式
#define QEP0_CFG_ZNC_BIT       BIT3                                         // [3] Z信号清零极性选择:低电平/下降沿清零使能
#define QEP0_CFG_ZPC_BIT       BIT2                                         // [2] Z信号清零极性选择:高电平/上升沿清零使能
#define QEP0_CFG_ZLC_BIT       BIT1                                         // [1] Z信号电平清零QEP计数器使能
#define QEP0_CFG_ZEC_BIT       BIT0                                         // [0] Z信号边沿清零QEP计数器使能

/* QEP0_TH QEP0计数门限寄存器 */
#define QEP0_TH_TH_POS  0                                            // QEP0_TH_TH起始位
#define QEP0_TH_TH_MASK (uint32_t)(0xFFFF << QEP0_TH_TH_POS)         // QEP0_TH_TH位掩码
#define QEP0_TH_TH(x)   (uint32_t)(((x) & 0xFFFF) << QEP0_TH_TH_POS) // [15:0] 计数门限TH。编码器向上计数（增）到TH值后，再次向上计数会导致计数器回到0。编码器向下计数（减）到0值后，再次向下计数会导致计数器回到TH。

/* QEP0_CNT QEP0计数值寄存器 */
#define QEP0_CNT_CNT_POS  0                                              // QEP0_CNT_CNT起始位
#define QEP0_CNT_CNT_MASK (uint32_t)(0xFFFF << QEP0_CNT_CNT_POS)         // QEP0_CNT_CNT位掩码
#define QEP0_CNT_CNT(x)   (uint32_t)(((x) & 0xFFFF) << QEP0_CNT_CNT_POS) // [15:0] QEP0计数值。

/* QEP0_IE QEP0中断使能寄存器 */
#define QEP0_IE_OF_IE_BIT BIT1 // [1] 上溢出中断使能，高电平有效。
#define QEP0_IE_UF_IE_BIT BIT0 // [0] 下溢出中断使能，高电平有效。

/* QEP0_IF QEP0中断标志寄存器 */
#define QEP0_IF_OF_IF_BIT BIT1 // [1] 上溢出中断标志。高电平有效，写1清0。当计数器计数达到计数门限时，上计数事件触发上溢出中断。
#define QEP0_IF_UF_IF_BIT BIT0 // [0] 下溢出中断标志。高电平有效，写1清0。当计数器计数达到0时，下计数事件触发下溢出中断。

/* MCPWM0_TH00 */
#define MCPWM0_TH00_TH00_POS  0                                                  // MCPWM0_TH00_TH00起始位
#define MCPWM0_TH00_TH00_MASK (uint32_t)(0xFFFF << MCPWM0_TH00_TH00_POS)         // MCPWM0_TH00_TH00位掩码
#define MCPWM0_TH00_TH00(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH00_TH00_POS) // [15:0] MCPWM CH0_P比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。写入的是预装载寄存器，更新事件发生时才会把预装载寄存器值写入影子寄存器，读出时读出的是影子寄存器的值。

/* MCPWM0_TH01 */
#define MCPWM0_TH01_TH01_POS  0                                                  // MCPWM0_TH01_TH01起始位
#define MCPWM0_TH01_TH01_MASK (uint32_t)(0xFFFF << MCPWM0_TH01_TH01_POS)         // MCPWM0_TH01_TH01位掩码
#define MCPWM0_TH01_TH01(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH01_TH01_POS) // [15:0] MCPWM CH0_N比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TH10 */
#define MCPWM0_TH10_TH10_POS  0                                                  // MCPWM0_TH10_TH10起始位
#define MCPWM0_TH10_TH10_MASK (uint32_t)(0xFFFF << MCPWM0_TH10_TH10_POS)         // MCPWM0_TH10_TH10位掩码
#define MCPWM0_TH10_TH10(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH10_TH10_POS) // 15:0] MCPWM CH1_P比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TH11 */
#define MCPWM0_TH11_TH11_POS  0                                                  // MCPWM0_TH11_TH11起始位
#define MCPWM0_TH11_TH11_MASK (uint32_t)(0xFFFF << MCPWM0_TH11_TH11_POS)         // MCPWM0_TH11_TH11位掩码
#define MCPWM0_TH11_TH11(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH11_TH11_POS) // [15:0] MCPWM CH1_N比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TH20 */
#define MCPWM0_TH20_TH20_POS  0                                                  // MCPWM0_TH20_TH20起始位
#define MCPWM0_TH20_TH20_MASK (uint32_t)(0xFFFF << MCPWM0_TH20_TH20_POS)         // MCPWM0_TH20_TH20位掩码
#define MCPWM0_TH20_TH20(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH20_TH20_POS) // [15:0] MCPWM CH2_P比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TH21 */
#define MCPWM0_TH21_TH21_POS  0                                                  // MCPWM0_TH21_TH21起始位
#define MCPWM0_TH21_TH21_MASK (uint32_t)(0xFFFF << MCPWM0_TH21_TH21_POS)         // MCPWM0_TH21_TH21位掩码
#define MCPWM0_TH21_TH21(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH21_TH21_POS) // [15:0] MCPWM CH2_N比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TH30 */
#define MCPWM0_TH30_TH30_POS  0                                                  // MCPWM0_TH30_TH30起始位
#define MCPWM0_TH30_TH30_MASK (uint32_t)(0xFFFF << MCPWM0_TH30_TH30_POS)         // MCPWM0_TH30_TH30位掩码
#define MCPWM0_TH30_TH30(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH30_TH30_POS) // [15:0] MCPWM CH3_P比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TH31 */
#define MCPWM0_TH31_TH31_POS  0                                                  // MCPWM0_TH31_TH31起始位
#define MCPWM0_TH31_TH31_MASK (uint32_t)(0xFFFF << MCPWM0_TH31_TH31_POS)         // MCPWM0_TH31_TH31位掩码
#define MCPWM0_TH31_TH31(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TH31_TH31_POS) // [15:0] MCPWM CH3_N比较门限值，16位有符号数；发生更新事件时，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TMR0 */
#define MCPWM0_TMR0_TMR0_POS  0                                                  // MCPWM0_TMR0_TMR0起始位
#define MCPWM0_TMR0_TMR0_MASK (uint32_t)(0xFFFF << MCPWM0_TMR0_TMR0_POS)         // MCPWM0_TMR0_TMR0位掩码
#define MCPWM0_TMR0_TMR0(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TMR0_TMR0_POS) // [15:0] ADC采样定时器比较门限0寄存器，16位有符号数；当MCPWM0_CNT0=TMR0时产生TADC[0]事件触发ADC进行采样。MCPWM发生更新事件后，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TMR1 */
#define MCPWM0_TMR1_TMR1_POS  0                                                  // MCPWM0_TMR1_TMR1起始位
#define MCPWM0_TMR1_TMR1_MASK (uint32_t)(0xFFFF << MCPWM0_TMR1_TMR1_POS)         // MCPWM0_TMR1_TMR1位掩码
#define MCPWM0_TMR1_TMR1(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TMR1_TMR1_POS) // [15:0] ADC采样定时器比较门限1寄存器，16位有符号数；当MCPWM0_CNT=TMR1时产生TADC[1]事件触发ADC进行采样。MCPWM发生更新事件后，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TMR2 */
#define MCPWM0_TMR2_TMR2_POS  0                                                  // MCPWM0_TMR2_TMR2起始位
#define MCPWM0_TMR2_TMR2_MASK (uint32_t)(0xFFFF << MCPWM0_TMR2_TMR2_POS)         // MCPWM0_TMR2_TMR2位掩码
#define MCPWM0_TMR2_TMR2(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TMR2_TMR2_POS) // [15:0] ADC采样定时器比较门限2寄存器，16位有符号数；发生更新事件后，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_TMR3 */
#define MCPWM0_TMR3_TMR3_POS  0                                                  // MCPWM0_TMR3_TMR3起始位
#define MCPWM0_TMR3_TMR3_MASK (uint32_t)(0xFFFF << MCPWM0_TMR3_TMR3_POS)         // MCPWM0_TMR3_TMR3位掩码
#define MCPWM0_TMR3_TMR3(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_TMR3_TMR3_POS) // [15:0] ADC采样定时器比较门限3寄存器，16位有符号数；发生更新事件后，本寄存器加载到MCPWM实际运行系统中。。

/* MCPWM0_TH0 */
#define MCPWM0_TH0_TH0_POS  0                                                // MCPWM0_TH0_TH0起始位
#define MCPWM0_TH0_TH0_MASK (uint32_t)(0x7FFF << MCPWM0_TH0_TH0_POS)         // MCPWM0_TH0_TH0位掩码
#define MCPWM0_TH0_TH0(x)   (uint32_t)(((x) & 0x7FFF) << MCPWM0_TH0_TH0_POS) // [14:0] MCPWM时基0计数器门限值，15位无符号数，MCPWM实际运行系统中的时基0计数器从-TH计数到TH；发生更新事件后，本寄存器加载到MCPWM实际运行系统中。

/* MCPWM0_CNT0 */
#define MCPWM0_CNT0_CNT0_POS  0                                                  // MCPWM0_CNT0_CNT0起始位
#define MCPWM0_CNT0_CNT0_MASK (uint32_t)(0xFFFF << MCPWM0_CNT0_CNT0_POS)         // MCPWM0_CNT0_CNT0位掩码
#define MCPWM0_CNT0_CNT0(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_CNT0_CNT0_POS) // [15:0] 向此寄存器写入，更改时基0计数器的设定值，发生更新事件后，本寄存器加载到MCPWM实际运行系统的时基0 CNT中。 读出的数据为MCPWM实际运行系统中时基0计数器的值。实际读出的计数范围为-TH ~ +TH

/* MCPWM0_UPDATE */
#define MCPWM0_UPDATE_IO3_UPDATE_BIT   BIT28 // [28] 写1产生软件（手动）触发，将MCPWM0_IO3/4/5由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TMR3_UPDATE_BIT  BIT25 // [25] 写1产生软件（手动）触发，将MCPWM0_TMR3由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TMR2_UPDATE_BIT  BIT24 // [24] 写1产生软件（手动）触发，将MCPWM0_TMR2由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH31_UPDATE_BIT  BIT17 // [17] 写1产生软件（手动）触发，将MCPWM0_TH31由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH30_UPDATE_BIT  BIT16 // [16] 写1产生软件（手动）触发，将MCPWM0_TH30由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_IO012_UPDATE_BIT BIT12 // [12] 写1产生软件（手动）触发，将MCPWM0_IO0/1/2由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_CNT0_UPDATE_BIT  BIT11 // [11] 写1产生软件（手动）触发，将MCPWM0_CNT0由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH0_UPDATE_BIT   BIT10 // [10] 写1产生软件（手动）触发，将MCPWM0_TH0由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TMR1_UPDATE_BIT  BIT9  // [9] 写1产生软件（手动）触发，将MCPWM0_TMR1由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TMR0_UPDATE_BIT  BIT8  // [8] 写1产生软件（手动）触发，将MCPWM0_TMR0由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH21_UPDATE_BIT  BIT5  // [5] 写1产生软件（手动）触发，将MCPWM0_TH21由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH20_UPDATE_BIT  BIT4  // [4] 写1产生软件（手动）触发，将MCPWM0_TH20由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH11_UPDATE_BIT  BIT3  // [3] 写1产生软件（手动）触发，将MCPWM0_TH11由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH10_UPDATE_BIT  BIT2  // [2] 写1产生软件（手动）触发，将MCPWM0_TH10由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH01_UPDATE_BIT  BIT1  // [1] 写1产生软件（手动）触发，将MCPWM0_TH01由预装载寄存器加载到MCPWM运行所使用的影子寄存器
#define MCPWM0_UPDATE_TH00_UPDATE_BIT  BIT0  // [0] 写1产生软件（手动）触发，将MCPWM0_TH00由预装载寄存器加载到MCPWM运行所使用的影子寄存器

/* MCPWM0_FCNT */
#define MCPWM0_FCNT_FCNT_POS  0                                                  // MCPWM0_FCNT_FCNT起始位
#define MCPWM0_FCNT_FCNT_MASK (uint32_t)(0xFFFF << MCPWM0_FCNT_FCNT_POS)         // MCPWM0_FCNT_FCNT位掩码
#define MCPWM0_FCNT_FCNT(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_FCNT_FCNT_POS) // [15:0] 若MCPWM0_CH_FAIL[15]=1，当发生fail0/1事件时，记录MCPWM0_CNT0值，存入MCPWM0_FCNT

/* MCPWM0_EVT0 */
#define MCPWM0_EVT0_TIMER2_CMP1_BIT BIT13 // [13] TIMER2 CMP1事件触发时基0开始计数
#define MCPWM0_EVT0_TIMER2_CMP0_BIT BIT12 // [12] TIMER2 CMP0事件触发时基0开始计数
#define MCPWM0_EVT0_TIMER1_CMP1_BIT BIT11 // [11] TIMER1 CMP1事件触发时基0开始计数
#define MCPWM0_EVT0_TIMER1_CMP0_BIT BIT10 // [10] TIMER1 CMP0事件触发时基0开始计数
#define MCPWM0_EVT0_TIMER0_CMP1_BIT BIT9  // [9] TIMER0 CMP1事件触发时基0开始计数
#define MCPWM0_EVT0_TIMER0_CMP0_BIT BIT8  // [8] TIMER0 CMP0事件触发时基0开始计数
#define MCPWM0_EVT0_PWM0_TMR3_BIT   BIT3  // [3] MCPWM0 TMR3事件触发时基0开始计数
#define MCPWM0_EVT0_PWM0_TMR2_BIT   BIT2  // [2] MCPWM0 TMR2事件触发时基0开始计数
#define MCPWM0_EVT0_PWM0_TMR1_BIT   BIT1  // [1] MCPWM0 TMR1事件触发时基0开始计数
#define MCPWM0_EVT0_PWM0_TMR0_BIT   BIT0  // [0] MCPWM0 TMR0事件触发时基0开始计数

/* MCPWM0_DTH00 */
#define MCPWM0_DTH00_DTH00_POS  0                                                   // MCPWM0_DTH00_DTH00起始位
#define MCPWM0_DTH00_DTH00_MASK (uint32_t)(0x3FF << MCPWM0_DTH00_DTH00_POS)         // MCPWM0_DTH00_DTH00位掩码
#define MCPWM0_DTH00_DTH00(x)   (uint32_t)(((x) & 0x3FF) << MCPWM0_DTH00_DTH00_POS) // [9:0] MCPWM CH0/1/2 /3 P通道死区宽度控制寄存器，10bit无符号数

/* MCPWM0_DTH01 */
#define MCPWM0_DTH01_DTH01_POS  0                                                   // MCPWM0_DTH01_DTH01起始位
#define MCPWM0_DTH01_DTH01_MASK (uint32_t)(0x3FF << MCPWM0_DTH01_DTH01_POS)         // MCPWM0_DTH01_DTH01位掩码
#define MCPWM0_DTH01_DTH01(x)   (uint32_t)(((x) & 0x3FF) << MCPWM0_DTH01_DTH01_POS) // [9:0] MCPWM CH0/1/2/3 N通道死区宽度控制寄存器，10bit无符号数

/* MCPWM0_FLT */
#define MCPWM0_FLT_FLT_CLKDIV_POS  0                                                     // MCPWM0_FLT_FLT_CLKDIV起始位
#define MCPWM0_FLT_FLT_CLKDIV_MASK (uint32_t)(0xFF << MCPWM0_FLT_FLT_CLKDIV_POS)         // MCPWM0_FLT_FLT_CLKDIV位掩码
#define MCPWM0_FLT_FLT_CLKDIV(x)   (uint32_t)(((x) & 0xFF) << MCPWM0_FLT_FLT_CLKDIV_POS) // [7:0] 滤波时钟分频寄存器，基于系统时钟分频，影响MCPWM0_CH_FAIL[1:0]。计算公式如下: 系统时钟 / (FLT_CLKDIV + 1)。分频范围是1-256。

/* MCPWM0_SDCFG */
#define MCPWM0_SDCFG_TR0_AEC_BIT       BIT6                                                    // [6] 更新事件是否自动清除MCPWM0_EIF[5:4]并置位MCPWM0_CH012_FAIL.MOE，恢复MCPWM通道0/1/2信号输出。 1:使能自动故障清除功能；0:关闭自动故障清除功能。
#define MCPWM0_SDCFG_TR0_T1_UPDATE_BIT BIT5                                                    // [5] 时基0 t1（过零）事件更新使能。1:使能；0，关闭。
#define MCPWM0_SDCFG_TR0_T0_UPDATE_BIT BIT4                                                    // [4] 时基0 t0（起点）事件更新使能。1:使能；0，关闭。
#define MCPWM0_SDCFG_TR0_UP_INTV_POS   0                                                       // MCPWM0_SDCFG_TR0_UP_INTV起始位
#define MCPWM0_SDCFG_TR0_UP_INTV_MASK  (uint32_t)(0xF << MCPWM0_SDCFG_TR0_UP_INTV_POS)         // MCPWM0_SDCFG_TR0_UP_INTV位掩码
#define MCPWM0_SDCFG_TR0_UP_INTV(x)    (uint32_t)(((x) & 0xF) << MCPWM0_SDCFG_TR0_UP_INTV_POS) // [3:0] 时基0更新间隔。一旦t0和t1事件发生次数同TR0_UP_INTV相等，MCPWM系统自动触发MCPWM0_TH0，MCPWM0_TH00~TH21和MCPWM0_TMR寄存器加载到MCPWM运行系统的操作。若TR0_T1_UEN和TR0_T0_UEN均关闭，将不会触发此类型加载，只能手动触发加载。

/* MCPWM0_AUEN */
#define MCPWM0_AUEN_IO3_AUPDATE_BIT   BIT28 // [28] MCWPM0_IO3自动加载使能。 MCPWM0_IO3指的是MCPWM0_IO23中的Bit[15:08]，即MCPWM的通道3的基本配置。 1：加载；0：不加载。
#define MCPWM0_AUEN_TMR3_AUPDATE_BIT  BIT25 // [25] MCPWM0_TMR3自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TMR2_AUPDATE_BIT  BIT24 // [24] MCPWM0_TMR2自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH31_AUPDATE_BIT  BIT17 // [17] MCPWM0_TH31自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH30_AUPDATE_BIT  BIT16 // [16] MCPWM0_TH30自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_IO012_AUPDATE_BIT BIT12 // [12] MCPWM0_IO01/MCWPM0_IO2自动加载使能。MCPWM0_IO2指的是MCPWM0_IO23中的Bit[7:0],即MCPWM的通道2的基本配置。 1:加载；0:不加载。
#define MCPWM0_AUEN_CNT0_AUPDATE_BIT  BIT11 // [11] MCPWM0_CNT0自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH0_AUPDATE_BIT   BIT10 // [10] MCPWM0_TH0自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TMR1_AUPDATE_BIT  BIT9  // [9] MCPWM0_TMR1自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TMR0_AUPDATE_BIT  BIT8  // [8] MCPWM0_TMR0自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH21_AUPDATE_BIT  BIT5  // [5] MCPWM0_TH21自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH20_AUPDATE_BIT  BIT4  // [4] MCPWM0_TH20自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH11_AUPDATE_BIT  BIT3  // [3] MCPWM0_TH11自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH10_AUPDATE_BIT  BIT2  // [2] MCPWM0_TH10自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH01_AUPDATE_BIT  BIT1  // [1] MCPWM0_TH01自动加载使能。1:加载；0:不加载。
#define MCPWM0_AUEN_TH00_AUPDATE_BIT  BIT0  // [0] MCPWM0_TH00自动加载使能。1:加载；0:不加载。

/* MCPWM0_TCLK */
#define MCPWM0_TCLK_CLK_DIV_POS      12                                                 // MCPWM0_TCLK_CLK_DIV起始位
#define MCPWM0_TCLK_CLK_DIV_MASK     (uint32_t)(0x7 << MCPWM0_TCLK_CLK_DIV_POS)         // MCPWM0_TCLK_CLK_DIV位掩码
#define MCPWM0_TCLK_CLK_DIV(x)       (uint32_t)(((x) & 0x7) << MCPWM0_TCLK_CLK_DIV_POS) // [14:12] MCPWM工作时钟分频寄存器。 0:系统时钟 1:系统时钟/2 2:系统时钟/4 3:系统时钟/8 4:系统时钟/16 5:系统时钟/32 6:系统时钟/64 7:系统时钟/128
#define MCPWM0_TCLK_EVT_CNT0_EN_BIT  BIT8                                               // [8] 时基0外部触发使能
#define MCPWM0_TCLK_BASE0_CNT_EN_BIT BIT6                                               // [6] MCPWM时基0计数器使能开关。1:使能；0:关闭。
#define MCPWM0_TCLK_CLK_EN_BIT       BIT2                                               // [2] MCPWM工作时钟使能。1:使能；0:关闭。 这个时钟使能主要作用的时钟是用来控制FAIL信号，死区控制以及处理DMA搬运请求的。并不影响PWM影子寄存器的更新以及波形输出和MCPWM_CNT的更新。

/* MCPWM0_IE0 */
#define MCPWM0_IE0_UP_IE_BIT   BIT14 // [14] 时基0更新事件中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TMR3_IE_BIT BIT13 // [13] MCPWM0_CNT0等于MCPWM0_TMR3中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TMR2_IE_BIT BIT12 // [12] MCPWM0_CNT0等于MCPWM0_TMR2中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TMR1_IE_BIT BIT11 // [11] MCPWM0_CNT0等于MCPWM0_TMR1中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TMR0_IE_BIT BIT10 // [10] MCPWM0_CNT0等于MCPWM0_TMR0中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH31_IE_BIT BIT9  // [9] MCPWM0_CNT0等于MCPWM0_TH31中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH30_IE_BIT BIT8  // [8] MCPWM0_CNT0等于MCPWM0_TH30中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH21_IE_BIT BIT7  // [7] MCPWM0_CNT0等于MCPWM0_TH21中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH20_IE_BIT BIT6  // [6] MCPWM0_CNT0等于MCPWM0_TH20中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH11_IE_BIT BIT5  // [5] MCPWM0_CNT0等于MCPWM0_TH11中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH10_IE_BIT BIT4  // [4] MCPWM0_CNT0等于MCPWM0_TH10中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH01_IE_BIT BIT3  // [3] MCPWM0_CNT0等于MCPWM0_TH01中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_TH00_IE_BIT BIT2  // [2] MCPWM0_CNT0等于MCPWM0_TH00中断源使能。1，使能；0，关闭。
#define MCPWM0_IE0_T1_IE_BIT   BIT1  // [1] 时基0 T1事件，MCPWM0_CNT0的计数值回0中断源使能。 1，使能；0，关闭。
#define MCPWM0_IE0_T0_IE_BIT   BIT0  // [0] 时基0 T0事件，MCPWM0_CNT0的计数值等于MCPWM0_TH0中断源使能。1，使能；0，关闭。

/* MCPWM0_IF0 */
#define MCPWM0_IF0_UP_IF_BIT   BIT14 // [14] 时基0更新事件 MCPWM0_TH0/MCPWM0_TH00~MCPWM0_TH21/MCPWM0_TMR等寄存器更新到MCPWM实际运行系统的中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TMR3_IF_BIT BIT13 // [13] MCPWM0_CNT0等于MCPWM0_TMR3中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TMR2_IF_BIT BIT12 // [12] MCPWM0_CNT0等于MCPWM0_TMR2中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TMR1_IF_BIT BIT11 // [11] MCPWM0_CNT0等于MCPWM0_TMR1中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TMR0_IF_BIT BIT10 // [10] MCPWM0_CNT0等于MCPWM0_TMR0中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TH21_IF_BIT BIT7  // [7] MCPWM0_CNT0等于MCPWM0_TH21中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TH20_IF_BIT BIT6  // [6] MCPWM0_CNT0等于MCPWM0_TH20中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TH11_IF_BIT BIT5  // [5] MCPWM0_CNT0等于MCPWM0_TH11中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TH10_IF_BIT BIT4  // [4] MCPWM0_CNT0等于MCPWM0_TH10中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TH01_IF_BIT BIT3  // [3] MCPWM0_CNT0等于MCPWM0_TH01中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_TH00_IF_BIT BIT2  // [2] MCPWM0_CNT0等于MCPWM0_TH00中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_T1_IF_BIT   BIT1  // [1] t1事件，MCPWM0_CNT0等于0中断事件。 1，发生；0，没发生。写1清零。
#define MCPWM0_IF0_T0_IF_BIT   BIT0  // [0] t0事件，MCPWM0_CNT0等于MCPWM0_TH中断事件。 1，发生；0，没发生。写1清零。

/* MCPWM0_EIE */
#define MCPWM0_EIE_FAIL1_IE_BIT BIT5 // [5] FAIL1中断源使能。1，使能；0，关闭。
#define MCPWM0_EIE_FAIL0_IE_BIT BIT4 // [4] FAIL0中断源使能。1，使能；0，关闭。

/* MCPWM0_EIF */
#define MCPWM0_EIF_FAIL1_IF_BIT BIT5 // [5] FAIL1中断源事件。1，发生；0，没发生。写1清零。
#define MCPWM0_EIF_FAIL0_IF_BIT BIT4 // [4] FAIL0中断源事件。1，发生；0，没发生。写1清零。

/* MCPWM0_RE */
#define MCPWM0_RE_TR0_T1_RE1_BIT BIT13 // [13] 时基0 T1事件DMA请求1使能。1:使能；0:关闭。
#define MCPWM0_RE_TR0_T0_RE1_BIT BIT12 // [12] 时基0 T0事件DMA请求1使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR3_RE1_BIT   BIT11 // [11] MCPWM计数器命中TMR3，DMA请求1使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR2_RE1_BIT   BIT10 // [10] MCPWM计数器命中TMR2，DMA请求1使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR1_RE1_BIT   BIT9  // [9] MCPWM计数器命中TMR1，DMA请求1使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR0_RE1_BIT   BIT8  // [8] MCPWM计数器命中TMR0，DMA请求1使能。1:使能；0:关闭。
#define MCPWM0_RE_TR0_T1_RE0_BIT BIT5  // [5] 时基0 T1事件DMA请求0使能。1:使能；0:关闭。
#define MCPWM0_RE_TR0_T0_RE0_BIT BIT4  // [4] 时基0 T0事件DMA请求0使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR3_RE0_BIT   BIT3  // [3] MCPWM计数器命中TMR3，DMA请求0使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR2_RE0_BIT   BIT2  // [2] MCPWM计数器命中TMR2，DMA请求0使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR1_RE0_BIT   BIT1  // [1] MCPWM计数器命中TMR1，DMA请求0使能。1:使能；0:关闭。
#define MCPWM0_RE_TMR0_RE0_BIT   BIT0  // [0] MCPWM计数器命中TMR0，DMA请求0使能。1:使能；0:关闭。

/* MCPWM0_PP */
#define MCPWM0_PP_IO3_PPE_BIT BIT3 // [3] IO3推挽模式使能信号。写1，使能；写0，关闭。
#define MCPWM0_PP_IO2_PPE_BIT BIT2 // [2] IO2推挽模式使能信号。写1，使能；写0，关闭。
#define MCPWM0_PP_IO1_PPE_BIT BIT1 // [1] IO1推挽模式使能信号。写1，使能；写0，关闭。
#define MCPWM0_PP_IO0_PPE_BIT BIT0 // [0] IO0推挽模式使能信号。写1，使能；写0，关闭。

/* MCPWM0_IO01 */
#define MCPWM0_IO01_CH1_WM_BIT     BIT15 // [15] CH1工作模式选择。1:边沿模式；0:互补模式。
#define MCPWM0_IO01_CH1_PN_SW_BIT  BIT14 // [14] CH1的P和N通道输出互换选择。即P通道信号最后从N通道输出，N通道的信号最后从P通道输出。1:互换；0:不互换。
#define MCPWM0_IO01_CH1_SCTRLP_BIT BIT13 // [13] 当CH1_PS=1时，输出到CH1 P通道的值。
#define MCPWM0_IO01_CH1_SCTRLN_BIT BIT12 // [12] 当CH1_NS=1时，输出到CH1 N通道的值。
#define MCPWM0_IO01_CH1_PS_BIT     BIT11 // [11] CH1 P来源。1:来自CH1_SCTRLP；0:MCPWM内部计数器产生。
#define MCPWM0_IO01_CH1_NS_BIT     BIT10 // [10] CH1 N来源。1:来自CH1_SCTRLN；0:MCPWM内部计数器产生。
#define MCPWM0_IO01_CH1_PP_BIT     BIT9  // [9] CH1 P极性选择。1:CH1 P信号取反输出；0:CH1 P信号正常输出。
#define MCPWM0_IO01_CH1_NP_BIT     BIT8  // [8] CH1 N极性选择。1:CH1 N信号取反输出；0:CH1 N信号正常输出。
#define MCPWM0_IO01_CH0_WM_BIT     BIT7  // [7] CH0工作模式选择。1:边沿模式；0:互补模式。
#define MCPWM0_IO01_CH0_PN_SW_BIT  BIT6  // [6] CH0的P和N通道输出互换选择。即P通道信号最后从N通道输出，N通道的信号最后从P通道输出。1:互换；0:不互换。
#define MCPWM0_IO01_CH0_SCTRLP_BIT BIT5  // [5] 当CH0_PS =1时，输出到CH0 P通道的值。
#define MCPWM0_IO01_CH0_SCTRLN_BIT BIT4  // [4] 当CH0_NS =1时，输出到CH0 N通道的值。
#define MCPWM0_IO01_CH0_PS_BIT     BIT3  // [3] CH0 P来源。1:来自CH0_SCTRLP；0:MCPWM实际运行系统中计数器产生。
#define MCPWM0_IO01_CH0_NS_BIT     BIT2  // [2] CH0 N来源。1:来自CH0_SCTRLN；0:MCPWM实际运行系统中计数器产生。
#define MCPWM0_IO01_CH0_PP_BIT     BIT1  // [1] CH0 P极性选择。1:CH0 P信号取反输出；0:CH0 P信号正常输出。
#define MCPWM0_IO01_CH0_NP_BIT     BIT0  // [0] CH0 N极性选择。1:CH0 N信号取反输出；0:CH0 N信号正常输出。极性选择跟随通道交换，例如CH0 N选择取反输出，同时选择了通道交换，则交换后的CH0 N仍是取反输出。

/* MCPWM0_IO23 */
#define MCPWM0_IO23_CH3_WM_BIT     BIT15 // [15] CH3工作模式选择。1:Edge模式；0:互补模式。
#define MCPWM0_IO23_CH3_PN_SW_BIT  BIT14 // [14] CH3的P和N通道输出互换选择。即P通道信号最后从N通道输出，N通道的信号最后从P通道输出。1:互换；0:不互换。
#define MCPWM0_IO23_CH3_SCTRLP_BIT BIT13 // [13] 当CH3_PS =1时，输出到CH3 P通道的值。
#define MCPWM0_IO23_CH3_SCTRLN_BIT BIT12 // [12] 当CH3_NS =1时，输出到CH3 N通道的值。
#define MCPWM0_IO23_CH3_PS_BIT     BIT11 // [11] CH3 P来源。1:来自CH3_SCTRLP；0:MCPWM实际运行系统中计数器产生。
#define MCPWM0_IO23_CH3_NS_BIT     BIT10 // [10] CH3 N来源。1:来自CH3_SCTRLN；0:MCPWM实际运行系统中计数器产生。
#define MCPWM0_IO23_CH3_PP_BIT     BIT9  // [9] CH3 P极性选择。1:CH3 P信号取反输出；0:CH3 P信号正常输出。
#define MCPWM0_IO23_CH3_NP_BIT     BIT8  // [8] CH3 N极性选择。1:CH3 N信号取反输出；0:CH3 N信号正常输出。
#define MCPWM0_IO23_CH2_WM_BIT     BIT7  // [7] CH2工作模式选择。1:Edge模式；0:互补模式。
#define MCPWM0_IO23_CH2_PN_SW_BIT  BIT6  // [6] CH2的P和N通道输出互换选择。即P通道信号最后从N通道输出，N通道的信号最后从P通道输出。1:互换；0:不互换。
#define MCPWM0_IO23_CH2_SCTRLP_BIT BIT5  // [5] 当CH2_PS =1时，输出到CH2 P通道的值。
#define MCPWM0_IO23_CH2_SCTRLN_BIT BIT4  // [4] 当CH2_NS =1时，输出到CH2 N通道的值。
#define MCPWM0_IO23_CH2_PS_BIT     BIT3  // [3] CH2 P来源。1:来自CH2_SCTRLP；0:MCPWM实际运行系统中计数器产生。
#define MCPWM0_IO23_CH2_NS_BIT     BIT2  // [2] CH2 N来源。1:来自CH2_SCTRLN；0:MCPWM实际运行系统中计数器产生。
#define MCPWM0_IO23_CH2_PP_BIT     BIT1  // [1] CH2 P极性选择。1:CH2 P信号取反输出；0:CH2 P信号正常输出。
#define MCPWM0_IO23_CH2_NP_BIT     BIT0  // [0] CH2 N极性选择。1:CH2 N信号取反输出；0:CH2 N信号正常输出。 极性选择跟随通道交换，例如CH0 N选择取反输出，同时选择了通道交换，则交换后的CH0 N仍是取反输出。

/* MCPWM0_CH_FAIL */
#define MCPWM0_CH_FAIL_FAIL0_CAP_BIT  BIT15                                                   // [15] 当发生fail0/1事件时，将MCPWM0_CNT0值存入MCPWM0_FCNT
#define MCPWM0_CH_FAIL_FAIL1_SEL_POS  10                                                      // MCPWM0_CH_FAIL_FAIL1_SEL起始位
#define MCPWM0_CH_FAIL_FAIL1_SEL_MASK (uint32_t)(0x3 << MCPWM0_CH_FAIL_FAIL1_SEL_POS)         // MCPWM0_CH_FAIL_FAIL1_SEL位掩码
#define MCPWM0_CH_FAIL_FAIL1_SEL(x)   (uint32_t)(((x) & 0x3) << MCPWM0_CH_FAIL_FAIL1_SEL_POS) // [11:10] FAIL1来源选择 0: MCPWM0_BKIN1 1: 比较器1原始输出 2: CLUOUT2 3: CLUOUT3
#define MCPWM0_CH_FAIL_FAIL0_SEL_POS  8                                                       // MCPWM0_CH_FAIL_FAIL0_SEL起始位
#define MCPWM0_CH_FAIL_FAIL0_SEL_MASK (uint32_t)(0x3 << MCPWM0_CH_FAIL_FAIL0_SEL_POS)         // MCPWM0_CH_FAIL_FAIL0_SEL位掩码
#define MCPWM0_CH_FAIL_FAIL0_SEL(x)   (uint32_t)(((x) & 0x3) << MCPWM0_CH_FAIL_FAIL0_SEL_POS) // [9:8] FAIL0来源选择 0: MCPWM0_BKIN0 1: 比较器0原始输出 2: CLUOUT0 3: CLUOUT1
#define MCPWM0_CH_FAIL_HALT_PRT_BIT   BIT7                                                    // [7] MCU进入HALT状态，MCPWM输出值选择。 1:正常输出；0:强制MCPWM输出保护值。
#define MCPWM0_CH_FAIL_MOE_BIT        BIT6                                                    // [6] MOE控制MCPWM通道P和N输出值。 1:输出MCPWM产生的正常信号 0:输出MCPWM0_CH_DEF设置的CHxN_DEFAULT和CHxP_DEFAULT默认值，此默认值不受极性/通道选择等控制。 MCPWM0_EIF.FAIL1_IF和MCPWM0_EIF.FAIL0_IF任意一位变1将触发MOE变成0，输出默认值。
#define MCPWM0_CH_FAIL_FAIL1_EN_BIT   BIT5                                                    // [5] FAIL1输入使能。1:使能；0:关闭。
#define MCPWM0_CH_FAIL_FAIL0_EN_BIT   BIT4                                                    // [4] FAIL0输入使能。1:使能；0:关闭。
#define MCPWM0_CH_FAIL_FAIL1_POL_BIT  BIT3                                                    // [3] FAIL1极性选择。1:信号极性取反输入，信号输入低为有效电平；0:信号极性正常输入，信号输入高为有效电平。
#define MCPWM0_CH_FAIL_FAIL0_POL_BIT  BIT2                                                    // [2] FAIL0极性选择。1:信号极性取反输入，信号输入低为有效电平；0:信号极性正常输入，信号输入高为有效电平。

/* MCPWM0_CH_DEF */
#define MCPWM0_CH_DEF_CH3P_DEFAULT_BIT BIT7 // [7] CH3 P通道默认值
#define MCPWM0_CH_DEF_CH3N_DEFAULT_BIT BIT6 // [6] CH3 N通道默认值。当发生FAIL事件或MOE为0时，相应通道输出默认电平。默认电平输出不受MCPWM0_IO23的 BIT0、BIT1、BIT8、BIT9、BIT6、BIT14通道交换和极性控制的影响，直接控制通道输出。
#define MCPWM0_CH_DEF_CH2P_DEFAULT_BIT BIT5 // [5] CH2_P通道默认值
#define MCPWM0_CH_DEF_CH2N_DEFAULT_BIT BIT4 // [4] CH2_N通道默认值
#define MCPWM0_CH_DEF_CH1P_DEFAULT_BIT BIT3 // [3] CH1_P通道默认值
#define MCPWM0_CH_DEF_CH1N_DEFAULT_BIT BIT2 // [2] CH1_N通道默认值
#define MCPWM0_CH_DEF_CH0P_DEFAULT_BIT BIT1 // [1] CH0_P通道默认值
#define MCPWM0_CH_DEF_CH0N_DEFAULT_BIT BIT0 // [0] CH0_N通道默认值。当发生FAIL事件或MOE为0时，相应通道输出默认电平。默认电平输出不受MCPWM0_IO01和MCPWM0_IO23的 BIT0、BIT1、BIT8、BIT9、BIT6、BIT14通道交换和极性控制的影响，直接控制通道输出。

/* MCPWM0_CH_MSK */
#define MCPWM0_CH_MSK_CH3P_FAIL_EN_BIT BIT7 // [7] CH3_P 通道FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH3N_FAIL_EN_BIT BIT6 // [6] CH3_N 通道FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH2P_FAIL_EN_BIT BIT5 // [5] CH2_P 通道FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH2N_FAIL_EN_BIT BIT4 // [4] CH2_N 通道FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH1P_FAIL_EN_BIT BIT3 // [3] CH1_P 通道FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH1N_FAIL_EN_BIT BIT2 // [2] CH1_N通道 FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH0P_FAIL_EN_BIT BIT1 // [1] CH0_P 通道FAIL事件使能，高有效，默认开启
#define MCPWM0_CH_MSK_CH0N_FAIL_EN_BIT BIT0 // [0] CH0_N 通道FAIL事件使能，1:发生FAIL事件或MCPWM0_CH012_FAIL.MOE=0时，CH0_N通道电平输出为默认值，0:发生FAIL事件或MCPWM0_CH012_FAIL.MOE=0时，CH0_N通道电平不受影响，仍由MCPWM内部硬件控制。默认开启FAIL使能

/* MCPWM0_PRT */
#define MCPWM0_PRT_PRT_POS  0                                                // MCPWM0_PRT_PRT起始位
#define MCPWM0_PRT_PRT_MASK (uint32_t)(0xFFFF << MCPWM0_PRT_PRT_POS)         // MCPWM0_PRT_PRT位掩码
#define MCPWM0_PRT_PRT(x)   (uint32_t)(((x) & 0xFFFF) << MCPWM0_PRT_PRT_POS) // [15:0] 写入0xDEAD，解除MCPWM寄存器写保护；写入其它值，MCPWM寄存器进入写保护。此寄存器读出恒为0。

/* MCPWM0_SW_FAIL */
#define MCPWM0_SW_FAIL_FAIL1_TE_BIT BIT5 // [5] FAIL1软件测试信号使能，高有效
#define MCPWM0_SW_FAIL_FAIL0_TE_BIT BIT4 // [4] FAIL0软件测试信号使能，高有效
#define MCPWM0_SW_FAIL_FAIL1_TD_BIT BIT1 // [1] FAIL1软件测试信号
#define MCPWM0_SW_FAIL_FAIL0_TD_BIT BIT0 // [0] FAIL0软件测试信号

/* GPIOx_PIE */
#define GPIOx_PIE_PIE15_BIT BIT15 // [15] GPIO x[15]/ Px[15]输入使能
#define GPIOx_PIE_PIE14_BIT BIT14 // [14] GPIO x[14]/ Px[14]输入使能
#define GPIOx_PIE_PIE13_BIT BIT13 // [13] GPIO x[13]/ Px[13]输入使能
#define GPIOx_PIE_PIE12_BIT BIT12 // [12] GPIO x[12]/ Px[12]输入使能
#define GPIOx_PIE_PIE11_BIT BIT11 // [11] GPIO x[11]/ Px[11]输入使能
#define GPIOx_PIE_PIE10_BIT BIT10 // [10] GPIO x[10]/ Px[10]输入使能
#define GPIOx_PIE_PIE9_BIT  BIT9  // [9] GPIO x[9]/ Px[9]输入使能
#define GPIOx_PIE_PIE8_BIT  BIT8  // [8] GPIO x[8]/ Px[8]输入使能
#define GPIOx_PIE_PIE7_BIT  BIT7  // [7] GPIO x[7]/ Px[7]输入使能
#define GPIOx_PIE_PIE6_BIT  BIT6  // [6] GPIO x[6]/ Px[6]输入使能
#define GPIOx_PIE_PIE5_BIT  BIT5  // [5] GPIO x[5]/ Px[5]输入使能
#define GPIOx_PIE_PIE4_BIT  BIT4  // [4] GPIO x[4]/ Px[4]输入使能
#define GPIOx_PIE_PIE3_BIT  BIT3  // [3] GPIO x[3]/ Px[3]输入使能
#define GPIOx_PIE_PIE2_BIT  BIT2  // [2] GPIO x[2]/ Px[2]输入使能
#define GPIOx_PIE_PIE1_BIT  BIT1  // [1] GPIO x[1]/ Px[1]输入使能
#define GPIOx_PIE_PIE0_BIT  BIT0  // [0] GPIO x[0]/ Px[0]输入使能

/* GPIOx_POE */
#define GPIOx_POE_POE15_BIT BIT15 // [15] GPIO x[15]/ Px[15]输出使能
#define GPIOx_POE_POE14_BIT BIT14 // [14] GPIO x[14]/ Px[14]输出使能
#define GPIOx_POE_POE13_BIT BIT13 // [13] GPIO x[13]/ Px[13]输出使能
#define GPIOx_POE_POE12_BIT BIT12 // [12] GPIO x[12]/ Px[12]输出使能
#define GPIOx_POE_POE11_BIT BIT11 // [11] GPIO x[11]/ Px[11]输出使能
#define GPIOx_POE_POE10_BIT BIT10 // [10] GPIO x[10]/ Px[10]输出使能
#define GPIOx_POE_POE9_BIT  BIT9  // [9] GPIO x[9]/ Px[9]输出使能
#define GPIOx_POE_POE8_BIT  BIT8  // [8] GPIO x[8]/ Px[8]输出使能
#define GPIOx_POE_POE7_BIT  BIT7  // [7] GPIO x[7]/ Px[7]输出使能
#define GPIOx_POE_POE6_BIT  BIT6  // [6] GPIO x[6]/ Px[6]输出使能
#define GPIOx_POE_POE5_BIT  BIT5  // [5] GPIO x[5]/ Px[5]输出使能
#define GPIOx_POE_POE4_BIT  BIT4  // [4] GPIO x[4]/ Px[4]输出使能
#define GPIOx_POE_POE3_BIT  BIT3  // [3] GPIO x[3]/ Px[3]输出使能
#define GPIOx_POE_POE2_BIT  BIT2  // [2] GPIO x[2]/ Px[2]输出使能
#define GPIOx_POE_POE1_BIT  BIT1  // [1] GPIO x[1]/ Px[1]输出使能
#define GPIOx_POE_POE0_BIT  BIT0  // [0] GPIO x[0]/ Px[0]输出使能

/* GPIOx_PDI */
#define GPIOx_PDI_PDI_POS  0                                               // GPIOx_PDI_PDI起始位
#define GPIOx_PDI_PDI_MASK (uint32_t)(0xFFFF << GPIOx_PDI_PDI_POS)         // GPIOx_PDI_PDI位掩码
#define GPIOx_PDI_PDI(x)   (uint32_t)(((x) & 0xFFFF) << GPIOx_PDI_PDI_POS) // [15:0] GPIO x输入数据

/* GPIOx_PDO */
#define GPIOx_PDO_PDO_POS  0                                               // GPIOx_PDO_PDO起始位
#define GPIOx_PDO_PDO_MASK (uint32_t)(0xFFFF << GPIOx_PDO_PDO_POS)         // GPIOx_PDO_PDO位掩码
#define GPIOx_PDO_PDO(x)   (uint32_t)(((x) & 0xFFFF) << GPIOx_PDO_PDO_POS) // [15:0] GPIO x输出数据

/* GPIOx_PUE */
#define GPIOx_PUE_PUE15_BIT BIT15 // [15] GPIO x[15]/ Px[15]上拉使能
#define GPIOx_PUE_PUE14_BIT BIT14 // [14] GPIO x[14]/ Px[14]上拉使能
#define GPIOx_PUE_PUE13_BIT BIT13 // [13] GPIO x[13]/ Px[13]上拉使能
#define GPIOx_PUE_PUE12_BIT BIT12 // [12] GPIO x[12]/ Px[12]上拉使能
#define GPIOx_PUE_PUE11_BIT BIT11 // [11] GPIO x[11]/ Px[11]上拉使能
#define GPIOx_PUE_PUE10_BIT BIT10 // [10] GPIO x[10]/ Px[10]上拉使能
#define GPIOx_PUE_PUE9_BIT  BIT9  // [9] GPIO x[9]/ Px[9]上拉使能
#define GPIOx_PUE_PUE8_BIT  BIT8  // [8] GPIO x[8]/ Px[8]上拉使能
#define GPIOx_PUE_PUE7_BIT  BIT7  // [7] GPIO x[7]/ Px[7]上拉使能
#define GPIOx_PUE_PUE6_BIT  BIT6  // [6] GPIO x[6]/ Px[6]上拉使能
#define GPIOx_PUE_PUE5_BIT  BIT5  // [5] GPIO x[5]/ Px[5]上拉使能
#define GPIOx_PUE_PUE4_BIT  BIT4  // [4] GPIO x[4]/ Px[4]上拉使能
#define GPIOx_PUE_PUE3_BIT  BIT3  // [3] GPIO x[3]/ Px[3]上拉使能
#define GPIOx_PUE_PUE2_BIT  BIT2  // [2] GPIO x[2]/ Px[2]上拉使能
#define GPIOx_PUE_PUE1_BIT  BIT1  // [1] GPIO x[1]/ Px[1]上拉使能
#define GPIOx_PUE_PUE0_BIT  BIT0  // [0] GPIO x[0]/ Px[0]上拉使能

/* GPIOx_PODE */
#define GPIOx_PODE_PODE15_BIT BIT15 // [15] GPIO x[15]/ Px[15]开漏使能
#define GPIOx_PODE_PODE14_BIT BIT14 // [14] GPIO x[14]/ Px[14]开漏使能
#define GPIOx_PODE_PODE13_BIT BIT13 // [13] GPIO x[13]/ Px[13]开漏使能
#define GPIOx_PODE_PODE12_BIT BIT12 // [12] GPIO x[12]/ Px[12]开漏使能
#define GPIOx_PODE_PODE11_BIT BIT11 // [11] GPIO x[11]/ Px[11]开漏使能
#define GPIOx_PODE_PODE10_BIT BIT10 // [10] GPIO x[10]/ Px[10]开漏使能
#define GPIOx_PODE_PODE9_BIT  BIT9  // [9] GPIO x[9]/ Px[9]开漏使能
#define GPIOx_PODE_PODE8_BIT  BIT8  // [8] GPIO x[8]/ Px[8]开漏使能
#define GPIOx_PODE_PODE7_BIT  BIT7  // [7] GPIO x[7]/ Px[7]开漏使能
#define GPIOx_PODE_PODE6_BIT  BIT6  // [6] GPIO x[6]/ Px[6]开漏使能
#define GPIOx_PODE_PODE5_BIT  BIT5  // [5] GPIO x[5]/ Px[5]开漏使能
#define GPIOx_PODE_PODE4_BIT  BIT4  // [4] GPIO x[4]/ Px[4]开漏使能
#define GPIOx_PODE_PODE3_BIT  BIT3  // [3] GPIO x[3]/ Px[3]开漏使能
#define GPIOx_PODE_PODE2_BIT  BIT2  // [2] GPIO x[2]/ Px[2]开漏使能
#define GPIOx_PODE_PODE1_BIT  BIT1  // [1] GPIO x[1]/ Px[1]开漏使能
#define GPIOx_PODE_PODE0_BIT  BIT0  // [0] GPIO x[0]/ Px[0]开漏使能

/* GPIOx_PFLT */
#define GPIOx_PFLT_PFLT15_BIT BIT15 // [15] GPIO x[15]/ Px[15]滤波使能
#define GPIOx_PFLT_PFLT14_BIT BIT14 // [14] GPIO x[14]/ Px[14]滤波使能
#define GPIOx_PFLT_PFLT13_BIT BIT13 // [13] GPIO x[13]/ Px[13]滤波使能
#define GPIOx_PFLT_PFLT12_BIT BIT12 // [12] GPIO x[12]/ Px[12]滤波使能
#define GPIOx_PFLT_PFLT11_BIT BIT11 // [11] GPIO x[11]/ Px[11]滤波使能
#define GPIOx_PFLT_PFLT10_BIT BIT10 // [10] GPIO x[10]/ Px[10]滤波使能
#define GPIOx_PFLT_PFLT9_BIT  BIT9  // [9] GPIO x[9]/ Px[9]滤波使能
#define GPIOx_PFLT_PFLT8_BIT  BIT8  // [8] GPIO x[8]/ Px[8]滤波使能
#define GPIOx_PFLT_PFLT7_BIT  BIT7  // [7] GPIO x[7]/ Px[7]滤波使能
#define GPIOx_PFLT_PFLT6_BIT  BIT6  // [6] GPIO x[6]/ Px[6]滤波使能
#define GPIOx_PFLT_PFLT5_BIT  BIT5  // [5] GPIO x[5]/ Px[5]滤波使能
#define GPIOx_PFLT_PFLT4_BIT  BIT4  // [4] GPIO x[4]/ Px[4]滤波使能
#define GPIOx_PFLT_PFLT3_BIT  BIT3  // [3] GPIO x[3]/ Px[3]滤波使能
#define GPIOx_PFLT_PFLT2_BIT  BIT2  // [2] GPIO x[2]/ Px[2]滤波使能
#define GPIOx_PFLT_PFLT1_BIT  BIT1  // [1] GPIO x[1]/ Px[1]滤波使能
#define GPIOx_PFLT_PFLT0_BIT  BIT0  // [0] GPIO x[0]/ Px[0]滤波使能

/* GPIOx_F3210 */
#define GPIOx_F3210_F3_POS  12                                            // GPIOx_F3210_F3起始位
#define GPIOx_F3210_F3_MASK (uint32_t)(0xF << GPIOx_F3210_F3_POS)         // GPIOx_F3210_F3位掩码
#define GPIOx_F3210_F3(x)   (uint32_t)(((x) & 0xF) << GPIOx_F3210_F3_POS) // [15:12] GPIO x[3]/ Px[3]功能选择
#define GPIOx_F3210_F2_POS  8                                             // GPIOx_F3210_F2起始位
#define GPIOx_F3210_F2_MASK (uint32_t)(0xF << GPIOx_F3210_F2_POS)         // GPIOx_F3210_F2位掩码
#define GPIOx_F3210_F2(x)   (uint32_t)(((x) & 0xF) << GPIOx_F3210_F2_POS) // [11:8] GPIO x[2]/ Px[2]功能选择
#define GPIOx_F3210_F1_POS  4                                             // GPIOx_F3210_F1起始位
#define GPIOx_F3210_F1_MASK (uint32_t)(0xF << GPIOx_F3210_F1_POS)         // GPIOx_F3210_F1位掩码
#define GPIOx_F3210_F1(x)   (uint32_t)(((x) & 0xF) << GPIOx_F3210_F1_POS) // [7:4] GPIO x[1]/ Px[1]功能选择
#define GPIOx_F3210_F0_POS  0                                             // GPIOx_F3210_F0起始位
#define GPIOx_F3210_F0_MASK (uint32_t)(0xF << GPIOx_F3210_F0_POS)         // GPIOx_F3210_F0位掩码
#define GPIOx_F3210_F0(x)   (uint32_t)(((x) & 0xF) << GPIOx_F3210_F0_POS) // [3:0] GPIO x[0]/ Px[0]功能选择

/* GPIOx_F7654 */
#define GPIOx_F7654_F7_POS  12                                            // GPIOx_F7654_F7起始位
#define GPIOx_F7654_F7_MASK (uint32_t)(0xF << GPIOx_F7654_F7_POS)         // GPIOx_F7654_F7位掩码
#define GPIOx_F7654_F7(x)   (uint32_t)(((x) & 0xF) << GPIOx_F7654_F7_POS) // [15:12] GPIO x[7]/ Px[7]功能选择
#define GPIOx_F7654_F6_POS  8                                             // GPIOx_F7654_F6起始位
#define GPIOx_F7654_F6_MASK (uint32_t)(0xF << GPIOx_F7654_F6_POS)         // GPIOx_F7654_F6位掩码
#define GPIOx_F7654_F6(x)   (uint32_t)(((x) & 0xF) << GPIOx_F7654_F6_POS) // [11:8] GPIO x[6]/ Px[6]功能选择
#define GPIOx_F7654_F5_POS  4                                             // GPIOx_F7654_F5起始位
#define GPIOx_F7654_F5_MASK (uint32_t)(0xF << GPIOx_F7654_F5_POS)         // GPIOx_F7654_F5位掩码
#define GPIOx_F7654_F5(x)   (uint32_t)(((x) & 0xF) << GPIOx_F7654_F5_POS) // [7:4] GPIO x[5]/ Px[5]功能选择
#define GPIOx_F7654_F4_POS  0                                             // GPIOx_F7654_F4起始位
#define GPIOx_F7654_F4_MASK (uint32_t)(0xF << GPIOx_F7654_F4_POS)         // GPIOx_F7654_F4位掩码
#define GPIOx_F7654_F4(x)   (uint32_t)(((x) & 0xF) << GPIOx_F7654_F4_POS) // [3:0] GPIO x[4]/ Px[4]功能选择

/* GPIOx_FBA98 */
#define GPIOx_FBA98_F11_POS  12                                             // GPIOx_FBA98_F11起始位
#define GPIOx_FBA98_F11_MASK (uint32_t)(0xF << GPIOx_FBA98_F11_POS)         // GPIOx_FBA98_F11位掩码
#define GPIOx_FBA98_F11(x)   (uint32_t)(((x) & 0xF) << GPIOx_FBA98_F11_POS) // [15:12] GPIO x[11]/ Px[11]功能选择
#define GPIOx_FBA98_F10_POS  8                                              // GPIOx_FBA98_F10起始位
#define GPIOx_FBA98_F10_MASK (uint32_t)(0xF << GPIOx_FBA98_F10_POS)         // GPIOx_FBA98_F10位掩码
#define GPIOx_FBA98_F10(x)   (uint32_t)(((x) & 0xF) << GPIOx_FBA98_F10_POS) // [11:8] GPIO x[10]/ Px[10]功能选择
#define GPIOx_FBA98_F9_POS   4                                              // GPIOx_FBA98_F9起始位
#define GPIOx_FBA98_F9_MASK  (uint32_t)(0xF << GPIOx_FBA98_F9_POS)          // GPIOx_FBA98_F9位掩码
#define GPIOx_FBA98_F9(x)    (uint32_t)(((x) & 0xF) << GPIOx_FBA98_F9_POS)  // [7:4] GPIO x[9]/ Px[9]功能选择
#define GPIOx_FBA98_F8_POS   0                                              // GPIOx_FBA98_F8起始位
#define GPIOx_FBA98_F8_MASK  (uint32_t)(0xF << GPIOx_FBA98_F8_POS)          // GPIOx_FBA98_F8位掩码
#define GPIOx_FBA98_F8(x)    (uint32_t)(((x) & 0xF) << GPIOx_FBA98_F8_POS)  // [3:0] GPIO x[8]/ Px[8]功能选择

/* GPIOx_FFEDC */
#define GPIOx_FFEDC_F15_POS  12                                             // GPIOx_FFEDC_F15起始位
#define GPIOx_FFEDC_F15_MASK (uint32_t)(0xF << GPIOx_FFEDC_F15_POS)         // GPIOx_FFEDC_F15位掩码
#define GPIOx_FFEDC_F15(x)   (uint32_t)(((x) & 0xF) << GPIOx_FFEDC_F15_POS) // [15:12] GPIO x[15]/ Px[15]功能选择
#define GPIOx_FFEDC_F14_POS  8                                              // GPIOx_FFEDC_F14起始位
#define GPIOx_FFEDC_F14_MASK (uint32_t)(0xF << GPIOx_FFEDC_F14_POS)         // GPIOx_FFEDC_F14位掩码
#define GPIOx_FFEDC_F14(x)   (uint32_t)(((x) & 0xF) << GPIOx_FFEDC_F14_POS) // [11:8] GPIO x[14]/ Px[14]功能选择
#define GPIOx_FFEDC_F13_POS  4                                              // GPIOx_FFEDC_F13起始位
#define GPIOx_FFEDC_F13_MASK (uint32_t)(0xF << GPIOx_FFEDC_F13_POS)         // GPIOx_FFEDC_F13位掩码
#define GPIOx_FFEDC_F13(x)   (uint32_t)(((x) & 0xF) << GPIOx_FFEDC_F13_POS) // [7:4] GPIO x[13]/ Px[13]功能选择
#define GPIOx_FFEDC_F12_POS  0                                              // GPIOx_FFEDC_F12起始位
#define GPIOx_FFEDC_F12_MASK (uint32_t)(0xF << GPIOx_FFEDC_F12_POS)         // GPIOx_FFEDC_F12位掩码
#define GPIOx_FFEDC_F12(x)   (uint32_t)(((x) & 0xF) << GPIOx_FFEDC_F12_POS) // [3:0] GPIO x[12]/ Px[12]功能选择

/* GPIOx_BSRR */
#define GPIOx_BSRR_CLR15_BIT BIT31 // [31] 写1将GPIO x[15]清零，写0无作用
#define GPIOx_BSRR_CLR14_BIT BIT30 // [30] 写1将GPIO x[14]清零，写0无作用
#define GPIOx_BSRR_CLR13_BIT BIT29 // [29] 写1将GPIO x[13]清零，写0无作用
#define GPIOx_BSRR_CLR12_BIT BIT28 // [28] 写1将GPIO x[12]清零，写0无作用
#define GPIOx_BSRR_CLR11_BIT BIT27 // [27] 写1将GPIO x[11]清零，写0无作用
#define GPIOx_BSRR_CLR10_BIT BIT26 // [26] 写1将GPIO x[10]清零，写0无作用
#define GPIOx_BSRR_CLR9_BIT  BIT25 // [25] 写1将GPIO x[9]清零，写0无作用
#define GPIOx_BSRR_CLR8_BIT  BIT24 // [24] 写1将GPIO x[8]清零，写0无作用
#define GPIOx_BSRR_CLR7_BIT  BIT23 // [23] 写1将GPIO x[7]清零，写0无作用
#define GPIOx_BSRR_CLR6_BIT  BIT22 // [22] 写1将GPIO x[6]清零，写0无作用
#define GPIOx_BSRR_CLR5_BIT  BIT21 // [21] 写1将GPIO x[5]清零，写0无作用
#define GPIOx_BSRR_CLR4_BIT  BIT20 // [20] 写1将GPIO x[4]清零，写0无作用
#define GPIOx_BSRR_CLR3_BIT  BIT19 // [19] 写1将GPIO x[3]清零，写0无作用
#define GPIOx_BSRR_CLR2_BIT  BIT18 // [18] 写1将GPIO x[2]清零，写0无作用
#define GPIOx_BSRR_CLR1_BIT  BIT17 // [17] 写1将GPIO x[1]清零，写0无作用
#define GPIOx_BSRR_CLR0_BIT  BIT16 // [16] 写1将GPIO x[0]清零，写0无作用
#define GPIOx_BSRR_SET15_BIT BIT15 // [15] 写1将GPIO x[15]置1，写0无作用
#define GPIOx_BSRR_SET14_BIT BIT14 // [14] 写1将GPIO x[14]置1，写0无作用
#define GPIOx_BSRR_SET13_BIT BIT13 // [13] 写1将GPIO x[13]置1，写0无作用
#define GPIOx_BSRR_SET12_BIT BIT12 // [12] 写1将GPIO x[12]置1，写0无作用
#define GPIOx_BSRR_SET11_BIT BIT11 // [11] 写1将GPIO x[11]置1，写0无作用
#define GPIOx_BSRR_SET10_BIT BIT10 // [10] 写1将GPIO x[10]置1，写0无作用
#define GPIOx_BSRR_SET9_BIT  BIT9  // [9] 写1将GPIO x[9]置1，写0无作用
#define GPIOx_BSRR_SET8_BIT  BIT8  // [8] 写1将GPIO x[8]置1，写0无作用
#define GPIOx_BSRR_SET7_BIT  BIT7  // [7] 写1将GPIO x[7]置1，写0无作用
#define GPIOx_BSRR_SET6_BIT  BIT6  // [6] 写1将GPIO x[6]置1，写0无作用
#define GPIOx_BSRR_SET5_BIT  BIT5  // [5] 写1将GPIO x[5]置1，写0无作用
#define GPIOx_BSRR_SET4_BIT  BIT4  // [4] 写1将GPIO x[4]置1，写0无作用
#define GPIOx_BSRR_SET3_BIT  BIT3  // [3] 写1将GPIO x[3]置1，写0无作用
#define GPIOx_BSRR_SET2_BIT  BIT2  // [2] 写1将GPIO x[2]置1，写0无作用
#define GPIOx_BSRR_SET1_BIT  BIT1  // [1] 写1将GPIO x[1]置1，写0无作用
#define GPIOx_BSRR_SET0_BIT  BIT0  // [0] 写1将GPIO x[0]置1，写0无作用

/* GPIOx_BRR */
#define GPIOx_BRR_CLR15_BIT BIT15 // [15] 写1将GPIO x[15]清零，写0无作用
#define GPIOx_BRR_CLR14_BIT BIT14 // [14] 写1将GPIO x[14]清零，写0无作用
#define GPIOx_BRR_CLR13_BIT BIT13 // [13] 写1将GPIO x[13]清零，写0无作用
#define GPIOx_BRR_CLR12_BIT BIT12 // [12] 写1将GPIO x[12]清零，写0无作用
#define GPIOx_BRR_CLR11_BIT BIT11 // [11] 写1将GPIO x[11]清零，写0无作用
#define GPIOx_BRR_CLR10_BIT BIT10 // [10] 写1将GPIO x[10]清零，写0无作用
#define GPIOx_BRR_CLR9_BIT  BIT9  // [9] 写1将GPIO x[9]清零，写0无作用
#define GPIOx_BRR_CLR8_BIT  BIT8  // [8] 写1将GPIO x[8]清零，写0无作用
#define GPIOx_BRR_CLR7_BIT  BIT7  // [7] 写1将GPIO x[7]清零，写0无作用
#define GPIOx_BRR_CLR6_BIT  BIT6  // [6] 写1将GPIO x[6]清零，写0无作用
#define GPIOx_BRR_CLR5_BIT  BIT5  // [5] 写1将GPIO x[5]清零，写0无作用
#define GPIOx_BRR_CLR4_BIT  BIT4  // [4] 写1将GPIO x[4]清零，写0无作用
#define GPIOx_BRR_CLR3_BIT  BIT3  // [3] 写1将GPIO x[3]清零，写0无作用
#define GPIOx_BRR_CLR2_BIT  BIT2  // [2] 写1将GPIO x[2]清零，写0无作用
#define GPIOx_BRR_CLR1_BIT  BIT1  // [1] 写1将GPIO x[1]清零，写0无作用
#define GPIOx_BRR_CLR0_BIT  BIT0  // [0] 写1将GPIO x[0]清零，写0无作用

/* EXTI_CR0 */
#define EXTI_CR0_T7_POS  14                                         // EXTI_CR0_T7起始位
#define EXTI_CR0_T7_MASK (uint32_t)(0x3 << EXTI_CR0_T7_POS)         // EXTI_CR0_T7位掩码
#define EXTI_CR0_T7(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T7_POS) // [15:14] GPIO 1[0]/ P1[0]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T6_POS  12                                         // EXTI_CR0_T6起始位
#define EXTI_CR0_T6_MASK (uint32_t)(0x3 << EXTI_CR0_T6_POS)         // EXTI_CR0_T6位掩码
#define EXTI_CR0_T6(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T6_POS) // [13:12] GPIO 0[15]/ P0[15]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T5_POS  10                                         // EXTI_CR0_T5起始位
#define EXTI_CR0_T5_MASK (uint32_t)(0x3 << EXTI_CR0_T5_POS)         // EXTI_CR0_T5位掩码
#define EXTI_CR0_T5(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T5_POS) // [11:10] GPIO 0[14]/ P0[14]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T4_POS  8                                          // EXTI_CR0_T4起始位
#define EXTI_CR0_T4_MASK (uint32_t)(0x3 << EXTI_CR0_T4_POS)         // EXTI_CR0_T4位掩码
#define EXTI_CR0_T4(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T4_POS) // [9:8] GPIO 0[13]/ P0[13]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T3_POS  6                                          // EXTI_CR0_T3起始位
#define EXTI_CR0_T3_MASK (uint32_t)(0x3 << EXTI_CR0_T3_POS)         // EXTI_CR0_T3位掩码
#define EXTI_CR0_T3(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T3_POS) // [7:6] GPIO 0[12]/ P0[12]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T2_POS  4                                          // EXTI_CR0_T2起始位
#define EXTI_CR0_T2_MASK (uint32_t)(0x3 << EXTI_CR0_T2_POS)         // EXTI_CR0_T2位掩码
#define EXTI_CR0_T2(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T2_POS) // [5:4] GPIO 0[11]/ P0[11]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T1_POS  2                                          // EXTI_CR0_T1起始位
#define EXTI_CR0_T1_MASK (uint32_t)(0x3 << EXTI_CR0_T1_POS)         // EXTI_CR0_T1位掩码
#define EXTI_CR0_T1(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T1_POS) // [3:2] GPIO 0[2]/ P0[2]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR0_T0_POS  0                                          // EXTI_CR0_T0起始位
#define EXTI_CR0_T0_MASK (uint32_t)(0x3 << EXTI_CR0_T0_POS)         // EXTI_CR0_T0位掩码
#define EXTI_CR0_T0(x)   (uint32_t)(((x) & 0x3) << EXTI_CR0_T0_POS) // [1:0] GPIO 0[0]/ P0[0]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发

/* EXTI_CR1 */
#define EXTI_CR1_T15_POS  14                                          // EXTI_CR1_T15起始位
#define EXTI_CR1_T15_MASK (uint32_t)(0x3 << EXTI_CR1_T15_POS)         // EXTI_CR1_T15位掩码
#define EXTI_CR1_T15(x)   (uint32_t)(((x) & 0x3) << EXTI_CR1_T15_POS) // [15:14] GPIO 2[0]/P2[0]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T14_POS  12                                          // EXTI_CR1_T14起始位
#define EXTI_CR1_T14_MASK (uint32_t)(0x3 << EXTI_CR1_T14_POS)         // EXTI_CR1_T14位掩码
#define EXTI_CR1_T14(x)   (uint32_t)(((x) & 0x3) << EXTI_CR1_T14_POS) // [13:12] GPIO 2[13]/P2[13]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T13_POS  10                                          // EXTI_CR1_T13起始位
#define EXTI_CR1_T13_MASK (uint32_t)(0x3 << EXTI_CR1_T13_POS)         // EXTI_CR1_T13位掩码
#define EXTI_CR1_T13(x)   (uint32_t)(((x) & 0x3) << EXTI_CR1_T13_POS) // [11:10] GPIO 2[6]/P2[6]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T12_POS  8                                           // EXTI_CR1_T12起始位
#define EXTI_CR1_T12_MASK (uint32_t)(0x3 << EXTI_CR1_T12_POS)         // EXTI_CR1_T12位掩码
#define EXTI_CR1_T12(x)   (uint32_t)(((x) & 0x3) << EXTI_CR1_T12_POS) // [9:8] GPIO 2[5]/P2[5]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T11_POS  6                                           // EXTI_CR1_T11起始位
#define EXTI_CR1_T11_MASK (uint32_t)(0x3 << EXTI_CR1_T11_POS)         // EXTI_CR1_T11位掩码
#define EXTI_CR1_T11(x)   (uint32_t)(((x) & 0x3) << EXTI_CR1_T11_POS) // [7:6] GPIO 2[4]/P2[4]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T10_POS  4                                           // EXTI_CR1_T10起始位
#define EXTI_CR1_T10_MASK (uint32_t)(0x3 << EXTI_CR1_T10_POS)         // EXTI_CR1_T10位掩码
#define EXTI_CR1_T10(x)   (uint32_t)(((x) & 0x3) << EXTI_CR1_T10_POS) // [5:4] GPIO 2[3]/P2[3]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T9_POS   2                                           // EXTI_CR1_T9起始位
#define EXTI_CR1_T9_MASK  (uint32_t)(0x3 << EXTI_CR1_T9_POS)          // EXTI_CR1_T9位掩码
#define EXTI_CR1_T9(x)    (uint32_t)(((x) & 0x3) << EXTI_CR1_T9_POS)  // [3:2] GPIO 2[9]/P2[9]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发
#define EXTI_CR1_T8_POS   0                                           // EXTI_CR1_T8起始位
#define EXTI_CR1_T8_MASK  (uint32_t)(0x3 << EXTI_CR1_T8_POS)          // EXTI_CR1_T8位掩码
#define EXTI_CR1_T8(x)    (uint32_t)(((x) & 0x3) << EXTI_CR1_T8_POS)  // [1:0] GPIO 2[7]/P2[7]外部触发类型选择 00:不触发 01:下降沿触发 10:上升沿触发 11:上升沿、下降沿均触发

/*  EXTI_IE */
#define EXTI_IE_EXTI2_RE_BIT BIT10 // [10] GPIO2 DMA 请求使能，需要配合EXTI_CR0/1使用
#define EXTI_IE_EXTI1_RE_BIT BIT9  // [9] GPIO1 DMA 请求使能，需要配合EXTI_CR0/1使用
#define EXTI_IE_EXTI0_RE_BIT BIT8  // [8] GPIO0 DMA 请求使能，需要配合EXTI_CR0/1使用
#define EXTI_IE_EXTI2_IE_BIT BIT2  // [2] GPIO2中断使能，需要配合EXTI_CR0/1使用
#define EXTI_IE_EXTI1_IE_BIT BIT1  // [1] GPIO1中断使能，需要配合EXTI_CR0/1使用
#define EXTI_IE_EXTI0_IE_BIT BIT0  // [0] GPIO0中断使能，需要配合EXTI_CR0/1使用

/*  EXTI_IF */
#define EXTI_IF_IF15_BIT BIT15 // [15] GPIO 2[0]/ P2[0]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF14_BIT BIT14 // [14] GPIO 2[13]/ P2[13]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF13_BIT BIT13 // [13] GPIO 2[6]/ P2[6]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF12_BIT BIT12 // [12] GPIO 2[5]/ P2[5]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF11_BIT BIT11 // [11] GPIO 2[4]/ P2[4]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF10_BIT BIT10 // [10] GPIO 2[3]/ P2[3]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF9_BIT  BIT9  // [9] GPIO 2[9]/ P2[9]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF8_BIT  BIT8  // [8] GPIO 2[7]/ P2[7]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF7_BIT  BIT7  // [7] GPIO 1[0]/ P1[0]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF6_BIT  BIT6  // [6] GPIO 0[15]/ P0[15]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF5_BIT  BIT5  // [5] GPIO 0[14]/ P0[14]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF4_BIT  BIT4  // [4] GPIO 0[13]/ P0[13]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF3_BIT  BIT3  // [3] GPIO 0[12]/ P0[12]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF2_BIT  BIT2  // [2] GPIO 0[11]/ P0[11]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF1_BIT  BIT1  // [1] GPIO 0[2]/ P0[2]外部中断标志。中断标志高有效，写1清零
#define EXTI_IF_IF0_BIT  BIT0  // [0] GPIO 0[0]/ P0[0]外部中断标志。中断标志高有效，写1清零

/* EXTI_CLKO */
#define EXTI_CLKO_HSE_OE_BIT BIT4 // [4] 晶振时钟输出使能。1:使能；0:禁用。
#define EXTI_CLKO_ADC_OE_BIT BIT3 // [3] ADC时钟输出使能。1:使能；0:禁用。
#define EXTI_CLKO_PLL_OE_BIT BIT2 // [2] PLL输出使能。1:使能；0:禁用。
#define EXTI_CLKO_HSI_OE_BIT BIT1 // [1] HRC输出使能。1:使能；0:禁用。
#define EXTI_CLKO_LSI_OE_BIT BIT0 // [0] LRC输出使能。1:使能；0:禁用。

/* PWM_SWAP */
#define PWM_SWAP_SWAP_POS  0                                            // PWM_SWAP_SWAP起始位
#define PWM_SWAP_SWAP_MASK (uint32_t)(0x3 << PWM_SWAP_SWAP_POS)         // PWM_SWAP_SWAP位掩码
#define PWM_SWAP_SWAP(x)   (uint32_t)(((x) & 0x3) << PWM_SWAP_SWAP_POS) // [1:0] 向此寄存器写入0x67可将BIT[1:0]写为1，写入0x69可将BIT[1:0]写为2，写其他值则将BIT[1:0]写为0。

/* CRC0_DR CRC信息码寄存器 */
#define CRC0_DR_DR_POS  0                                                // CRC0_DR_DR起始位
#define CRC0_DR_DR_MASK (uint32_t)(0xFFFFFFFF << CRC0_DR_DR_POS)         // CRC0_DR_DR位掩码
#define CRC0_DR_DR(x)   (uint32_t)(((x) & 0xFFFFFFFF) << CRC0_DR_DR_POS) // [31:0] 存放待编码的信息码和经CRC校验后的编码

/* CRC0_CR CRC控制寄存器 */
#define CRC0_CR_REV_OUT_TYPE_BIT BIT12                                              // [12] 是否将CRC校验后的编码反转后输出，即b[31]=b[0], b[30]=b[1],… [b0]=b[31]
#define CRC0_CR_REV_IN_TYPE_POS  8                                                  // CRC0_CR_REV_IN_TYPE起始位
#define CRC0_CR_REV_IN_TYPE_MASK (uint32_t)(0x3 << CRC0_CR_REV_IN_TYPE_POS)         // CRC0_CR_REV_IN_TYPE位掩码
#define CRC0_CR_REV_IN_TYPE(x)   (uint32_t)(((x) & 0x3) << CRC0_CR_REV_IN_TYPE_POS) // [9:8] 待编码数据反转类型 00:不反转 01:按字节反转，即b[31]=b[24], b[30]=b[25], …, b[24]=b[31], …, b[7]=b[0], b[6]=b[1], …, b[0]=b[7]10:按半字（16bit）反转，即b[31]=b[16], b[30]=b[17], …, b[16]=b[31], …, b[15]=b[0], b[14]=b[1], …, b[0]=b[15]11:按字反转，即b[31]=b[0], b[30]=b[1],… [b0]=b[31]
#define CRC0_CR_POLY_SIZE_POS    4                                                  // CRC0_CR_POLY_SIZE起始位
#define CRC0_CR_POLY_SIZE_MASK   (uint32_t)(0x3 << CRC0_CR_POLY_SIZE_POS)           // CRC0_CR_POLY_SIZE位掩码
#define CRC0_CR_POLY_SIZE(x)     (uint32_t)(((x) & 0x3) << CRC0_CR_POLY_SIZE_POS)   // [5:4] 输出编码（多项式）位宽 00: 32bits 01: 16bits 10: 8bits 11: 7bits
#define CRC0_CR_RESET_BIT        BIT0                                               // [0] 与输入信息码进行CRC计算的数据来源 0:来自于上一次的计算结果 1:来自于CRC0_INIT 写入1实现CRC数据重置并自动清零，读回恒为0.

/* CRC0_INIT CRC初始码寄存器 */
#define CRC0_INIT_INIT_POS  0                                                    // CRC0_INIT_INIT起始位
#define CRC0_INIT_INIT_MASK (uint32_t)(0xFFFFFFFF << CRC0_INIT_INIT_POS)         // CRC0_INIT_INIT位掩码
#define CRC0_INIT_INIT(x)   (uint32_t)(((x) & 0xFFFFFFFF) << CRC0_INIT_INIT_POS) // [31:0] 存放初始码

/* CRC0_POL CRC生成码寄存器 */
#define CRC0_POL_POL_POS  0                                                  // CRC0_POL_POL起始位
#define CRC0_POL_POL_MASK (uint32_t)(0xFFFFFFFF << CRC0_POL_POL_POS)         // CRC0_POL_POL位掩码
#define CRC0_POL_POL(x)   (uint32_t)(((x) & 0xFFFFFFFF) << CRC0_POL_POL_POS) // [31:0] 存放生成多项式对应的生成码

/* UARTx_CTRL UARTx控制寄存器 (x = 0,1,2) */
#define UARTx_CTRL_DUPLEX_BIT    BIT7 // [7] 双工，默认值为0。 0:全双工；1:半双工
#define UARTx_CTRL_LIN_EN_BIT    BIT6 // [6] LIN模式使能，默认值为0。 0:关闭；1:开启
#define UARTx_CTRL_MD_EN_BIT     BIT5 // [5] 使能Multi-drop，默认值为0。 0:关闭；1:开启
#define UARTx_CTRL_CK_EN_BIT     BIT4 // [4] 数据校验开关，默认值为0。 0:关闭；1:开启
#define UARTx_CTRL_CK_TYPE_BIT   BIT3 // [3] 奇偶校验配置，默认值为0。 0:偶校验（EVEN）；1: 奇校验（ODD）
#define UARTx_CTRL_BIT_ORDER_BIT BIT2 // [2] 数据发送顺序配置，默认值为0。 0:LSB；1:MSB
#define UARTx_CTRL_STOP_LEN_BIT  BIT1 // [1] 停止位长度配置，默认值为0。 0:1-Bit；1:2-Bit
#define UARTx_CTRL_BYTE_LEN_BIT  BIT0 // [0] 数据长度配置，默认值为0。 0:8-Bit；1:9-Bit

/* UARTx_DIVH UARTx波特率设置高字节寄存器 (x = 0,1,2) */
#define UARTx_DIVH_DIVH_POS  0                                               // UARTx_DIVH_DIVH起始位
#define UARTx_DIVH_DIVH_MASK (uint32_t)(0xFF << UARTx_DIVH_DIVH_POS)         // UARTx_DIVH_DIVH位掩码
#define UARTx_DIVH_DIVH(x)   (uint32_t)(((x) & 0xFF) << UARTx_DIVH_DIVH_POS) // [7:0] 波特率设置高字节 BAUDRATE =主时钟/(1+256\* UART_DIVH+UART_DIVL)

/* UARTx_DIVL UARTx波特率设置低字节寄存器 (x = 0,1,2) */
#define UARTx_DIVL_DIVL_POS  0                                               // UARTx_DIVL_DIVL起始位
#define UARTx_DIVL_DIVL_MASK (uint32_t)(0xFF << UARTx_DIVL_DIVL_POS)         // UARTx_DIVL_DIVL位掩码
#define UARTx_DIVL_DIVL(x)   (uint32_t)(((x) & 0xFF) << UARTx_DIVL_DIVL_POS) // [7:0] 波特率设置低字节 BAUDRATE =主时钟/(1+256\* UART_DIVH+UART_DIVL)

/* UARTx_BUFF UARTx收发缓冲寄存器 (x = 0,1,2) */
#define UARTx_BUFF_BUFF_POS  0                                                // UARTx_BUFF_BUFF起始位
#define UARTx_BUFF_BUFF_MASK (uint32_t)(0x1FF << UARTx_BUFF_BUFF_POS)         // UARTx_BUFF_BUFF位掩码
#define UARTx_BUFF_BUFF(x)   (uint32_t)(((x) & 0x1FF) << UARTx_BUFF_BUFF_POS) // [8:0] 写:发送数据缓存；读:接收数据寄存器

/* UARTx_ADR UARTx地址匹配寄存器 (x = 0,1,2) */
#define UARTx_ADR_ADR_POS  0                                             // UARTx_ADR_ADR起始位
#define UARTx_ADR_ADR_MASK (uint32_t)(0xFF << UARTx_ADR_ADR_POS)         // UARTx_ADR_ADR位掩码
#define UARTx_ADR_ADR(x)   (uint32_t)(((x) & 0xFF) << UARTx_ADR_ADR_POS) // [7:0] 多机通讯时的从机地址

/* UARTx_STT UARTx状态寄存器 (x = 0,1,2) */
#define UARTx_STT_RX_BUSY_BIT      BIT3 // [3] 1:UART已检测到起始符并正处于接收状态 0:UART接收端空闲 此状态位只读，置位与清零均由硬件完成
#define UARTx_STT_ADR_MATCH_BIT    BIT2 // [2] Multi-drop模式下，地址匹配标志位。 1:匹配；0:未匹配。
#define UARTx_STT_TX_DONE_BIT      BIT1 // [1] 发送完成标志位。 1:完成；0:未完成。
#define UARTx_STT_TX_BUF_EMPTY_BIT BIT0 // [0] 发送缓存状态位。 1:空；0:非空。

/* UARTx_RE UARTx DMA请求使能寄存器 (x = 0,1,2) */
#define UARTx_RE_TX_BUF_EMPTY_BIT BIT2 // [2] 发送缓冲区空DMA请求开关，默认值为0。 0:关闭；1:开启。
#define UARTx_RE_RX_DONE_BIT      BIT1 // [1] 接收完成DMA请求开关，默认值为0。 0:关闭；1:开启。
#define UARTx_RE_TX_DONE_BIT      BIT0 // [0] 发送完成DMA请求开关，默认值为0。 0:关闭；1:开启。

/* UARTx_IE UARTx中断使能寄存器 (x = 0,1,2) */
#define UARTx_IE_ABD_BIT          BIT9 // [9] 波特率自适应中断使能 0:关闭；1:开启
#define UARTx_IE_IDLE_BIT         BIT8 // [8] 空闲帧中断使能 0:关闭；1:开启
#define UARTx_IE_LBD_BIT          BIT7 // [7] LIN break character检测中断使能 0:关闭；1:开启
#define UARTx_IE_RX_OV_BIT        BIT6 // [6] 接收缓冲区溢出中断使能 0:关闭；1:开启
#define UARTx_IE_TX_OV_BIT        BIT5 // [5] 发送缓冲区溢出中断使能 0:关闭；1:开启
#define UARTx_IE_CK_ERR_BIT       BIT4 // [4] 校验错误中断开关，默认值为0。 0:关闭；1:开启
#define UARTx_IE_STOP_ERR_BIT     BIT3 // [3] 停止位错误中断开关，默认值为0。 0:关闭；1:开启
#define UARTx_IE_TX_BUF_EMPTY_BIT BIT2 // [2] 发送缓冲区空中断开关，默认值为0。 0:关闭；1:开启
#define UARTx_IE_RX_DONE_BIT      BIT1 // [1] 接收完成中断开关，默认值为0。 0:关闭；1:开启
#define UARTx_IE_TX_DONE_BIT      BIT0 // [0] 发送完成中断开关，默认值为0。 0:关闭；1:开启

/* UARTx_IF UARTx中断标志寄存器 (x = 0,1,2) */
#define UARTx_IF_ABD_BIT          BIT9 // [9] 波特率自适应使能情况下，发生波特率更新事件，高有效，写1清零
#define UARTx_IF_IDLE_BIT         BIT8 // [8] 空闲帧中断标志，高有效，写1清零 当UART检测到空闲帧后，硬件置位这一标志，如果UARTx_IE.IDLE_IE=1，则产生中断请求；写1清零后，只有待RX_DONE_IF标志再次置位后，IDLE_IF标志才会置位。在多从机（Multi-drop）场景中，只有从机地址命中时，即UARTx_STT.ADR_MATCH=1时，表示主机此时欲与本从机通讯，IDLE_IF才会置位，否则即使UARTx_RX信号为常高，IDLE_IF也不会置位。
#define UARTx_IF_LBD_BIT          BIT7 // [7] LIN break character检测中断标志，高有效，写1清零
#define UARTx_IF_RX_OV_BIT        BIT6 // [6] 接收缓冲区溢出中断标志，高有效，写1清零
#define UARTx_IF_TX_OV_BIT        BIT5 // [5] 发送缓冲区溢出中断标志，高有效，写1清零
#define UARTx_IF_CK_ERR_BIT       BIT4 // [4] 校验错误中断标志，高有效，写1清零
#define UARTx_IF_STOP_ERR_BIT     BIT3 // [3] 停止位错误中断标志，高有效，写1清零
#define UARTx_IF_TX_BUF_EMPTY_BIT BIT2 // [2] 发送缓冲区空中断标志，高有效，写1清零
#define UARTx_IF_RX_DONE_BIT      BIT1 // [1] 接收完成中断标志，高有效，写1清零
#define UARTx_IF_TX_DONE_BIT      BIT0 // [0] 发送完成中断标志，高有效，写1清零

/* UARTx_IOC UARTx IO控制寄存器 (x = 0,1,2) */
#define UARTx_IOC_SBK_BIT     BIT7 // [7] LIN模式下，写1发送一次break character，即连续13个0，完成后自动清零，未完成时读回为1，向此位写1之前需要先配置UARTx_CTRL.LIN_EN=1，否则无法进行break character的发送
#define UARTx_IOC_LBDL_BIT    BIT6 // [6] LIN break character检测长度，10/11个0 0:10bits，1:11bits
#define UARTx_IOC_ABD_EN_BIT  BIT4 // [4] 波特率自适应使能 0:关闭；1:开启 当配置UARTx_CTRL.LIN_EN=1，每一帧LIN frame都会进行波特率自适应，ABD_EN在软件配置为1后，即保持为1； 当配置UARTx_CTRL.LIN_EN=0，软件设置ABD_EN从0置为1，会触发一次波特率自适应，通常主机会发送一个0x55至从机，使从机完成波特率识别，完成后从机的ABD_EN位被硬件清零。主机无须设置波特率自适应。 如果UARTx_CTRL.LIN_EN=0且ABD_EN =1，建议软件先设置ABD_EN =0，再设置ABD_EN =1。
#define UARTx_IOC_TXD_INV_BIT BIT1 // [1] TXD输出极性使能开关，默认值为0。 0:正常输出；1:取反输出。 正常输出极性，即软件发送1，硬件发送1；取反输出极性，即应用发送1，硬件发送0。
#define UARTx_IOC_RXD_INV_BIT BIT0 // [0] RXD输入极性使能开关，默认值为0。 0:正常输入；1:取反输入。 正常输入极性，即硬件接收到1，软件接收的是1；取反输入极性，即硬件接收1，软件接收的是0。

/* DMA_CCRx (where x =0,1,2,3) */
#define DMA_CCRx_SBTW_POS  10                                           // DMA_CCRx_SBTW起始位
#define DMA_CCRx_SBTW_MASK (uint32_t)(0x3 << DMA_CCRx_SBTW_POS)         // DMA_CCRx_SBTW位掩码
#define DMA_CCRx_SBTW(x)   (uint32_t)(((x) & 0x3) << DMA_CCRx_SBTW_POS) // [11:10] 源地址访问位宽 0: Byte 1: Halfword 2: Word 3: 保留
#define DMA_CCRx_DBTW_POS  8                                            // DMA_CCRx_DBTW起始位
#define DMA_CCRx_DBTW_MASK (uint32_t)(0x3 << DMA_CCRx_DBTW_POS)         // DMA_CCRx_DBTW位掩码
#define DMA_CCRx_DBTW(x)   (uint32_t)(((x) & 0x3) << DMA_CCRx_DBTW_POS) // [9:8] 目的地址访问位宽 0: Byte 1: Halfword 2: Word 3: 保留
#define DMA_CCRx_SINC_BIT  BIT6                                         // [6] 源地址递增方式 0:不递增 1:每传输一次，地址按照SBTW对应大小递增1/2/4
#define DMA_CCRx_DINC_BIT  BIT4                                         // [4] 目的地址递增方式 0:不递增 1:每传输一次，地址按照DBTW对应大小递增1/2/4
#define DMA_CCRx_CIRC_BIT  BIT3                                         // [3] 循环模式，高有效
#define DMA_CCRx_RMODE_BIT BIT1                                         // [1] 0:单轮传输，一轮连续传输多次，每收到DMA请求传输一轮，一个DMA请求即传输完毕 1:多轮，每轮进行一次数据传输，每收到DMA请求传输一轮，多个DMA请求才传输完毕 不支持多轮×多次传输
#define DMA_CCRx_EN_BIT    BIT0                                         // [0] 通道使能，高有效，软件置1开启通道进行DMA搬运操作，搬运完成后DMA硬件将此位清零

/* DMA_CTMSx (where x = 0,1,2,3) */
#define DMA_CTMSx_TMS_POS  0                                              // DMA_CTMSx_TMS起始位
#define DMA_CTMSx_TMS_MASK (uint32_t)(0xFFF << DMA_CTMSx_TMS_POS)         // DMA_CTMSx_TMS位掩码
#define DMA_CTMSx_TMS(x)   (uint32_t)(((x) & 0xFFF) << DMA_CTMSx_TMS_POS) // [11:0] DMA通道0数据搬运次数。此寄存器在该通道使能后变为只读。

/* DMA_SADRx (where x = 0,1,2,3) */
#define DMA_SADRx_ADDR_POS  0                                                    // DMA_SADRx_ADDR起始位
#define DMA_SADRx_ADDR_MASK (uint32_t)(0xFFFFFFFF << DMA_SADRx_ADDR_POS)         // DMA_SADRx_ADDR位掩码
#define DMA_SADRx_ADDR(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DMA_SADRx_ADDR_POS) // [31:0] DMA通道x源地址

/* DMA_DADRx (where x = 0,1,2,3) */
#define DMA_DADRx_ADDR_POS  0                                                    // DMA_DADRx_ADDR起始位
#define DMA_DADRx_ADDR_MASK (uint32_t)(0xFFFFFFFF << DMA_DADRx_ADDR_POS)         // DMA_DADRx_ADDR位掩码
#define DMA_DADRx_ADDR(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DMA_DADRx_ADDR_POS) // [31:0] DMA通道x目的地址

/* DMA_CTRL DMA控制寄存器 */
#define DMA_CTRL_EN_BIT BIT0 // [0] DMA整体使能

/* DMA_IE DMA中断使能寄存器 */
#define DMA_IE_CH3_FIE_BIT BIT3 // [3] 通道3完成中断使能
#define DMA_IE_CH2_FIE_BIT BIT2 // [2] 通道2完成中断使能
#define DMA_IE_CH1_FIE_BIT BIT1 // [1] 通道1完成中断使能
#define DMA_IE_CH0_FIE_BIT BIT0 // [0] 通道0完成中断使能

/* DMA_IF DMA中断标志寄存器 */
#define DMA_IF_CH3_FIF_BIT BIT3 // [3] 通道3完成中断标志，高有效，写1清零
#define DMA_IF_CH2_FIF_BIT BIT2 // [2] 通道2完成中断标志，高有效，写1清零
#define DMA_IF_CH1_FIF_BIT BIT1 // [1] 通道1完成中断标志，高有效，写1清零
#define DMA_IF_CH0_FIF_BIT BIT0 // [0] 通道0完成中断标志，高有效，写1清零

/* DSP0_DID */
#define DSP0_DID_DID_POS  0                                                  // DSP0_DID_DID起始位
#define DSP0_DID_DID_MASK (uint32_t)(0xFFFFFFFF << DSP0_DID_DID_POS)         // DSP0_DID_DID位掩码
#define DSP0_DID_DID(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_DID_DID_POS) // [31:0] DSP 除法被除数寄存器，中断优先级高

/* DSP0_DIS */
#define DSP0_DIS_DIS_POS  0                                                  // DSP0_DIS_DIS起始位
#define DSP0_DIS_DIS_MASK (uint32_t)(0xFFFFFFFF << DSP0_DIS_DIS_POS)         // DSP0_DIS_DIS位掩码
#define DSP0_DIS_DIS(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_DIS_DIS_POS) // [31:0] DSP 除法除数寄存器，中断优先级高

/* DSP0_QUO */
#define DSP0_QUO_QUO_POS  0                                                  // DSP0_QUO_QUO起始位
#define DSP0_QUO_QUO_MASK (uint32_t)(0xFFFFFFFF << DSP0_QUO_QUO_POS)         // DSP0_QUO_QUO位掩码
#define DSP0_QUO_QUO(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_QUO_QUO_POS) // [31:0] DSP 商寄存器，中断优先级高

/* DSP0_DID1 */
#define DSP0_DID1_DID1_POS  0                                                    // DSP0_DID1_DID1起始位
#define DSP0_DID1_DID1_MASK (uint32_t)(0xFFFFFFFF << DSP0_DID1_DID1_POS)         // DSP0_DID1_DID1位掩码
#define DSP0_DID1_DID1(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_DID1_DID1_POS) // [31:0] DSP 除法被除数寄存器，中断优先级低

/* DSP0_DIS1 */
#define DSP0_DIS1_DIS1_POS  0                                                    // DSP0_DIS1_DIS1起始位
#define DSP0_DIS1_DIS1_MASK (uint32_t)(0xFFFFFFFF << DSP0_DIS1_DIS1_POS)         // DSP0_DIS1_DIS1位掩码
#define DSP0_DIS1_DIS1(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_DIS1_DIS1_POS) // [31:0] DSP 除法除数寄存器，中断优先级低

/* DSP0_QUO1 */
#define DSP0_QUO1_QUO1_POS  0                                                    // DSP0_QUO1_QUO1起始位
#define DSP0_QUO1_QUO1_MASK (uint32_t)(0xFFFFFFFF << DSP0_QUO1_QUO1_POS)         // DSP0_QUO1_QUO1位掩码
#define DSP0_QUO1_QUO1(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_QUO1_QUO1_POS) // [31:0] DSP 商寄存器，中断优先级低

/* DSP0_RAD */
#define DSP0_RAD_RAD_POS  0                                                  // DSP0_RAD_RAD起始位
#define DSP0_RAD_RAD_MASK (uint32_t)(0xFFFFFFFF << DSP0_RAD_RAD_POS)         // DSP0_RAD_RAD位掩码
#define DSP0_RAD_RAD(x)   (uint32_t)(((x) & 0xFFFFFFFF) << DSP0_RAD_RAD_POS) // [31:0] 协处理器被开方数寄存器

/* DSP0_SQRT */
#define DSP0_SQRT_SQRT_POS  0                                                // DSP0_SQRT_SQRT起始位
#define DSP0_SQRT_SQRT_MASK (uint32_t)(0xFFFF << DSP0_SQRT_SQRT_POS)         // DSP0_SQRT_SQRT位掩码
#define DSP0_SQRT_SQRT(x)   (uint32_t)(((x) & 0xFFFF) << DSP0_SQRT_SQRT_POS) // [15:0] 协处理器平方根寄存器

/* IWDG_PSW独立看门狗密码寄存器 */
#define IWDG_PSW_PSW_POS  0                                              // IWDG_PSW_PSW起始位
#define IWDG_PSW_PSW_MASK (uint32_t)(0xFFFF << IWDG_PSW_PSW_POS)         // IWDG_PSW_PSW位掩码
#define IWDG_PSW_PSW(x)   (uint32_t)(((x) & 0xFFFF) << IWDG_PSW_PSW_POS) // [15:0] 写入0xA6B4，才能对IWDG_CLR/ IWDG_RTH等进行写操作，对IWDG_CLR或IWDG_RTH的写操作会将密码清空，因此每次对看门狗IWDG_CLR/ IWDG_RTH寄存器进行写操作前都需要重新写入密码

/* IWDG_CFG独立看门狗配置寄存器 */
#define IWDG_CFG_DWK_EN_BIT BIT4 // [4] 深度休眠定时唤醒使能，0:禁用，1:使能
#define IWDG_CFG_WDG_EN_BIT BIT0 // [0] 独立看门狗使能，0:禁用，1:使能。默认使能，写1置位，写0同时向[15:8]写入0x3C可清零。当看门狗被禁用时，不再产生复位信号，但仍可计数并产生定时唤醒信号

/* IWDG_CLR独立看门狗清零寄存器 */
#define IWDG_CLR_CLR_POS  0                                              // IWDG_CLR_CLR起始位
#define IWDG_CLR_CLR_MASK (uint32_t)(0xFFFF << IWDG_CLR_CLR_POS)         // IWDG_CLR_CLR位掩码
#define IWDG_CLR_CLR(x)   (uint32_t)(((x) & 0xFFFF) << IWDG_CLR_CLR_POS) // [15:0] 写入字节 16’b0111_1001_1000_110B0，高15位为密码，密码正确时，B[0]才能写入 B[0]写入1，则重置WDT计数器为TH，且该bit写入后自动清零，写入0无效

/* IWDG_WTH独立看门狗定时唤醒门限寄存器 */
#define IWDG_WTH_WTH_POS  8                                              // IWDG_WTH_WTH起始位
#define IWDG_WTH_WTH_MASK (uint32_t)(0x1FFF << IWDG_WTH_WTH_POS)         // IWDG_WTH_WTH位掩码
#define IWDG_WTH_WTH(x)   (uint32_t)(((x) & 0x1FFF) << IWDG_WTH_WTH_POS) // [20:8] 看门狗定时唤醒门限值，看门狗使用32kHz LRC时钟从IWDG_RTH开始计数，递减计数至WTH产生唤醒信号。

/* IWDG_RTH独立看门狗超时复位门限寄存器 */
#define IWDG_RTH_RTH_POS  8                                              // IWDG_RTH_RTH起始位
#define IWDG_RTH_RTH_MASK (uint32_t)(0x1FFF << IWDG_RTH_RTH_POS)         // IWDG_RTH_RTH位掩码
#define IWDG_RTH_RTH(x)   (uint32_t)(((x) & 0x1FFF) << IWDG_RTH_RTH_POS) // [20:8] 看门狗超时复位门限值，也是重新装载值。看门狗使用32kHz LRC时钟从RTH开始计数，计数至0x7产生复位。向该寄存器写入0x0，会被硬件强制改写为0x100。先向IWDG_PSW写入正确密码才能改写IWDG_RTH寄存器。改写RTH同样具有重置看门狗计数器的作用，看门狗会从新的IWDG_RTH开始计数。

/* IWDG_CNT独立看门狗当前计数值寄存器 */
#define IWDG_CNT_CNT_POS  0                                                // IWDG_CNT_CNT起始位
#define IWDG_CNT_CNT_MASK (uint32_t)(0x1FFFFF << IWDG_CNT_CNT_POS)         // IWDG_CNT_CNT位掩码
#define IWDG_CNT_CNT(x)   (uint32_t)(((x) & 0x1FFFFF) << IWDG_CNT_CNT_POS) // [20:0] 看门狗当前计数值，此数值≤IWDG_TH

/* AON_PWR_CFG 功耗管理配置寄存器 */
#define AON_PWR_CFG_IOWK_FLT_BIT BIT1 // [1] IO唤醒信号滤波使能，默认使能

/* AON_EVT_RCD事件记录寄存器 */
#define AON_EVT_RCD_DEEPSLEEP_BIT   BIT13 // [13] 深度休眠记录，高表示发生过
#define AON_EVT_RCD_SLEEP_BIT       BIT12 // [12] 休眠记录，高表示发生过
#define AON_EVT_RCD_IWDG_WK_BIT     BIT9  // [9] IWDG定时唤醒记录，高表示Deep Sleep休眠被IWDG定时唤醒
#define AON_EVT_RCD_EVT_WK_BIT      BIT8  // [8] IO唤醒或CLU唤醒记录，高表示Deep Sleep休眠被AON_IO_WAKE_EN中对应的使能信号唤醒
#define AON_EVT_RCD_IWDG_RST_BIT    BIT3  // [3] 独立看门狗复位发生记录，高表示发生过
#define AON_EVT_RCD_KEY_RST_RCD_BIT BIT2  // [2] 按键复位发生记录，高表示发生过
#define AON_EVT_RCD_POR_RST_RCD_BIT BIT0  // [0] POR复位发生记录，高表示发生过

/* AON_IO_WAKE_POL IO唤醒极性寄存器 */
#define AON_IO_WAKE_POL_P2_0_POL_BIT  BIT7 // [7] P2[0]外部唤醒极性
#define AON_IO_WAKE_POL_P2_4_POL_BIT  BIT6 // [6] P2[4]外部唤醒极性
#define AON_IO_WAKE_POL_P2_7_POL_BIT  BIT5 // [5] P2[7]外部唤醒极性
#define AON_IO_WAKE_POL_P0_14_POL_BIT BIT4 // [4] P0[14]外部唤醒极性
#define AON_IO_WAKE_POL_P0_13_POL_BIT BIT3 // [3] P0[13]外部唤醒极性
#define AON_IO_WAKE_POL_P0_12_POL_BIT BIT2 // [2] P0[12]外部唤醒极性
#define AON_IO_WAKE_POL_P0_2_POL_BIT  BIT1 // [1] P0[2]外部唤醒极性
#define AON_IO_WAKE_POL_P0_0_POL_BIT  BIT0 // [0] P0[0]外部唤醒极性

/* AON_IO_WAKE_EN IO唤醒使能寄存器 */
#define AON_IO_WAKE_EN_CLUOUT3_EN_BIT BIT11 // [11] CLUOUT3作为唤醒使能
#define AON_IO_WAKE_EN_CLUOUT2_EN_BIT BIT10 // [10] CLUOUT2作为唤醒使能
#define AON_IO_WAKE_EN_CLUOUT1_EN_BIT BIT9  // [9] CLUOUT1作为唤醒使能
#define AON_IO_WAKE_EN_CLUOUT0_EN_BIT BIT8  // [8] CLUOUT0作为唤醒使能
#define AON_IO_WAKE_EN_P2_0_EN_BIT    BIT7  // [7] P2[0]外部唤醒使能
#define AON_IO_WAKE_EN_P2_4_EN_BIT    BIT6  // [6] P2[4]外部唤醒使能
#define AON_IO_WAKE_EN_P2_7_EN_BIT    BIT5  // [5] P2[7]外部唤醒使能
#define AON_IO_WAKE_EN_P0_14_EN_BIT   BIT4  // [4] P0[14]外部唤醒使能
#define AON_IO_WAKE_EN_P0_13_EN_BIT   BIT3  // [3] P0[13]外部唤醒使能
#define AON_IO_WAKE_EN_P0_12_EN_BIT   BIT2  // [2] P0[12]外部唤醒使能
#define AON_IO_WAKE_EN_P0_2_EN_BIT    BIT1  // [1] P0[2]外部唤醒使能
#define AON_IO_WAKE_EN_P0_0_EN_BIT    BIT0  // [0] P0[0]外部唤醒使能

/* AON_BKP_REG0后备寄存器0 */

/* AON_BKP_REG1后备寄存器1 */

/* SIF0_CFG 配置寄存器 */
#define SIF0_CFG_DONE_BIT       BIT7 // [7] SIF模块数据传输，完成信号默认电平 1:默认高电平 0:默认低电平
#define SIF0_CFG_SYNC_BIT       BIT6 // [6] SIF模块数据传输，同步信号默认电平 1:默认高电平 0:默认低电平
#define SIF0_CFG_SYNC_PULSE_BIT BIT5 // [5] SIF模块数据传输，同步信号是否产生脉冲信号 1:同步信号有脉冲信号 0:同步信号无脉冲信号
#define SIF0_CFG_DONE_VLD_BIT   BIT4 // [4] SIF模块数据传输，结束信号控制位 1:有结束信号 0:无结束信号
#define SIF0_CFG_SYNC_VLD_BIT   BIT3 // [3] SIF模块数据传输，同步信号控制位 1:有同步信号 0:无同步信号
#define SIF0_CFG_RATIO_BIT      BIT2 // [2] SIF模块数据占空比控制位 1:3:1 0:2:1
#define SIF0_CFG_ENDIAN_BIT     BIT1 // [1] SIF模块数据大小头控制位 1:MSB 0:LSB
#define SIF0_CFG_EN_BIT         BIT0 // [0] SIF模块使能位 1:SIF模块使能 0:SIF模块关闭

/* SIF0_TOSC 时基寄存器 */
#define SIF0_TOSC_TOSC_POS  0                                               // SIF0_TOSC_TOSC起始位
#define SIF0_TOSC_TOSC_MASK (uint32_t)(0xFFF << SIF0_TOSC_TOSC_POS)         // SIF0_TOSC_TOSC位掩码
#define SIF0_TOSC_TOSC(x)   (uint32_t)(((x) & 0xFFF) << SIF0_TOSC_TOSC_POS) // [11:0] SIF模块时基设置 时基= 2TOSC×(系统时钟周期\*32)

/* SIF0_TSTH1 同步时间寄存器 */
#define SIF0_TSTH1_TSTH_POS  0                                                // SIF0_TSTH1_TSTH起始位
#define SIF0_TSTH1_TSTH_MASK (uint32_t)(0x3FF << SIF0_TSTH1_TSTH_POS)         // SIF0_TSTH1_TSTH位掩码
#define SIF0_TSTH1_TSTH(x)   (uint32_t)(((x) & 0x3FF) << SIF0_TSTH1_TSTH_POS) // [9:0] SIF模块同步信号周期 Time = 2TSTH1×Tosc

/* SIF0_TDTH1 结束时间寄存器 */
#define SIF0_TDTH1_TDTH_POS  0                                              // SIF0_TDTH1_TDTH起始位
#define SIF0_TDTH1_TDTH_MASK (uint32_t)(0xF << SIF0_TDTH1_TDTH_POS)         // SIF0_TDTH1_TDTH位掩码
#define SIF0_TDTH1_TDTH(x)   (uint32_t)(((x) & 0xF) << SIF0_TDTH1_TDTH_POS) // [3:0] SIF模块结束信号周期 Time = 2TDTH1×Tosc

/* SIF0_IRQ 中断寄存器 */
#define SIF0_IRQ_IRQ_IF_BIT BIT4 // [4] SIF模块中断标志位，写1清零。 1:有SIF中断标志位 0:无SIF中断标志位
#define SIF0_IRQ_DMA_EN_BIT BIT1 // [1] SIF模块DMA使能控制位 1:使能 0:关闭
#define SIF0_IRQ_IRQ_EN_BIT BIT0 // [0] SIF模块中断使能控制位 1:使能中断 0:关闭中断

/* SIF0_WDATA 数据寄存器 */
#define SIF0_WDATA_WDATA_POS  0                                                // SIF0_WDATA_WDATA起始位
#define SIF0_WDATA_WDATA_MASK (uint32_t)(0xFF << SIF0_WDATA_WDATA_POS)         // SIF0_WDATA_WDATA位掩码
#define SIF0_WDATA_WDATA(x)   (uint32_t)(((x) & 0xFF) << SIF0_WDATA_WDATA_POS) // [7:0] SIF模块数据寄存器

/* CL0_EN0 CL0使能寄存器 */
#define CL0_EN0_C3EN_BIT BIT3 // [3] CLU3使能。默认关闭。 0: 关闭 1: 使能
#define CL0_EN0_C2EN_BIT BIT2 // [2] CLU2使能。默认关闭。 0: 关闭 1: 使能
#define CL0_EN0_C1EN_BIT BIT1 // [1] CLU1使能。默认关闭。 0: 关闭 1: 使能
#define CL0_EN0_C0EN_BIT BIT0 // [0] CLU0使能。默认关闭。 0: 关闭 1: 使能

/* CL0_IE0 CL0中断使能寄存器 */
#define CL0_IE0_C3RIE_BIT BIT7 // [7] CLU3上升沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C3FIE_BIT BIT6 // [6] CLU3下降沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C2RIE_BIT BIT5 // [5] CLU2上升沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C2FIE_BIT BIT4 // [4] CLU2下降沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C1RIE_BIT BIT3 // [3] CLU1上升沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C1FIE_BIT BIT2 // [2] CLU1下降沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C0RIE_BIT BIT1 // [1] CLU0上升沿触发中断使能。默认关闭。 0: 关闭 1: 使能
#define CL0_IE0_C0FIE_BIT BIT0 // [0] CLU0下降沿触发中断使能。默认关闭。 0: 关闭 1: 使能

/* CL0_IF0 CL0中断标志寄存器 */
#define CL0_IF0_C3RIF_BIT BIT7 // [7] CLU3上升沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C3FIF_BIT BIT6 // [6] CLU3下降沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C2RIF_BIT BIT5 // [5] CLU2上升沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C2FIF_BIT BIT4 // [4] CLU2下降沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C1RIF_BIT BIT3 // [3] CLU1上升沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C1FIF_BIT BIT2 // [2] CLU1下降沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C0RIF_BIT BIT1 // [1] CLU0上升沿中断标志位。中断标志高有效，写1清零。
#define CL0_IF0_C0FIF_BIT BIT0 // [0] CLU0下降沿中断标志位。中断标志高有效，写1清零。

/* CL0_OUT0 CL0输出寄存器 */
#define CL0_OUT0_C3OUT_BIT BIT3 // [3] CLU3输出状态，与系统时钟同步。
#define CL0_OUT0_C2OUT_BIT BIT2 // [2] CLU2输出状态，与系统时钟同步。
#define CL0_OUT0_C1OUT_BIT BIT1 // [1] CLU1输出状态，与系统时钟同步。
#define CL0_OUT0_C0OUT_BIT BIT0 // [0] CLU0输出状态，与系统时钟同步。

/* CL0_MX0 CL0输入多路复选寄存器 */
#define CL0_MX0_C3MXA_POS  28                                           // CL0_MX0_C3MXA起始位
#define CL0_MX0_C3MXA_MASK (uint32_t)(0xF << CL0_MX0_C3MXA_POS)         // CL0_MX0_C3MXA位掩码
#define CL0_MX0_C3MXA(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C3MXA_POS) // [31:28] CLU3 A输入多路复用选择
#define CL0_MX0_C3MXB_POS  24                                           // CL0_MX0_C3MXB起始位
#define CL0_MX0_C3MXB_MASK (uint32_t)(0xF << CL0_MX0_C3MXB_POS)         // CL0_MX0_C3MXB位掩码
#define CL0_MX0_C3MXB(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C3MXB_POS) // [27:24] CLU3 B输入多路复用选择
#define CL0_MX0_C2MXA_POS  20                                           // CL0_MX0_C2MXA起始位
#define CL0_MX0_C2MXA_MASK (uint32_t)(0xF << CL0_MX0_C2MXA_POS)         // CL0_MX0_C2MXA位掩码
#define CL0_MX0_C2MXA(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C2MXA_POS) // [23:20] CLU2 A输入多路复用选择
#define CL0_MX0_C2MXB_POS  16                                           // CL0_MX0_C2MXB起始位
#define CL0_MX0_C2MXB_MASK (uint32_t)(0xF << CL0_MX0_C2MXB_POS)         // CL0_MX0_C2MXB位掩码
#define CL0_MX0_C2MXB(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C2MXB_POS) // [19:16] CLU2 B输入多路复用选择
#define CL0_MX0_C1MXA_POS  12                                           // CL0_MX0_C1MXA起始位
#define CL0_MX0_C1MXA_MASK (uint32_t)(0xF << CL0_MX0_C1MXA_POS)         // CL0_MX0_C1MXA位掩码
#define CL0_MX0_C1MXA(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C1MXA_POS) // [15:12] CLU1 A输入多路复用选择
#define CL0_MX0_C1MXB_POS  8                                            // CL0_MX0_C1MXB起始位
#define CL0_MX0_C1MXB_MASK (uint32_t)(0xF << CL0_MX0_C1MXB_POS)         // CL0_MX0_C1MXB位掩码
#define CL0_MX0_C1MXB(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C1MXB_POS) // [11:8] CLU1 B输入多路复用选择
#define CL0_MX0_C0MXA_POS  4                                            // CL0_MX0_C0MXA起始位
#define CL0_MX0_C0MXA_MASK (uint32_t)(0xF << CL0_MX0_C0MXA_POS)         // CL0_MX0_C0MXA位掩码
#define CL0_MX0_C0MXA(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C0MXA_POS) // [7:4] CLU0 A输入多路复用选择
#define CL0_MX0_C0MXB_POS  0                                            // CL0_MX0_C0MXB起始位
#define CL0_MX0_C0MXB_MASK (uint32_t)(0xF << CL0_MX0_C0MXB_POS)         // CL0_MX0_C0MXB位掩码
#define CL0_MX0_C0MXB(x)   (uint32_t)(((x) & 0xF) << CL0_MX0_C0MXB_POS) // [3:0] CLU0 B输入多路复用选择

/* CL0_FN0 CL0功能选择寄存器 */
#define CL0_FN0_C3FN_POS  24                                           // CL0_FN0_C3FN起始位
#define CL0_FN0_C3FN_MASK (uint32_t)(0xFF << CL0_FN0_C3FN_POS)         // CL0_FN0_C3FN位掩码
#define CL0_FN0_C3FN(x)   (uint32_t)(((x) & 0xFF) << CL0_FN0_C3FN_POS) // [31:24] CLU3 查找表功能选择。
#define CL0_FN0_C2FN_POS  16                                           // CL0_FN0_C2FN起始位
#define CL0_FN0_C2FN_MASK (uint32_t)(0xFF << CL0_FN0_C2FN_POS)         // CL0_FN0_C2FN位掩码
#define CL0_FN0_C2FN(x)   (uint32_t)(((x) & 0xFF) << CL0_FN0_C2FN_POS) // [23:16] CLU2 查找表功能选择。
#define CL0_FN0_C1FN_POS  8                                            // CL0_FN0_C1FN起始位
#define CL0_FN0_C1FN_MASK (uint32_t)(0xFF << CL0_FN0_C1FN_POS)         // CL0_FN0_C1FN位掩码
#define CL0_FN0_C1FN(x)   (uint32_t)(((x) & 0xFF) << CL0_FN0_C1FN_POS) // [15:8] CLU1查找表功能选择。
#define CL0_FN0_C0FN_POS  0                                            // CL0_FN0_C0FN起始位
#define CL0_FN0_C0FN_MASK (uint32_t)(0xFF << CL0_FN0_C0FN_POS)         // CL0_FN0_C0FN位掩码
#define CL0_FN0_C0FN(x)   (uint32_t)(((x) & 0xFF) << CL0_FN0_C0FN_POS) // [7:0] CLU0查找表功能选择。

/* CL0_CF0 CL0配置寄存器 */
#define CL0_CF0_C3OUTSEL_BIT  BIT31                                           // [31] CLU3输出选取 0: D触发器输出 1: LUT输出
#define CL0_CF0_C3OEN_BIT     BIT30                                           // [30] CLU3输出使能。默认关闭。 0: 关闭 1: 使能
#define CL0_CF0_C3RST_BIT     BIT27                                           // [27] CLU3 D触发器复位。该位写1复位。读取恒为0。
#define CL0_CF0_C3CLKINV_BIT  BIT26                                           // [26] CLU3 D触发器时钟电平反向。 0: 关闭 1: 使能
#define CL0_CF0_C3CLKSEL_POS  24                                              // CL0_CF0_C3CLKSEL起始位
#define CL0_CF0_C3CLKSEL_MASK (uint32_t)(0x3 << CL0_CF0_C3CLKSEL_POS)         // CL0_CF0_C3CLKSEL位掩码
#define CL0_CF0_C3CLKSEL(x)   (uint32_t)(((x) & 0x3) << CL0_CF0_C3CLKSEL_POS) // [25:24] CLU3 D触发器时钟选择。 0x0: 进位输入 0x1: MXA输入 0x2: TIMER1比较/捕获事件0 0x3: TIMER0比较/捕获事件0
#define CL0_CF0_C2OUTSEL_BIT  BIT23                                           // [23] CLU2输出选取 0: D触发器输出 1: LUT输出
#define CL0_CF0_C2OEN_BIT     BIT22                                           // [22] CLU2输出使能。默认关闭。 0: 关闭 1: 使能
#define CL0_CF0_C2RST_BIT     BIT19                                           // [19] CLU2 D触发器复位。该位写1复位。读取恒为0。
#define CL0_CF0_C2CLKINV_BIT  BIT18                                           // [18] CLU2 D触发器时钟电平反向。 0: 关闭 1: 使能
#define CL0_CF0_C2CLKSEL_POS  16                                              // CL0_CF0_C2CLKSEL起始位
#define CL0_CF0_C2CLKSEL_MASK (uint32_t)(0x3 << CL0_CF0_C2CLKSEL_POS)         // CL0_CF0_C2CLKSEL位掩码
#define CL0_CF0_C2CLKSEL(x)   (uint32_t)(((x) & 0x3) << CL0_CF0_C2CLKSEL_POS) // [17:16] CLU2 D触发器时钟选择 。 0x0: 进位输入 0x1: MXA输入 0x2: TIMER0比较/捕获事件1 0x3: TIMER1比较/捕获事件1
#define CL0_CF0_C1OUTSEL_BIT  BIT15                                           // [15] CLU1输出选取 0: D触发器输出 1: LUT输出
#define CL0_CF0_C1OEN_BIT     BIT14                                           // [14] CLU1输出使能。默认关闭。 0: 关闭 1: 使能
#define CL0_CF0_C1RST_BIT     BIT11                                           // [11] CLU1 D触发器复位。该位写1复位。读取恒为0。
#define CL0_CF0_C1CLKINV_BIT  BIT10                                           // [10] CLU1 D触发器时钟电平反向。 0: 关闭 1: 使能
#define CL0_CF0_C1CLKSEL_POS  8                                               // CL0_CF0_C1CLKSEL起始位
#define CL0_CF0_C1CLKSEL_MASK (uint32_t)(0x3 << CL0_CF0_C1CLKSEL_POS)         // CL0_CF0_C1CLKSEL位掩码
#define CL0_CF0_C1CLKSEL(x)   (uint32_t)(((x) & 0x3) << CL0_CF0_C1CLKSEL_POS) // [9:8] CLU1 D触发器时钟选择 。 0x0: 进位输入 0x1: MXA输入 0x2: TIMER0比较/捕获事件0 0x3: TIMER1比较/捕获事件0
#define CL0_CF0_C0OUTSEL_BIT  BIT7                                            // [7] CLU0输出选取 0: D触发器输出 1: LUT输出
#define CL0_CF0_C0OEN_BIT     BIT6                                            // [6] CLU0输出使能。默认关闭。 0: 关闭 1: 使能
#define CL0_CF0_C0RST_BIT     BIT3                                            // [3] CLU0 D触发器复位。该位写1复位。读取恒为0。
#define CL0_CF0_C0CLKINV_BIT  BIT2                                            // [2] CLU0 D触发器时钟电平反向。 0: 关闭 1: 使能
#define CL0_CF0_C0CLKSEL_POS  0                                               // CL0_CF0_C0CLKSEL起始位
#define CL0_CF0_C0CLKSEL_MASK (uint32_t)(0x3 << CL0_CF0_C0CLKSEL_POS)         // CL0_CF0_C0CLKSEL位掩码
#define CL0_CF0_C0CLKSEL(x)   (uint32_t)(((x) & 0x3) << CL0_CF0_C0CLKSEL_POS) // [1:0] CLU0 D触发器时钟选择 。 0x0: 进位输入 0x1: MXA输入 0x2: TIMER1比较/捕获事件1 0x3: TIMER0比较/捕获事件1

/* EEPROM_CFG EEPROM控制器配置寄存器 */
#define EEPROM_CFG_BUSY_BIT         BIT17                                                  // [17] I2C传输繁忙信号，这个信号只有在使能RDY_RLS信号时，才会有效。不使能RDY_RLS时，BUSY一直为0。 1:表明此时正在进行I2C传输 0:表明此时没有进行I2C传输
#define EEPROM_CFG_RDY_RLS_BIT      BIT16                                                  // [16] 软件等待选择信号 1:进行eeprom读写时不会造成软件等待，可以对其他外设进行操作。 0:进行eeprom读写时会造成软件等待，无法对其他外设进行操作。 用户可以通过将RDY_RLS置1与否来选择当进行EEPROM读写时是否可以对其他外设进行操作。
#define EEPROM_CFG_STATE_POS        12                                                     // EEPROM_CFG_STATE起始位
#define EEPROM_CFG_STATE_MASK       (uint32_t)(0xF << EEPROM_CFG_STATE_POS)                // EEPROM_CFG_STATE位掩码
#define EEPROM_CFG_STATE(x)         (uint32_t)(((x) & 0xF) << EEPROM_CFG_STATE_POS)        // [15:12] I2C传输状态 0:IDLE状态。I2C处于空闲状态，没有进行传输。 1:START1状态。产生I2C传输的start信号。 2:SEND_D_ADDR状态。发送设备地址。 3:ACK1状态。EEPROM颗粒对设备地址回复应答信号。 4:SEND_B_ADDR_H状态。发送数据地址的高8位。 5:ACK2状态。EEPROM颗粒对接收到的数据地址高8位回复应答信号 6:SEND_B_ADDR_L状态。发送数据地址的低8位。 7:ACK3状态。EEPROM颗粒对接收到的数据地址低8位回复应答信号 8:WR_DATA状态。往目的数据地址写入数据。 9:ACK4状态。EEPROM颗粒对写入的数据回复应答信号。 10:START2状态。读操作下产生第二次start信号。 11:SEND_RD_ADDR状态。读操作下第二次发送设备地址。 12:ACK5状态。EEPROM颗粒对第二次接收到的设备地址回复应答信号。 13:RD_DATA状态。读取EEPROM颗粒对应数据地址的数据。 14:NACK状态。EEPROM控制器对读取的数据回复NACK。 15:STOP状态。I2C传输结束。 当出现I2C传输卡住的情况，如未接受到正确的应答信号，I2C的传输会卡住，此时可以复位通过将SYS_SFT_RST的EEPROM_SFT_RST置位来复位EEPROM模块，以达到复位I2C传输状态的目的，复位后I2C状态机处于IDLE状态。随后将SYS_SFT_RST的EEPROM_SFT_RST清零释放EEPROM模块，重新配置EEPROM_CFG寄存器，启动新一轮的I2C传输。
#define EEPROM_CFG_RCV_NACK_BIT     BIT11                                                  // [11] 接收到NACK信号 1:接收到NACK信号 0:没有接收到NACK信号 当接收到NACK信号时，I2C传输的状态机会复位，并且当前的读写操作无效。需要再次发起读写操作。如果对EEPROM进行读操作时，接收到了NACK，则表明此次的读操作是无效的，并且读取到结果为0
#define EEPROM_CFG_SWITCH_BIT       BIT10                                                  // [10] 管脚功能切换 0:SCL输出IIC时钟,SDA输出IIC数据 1:SCL输出IIC数据，SDA输出IIC时钟
#define EEPROM_CFG_ADDR_LENTH_BIT   BIT9                                                   // [9] 数据地址长度选择信号 0:数据地址长度为8位 1:数据地址长度位16位
#define EEPROM_CFG_DEVICE_ADDR_POS  2                                                      // EEPROM_CFG_DEVICE_ADDR起始位
#define EEPROM_CFG_DEVICE_ADDR_MASK (uint32_t)(0x7F << EEPROM_CFG_DEVICE_ADDR_POS)         // EEPROM_CFG_DEVICE_ADDR位掩码
#define EEPROM_CFG_DEVICE_ADDR(x)   (uint32_t)(((x) & 0x7F) << EEPROM_CFG_DEVICE_ADDR_POS) // [8:2] 设备地址的高7位，R/W位由控制器自动生成。
#define EEPROM_CFG_CLK_DIV_POS      0                                                      // EEPROM_CFG_CLK_DIV起始位
#define EEPROM_CFG_CLK_DIV_MASK     (uint32_t)(0x3 << EEPROM_CFG_CLK_DIV_POS)              // EEPROM_CFG_CLK_DIV位掩码
#define EEPROM_CFG_CLK_DIV(x)       (uint32_t)(((x) & 0x3) << EEPROM_CFG_CLK_DIV_POS)      // [1:0] IIC SCL时钟频率选择，IIC时钟通常不超过1MHz速率，具体请参考DATASHEET 00:100KHz 01:400KHz 10:1MHz 11:1.2MHz

/* EEPROM_RDATA EEPROM数据寄存器 */
#define EEPROM_RDATA_RDATA_POS  0                                                  // EEPROM_RDATA_RDATA起始位
#define EEPROM_RDATA_RDATA_MASK (uint32_t)(0xFF << EEPROM_RDATA_RDATA_POS)         // EEPROM_RDATA_RDATA位掩码
#define EEPROM_RDATA_RDATA(x)   (uint32_t)(((x) & 0xFF) << EEPROM_RDATA_RDATA_POS) // [7:0] RDT_RLS为1时，软件直接读取EEPROM地址空间，得到的数据保留在EEPROM_RDATA寄存器中。若RDY_RLS为0，软件直接读取EEPROM地址空间便可取得数据，不用再读取EEPROM_RDATA寄存器。
#endif
