菜农NUC100学习笔记1

hotpower

/*-------------------------------------------------------------------------------
文   件   名 :  NUC1xxcfg.h
创   建   人 :  Cortex-M0菜鸟HotPower@163.com,HotPower@126.com,QQ:1270688699
创 建 日  期 :  2010.10.18   18:18
最近修改日期 :  2010.12.3    16:58
创 建  地 点 ： 西安大雁塔村队部
版   本   号 ： V1.03 (红杏版)
修 改  原 因 ：
说        明 ：
备        注 ： 本头文件风格归属于菜农的《红杏出墙》系列，堪称“红杏级别”
                将本文件拷贝到...\CMSIS\CM0\DeviceSupport\Nuvoton\NUC1xx内。
-------------------------------------------------------------------------------*/

#ifndef __NUC1xxcfg_H__
#define __NUC1xxcfg_H__

#ifdef __cplusplus
extern "C" {
#endif

#if defined (__CC_ARM)
  #pragma anon_unions
#endif

#include "NUC1xx.h"

typedef volatile unsigned int NU_REG;// Hardware register definition
#define __noinit__ __attribute__((zero_init))//变量不初始化为0

typedef enum
{
__0 = (NU_REG)0,
__1 = (NU_REG)1,
__2 = (NU_REG)2,
__3 = (NU_REG)3,
__4 = (NU_REG)4,
__5 = (NU_REG)5,
__6 = (NU_REG)6,
__7 = (NU_REG)7,
__8 = (NU_REG)8,
__9 = (NU_REG)9,
__10 = (NU_REG)10,
__11 = (NU_REG)11,
__12 = (NU_REG)12,
__13 = (NU_REG)13,
__14 = (NU_REG)14,
__15 = (NU_REG)15,
__16 = (NU_REG)16,
__17 = (NU_REG)17,
__18 = (NU_REG)18,
__19 = (NU_REG)19,
__20 = (NU_REG)20,
__21 = (NU_REG)21,
__22 = (NU_REG)22,
__23 = (NU_REG)23,
__24 = (NU_REG)24,
__25 = (NU_REG)25,
__26 = (NU_REG)26,
__27 = (NU_REG)27,
__28 = (NU_REG)28,
__29 = (NU_REG)29,
__30 = (NU_REG)30,
__31 = (NU_REG)31
}Number_enum;

typedef volatile struct
{
  NU_REG Bit0:  1;
  NU_REG Bit1:  1;
  NU_REG Bit2:  1;
  NU_REG Bit3:  1;
  NU_REG Bit4:  1;
  NU_REG Bit5:  1;
  NU_REG Bit6:  1;
  NU_REG Bit7:  1;
  NU_REG Bit8:  1;
  NU_REG Bit9:  1;
  NU_REG Bit10:  1;
  NU_REG Bit11:  1;
  NU_REG Bit12:  1;
  NU_REG Bit13:  1;
  NU_REG Bit14:  1;
  NU_REG Bit15:  1;
  NU_REG Bit16:  1;
  NU_REG Bit17:  1;
  NU_REG Bit18:  1;
  NU_REG Bit19:  1;
  NU_REG Bit20:  1;
  NU_REG Bit21:  1;
  NU_REG Bit22:  1;
  NU_REG Bit23:  1;
  NU_REG Bit24:  1;
  NU_REG Bit25:  1;
  NU_REG Bit26:  1;
  NU_REG Bit27:  1;
  NU_REG Bit28:  1;
  NU_REG Bit29:  1;
  NU_REG Bit30:  1;
  NU_REG Bit31:  1;
}NU_BITs;
//===============================================//
typedef volatile struct
{
  NU_REG Pin0:  1;
  NU_REG Pin1:  1;
  NU_REG Pin2:  1;
  NU_REG Pin3:  1;
  NU_REG Pin4:  1;
  NU_REG Pin5:  1;
  NU_REG Pin6:  1;
  NU_REG Pin7:  1;
  NU_REG Pin8:  1;
  NU_REG Pin9:  1;
  NU_REG Pin10:  1;
  NU_REG Pin11:  1;
  NU_REG Pin12:  1;
  NU_REG Pin13:  1;
  NU_REG Pin14:  1;
  NU_REG Pin15:  1;
  NU_REG Pin16:  1;
  NU_REG Pin17:  1;
  NU_REG Pin18:  1;
  NU_REG Pin19:  1;
  NU_REG Pin20:  1;
  NU_REG Pin21:  1;
  NU_REG Pin22:  1;
  NU_REG Pin23:  1;
  NU_REG Pin24:  1;
  NU_REG Pin25:  1;
  NU_REG Pin26:  1;
  NU_REG Pin27:  1;
  NU_REG Pin28:  1;
  NU_REG Pin29:  1;
  NU_REG Pin30:  1;
  NU_REG Pin31:  1;
}NU_PINs;

//============================================
typedef volatile union
{
  __IO NU_REG  Regs;
  __IO NU_BITs Bits;
}NU_REG_BITs;

typedef volatile union
{
  __IO NU_REG  Regs;
  __IO NU_PINs Bits;
}NU_REG_PINs;

typedef struct
{
        __IO NU_REG RESERVED:16;
    __IO NU_REG OFFD0:1;
    __IO NU_REG OFFD1:1;
    __IO NU_REG OFFD2:1;
    __IO NU_REG OFFD3:1;
    __IO NU_REG OFFD4:1;
    __IO NU_REG OFFD5:1;
    __IO NU_REG OFFD6:1;
    __IO NU_REG OFFD7:1;
    __IO NU_REG OFFD8:1;
    __IO NU_REG OFFD9:1;
    __IO NU_REG OFFD10:1;
    __IO NU_REG OFFD11:1;
    __IO NU_REG OFFD12:1;
    __IO NU_REG OFFD13:1;
    __IO NU_REG OFFD14:1;
    __IO NU_REG OFFD15:1;
}NU_GPIO_OFFD_Bits;

typedef volatile union
{
  NU_REG     Regs;
  GPIO_PMD_T Bits;
}NU_GPIO_PMD_T;

typedef volatile union
{
  NU_REG            Regs;
  NU_GPIO_OFFD_Bits Bits;
}NU_GPIO_OFFD_T;

//----------------------------------------------------//
//改造GPIO为结构(不占用空间)
typedef struct
{
    NU_GPIO_PMD_T   PMD;//模式控制(0输入1输出2开漏3准双向)
    NU_GPIO_OFFD_T  OFFD;//数字使能(高16位)
    NU_REG_PINs     DOUT;//数据输出值(低16位)
    NU_REG_PINs     DMASK;//数据输出写屏蔽
    NU_REG_PINs     PIN;//管脚数值(低16位)
    NU_REG_PINs     DBEN;//防反弹使能
    NU_REG_PINs     IMD;//中断模式控制(0边沿触发中断1电平触发中断)
    NU_REG_BITs     IEN;//中断使能(高16位上升沿或高电平，低16位下降沿或低电平)
    NU_REG_PINs     ISRC;//中断源标志
        NU_REG          RESERVED[7];//保留,为了构造GPIO结构数组
} NU_GPIO_T;

typedef volatile union
{
  NU_REG          Regs;
  GPIO_DBNCECON_T Bits;
}NU_GPIO_DBNCECON_T;

typedef struct {
  union {
    __IO NU_GPIO_T Px[5];//GPIOs.Px[0].DOUT.Regs |= 1;GPIOs.Px[0].DOUT.Bits.Pin0 = 1;
        struct {
            __IO NU_GPIO_T PA;//GPIOs.PA.DOUT.Regs |=1;GPIOs.PA.DOUT.Bits.Pin0=1;
            __IO NU_GPIO_T PB;//GPIOs.PB.DOUT.Regs |=2;GPIOs.PB.DOUT.Bits.Pin1=1;
            __IO NU_GPIO_T PC;//GPIOs.PC.DOUT.Regs |=4;GPIOs.PC.DOUT.Bits.Pin2=1;
            __IO NU_GPIO_T PD;//GPIOs.PD.DOUT.Regs |=8;GPIOs.PD.DOUT.Bits.Pin3=1;
            __IO NU_GPIO_T PE;//GPIOs.PE.DOUT.Regs |=16;GPIOs.PE.DOUT.Bits.Pin4=1;
        };
  };
  __I  NU_REG             RESERVED[16];
  __IO NU_GPIO_DBNCECON_T DBNCECON;
}NUS_GPIO, *NUPS_GPIO;

#define NU_BASE_GPIO  ((NUPS_GPIO) GPIOA_BASE)//定义硬件结构指针（硬件地址）
#define GPIOs (*NU_BASE_GPIO)//定位全局结构变量GPIOs
//----------------------------------------------------//
#define GPIOAs  (*((NU_GPIO_T *) GPIOA_BASE))//定位全局结构变量GPIOAs
#define GPIOBs  (*((NU_GPIO_T *) GPIOB_BASE))//定位全局结构变量GPIOBs
#define GPIOCs  (*((NU_GPIO_T *) GPIOC_BASE))//定位全局结构变量GPIOCs
#define GPIODs  (*((NU_GPIO_T *) GPIOD_BASE))//定位全局结构变量GPIODs
#define GPIOEs  (*((NU_GPIO_T *) GPIOE_BASE))//定位全局结构变量GPIOEs
//----------------------------------------------------//

#define GPIOx(x)  ((NU_GPIO_T *) GPIOA_BASE  + (x * 0x0040))
#define Px(x)     ((NU_GPIO_T *) GPIOA_BASE  + (x * 0x0040))
//----------------------------------------------------//

typedef enum
{
    SPI_CNTRL_GO_BUSY = 0,//通讯或忙状态标志
    SPI_CNTRL_RX_NEG  = 1,//接收数据边沿反向位(0=SDI信号在SPICLK上升沿接收)
    SPI_CNTRL_TX_NEG  = 2,//发送数据边沿反向位(0=SDO信号在SPICLK的上升沿发送)
    SPI_CNTRL_TX_BIT_LEN = 3,//传输位长度(32,1,...31)
    SPI_CNTRL_TX_NUM = 8,//发送/接收数量(00=每次传输仅完成1次发送/接收,01=每次传输仅完成2次发送/接收)
    SPI_CNTRL_LSB = 10,//优先传送LSB(0=优先发送/接收MSB,根据CNTRL寄存器的Tx_BIT_LEN 决定TxX/RxX)
    SPI_CNTRL_CLKP = 11,//时钟极性(0=SCLK低电平闲置)
    SPI_CNTRL_SP_CYCLE = 12,//暂缓间隙 (仅主机模式)
    SPI_CNTRL_IF = 16,//中断标志(0=表示传输未结束, 该位写1清零)
    SPI_CNTRL_IE = 17,//中断使能
    SPI_CNTRL_SLAVE = 18,//SLAVE模式标志(0=MCU作为主机模式)
    SPI_CNTRL_BYTE_REORDER = 19,
    SPI_CNTRL_TWOB= 21,
    SPI_CNTRL_VARCLK_EN = 22
}NU_SPI_CNTRL_ENUM;

typedef enum
{
    SPI_SSR_SSR = 0,//从机选择寄存器(主机模式)
    SPI_SSR_SS_LVL = 2,//从机选择触发电平选择
    SPI_SSR_AUTOSS = 3,//自动从机选择(主机模式)
    SPI_SSR_SS_LTRIG = 4,//从机电平触发选择（从机模式）
    SPI_SSR_LTRIG_FLAG = 5//电平触发标志
}NU_SPI_SSR_ENUM;

typedef enum
{
    SPI_DMA_TX_DMA_GO = 0,//发送DMA开始(如果采用DMA发送数据，将不会对SPI_CNTRL寄存器的GO_BUSY位置位)
    SPI_DMA_RX_DMA_GO = 1//接收DMA开始
}NU_SPI_DMA_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  SPI_CNTRL_T       Bits;
}NU_SPI_CNTRL_T;

typedef volatile union
{
  NU_REG            Regs;
  SPI_SSR_T         Bits;
}NU_SPI_SSR_T;

typedef volatile union
{
  NU_REG            Regs;
  SPI_DIVIDER_T     Bits;
}NU_SPI_DIVIDER_T;

typedef volatile union
{
  NU_REG            Regs;
  SPI_DMA_T         Bits;
}NU_SPI_DMA_T;

typedef struct
{
    NU_SPI_CNTRL_T   CNTRL;//控制及状态寄存器
    NU_SPI_DIVIDER_T DIVIDER;//时钟除频寄存器
    NU_SPI_SSR_T     SSR;//从机选择寄存器
    NU_REG           RESERVE0;//保留
        union{
            NU_REG_BITs      RX[2];//接收数据寄存器数组
                struct{
                    NU_REG_BITs      RX0;//接收数据寄存器低32位
                    NU_REG_BITs      RX1;//接收数据寄存器高32位
                };
        };
    NU_REG           RESERVE1[2];//保留
        union{
            NU_REG_BITs      TX[2];//数据发送寄存器数组
                struct{
                    NU_REG_BITs      TX0;//数据发送寄存器低32位
                    NU_REG_BITs      TX1;//数据发送寄存器高32位
                };
        };
    NU_REG           RESERVE2[3];//保留
    NU_REG_BITs      VARCLK;
    NU_SPI_DMA_T     DMA;//SPIDMA控制寄存器
}NU_SPI_T;
//----------------------------------------------------//
#define SPI0s     (*((NU_SPI_T *) SPI0_BASE))//定位全局结构变量SPI0s
#define SPI1s     (*((NU_SPI_T *) SPI1_BASE))//定位全局结构变量SPI1s
#define SPI2s     (*((NU_SPI_T *) SPI2_BASE))//定位全局结构变量SPI2s
#define SPI3s     (*((NU_SPI_T *) SPI3_BASE))//定位全局结构变量SPI3s
//----------------------------------------------------//
#define SPIx(x)   ((NU_SPI_T *)  SPI0_BASE   + ((x & 1) * 0x4000) + ((x >> 1) * 0x100000))
//----------------------------------------------------//
typedef volatile union
{
  NU_REG            Regs;
  PDMA_CSR_T        Bits;
}NU_PDMA_CSR_T;


typedef volatile union
{
  NU_REG            Regs;
  PDMA_CBCR_T       Bits;
}NU_PDMA_CBCR_T;

typedef volatile union
{
  NU_REG            Regs;
  PDMA_IER_T        Bits;
}NU_PDMA_IER_T;

typedef volatile union
{
  NU_REG            Regs;
  PDMA_ISR_T        Bits;
}NU_PDMA_ISR_T;

typedef enum
{
        PDMA_CSR_PDMACEN = 0,//PDMA通道使能
        PDMA_CSR_SW_RST = 1,//软件产生复位
        PDMA_CSR_MODE_SEL = 2,//PDMA模式选择
        PDMA_CSR_SAD_SEL = 4,//传输源地址方向选择
        PDMA_CSR_DAD_SEL = 6,//传输目的地址方向选择
        PDMA_CSR_WAR_BCR_SEL = 12,
        PDMA_CSR_APB_TWS = 19,//外设传输宽度选择
        PDMA_CSR_TRIG_EN = 23//PDMA数据读写传输使能(当PDMA传输完成, 该位自动清除.)
}NU_PDMA_CSR_ENUM;

typedef enum
{
    PDMA_CBCR_CBCR = 0
}NU_PDMA_CBCR_ENUM;

typedef enum
{
    PDMA_IER_TABORT_IE = 0,//读写异常使能
    PDMA_IER_BLKD_IE   = 1,//Transfer Done中断使能
    PDMA_IER_WAR_IE    = 2//Wrap Around中断使能
}NU_PDMA_IER_ENUM;

typedef enum
{
    PDMA_ISR_TABORT_IF = 0,//PDMA 读/写 目标异常中断标志位
    PDMA_ISR_BLKD_IF   = 1,//Block 传递完成 中断标志位
    PDMA_ISR_WAR_BCR_IF= 8,//Wrap around传递字节计时器中断标志位
    PDMA_ISR_INTR      = 31//中断管脚状态(只读)
}NU_PDMA_ISR_ENUM;

typedef struct
{
    NU_PDMA_CSR_T   CSR;//控制寄存器
    NU_REG_BITs     SAR;//源地址寄存器
    NU_REG_BITs     DAR;//目的地址寄存器
    NU_REG_BITs     BCR;//发送字节计数寄存器
    NU_REG_BITs     POINT;//内部数据指示器
    NU_REG_BITs     CSAR;//当前源目的地址
    NU_REG_BITs     CDAR;//当前目的地址寄存器
    NU_PDMA_CBCR_T  CBCR;//当前传输字节计数寄存器
    NU_PDMA_IER_T   IER;//中断使能寄存器
    NU_PDMA_ISR_T   ISR;//中断状态寄存器
        union{
            NU_REG_BITs     SBUF[4];//共享缓冲FIFO
                struct{
                    NU_REG_BITs     SBUF0;//共享缓冲FIFO
                    NU_REG_BITs     SBUF1;//共享缓冲FIFO
                    NU_REG_BITs     SBUF2;//共享缓冲FIFO
                    NU_REG_BITs     SBUF3;//共享缓冲FIFO
                };
        };
}NU_PDMA_T;

typedef struct {
  union {
    __IO NU_PDMA_T CHx[16];
        struct {
            __IO NU_PDMA_T CH0;
            __IO NU_PDMA_T CH1;
            __IO NU_PDMA_T CH2;
            __IO NU_PDMA_T CH3;
            __IO NU_PDMA_T CH4;
            __IO NU_PDMA_T CH5;
            __IO NU_PDMA_T CH6;
            __IO NU_PDMA_T CH7;
            __IO NU_PDMA_T CH8;
                __IO NU_PDMA_T RESERVE[7];
        };
  };
}NUS_PDMA, *NUPS_PDMA;

#define NU_BASE_PDMA  ((NUPS_PDMA) PDMA0_BASE)//定义硬件结构指针（硬件地址）
#define PDMAs (*NU_BASE_PDMA)//定位全局结构变量PDMAs
//----------------------------------------------------//
#define PDMA0s    (*((NU_PDMA_T *) PDMA0_BASE))//定位全局结构变量PDMA0s
#define PDMA1s    (*((NU_PDMA_T *) PDMA1_BASE))//定位全局结构变量PDMA1s
#define PDMA2s    (*((NU_PDMA_T *) PDMA2_BASE))//定位全局结构变量PDMA2s
#define PDMA3s    (*((NU_PDMA_T *) PDMA3_BASE))//定位全局结构变量PDMA3s
#define PDMA4s    (*((NU_PDMA_T *) PDMA4_BASE))//定位全局结构变量PDMA4s
#define PDMA5s    (*((NU_PDMA_T *) PDMA5_BASE))//定位全局结构变量PDMA5s
#define PDMA6s    (*((NU_PDMA_T *) PDMA6_BASE))//定位全局结构变量PDMA6s
#define PDMA7s    (*((NU_PDMA_T *) PDMA7_BASE))//定位全局结构变量PDMA7s
#define PDMA8s    (*((NU_PDMA_T *) PDMA8_BASE))//定位全局结构变量PDMA8s
//----------------------------------------------------//
#define PDMAx(x)  ((NU_PDMA_T *) PDMA0_BASE  + (x * 0x0100))
//----------------------------------------------------//
typedef enum
{
    TIMER_TCSR_PRESCALE   = 0,//预分频计数器
    TIMER_TCSR_TDR_EN     = 16,//数据锁存使能
    TIMER_TCSR_COUNTER_EN = 24,//                  
    TIMER_TCSR_CACT       = 25,//定时器工作状态                  
    TIMER_TCSR_CRST       = 26,//计数器重置
    TIMER_TCSR_MODE       = 27,//定时器工作模式
    TIMER_TCSR_TMR_IE     = 29,//中断使能
    TIMER_TCSR_CEN        = 30,//计数器使能位
    TIMER_TCSR_nDBGACK_EN = 31
}NU_TIMER_TCSR_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  TIMER_TCSR_T     Bits;
}NU_TIMER_TCSR_T;

typedef enum
{
    TIMER_TISR_TIF   = 0//定时器中断标志
}NU_TIMER_TISR_T_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  TIMER_TISR_T     Bits;
}NU_TIMER_TISR_T;

typedef struct
{
    __IO NU_TIMER_TCSR_T     TCSR;//控制与状态寄存器
    __IO NU_REG_BITs         TCMPR;//比较寄存器
    __IO NU_TIMER_TISR_T     TISR;//中断状态寄存器   
    __IO NU_REG_BITs         TDR;//数据寄存器
}NU_TIMER_T;

//----------------------------------------------------//
#define TIMER0s    (*((NU_TIMER_T *) TIMER0_BASE))//定位全局结构变量TIMER0s
#define TIMER1s    (*((NU_TIMER_T *) TIMER1_BASE))//定位全局结构变量TIMER1s
#define TIMER2s    (*((NU_TIMER_T *) TIMER2_BASE))//定位全局结构变量TIMER2s
#define TIMER3s    (*((NU_TIMER_T *) TIMER3_BASE))//定位全局结构变量TIMER3s
//----------------------------------------------------//
#define TIMERx(x) ((NU_TIMER_T *)TIMER0_BASE + ((x & 1) * 0x0020) + ((x >> 1) * 0x100000))
//----------------------------------------------------//
typedef enum
{
    I2C_CON_AA   = 2,//I2C接收应答标志位
    I2C_CON_SI   = 3,//I2C中断标志位
    I2C_CON_STO  = 4,//I2C停止标志
    I2C_CON_STA  = 5,//I2C起始标志
    I2C_CON_ENSI = 6,//I2C控制使能/禁止
    I2C_CON_EI   = 7 //使能中断
}NU_I2C_CON_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  I2C_CON_T        Bits;
}NU_I2C_CON_T;

typedef enum
{
    I2C_ADDR_GC    = 0,//全呼功能
    I2C_ADDR_ADDR  = 1 //I2C地址寄存器
}NU_I2C_ADDR_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  I2C_ADDR_T        Bits;
}NU_I2C_ADDR_T;

typedef enum
{
    I2C_ADRM_ADM  = 1  //I2C隐藏地址寄存器
}NU_I2C_ADRM_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  I2C_ADRM_T        Bits;
}NU_I2C_ADRM_T;

typedef enum
{
    I2C_TOC_TIF  = 0,//超时标志
    I2C_TOC_DIV4 = 1,//超时计数输入时钟除4
    I2C_TOC_ENTI = 2 //超时计数使能/禁止
}NU_I2C_TOC_NUM;

typedef volatile union
{
  NU_REG            Regs;
  I2C_TOC_T         Bits;
}NU_I2C_TOC_T;

typedef struct
{
    __IO NU_I2C_CON_T    CON;//I2C控制寄存器
    __IO NU_I2C_ADDR_T   ADDR0;//I2C从机地址寄存器0
    __IO NU_REG_BITs     DATA;//I2C数据寄存器
    __IO NU_REG_BITs     STATUS;//I2C状态寄存器
    __IO NU_REG_BITs     CLK;//I2C时钟时钟分频寄存器
    __IO NU_I2C_TOC_T    TOC;//I2C超时控制寄存器
        __IO NU_I2C_ADDR_T         ADDR1;//从机地址寄存器1
        __IO NU_I2C_ADDR_T         ADDR2;//从机地址寄存器2
        __IO NU_I2C_ADDR_T         ADDR3;//从机地址寄存器3
        __IO NU_I2C_ADRM_T         ADRM0;//从机隐藏地址寄存器0
        __IO NU_I2C_ADRM_T         ADRM1;//从机隐藏地址寄存器1
        __IO NU_I2C_ADRM_T         ADRM2;//从机隐藏地址寄存器2
        __IO NU_I2C_ADRM_T         ADRM3;//从机隐藏地址寄存器3        
        __IO NU_REG          RESERVE[((I2C1_BASE - I2C0_BASE) - sizeof(I2C_T)) / sizeof(NU_REG)];
}NU_I2C_T;
//----------------------------------------------------//
typedef struct {
  union {
    __IO NU_I2C_T PORT[2];
        struct {
            __IO NU_I2C_T PORT0;
            __IO NU_I2C_T PORT1;
        };
  };
}NUS_I2C, *NUPS_I2C;

#define NU_BASE_I2C  ((NUPS_I2C) I2C0_BASE)//定义硬件结构指针（硬件地址）
#define I2Cs (*NU_BASE_I2C)//定位全局结构变量I2Cs
//----------------------------------------------------//
#define I2C0s     (*((NU_I2C_T *) I2C0_BASE))//定位全局结构变量I2C0s
#define I2C1s     (*((NU_I2C_T *) I2C1_BASE))//定位全局结构变量I2C0s
//----------------------------------------------------//
#define I2Cx(x)   ((NU_I2C_T *)  I2C0_BASE   + (x * 0x100000))
//----------------------------------------------------//
typedef volatile union
{
  NU_REG            Regs;
  PWM_PPR_T        Bits;
}NU_PWM_PPR_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_CSR_T        Bits;
}NU_PWM_CSR_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_PCR_T        Bits;
}NU_PWM_PCR_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_PBCR_T        Bits;
}NU_PWM_PBCR_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_PIER_T        Bits;
}NU_PWM_PIER_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_PIIR_T        Bits;
}NU_PWM_PIIR_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_CCR0_T        Bits;
}NU_PWM_CCR0_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_CCR2_T        Bits;
}NU_PWM_CCR2_T;

typedef volatile union
{
  NU_REG            Regs;
  PWM_POE_T         Bits;
}NU_PWM_POE_T;

typedef struct
{
    __IO NU_PWM_PPR_T    PPR;//PWM0~3或PWM4~7预分频寄存器
    __IO NU_PWM_CSR_T    CSR;//PWM0~3或PWM4~7时钟选择寄存器
    __IO NU_PWM_PCR_T    PCR;//PWM0~3或PWM4~7控制寄存器
    __IO NU_REG_BITs     CNR0;//PWM0或PWM4计数器寄存器
    __IO NU_REG_BITs     CMR0;//PWM0或PWM4比较寄存器
    __IO NU_REG_BITs     PDR0;//PWM0或PWM4数据寄存器
    __IO NU_REG_BITs     CNR1;//PWM1或PWM5计数器寄存器
    __IO NU_REG_BITs     CMR1;//PWM1或PWM5比较寄存器
    __IO NU_REG_BITs     PDR1;//PWM1或PWM5数据寄存器
    __IO NU_REG_BITs     CNR2;//PWM2或PWM6计数器寄存器
    __IO NU_REG_BITs     CMR2;//PWM2或PWM6比较寄存器
    __IO NU_REG_BITs     PDR2;//PWM2或PWM6数据寄存器
    __IO NU_REG_BITs     CNR3;//PWM3或PWM7计数器寄存器
    __IO NU_REG_BITs     CMR3;//PWM3或PWM7比较寄存器
    __IO NU_REG_BITs     PDR3;//PWM3或PWM7数据寄存器
    __IO NU_PWM_PBCR_T         PBCR;
    __IO NU_PWM_PIER_T   PIER;//PWM0~3或PWM4~7中断使能寄存器
    __IO NU_PWM_PIIR_T   PIIR;
    __I NU_REG           RESERVE1[2];
    __IO NU_PWM_CCR0_T   CCR0;
    __IO NU_PWM_CCR2_T   CCR2;
    __IO NU_REG_BITs     CRLR0;
    __IO NU_REG_BITs     CFLR0;
    __IO NU_REG_BITs     CRLR1;
    __IO NU_REG_BITs     CFLR1;
    __IO NU_REG_BITs     CRLR2;
    __IO NU_REG_BITs     CFLR2;
    __IO NU_REG_BITs     CRLR3;
    __IO NU_REG_BITs     CFLR3;
    __IO NU_REG_BITs     CAPENR;
    __IO NU_PWM_POE_T    POE;   
}NU_PWM_T;
//----------------------------------------------------//
#define PWM03s    (*((NU_PWM_T *) PWMA_BASE))//定位全局结构变量PWM03s
#define PWM47s    (*((NU_PWM_T *) PWMB_BASE))//定位全局结构变量PWM47s
//----------------------------------------------------//
#define PWMx(x)   ((NU_PWM_T *)  PWMA_BASE   + (x * 0x100000))
//----------------------------------------------------//
typedef volatile union
{
  NU_REG            Regs;
  UART_IER_T        Bits;
}NU_UART_IER_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_FCR_T        Bits;
}NU_UART_FCR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_LCR_T        Bits;
}NU_UART_LCR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_MCR_T        Bits;
}NU_UART_MCR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_MSR_T        Bits;
}NU_UART_MSR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_FSR_T        Bits;
}NU_UART_FSR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_ISR_T        Bits;
}NU_UART_ISR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_TOR_T        Bits;
}NU_UART_TOR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_BAUD_T        Bits;
}NU_UART_BAUD_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_IRCR_T       Bits;
}NU_UART_IRCR_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_ALTCON_T     Bits;
}NU_UART_ALTCON_T;

typedef volatile union
{
  NU_REG            Regs;
  UART_FUNSEL_T     Bits;
}NU_UART_FUNSEL_T;

typedef struct
{
          union{
            __IO NU_REG_BITs  DATA;//接收发送数据
            __I  NU_REG_BITs  RBR;//接收数据缓存寄存器
            __O  NU_REG_BITs  THR;//发送保持寄存器
    };
    __IO NU_UART_IER_T    IER;//中断使能寄存器
    __IO NU_UART_FCR_T    FCR;//FIFO控制寄存器
    __IO NU_UART_LCR_T    LCR;//Line控制寄存器
    __IO NU_UART_MCR_T    MCR;//Modem控制寄存器
    __IO NU_UART_MSR_T    MSR;//Modem状态寄存器
    __IO NU_UART_FSR_T    FSR;//FIFO状态寄存器
    __IO NU_UART_ISR_T    ISR;//中断状态寄存器
    __IO NU_UART_TOR_T    TOR;//定时溢出寄存器
    __IO NU_UART_BAUD_T   BAUD;//波特率分频寄存器
    __IO NU_UART_IRCR_T   IRCR;//IrDA控制寄存器
    __IO NU_UART_ALTCON_T ALTCON;//LIN Break失败计数寄存器   
        __IO NU_UART_FUNSEL_T FUNSEL;//功能选择寄存器   
}NU_UART_T;

//----------------------------------------------------//
#define UART0s    (*((NU_UART_T *) UART0_BASE))//定位全局结构变量UART0s
#define UART1s    (*((NU_UART_T *) UART1_BASE))//定位全局结构变量UART0s
#define UART2s    (*((NU_UART_T *) UART2_BASE))//定位全局结构变量UART0s
#define UART3s    (*((NU_UART_T *) UART3_BASE))//定位全局结构变量UART0s
//----------------------------------------------------//
#define UARTx(x)  ((NU_UART_T *) UART0_BASE + ((x & 1) * 0x100000) + ((x >> 1) * 0x104000))
#define Ux(x)     ((NU_UART_T *) UART0_BASE + ((x & 1) * 0x100000) + ((x >> 1) * 0x104000))
//----------------------------------------------------//
typedef enum
{
    ADC_ADDR_RSLT    = 0,//A/D转换结果
    ADC_ADDR_OVERRUN = 16,//结束运行标志位
    ADC_ADDR_VALID   = 17//有效标志位
}NU_ADC_ADDR_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADDR_T       Bits;
}NU_ADC_ADDR_T;

typedef enum
{
    ADC_ADCR_ADEN    = 0,//A/D转换使能
    ADC_ADCR_ADIE    = 1,//A/D中断使能
    ADC_ADCR_ADMD    = 2,//A/D转换操作模式
    ADC_ADCR_TRGS    = 4,//硬件触发源
    ADC_ADCR_TRGCOND = 6,//外部触发条件
    ADC_ADCR_TRGEN   = 8,//外部触发使能
    ADC_ADCR_PTEN    = 9,//PDMA 传送使能
    ADC_ADCR_DIFFEN  = 10,//A/D差分输入模式使能
    ADC_ADCR_ADST    = 11,//A/D转换开始
    ADC_ADCR_DMOF    = 31
}NU_ADC_ADCR_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADCR_T       Bits;
}NU_ADC_ADCR_T;

typedef enum
{
    ADC_ADCHER_CHEN0    = 0,//模拟输入通道0
    ADC_ADCHER_CHEN1    = 1,//模拟输入通道1
    ADC_ADCHER_CHEN2    = 2,//模拟输入通道2
    ADC_ADCHER_CHEN3    = 3,//模拟输入通道3
    ADC_ADCHER_CHEN4    = 4,//模拟输入通道4
    ADC_ADCHER_CHEN5    = 5,//模拟输入通道5
    ADC_ADCHER_CHEN6    = 6,//模拟输入通道6
    ADC_ADCHER_CHEN7    = 7,//模拟输入通道7
    ADC_ADCHER_PRESEL   = 8 //模拟输入通道7选择位
                              //00:模拟输入通道7 01:Bandgap(VBG)模拟输入
                                                  //10:VTEMP模拟输入 11:模拟地
}NU_ADC_ADCHER_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADCHER_T     Bits;
}NU_ADC_ADCHER_T;

typedef enum
{
    ADC_ADCMPR_CMPEN     = 0,        //比较使能
    ADC_ADCMPR_CMPIE     = 1,        //比较中断使能
    ADC_ADCMPR_CMPCOND   = 2,        //比较条件
    ADC_ADCMPR_CMPCH     = 3,        //Compare通道选择(000=选择通道0转换结果,111=选择通道7转换结果)
    ADC_ADCMPR_CMPMATCNT = 8,        //比较匹配值
    ADC_ADCMPR_CMPD      = 16 //比较数值
}NU_ADC_ADCMPR_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADCMPR_T     Bits;
}NU_ADC_ADCMPR_T;

typedef enum
{
    ADC_ADSR_ADF          = 0,//A/D转换结束标志位
    ADC_ADSR_CMPF0        = 1,//比较标志位
    ADC_ADSR_CMPF1        = 2,//较标志位
    ADC_ADSR_BUSY         = 3,//BUSY/IDLE
    ADC_ADSR_CHANNEL      = 4,//当前转换通道
    ADC_ADSR_VALID   = 8,//数据有效标志位
    ADC_ADSR_OVERRUN = 16//结束运行标志位
}NU_ADC_ADSR_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADSR_T     Bits;
}NU_ADC_ADSR_T;

typedef enum
{
    ADC_ADCALR_CALEN   = 0,//自身校准功能使能
    ADC_ADCALR_CALDONE = 1 //校准完成标志(只读)
}NU_ADC_ADCALR_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADCALR_T     Bits;
}NU_ADC_ADCALR_T;

typedef enum
{
    ADC_ADPDMA_AD_PDMA = 0 //ADC PDMA当前数据传输寄存器
}NU_ADC_ADPDMA_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  ADC_ADPDMA_T     Bits;
}NU_ADC_ADPDMA_T;

typedef struct
{
        union{
            __I  NU_ADC_ADDR_T      ADDR[8];//A/D数据寄存器0~7
                struct{
                    __I  NU_ADC_ADDR_T  ADDR0;//A/D数据寄存器0
                    __I  NU_ADC_ADDR_T  ADDR1;//A/D数据寄存器1
                    __I  NU_ADC_ADDR_T  ADDR2;//A/D数据寄存器2
                    __I  NU_ADC_ADDR_T  ADDR3;//A/D数据寄存器3
                    __I  NU_ADC_ADDR_T  ADDR4;//A/D数据寄存器4
                    __I  NU_ADC_ADDR_T  ADDR5;//A/D数据寄存器5
                    __I  NU_ADC_ADDR_T  ADDR6;//A/D数据寄存器6
                    __I  NU_ADC_ADDR_T  ADDR7;//A/D数据寄存器7
                };
        };
    __IO NU_ADC_ADCR_T      ADCR;//ADC控制寄存器
    __IO NU_ADC_ADCHER_T    ADCHER;//A/D 通道使能
        union{
            __IO NU_ADC_ADCMPR_T    ADCMPR[2];//A/D比较寄存器0,1
                struct{
              __IO NU_ADC_ADCMPR_T    ADCMPR0;//A/D比较寄存器0
              __IO NU_ADC_ADCMPR_T    ADCMPR1;//A/D比较寄存器1
                };
        };
    __IO NU_ADC_ADSR_T      ADSR;//ADC状态寄存器
    __IO NU_ADC_ADCALR_T    ADCALR;//A/D校准寄存器
    __I  NU_REG             RESERVE0;
    __I  NU_REG             RESERVE1;
    __IO NU_ADC_ADPDMA_T    ADPDMA;//A/D PDMA当前数据传输寄存器
}NU_ADC_T;
//----------------------------------------------------//
#define ADCs    (*((NU_ADC_T *) ADC_BASE))//定位全局结构变量ADCs
//----------------------------------------------------//
#define ADCx   ((NU_ADC_T *)  ADC_BASE)
//----------------------------------------------------//
typedef enum
{
    SYSCLK_PWRCON_XTL12M_EN    = 0,//外部12MHz晶振控制
    SYSCLK_PWRCON_XTL32K_EN    = 1,//外部32.768KHz晶振控制
    SYSCLK_PWRCON_OSC22M_EN    = 2,//内部22MHz振荡器控制
    SYSCLK_PWRCON_OSC10K_EN    = 3,//内部10KHz振荡器控制
    SYSCLK_PWRCON_PD_WU_DLY    = 4,//使能唤醒延时计数器
    SYSCLK_PWRCON_PD_WU_INT_EN = 5,//掉电模式唤醒的中断使能
    SYSCLK_PWRCON_PD_WU_STS    = 6,//芯片掉电唤醒状态标志
    SYSCLK_PWRCON_PWR_DOWN     = 7,//激活或使能系统掉电模式
    SYSCLK_PWRCON_PD_WAIT_CPU  = 8 //控制进入掉电模式的条件
}NU_SYSCLK_PWRCON_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  SYSCLK_PWRCON_T     Bits;
}NU_SYSCLK_PWRCON_T;

typedef enum
{
    SYSCLK_AHBCLK_PDMA_EN  = 1,//PDMA控制器时钟使能控制
    SYSCLK_AHBCLK_ISP_EN   = 2,//Flash ISP控制器时钟使能控制
        SYSCLK_AHBCLK_EBI_EN   = 3 //
}NU_SYSCLK_AHBCLK_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_AHBCLK_T     Bits;
}NU_SYSCLK_AHBCLK_T;

typedef enum
{
    SYSCLK_APBCLK_WDT_EN   = 0,//Watch Dog时钟使能
    SYSCLK_APBCLK_RTC_EN   = 1,//Real-Time-Clock APB接口时钟控制
    SYSCLK_APBCLK_TMR0_EN  = 2,//Timer0时钟使能控制
    SYSCLK_APBCLK_TMR1_EN  = 3,//Timer1时钟使能控制
    SYSCLK_APBCLK_TMR2_EN  = 4,//Timer2时钟使能控制
    SYSCLK_APBCLK_TMR3_EN  = 5,//Timer3时钟使能控制
    SYSCLK_APBCLK_FDIV_EN  = 6,//分频器输出时钟使能控制
    SYSCLK_APBCLK_I2C0_EN  = 8,//I2C0时钟使能控制
    SYSCLK_APBCLK_I2C1_EN  = 9,//I2C1时钟使能控制
    SYSCLK_APBCLK_SPI0_EN  = 12,//SPI0时钟使能控制
    SYSCLK_APBCLK_SPI1_EN  = 13,//SPI1时钟使能控制
    SYSCLK_APBCLK_SPI2_EN  = 14,//SPI2时钟使能控制
    SYSCLK_APBCLK_SPI3_EN  = 15,//SPI3时钟使能控制
    SYSCLK_APBCLK_UART0_EN = 16,//UART0时钟使能控制
    SYSCLK_APBCLK_UART1_EN = 17,//UART1时钟使能控制
        SYSCLK_APBCLK_UART2_EN = 18,//UART2时钟使能控制
    SYSCLK_APBCLK_PWM01_EN = 20,//PWM_01时钟使能控制
    SYSCLK_APBCLK_PWM23_EN = 21,//PWM_23时钟使能控制
        SYSCLK_APBCLK_PWM45_EN = 22,//PWM_45时钟使能控制
    SYSCLK_APBCLK_PWM67_EN = 23,//PWM_67时钟使能控制
    SYSCLK_APBCLK_CAN0_EN = 24,//使能CAN线控制器0时钟控制
    SYSCLK_APBCLK_USBD_EN = 27,//USB FS设备控制器时钟使能控制
    SYSCLK_APBCLK_ADC_EN = 28,//使能ADC时钟控制
        SYSCLK_APBCLK_I2S_EN = 29,//I2S时钟使能控制
    SYSCLK_APBCLK_ACMP_EN = 30,//模拟比较器时钟使能控制
    SYSCLK_APBCLK_PS2_EN = 31//PS2时钟使能控制
}NU_SYSCLK_APBCLK_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_APBCLK_T     Bits;
}NU_SYSCLK_APBCLK_T;

typedef enum
{
    SYSCLK_CLKSTATUS_XTL12M_STB  = 0,
        SYSCLK_CLKSTATUS_XTL32K_STB  = 1,
    SYSCLK_CLKSTATUS_PLL_STB     = 2,
        SYSCLK_CLKSTATUS_OSC10K_STB  = 3,
        SYSCLK_CLKSTATUS_OSC22M_STB  = 4,
    SYSCLK_CLKSTATUS_RESERVE0    = 5,
        SYSCLK_CLKSTATUS_CLK_SW_FAIL = 7
}NU_SYSCLK_CLKSTATUS_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_CLKSTATUS_T  Bits;
}NU_SYSCLK_CLKSTATUS_T;

typedef enum
{
    SYSCLK_CLKSEL0_HCLK_S  = 0,
    SYSCLK_CLKSEL0_STCLK_S = 3
}NU_SYSCLK_CLKSEL0_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_CLKSEL0_T    Bits;
}NU_SYSCLK_CLKSEL0_T;

typedef enum
{
    SYSCLK_CLKSEL1_WDT_S   = 0,//WDGCLK时钟源选择
    SYSCLK_CLKSEL1_ADC_S   = 1,//ADC时钟源选择
    SYSCLK_CLKSEL1_TMR0_S  = 8,//TIMER0时钟源选择
    SYSCLK_CLKSEL1_TMR1_S  = 12,//TIMER1时钟源选择
    SYSCLK_CLKSEL1_TMR2_S  = 16,//TIMER2时钟源选择
    SYSCLK_CLKSEL1_TMR3_S  = 20,//TIMER3时钟源选择
    SYSCLK_CLKSEL1_UART_S  = 24,//UART时钟源选择
    SYSCLK_CLKSEL1_CAN_S   = 26,//CAN时钟源选择
    SYSCLK_CLKSEL1_PWM01_S = 28,//PWM1与PWM0的时钟源选择
    SYSCLK_CLKSEL1_PWM23_S = 30 //PWM3与PWM2的时钟源选择.
}NU_SYSCLK_CLKSEL1_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_CLKSEL1_T    Bits;
}NU_SYSCLK_CLKSEL1_T;

typedef enum
{
    SYSCLK_CLKDIV_HCLK_N    = 0,//HCLK时钟频率=(HCLK时钟源频率)/(HCLK_N+1)
    SYSCLK_CLKDIV_USB_N     = 4,//USB时钟频率=(PLL频率)/(USB_N+1)
    SYSCLK_CLKDIV_UART_N    = 8,//UART时钟频率=(UART时钟源频率)/(UART_N+1)
    SYSCLK_CLKDIV_CAN_N     = 12,//APU时钟频率=(CAN时钟源频率)/(CAN_N+1)
    SYSCLK_CLKDIV_ADC_N     = 16,//ADC时钟频率=ADC时钟源频率/(ADC_N+1)
        SYSCLK_CLKDIV_CAN_N_EXT = 24//
}NU_SYSCLK_CLKDIV_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_CLKDIV_T    Bits;
}NU_SYSCLK_CLKDIV_T;

typedef enum
{
    SYSCLK_CLKSEL2_I2S_S    = 0,//I2S时钟源选择
    SYSCLK_CLKSEL2_FRQDIV_S = 2,//时钟分频器时钟源选择
        SYSCLK_CLKSEL2_PWM45_S  = 4,//PWM4与PWM5的时钟源选择
    SYSCLK_CLKSEL2_PWM67_S  = 6 //PWM6与PWM7的时钟源选择
}NU_SYSCLK_CLKSEL2_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_CLKSEL2_T    Bits;
}NU_SYSCLK_CLKSEL2_T;

typedef enum
{
    SYSCLK_PLLCON_FB_DV   = 0,//PLL反馈分频控制引脚
    SYSCLK_PLLCON_IN_DV   = 9,//PLL输入分频控制引脚
    SYSCLK_PLLCON_OUT_DV  = 14,//PLL输出分频控制引脚
    SYSCLK_PLLCON_PD      = 16,//掉电模式
    SYSCLK_PLLCON_BP      = 17,//PLL旁路控制
    SYSCLK_PLLCON_OE      = 18,//PLL OE(FOUT enable)引脚控制
    SYSCLK_PLLCON_PLL_SRC = 19 //PLL时钟源选择
}NU_SYSCLK_PLLCON_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_PLLCON_T    Bits;
}NU_SYSCLK_PLLCON_T;


typedef enum
{
    SYSCLK_FRQDIV_FSEL    = 0,//分频器输出频率选择位
        SYSCLK_FRQDIV_FDIV_EN = 4 //频率分频器使能位
}NU_SYSCLK_FRQDIV_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  SYSCLK_FRQDIV_T    Bits;
}NU_SYSCLK_FRQDIV_T;

typedef struct
{
    __IO NU_SYSCLK_PWRCON_T    PWRCON;//系统掉电控制寄存器
    __IO NU_SYSCLK_AHBCLK_T    AHBCLK;//AHB设备时钟使能控制寄存器
    __IO NU_SYSCLK_APBCLK_T    APBCLK;//APB设备时钟使能控制寄存器
    __IO NU_SYSCLK_CLKSTATUS_T CLKSTATUS;
    __IO NU_SYSCLK_CLKSEL0_T   CLKSEL0;//时钟源选择控制寄存器0
    __IO NU_SYSCLK_CLKSEL1_T   CLKSEL1;//时钟源选择控制寄存器1
    __IO NU_SYSCLK_CLKDIV_T    CLKDIV;//时钟分频寄存器
    __IO NU_SYSCLK_CLKSEL2_T   CLKSEL2;//时钟源选择控制寄存器2
        __IO NU_SYSCLK_PLLCON_T    PLLCON;//PLL 控制寄存器
        __IO NU_SYSCLK_FRQDIV_T    FRQDIV;//频率分频器控制寄存器
}NU_SYSCLK_T;
//----------------------------------------------------//
#define SYSCLKs    (*((NU_SYSCLK_T *) SYSCLK_BASE))//定位全局结构变量SYSCLKs
//----------------------------------------------------//
#define SYSCLKx   ((NU_SYSCLK_T *)  SYSCLK_BASE)
//----------------------------------------------------//
typedef enum
{
    GCR_RSTSRC_RSTS_POR   = 0,//RSTS_POR标志位由POR模块的”复位信号”置1
        GCR_RSTSRC_RSTS_RESET = 1,//RSTS_PAD标志位由/RESET脚的”复位信号”置1
        GCR_RSTSRC_RSTS_WDT   = 2,//RSTS_WDG标志位由看门狗模块的”复位信号”置1
        GCR_RSTSRC_RSTS_LVR   = 3,//RSTS_LVR标志位由低压复位模块的”复位信号”置1
        GCR_RSTSRC_RSTS_BOD   = 4,//RSTS_BOD标志位由欠压检测模块的”复位信号”置1
        GCR_RSTSRC_RSTS_MCU   = 5,//RSTS_SYS由来自MCU Cortex_M0的“复位信号“置位
        GCR_RSTSRC_RSTS_CPU   = 7 //RSTS_CPU标志由硬件置位
}NU_GCR_RSTSRC_ENUM;

typedef volatile union
{
  NU_REG              Regs;
  GCR_RSTSRC_T    Bits;
}NU_GCR_RSTSRC_T;

typedef enum
{
    GCR_IPRSTC1_CHIP_RST = 0,//CHIP复位
    GCR_IPRSTC1_CPU_RST  = 1,//CPU内核复位
    GCR_IPRSTC1_PDMA_RST = 2,//PDMA控制器复位
        GCR_IPRSTC1_EBI_RST  = 3 //EBI接口复位
}NU_GCR_IPRSTC1_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  GCR_IPRSTC1_T    Bits;
}NU_GCR_IPRSTC1_T;

typedef enum
{
    GCR_IPRSTC2_GPIO_RST = 1,//GPIO控制器复位
    GCR_IPRSTC2_TMR0_RST = 2,//Timer0控制器复位
    GCR_IPRSTC2_TMR1_RST = 3,//Timer1控制器复位
    GCR_IPRSTC2_TMR2_RST = 4,//Timer2控制器复位
    GCR_IPRSTC2_TMR3_RST = 5,//Timer3控制器复位
    GCR_IPRSTC2_I2C0_RST = 8,//I2C0控制器复位
    GCR_IPRSTC2_I2C1_RST = 9,//I2C1控制器复位
    GCR_IPRSTC2_SPI0_RST = 12,//SPI0控制器复位
    GCR_IPRSTC2_SPI1_RST = 13,//SPI1控制器复位
    GCR_IPRSTC2_SPI2_RST = 14,//SPI2控制器复位
    GCR_IPRSTC2_SPI3_RST = 15,//SPI3控制器复位
    GCR_IPRSTC2_UART0_RST = 16,//UART0控制器复位
    GCR_IPRSTC2_UART1_RST = 17,//UART1控制器复位
    GCR_IPRSTC2_UART2_RST = 18,//UART2控制器复位
    GCR_IPRSTC2_PWM03_RST = 20,//PWM03控制器复位
    GCR_IPRSTC2_PWM47_RST = 21,//PWM47控制器复位
    GCR_IPRSTC2_ACMP_RST = 22,//模拟比较器控制器复位
    GCR_IPRSTC2_PS2_RST = 23,//PS2控制器复位
    GCR_IPRSTC2_CAN0_RST = 24,//CAN0控制器复位
    GCR_IPRSTC2_USBD_RST = 27,//USB设备控制器复位
    GCR_IPRSTC2_ADC_RST = 28,//ADC控制器复位
    GCR_IPRSTC2_I2S_RST = 29,//I2S控制器复位
}NU_GCR_IPRSTC2_ENUM;

typedef volatile union
{
  NU_REG           Regs;
  GCR_IPRSTC2_T    Bits;
}NU_GCR_IPRSTC2_T;

typedef enum
{
    GCR_CPR_HPE = 0 //CHIP复位
}NU_GCR_CPR_ENUM;


typedef volatile union
{
  NU_REG            Regs;
  GCR_CPR_T                Bits;
}NU_GCR_CPR_T;

typedef enum
{
    GCR_BODCR_BOD_EN = 0,//欠压检测使能
    GCR_BODCR_BOD_VL = 1,//欠压检测Threshold电压选择
    GCR_BODCR_BOD_RSTEN = 3,//欠压复位使能
    GCR_BODCR_BOD_INTF = 4,//欠压检测中断标志
    GCR_BODCR_BOD_LPM = 5,//低压模式下的欠压检测
    GCR_BODCR_BOD_OUT = 6,//欠压检测输出的状态位
        GCR_BODCR_LVR_EN = 7//低压复位使能
}NU_GCR_BODCR_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_BODCR_T            Bits;
}NU_GCR_BODCR_T;

typedef enum
{
    GCR_TEMPCR_VTEMP_EN = 0,//温度传感器使能
}NU_GCR_TEMPCR_ENUM;

typedef struct
{
    __IO uint32_t  VTEMP_EN:1;//温度传感器使能
    __I  uint32_t  RESERVE1:31;
}GCR_TEMPCR_Bits;

typedef volatile union
{
  NU_REG            Regs;
  GCR_TEMPCR_Bits          Bits;
}NU_GCR_TEMPCR_T;


typedef enum
{
    GCR_GPAMFP_ADC0 = 0,         //PA.0 Pin功能选择ADC0
    GCR_GPAMFP_ADC1_AD12 = 1,    //PA.1 Pin功能选择ADC1
    GCR_GPAMFP_ADC2_AD11 = 2,    //PA.2 Pin功能选择ADC2
    GCR_GPAMFP_ADC3_AD10 = 3,    //PA.3 Pin功能选择ADC3
    GCR_GPAMFP_ADC4_AD9 = 4,     //PA.4 Pin功能选择ADC4
    GCR_GPAMFP_ADC5_AD8 = 5,     //PA.5 Pin功能选择ADC5
    GCR_GPAMFP_ADC6_AD7 = 6,     //PA.6 Pin功能选择ADC6
    GCR_GPAMFP_ADC7_SS21_AD6 = 7,//PA.7 Pin功能选择ADC7
    GCR_GPAMFP_I2C0_SDA = 8,     //PA.8 Pin功能选择I2C0_SDA
    GCR_GPAMFP_I2C0_SCL = 9,     //PA.9 Pin功能选择I2C0_SCL
    GCR_GPAMFP_I2C1_SDA_nWR = 10,//PA.10 Pin功能选择I2C1_SDA
    GCR_GPAMFP_I2C1_SCL_nRD = 11,//PA.11 Pin功能选择I2C1_SCL
    GCR_GPAMFP_PWM0_AD13 = 12,   //PA.12 Pin功能选择PWM0
    GCR_GPAMFP_PWM1_AD14 = 13,   //PA.13 Pin功能选择PWM1
    GCR_GPAMFP_PWM2_AD15 = 14,   //PA.14 Pin功能选择PWM2
    GCR_GPAMFP_PWM3_I2SMCLK = 15,//PA.15 Pin功能选择PWM3
    GCR_GPAMFP_SCHMITT = 16,     //PA[15:0]I/O史密特触发输入使能
}NU_GCR_GPAMFP_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_GPAMFP_T            Bits;
}NU_GCR_GPAMFP_T;

typedef enum
{
    GCR_GPBMFP_UART0_RX = 0,//PB.0 Pin功能选择
    GCR_GPBMFP_UART0_TX = 1,//PB.1 Pin功能选择
    GCR_GPBMFP_UART0_nRTS_nWRL = 2,//PB.2 Pin功能选择
    GCR_GPBMFP_UART0_nCTS_nWRH = 3,//PB.3 Pin功能选择
    GCR_GPBMFP_UART1_RX = 4,//PB.4 Pin功能选择
    GCR_GPBMFP_UART1_TX = 5,//PB.5 Pin功能选择
    GCR_GPBMFP_UART1_nRTS_ALE = 6,//PB.6 Pin功能选择
    GCR_GPBMFP_UART1_nCTS_nCS = 7,//PB.7 Pin功能选择
    GCR_GPBMFP_TM0 = 8,//PB.8 Pin功能选择
    GCR_GPBMFP_TM1_SS11 = 9,//PB.9 Pin功能选择                                                          
    GCR_GPBMFP_TM2_SS01 = 10,//PB.10 Pin功能选择
    GCR_GPBMFP_TM3_PWM4 = 11,//PB.11 Pin功能选择                                          
    GCR_GPBMFP_CPO0_CLKO_AD0 = 12,//PB.12 Pin功能选择
    GCR_GPBMFP_CPO1_AD1 = 13,//PB.13 Pin功能选择
    GCR_GPBMFP_INT1_SS31 = 14,//PB.14 Pin功能选择
        GCR_GPBMFP_INT0 = 15,//PB.15 Pin功能选择
    GCR_GPBMFP_SCHMITT = 16//PB[15:0]I/O史密特触发输入使能   
}NU_GCR_GPBMFP_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_GPBMFP_T            Bits;
}NU_GCR_GPBMFP_T;


typedef enum
{
    GCR_GPCMFP_SPI0_SS0_I2SLRCLK = 0,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI0_CLK_I2SBCLK = 1,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI0_MISO0_I2SDI = 2,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI0_MOSI0_I2SDO = 3,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI0_MISO1 = 4,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI0_MOSI1 = 5,//PC.0 Pin功能选择
    GCR_GPCMFP_CPP0_AD4 = 6,//PC.0 Pin功能选择
    GCR_GPCMFP_CPN0_AD5 = 7,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI1_SS0_MCLK = 8,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI1_CLK = 9,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI1_MISO0 = 10,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI1_MOSI0 = 11,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI1_MISO1 = 12,//PC.0 Pin功能选择
    GCR_GPCMFP_SPI1_MOSI1 = 13,//PC.0 Pin功能选择
    GCR_GPCMFP_CPP1_AD2 = 14,//PC.0 Pin功能选择
    GCR_GPCMFP_CPN1_AD3 = 15,//PC.0 Pin功能选择
    GCR_GPCMFP_SCHMITT = 16,//PC[15:0]I/O史密特触发输入使能   
}NU_GCR_GPCMFP_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_GPCMFP_T            Bits;
}NU_GCR_GPCMFP_T;


typedef enum
{
    GCR_GPDMFP_SPI2_SS0 = 0,//PD.0 Pin功能选择
    GCR_GPDMFP_SPI2_CLK_SPI0_SS1 = 1,//PD.1 Pin功能选择
    GCR_GPDMFP_SPI2_MISO0_SPI0_MISO1 = 2,//PD.2 Pin功能选择
    GCR_GPDMFP_SPI2_MOSI0_SPI0_MOSI1 = 3,//PD.3 Pin功能选择
    GCR_GPDMFP_SPI2_MISO1 = 4,//PD.4 Pin功能选择
    GCR_GPDMFP_SPI2_MOSI1 = 5,//PD.5 Pin功能选择
    GCR_GPDMFP_CAN0_RX = 6,//PD.6 Pin功能选择
    GCR_GPDMFP_CAN0_TX = 7,//PD.7 Pin功能选择
    GCR_GPDMFP_SPI3_SS0 = 8,//PD.8 Pin功能选择
    GCR_GPDMFP_SPI3_CLK = 9,//PD.9 Pin功能选择
    GCR_GPDMFP_SPI3_MISO0 = 10,//PD.10 Pin功能选择
    GCR_GPDMFP_SPI3_MOSI0 = 11,//PD.11 Pin功能选择
    GCR_GPDMFP_SPI3_MISO1 = 12,//PD.12 Pin功能选择
    GCR_GPDMFP_SPI3_MOSI1 = 13,//PD.13 Pin功能选择
    GCR_GPDMFP_UART2_RX = 14,//PD.14 Pin功能选择
    GCR_GPDMFP_UART2_TX = 15,//PD.15 Pin功能选择
    GCR_GPDMFP_SCHMITT = 16,//PD[15:0]I/O史密特触发输入使能   
}NU_GCR_GPDMFP_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_GPDMFP_T            Bits;
}NU_GCR_GPDMFP_T;

typedef enum
{
    GCR_GPEMFP_PWM6 = 0,//PE.0 Pin功能选择
    GCR_GPEMFP_PWM7 = 1,//PE.1 Pin功能选择
    GCR_GPEMFP_PWM5 = 5,//PE.6 Pin功能选择
    GCR_GPEMFP_SCHMITT = 16 //PE[15:0]I/O史密特触发输入使能
}NU_GCR_GPEMFP_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_GPEMFP_T            Bits;
}NU_GCR_GPEMFP_T;

typedef enum
{
    GCR_ALTMFP_PB10_S01 = 0,//PB10_S01与GPB_MFP[10]决定GPB.10的功能
    GCR_ALTMFP_PB9_S11  = 1,//PB9_S11与GPB_MFP[9]决定PB.9的功能
    GCR_ALTMFP_PA7_S21 = 2,//PA7_S21与GPA_MFP[7]决定PA.7的功能
    GCR_ALTMFP_PB14_S31 = 3,//PB14_S31与GPB_MFP[14]决定PB.14的功能
    GCR_ALTMFP_PB11_PWM4 = 4,//PB11_PWM4与GPB_MFP[11]决定PB.11的功能
    GCR_ALTMFP_PC0_I2SLRCLK = 5,//PC0_I2SLRCLK与GPC_MFP[0]决定PC.0的功能
    GCR_ALTMFP_PC1_I2SBCLK = 6,//PC1_I2SBCLK与GPC_MFP[1 决定PC.1的功能
    GCR_ALTMFP_PC2_I2SDI = 7,//PC2_I2SDI与GPC_MFP[2]决定PC.2的功能
    GCR_ALTMFP_PC3_I2SDO = 8,//PC2_I2SDO与GPC_MFP[3]决定PC.3的功能
    GCR_ALTMFP_PA15_I2SMCLK = 9,//PA15_I2SMCLK与GPA_MFP[15]决定PA.15的功能
    GCR_ALTMFP_PB12_CLKO = 10,//PB12_CLKO与GPB_MFP[12]决定PB.12的功能
    GCR_ALTMFP_EBI_EN = 11,                    
    GCR_ALTMFP_EBI_MCLK_EN = 12,   /* GPC8  */
    GCR_ALTMFP_EBI_WRL_EN =13,    /* GPB2  */
    GCR_ALTMFP_EBI_WRH_EN = 14,    /* GPB3  */
    GCR_ALTMFP_EBI_HB_EN  = 15     
}NU_GCR_ALTMFP_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_ALTMFP_T            Bits;
}NU_GCR_ALTMFP_T;

typedef struct
{
    __IO NU_REG_BITs        PDID;   
    __IO NU_GCR_RSTSRC_T    RSTSRC;//系统管理器控制寄存器
    __IO NU_GCR_IPRSTC1_T   IPRSTC1;//IP复位控制寄存器1
    __IO NU_GCR_IPRSTC2_T   IPRSTC2;//IP复位控制寄存器2
        __IO NU_GCR_CPR_T       CPR;
        __I NU_REG                        RESERVE0;
    __IO NU_GCR_BODCR_T     BODCR;//欠压检测控制寄存器
    __IO NU_GCR_TEMPCR_T    TEMPCR;//温度传感器控制寄存器
        __I NU_REG              RESERVE1;
        __IO NU_REG_BITs                PORCR;//上电复位控制寄存器
        __I NU_REG                        RESERVE2[2];
    __IO NU_GCR_GPAMFP_T    GPAMFP;//多功能GPIOA控制寄存器
    __IO NU_GCR_GPBMFP_T    GPBMFP;//多功能GPIOB控制寄存器
    __IO NU_GCR_GPCMFP_T    GPCMFP;//多功能GPIOC控制寄存器
    __IO NU_GCR_GPDMFP_T    GPDMFP;//多功能GPIOD控制寄存器
    __IO NU_GCR_GPEMFP_T    GPEMFP;//多功能GPIOE控制寄存器
    __I NU_REG                        RESERVE3[3];
        __IO NU_GCR_ALTMFP_T    ALTMFP;//可选多功能引脚控制寄存器
    __I NU_REG                        RESERVE4[43];
    __IO NU_REG_BITs        REGLOCK;//寄存器锁定键地址寄存器
        __I NU_REG                        RESERVE5[3];
        __IO NU_REG_BITs                RCADJ;//RC 校验控制寄存器
}NU_GCR_T;
//----------------------------------------------------//
#define SYSs    (*((NU_GCR_T *) GCR_BASE))//定位全局结构变量SYSs
//----------------------------------------------------//
#define SYSx   ((NU_GCR_T *)  GCR_BASE)
//----------------------------------------------------//
typedef enum
{
    GCR_INTSRC_INTSRC = 0//
}NU_GCR_INTSRC_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_INTSRC_T            Bits;
}NU_GCR_INTSRC_T;

typedef enum
{
    GCR_NMISEL_NMISEL   = 0,//Cortex-M0的NMI 中断源可以从interrupt[31:0]中选择一个
    GCR_NMISEL_INT_TEST = 7//
}NU_GCR_NMISEL_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  GCR_NMISEL_T            Bits;
}NU_GCR_NMISEL_T;

typedef struct
{
    __I  NU_GCR_INTSRC_T    INTSRC[32];//MCU IRQ0~31 (BOD) 中断源识别
    __IO NU_GCR_NMISEL_T    NMISEL;//NMI 中断源选择控制寄存器
    __IO NU_REG_BITs        MCUIRQ;//MCU IRQ 号识别寄存器   
}NU_GCR_INT_T;

//----------------------------------------------------//
#define SYSINTs    (*((NU_GCR_INT_T *) INT_BASE))//定位全局结构变量GCR_INTs
//----------------------------------------------------//
#define SYSINTx   ((NU_GCR_INT_T *)  INT_BASE)
//----------------------------------------------------//
typedef enum
{
    WDT_WTCR_WTR = 0,//看门狗定时器重置
        WDT_WTCR_WTRE = 1,//看门狗定时器复位使能
        WDT_WTCR_WTRF = 2,//看门狗定时器复位标志
        WDT_WTCR_WTIF = 3,//看门狗定时器中断标志
        WDT_WTCR_WTWKE = 4,//看门狗定时器唤醒功能使能位
        WDT_WTCR_WTWKF = 5,//看门狗定时器唤醒标志
        WDT_WTCR_WTIE = 6,//看门狗定时器中断使能
        WDT_WTCR_WTE = 7,//看门狗定时器使能
        WDT_WTCR_WTIS = 8,//看门狗定时器间隔选择
                          //000:69.33us 001:72.53us 010:85.33us        011:170.67us
                          //100:426.67us 101:1.45ms 110:5.55ms        111:21.93ms
}NU_WDT_WTCR_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  WDT_WTCR_T            Bits;
}NU_WDT_WTCR_T;

typedef struct
{
    __IO NU_WDT_WTCR_T     WTCR;//看门狗定时器控制寄存器
}NU_WDT_T;
//----------------------------------------------------//
#define WDTs    (*((NU_WDT_T *) WDT_BASE))//定位全局结构变量WDTs
//----------------------------------------------------//
#define WDTx   ((NU_WDT_T *)  WDT_BASE)
//----------------------------------------------------//
typedef enum
{
    RTC_AER_AER = 0,//RTC寄存器写入使能密码(只写)
    RTC_AER_ENF = 16//RTC 寄存器写入使能标志(只读)
}NU_RTC_AER_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  RTC_AER_T            Bits;
}NU_RTC_AER_T;

typedef enum
{
    RTC_FCR_INTEGER_32761 = 0,
    RTC_FCR_INTEGER_32762 = 1,
    RTC_FCR_INTEGER_32763 = 2,
    RTC_FCR_INTEGER_32764 = 3,
    RTC_FCR_INTEGER_32765 = 4,
    RTC_FCR_INTEGER_32766 = 5,
    RTC_FCR_INTEGER_32767 = 6,
    RTC_FCR_INTEGER_32768 = 7,
    RTC_FCR_INTEGER_32769 = 8,
    RTC_FCR_INTEGER_32770 = 9,
    RTC_FCR_INTEGER_32771 = 10,
    RTC_FCR_INTEGER_32772 = 11,
    RTC_FCR_INTEGER_32773 = 12,
    RTC_FCR_INTEGER_32774 = 13,
    RTC_FCR_INTEGER_32775 = 14,
    RTC_FCR_INTEGER_32776 = 15
}NU_RTC_FCR_INTEGER_ENUM;

typedef enum
{
    RTC_FCR_FRACTION = 0,//分数部分(公式=(分数部分值)x60)
    RTC_FCR_INTEGER  = 8 //整数部分
}NU_RTC_FCR_ENUM;

typedef volatile union
{
  NU_REG            Regs;
  RTC_FCR_T            Bits;
}NU_RTC_FCR_T;

typedef enum
{
    RTC_TLR_SEC1  = 0,//秒个位
    RTC_TLR_SEC10 = 4,//秒十位
    RTC_TLR_MIN1  = 8,//分个位
    RTC_TLR_MIN10 = 12,//分十位
    RTC_TLR_HR1   = 16,//小时个位
    RTC_TLR_HR10  = 20//小时十位
}NU_RTC_TLR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_TLR_T            Bits;
}NU_RTC_TLR_T;

typedef enum
{
    RTC_CLR_DAY1   = 0,//日位
    RTC_CLR_DAY10  = 4,//日十位
    RTC_CLR_MON1   = 8,//月个位
    RTC_CLR_MON10  = 12,//月十位
    RTC_CLR_YEAR1  = 16,//年个位
    RTC_CLR_YEAR10 = 20//年十位
}NU_RTC_CLR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_CLR_T            Bits;
}NU_RTC_CLR_T;

typedef enum
{
    RTC_TSSR_HR24 = 0//(1)24-小时/(0)12-小时模式选择(带AM /PM 指示)
}NU_RTC_TSSR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_TSSR_T    Bits;
}NU_RTC_TSSR_T;

typedef enum
{
    RTC_DWR_DWR = 0//一周日期寄存器(0:星期天 1:星期一 6:星期六)
}NU_RTC_DWR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_DWR_T     Bits;
}NU_RTC_DWR_T;

typedef enum
{
    RTC_TAR_SEC1  = 0,//秒个位
    RTC_TAR_SEC10 = 4,//秒十位
    RTC_TAR_MIN1  = 8,//分个位
    RTC_TAR_MIN10 = 12,//分十位
    RTC_TAR_HR1   = 16,//小时个位
    RTC_TAR_HR10  = 20//小时十位
}NU_RTC_TAR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_TLR_T     Bits;
}NU_RTC_TAR_T;

typedef enum
{
    RTC_CAR_DAY1   = 0,//日位
    RTC_CAR_DAY10  = 4,//日十位
    RTC_CAR_MON1   = 8,//月个位
    RTC_CAR_MON10  = 12,//月十位
    RTC_CAR_YEAR1  = 16,//年个位
    RTC_CAR_YEAR10 = 20//年十位
}NU_RTC_CAR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_CLR_T     Bits;
}NU_RTC_CAR_T;

typedef enum
{
    RTC_LIR_LIR = 0//按年分割指示寄存器(只读)
}NU_RTC_LIR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_LIR_T     Bits;
}NU_RTC_LIR_T;

typedef enum
{
    RTC_RIER_AIER = 0,//闹钟中断使能
    RTC_RIER_TIER = 1 //时钟节拍中断使能
}NU_RTC_RIER_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_RIER_T    Bits;
}NU_RTC_RIER_T;

typedef enum
{
    RTC_RIIR_AI = 0,//RTC闹钟中断标志
    RTC_RIIR_TI = 1 //RTC时钟节拍中断标志
}NU_RTC_RIIR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_RIIR_T    Bits;
}NU_RTC_RIIR_T;

typedef enum
{
    RTC_TTR_TWKE_1     = 0,//时钟节拍1
    RTC_TTR_TWKE_1_2   = 1,//时钟节拍1/2
    RTC_TTR_TWKE_1_4   = 2,//时钟节拍1/4
    RTC_TTR_TWKE_1_8   = 3,//时钟节拍1/8
    RTC_TTR_TWKE_1_16  = 4,//时钟节拍1/16
    RTC_TTR_TWKE_1_32  = 5,//时钟节拍1/32
    RTC_TTR_TWKE_1_64  = 6,//时钟节拍1/64
    RTC_TTR_TWKE_1_128 = 7,//时钟节拍1/128
}NU_RTC_TTR_TWKE_ENUM;

typedef enum
{
    RTC_TTR_TTR  = 0,//时钟节拍寄存器
        RTC_TTR_TWKE = 3 //RTC定时器唤醒CPU使能位
}NU_RTC_TTR_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_TTR_T    Bits;
}NU_RTC_TTR_T;

typedef enum
{
    RTC_PWRCON_PTOUT  = 0,//
    RTC_PWRCON_PWROFF = 16//
}NU_RTC_PWRCON_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  RTC_PWRCON_T    Bits;
}NU_RTC_PWRCON_T;

typedef struct
{
    __IO NU_REG_BITs     INIR;//RTC复位寄存器
    __IO NU_RTC_AER_T    AER;//RTC读写使能寄存器
    __IO NU_RTC_FCR_T    FCR;//RTC频率补偿寄存器
    __IO NU_RTC_TLR_T    TLR;//时间载入寄存器
    __IO NU_RTC_CLR_T    CLR;//日历载入寄存器
    __IO NU_RTC_TSSR_T   TSSR;//时间格式选择寄存器
    __IO NU_RTC_DWR_T    DWR;//一周日期寄存器
    __IO NU_RTC_TAR_T    TAR;//时间闹钟寄存器
    __IO NU_RTC_CAR_T    CAR;//日历闹钟寄存器
    __IO NU_RTC_LIR_T    LIR;//年分割指示寄存器
    __IO NU_RTC_RIER_T   RIER;//RTC中断使能寄存器
    __IO NU_RTC_RIIR_T   RIIR;//RTC中断指示寄存器
    __IO NU_RTC_TTR_T    TTR;//RTC时钟节拍寄存器
    __IO NU_RTC_PWRCON_T PWRCON;
}NU_RTC_T;
//----------------------------------------------------//
#define RTCs    (*((NU_RTC_T *) RTC_BASE))//定位全局结构变量RTCs
//----------------------------------------------------//
#define RTCx   ((NU_RTC_T *)  RTC_BASE)
//----------------------------------------------------//
typedef enum
{
    FMC_ISPCON_ISPEN = 0,//
    FMC_ISPCON_BS = 0,//
    FMC_ISPCON_CFGUEN = 0,//
        FMC_ISPCON_LDUEN = 0,//
    FMC_ISPCON_ISPFF = 0,//
    FMC_ISPCON_SWRST = 0,//
    FMC_ISPCON_PT = 0,//
        FMC_ISPCON_ET = 0 //
}NU_FMC_ISPCON_ENUM;

typedef volatile union
{
  NU_REG        Regs;
  FMC_ISPCON_T    Bits;
}NU_FMC_ISPCON_T;

typedef struct
{
    FMC_ISPCON_T ISPCON;
    FMC_ISPADR_T ISPADR;
    FMC_ISPDAT_T ISPDAT;
    FMC_ISPCMD_T ISPCMD;
    FMC_ISPTRG_T ISPTRG;
    FMC_DFBADR_T DFBADR;
    FMC_FATCON_T FATCON;
}NU_FMC_T;
//----------------------------------------------------//
#define FMCs    (*((NU_FMC_T *) FMC_BASE))//定位全局结构变量FMCs
//----------------------------------------------------//
#define FMCx   ((NU_FMC_T *)  FMC_BASE)
//----------------------------------------------------//
typedef struct
{
    PS2_CON_T       PS2CON;
        union{
      PS2_DATA_T      TXDATA[4];
          struct{
        PS2_DATA_T    TXDATA0;
        PS2_DATA_T    TXDATA1;
        PS2_DATA_T    TXDATA2;
        PS2_DATA_T    TXDATA3;
          };
        };
    PS2_DATA_T      RXDATA;
    PS2_STATUS_T    STATUS;
    PS2_INTID_T     INTID;
}NU_PS2_T;

//----------------------------------------------------//
#define PS2s    (*((NU_PS2_T *) PS2_BASE))//定位全局结构变量PS2s
//----------------------------------------------------//
#define PS2x   ((NU_PS2_T *)  PS2_BASE)
//----------------------------------------------------//
typedef struct
{
    CAN_OPMODE_T    OPMODE;
    CAN_CMD_T       CMD;
        CAN_BUSSTS_T    BUSSTS;   
        CAN_INTR_T      INTR;

    CAN_INTEN_T     INTEN;
    CAN_BTIMR_T     BTIMR;
        union{
          CAN_RESERVE_T        PROTECT[2];
          struct{
            CAN_RESERVE_T        PROTECT_0;
            CAN_RESERVE_T        PROTECT_1;
          };
        };

    CAN_ERRCR_T     ERRCR;
        CAN_RESERVE_T        PROTECT1;
    CAN_RECNTR_T    RECNTR;
    CAN_TECNTR_T  
          TECNTR;

    CAN_TXFINFO_T   TXFINFO;
    CAN_TXIDR_T     TXIDR;
        union{
      CAN_TXDATA_T    TXDATA[2];
          struct{
        CAN_TXDATA_T    TXDATA0;
        CAN_TXDATA_T    TXDATA1;
          };
        };

    CAN_RXFINFO_T   RXFINFO;
    CAN_RXIDR_T     RXIDR;
    CAN_RXDATA_T    RX_DATA[2];
    CAN_ACR_T       ACR;
    CAN_AMR_T       AMR;   
}NU_CAN_T;

//----------------------------------------------------//
#define CANs    (*((NU_CAN_T *) CAN_BASE))//定位全局结构变量CANs
//----------------------------------------------------//
#define CANx   ((NU_CAN_T *)  CAN_BASE)
//----------------------------------------------------//
typedef struct
{
    USBD_INTEN_T    INTEN;                       
    USBD_INTSTS_T   INTSTS;                       
    USBD_FADDR_T    FADDR;                       
    USBD_EPSTS_T    EPSTS;
    USBD_ATTR_T     ATTR;
    USBD_FLDET_T    FLDET;
    USBD_BUFSEG_T   BUFSEG;
    uint32_t        RESERVE0;
        union{
                USBD_EP_T       EP[6];
                struct{
                        USBD_EP_T       EP0;
                        USBD_EP_T       EP1;
                        USBD_EP_T       EP2;
                        USBD_EP_T       EP3;
                        USBD_EP_T       EP4;
                        USBD_EP_T       EP5;
                };
        };
    uint32_t        RESERVE1[4];
        USBD_DRVSE0_T   DRVSE0;
    uint32_t        RESERVE2[4];
    USBD_PDMA_T     PDMA;
}NU_USBD_T;

//----------------------------------------------------//
#define USBDs    (*((NU_USBD_T *) USBD_BASE))//定位全局结构变量USBDs
//----------------------------------------------------//
#define USBDx   ((NU_USBD_T *)  USBD_BASE)
//----------------------------------------------------//
typedef struct
{
    I2S_CON_T        CON;
        I2S_CLKDIV_T     CLKDIV;
    I2S_IE_T               IE;
    I2S_STATUS_T     STATUS;
    I2S_TXFIFO_T     TXFIFO;
        I2S_RXFIFO_T     RXFIFO;
}NU_I2S_T;

//----------------------------------------------------//
#define I2Ss    (*((NU_I2S_T *) I2S_BASE))//定位全局结构变量I2Ss
//----------------------------------------------------//
#define I2Sx   ((NU_I2S_T *)  I2S_BASE)
//----------------------------------------------------//
typedef struct
{
    EBI_CON_T       CON;
    EBI_TIME_T      TIME;
}NU_EBI_T;

//----------------------------------------------------//
#define EBIs    (*((NU_EBI_T *) EBI_BASE))//定位全局结构变量EBIs
//----------------------------------------------------//
#define EBIx   ((NU_EBI_T *)  EBI_BASE)
//----------------------------------------------------//
typedef struct
{
  __I NU_REG_BITs ISER;//IRQ0~IRQ31设置使能控制寄存器
  __I NU_REG      RESERVED0[31];
  __I NU_REG_BITs ICER;//IRQ0~IRQ31清使能控制寄存器
  __I NU_REG      RSERVED1[31];
  __I NU_REG_BITs ISPR;//IRQ0~IRQ31设置挂起控制寄存器
  __I NU_REG      RESERVED2[31];
  __I NU_REG_BITs ICPR;//IRQ0~IRQ31清挂起控制寄存器
  __I NU_REG      RESERVED3[31];
  __I NU_REG      RESERVED4[64];
  union{
          __I NU_REG_BITs IPR[8];//IRQ0~IRQ31优先级控制寄存器
        struct{
                  __I NU_REG_BITs IPR0;//IRQ0~IRQ3优先级控制寄存器
                  __I NU_REG_BITs IPR1;//IRQ4~IRQ7优先级控制寄存器
                  __I NU_REG_BITs IPR2;//IRQ8~IRQ11优先级控制寄存器
                  __I NU_REG_BITs IPR3;//IRQ12~IRQ15优先级控制寄存器
                  __I NU_REG_BITs IPR4;//IRQ16~IRQ19优先级控制寄存器
                  __I NU_REG_BITs IPR5;//IRQ20~IRQ23优先级控制寄存器
                  __I NU_REG_BITs IPR6;//IRQ24~IRQ27优先级控制寄存器
                  __I NU_REG_BITs IPR7;//IRQ28~IRQ31优先级控制寄存器
        };
  };
}NU_NVIC_Type;
//----------------------------------------------------//
#define NVICs    (*((NU_NVIC_Type *) NVIC_BASE))//定位全局结构变量NVICs
//----------------------------------------------------//
#define NVICx   ((NU_NVIC_Type *)  NVIC_BASE)
//----------------------------------------------------//
typedef enum
{
    SCB_CPUID_REVISION = 0,//值为0x0
    SCB_CPUID_PARTNO = 4,//值为0xC20
    SCB_CPUID_PART = 16,//ARMv6-M值为0xC
    SCB_CPUID_IMPLEMENTER = 24,//由ARM分配执行码(ARM=0x41)
}NU_SCB_CPUID_ENUM;

typedef struct
{
    __I  NU_REG  REVISION:4;
    __I  NU_REG  PARTNO:12;
    __I  NU_REG  PART:4;
    __I  NU_REG  RESERVE:4;
    __I  NU_REG  IMPLEMENTER:8;
}SCB_CPUID_T;

typedef volatile union
{
  NU_REG        Regs;
  SCB_CPUID_T   Bits;
}NU_SCB_CPUID_T;

typedef enum
{
        SCB_ICSR_VECTACTIVE = 0,//0:线程模式 value > 1: 当前执行异常处理的数目
        SCB_ICSR_VECTPENDING = 12,//表示最高优先级挂起异常的数目
    SCB_ICSR_ISRPENDING = 22,//表示外部配置中断是否挂起
    SCB_ICSR_ISRPREEMPT = 23,//如果置位，挂起异常生效，由调试停止状态退出
    SCB_ICSR_PENDSTCLR = 25,//写1清除挂起SysTick
    SCB_ICSR_PENDSTSET = 26,//设置挂起SysTick.由当前状态读回(1 if Pending,0 if not)
    SCB_ICSR_PENDSVCLR = 27,//写1清PendSV中断
    SCB_ICSR_PENDSVSET = 28,//设置PendSV 中断.通常用于请求内容切换.由当前状态读回(1 if Pending, 0 if not)
    SCB_ICSR_NMIPENDSET = 31//
}NU_SCB_ICSR_ENUM;

typedef struct
{
    __I  NU_REG  VECTACTIVE:9;
    __I  NU_REG  VECTPENDING:9;
    __I  NU_REG  ISRPENDING:1;
    __I  NU_REG  ISRPREEMPT:1;
    __I  NU_REG  RESERVE1:1;
    __O  NU_REG  PENDSTCLR:1;
    __IO NU_REG  PENDSTSET:1;
    __I  NU_REG  PENDSVCLR:1;
    __IO NU_REG  PENDSVSET:1;
    __I  NU_REG  RESERVE2:2;
    __IO NU_REG  NMIPENDSET:1;
}SCB_ICSR_T;

typedef volatile union
{
  NU_REG        Regs;
  SCB_ICSR_T    Bits;
}NU_SCB_ICSR_T;

typedef enum
{
    SCB_SCR_SLEEPONEXIT = 1,//设置为1,在异常返回到线程模式时,内核进入休眠状态
    SCB_SCR_SLEEPDEEP   = 2,//提示从休眠中唤醒需要较长时间
    SCB_SCR_SEVONPEND   = 4 //当使能时，中断由不活动到挂起，包括了唤醒事件(WFE指令)
}NU_SCB_SCR_ENUM;

typedef struct
{
    __I  NU_REG  RESERVE0:1;
    __I  NU_REG  SLEEPONEXIT:1;
    __I  NU_REG  SLEEPDEEP:1;
    __I  NU_REG  RESERVE1:1;
    __O  NU_REG  SEVONPEND:1;
    __I  NU_REG  RESERVE2:27;
}SCB_SCR_T;

typedef volatile union
{
  NU_REG        Regs;
  SCB_ICSR_T    Bits;
}NU_SCB_SCR_T;

typedef struct
{
  __I  NU_SCB_CPUID_T CPUID;//CPUID Base 寄存器
  __IO NU_SCB_ICSR_T  ICSR;//中断控制状态寄存器
  __I  NU_REG         RESERVED0;                                      
  __IO NU_REG_BITs    AIRCR;
  __IO NU_SCB_SCR_T   SCR;//系统控制寄存器
  __IO NU_REG_BITs    CCR;
  __I  NU_REG         RESERVED1;
  union{                                      
          __IO NU_REG_BITs     SHP[2];//系统处理器优先级寄存器2和3
        struct{
                  __IO NU_REG_BITs SHP2;//系统处理器优先级寄存器2
                  __IO NU_REG_BITs SHP3;//系统处理器优先级寄存器3
        };
  };
  __IO NU_REG_BITs    SHCSR;
  __I  NU_REG         RESERVED2[2];                                   
  __IO NU_REG_BITs    DFSR;
}NU_SCB_Type;                                                
//----------------------------------------------------//
#define SCBs    (*((NU_SCB_Type *) SCB_BASE))//定位全局结构变量SCBs
//----------------------------------------------------//
#define SCBx   ((NU_SCB_Type *)  SCB_BASE)
//----------------------------------------------------//
typedef enum
{
    SysTick_CTRL_TICKENABLE = 0,//
    SysTick_CTRL_TICKINT    = 1,//
    SysTick_CTRL_CLKSRC     = 2,//
    SysTick_CTRL_COUNTFLAG  = 16//
}NU_SysTick_CTRL_ENUM;

typedef struct
{
    __IO NU_REG  TICKENABLE:1;
    __IO NU_REG  TICKINT:1;
    __IO NU_REG  CLKSRC:1;
    __IO NU_REG  RESERVE0:13;
    __IO NU_REG  COUNTFLAG:1;
    __IO NU_REG  RESERVE1:15;
}SysTick_CTRL_T;

typedef volatile union
{
  NU_REG         Regs;
  SysTick_CTRL_T Bits;
}NU_SysTick_CTRL_T;

typedef enum
{
    SysTick_LOAD_RELOAD = 0,//当计数器达到0时，值加载到当前值寄存器
}NU_SysTick_LOAD_ENUM;

typedef struct
{
    __IO NU_REG  RELOAD:24;
    __IO NU_REG  RESERVE:8;
}SysTick_LOAD_T;

typedef volatile union
{
  NU_REG         Regs;
  SysTick_LOAD_T Bits;
}NU_SysTick_LOAD_T;

typedef enum
{
    SysTick_VAL_CURRENT = 0,//当前计数值，为采样时刻的计数器的值
}NU_SysTick_VAL_ENUM;

typedef struct
{
    __IO NU_REG  CURRENT:24;
    __IO NU_REG  RESERVE:8;
}SysTick_VAL_T;

typedef volatile union
{
  NU_REG         Regs;
  SysTick_VAL_T Bits;
}NU_SysTick_VAL_T;

typedef struct
{
  __IO NU_SysTick_CTRL_T CTRL;//SysTick控制与状态
  __IO NU_SysTick_LOAD_T LOAD;//SysTick重新加载值
  __IO NU_SysTick_VAL_T  VAL;//SysTick当前值
  __I  NU_REG_BITs       CALIB;
}NU_SysTick_Type;
//----------------------------------------------------//
#define SysTicks    (*((NU_SysTick_Type *) SysTick_BASE))//定位全局结构变量SysTicks
//----------------------------------------------------//
#define SysTickx   ((NU_SysTick_Type *)  SysTick_BASE)
//----------------------------------------------------//
typedef struct
{
  __IO NU_REG_BITs DHCSR;
  __O  NU_REG_BITs DCRSR;
  __IO NU_REG_BITs DCRDR;
  __IO NU_REG_BITs DEMCR;
}NU_CoreDebug_Type;
//----------------------------------------------------//
#define CoreDebugs    (*((NU_CoreDebug_Type *) CoreDebug_BASE))//定位全局结构变量CoreDebugs
//----------------------------------------------------//
#define CoreDebugx   ((NU_CoreDebug_Type *)  CoreDebug_BASE)
//----------------------------------------------------//



#ifdef __cplusplus
}
#endif

#endif  /* __NUC1xxcfg_H__ */

hotpower

应用：Smpl_HIDTransfer.c

/*---------------------------------------------------------------------------------------------------------*/
/*                                                                                                         */
/* Copyright(c) 2009 Nuvoton Technology Corp. All rights reserved.                                         */
/*                                                                                                         */
/*---------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include "NUC1xx.h"
#include "NUC1xxcfg.h"//加入菜农头文件

#include "Driver\DrvGPIO.h"
#include "Driver\DrvSYS.h"
#include "Driver\DrvUART.h"
#include "Driver\DrvUSB.h"
#include "Driver\DrvSPI.h"
#include "Driver\DrvPDMA.h"
#define DEBUG 0

#define        TEST_LENGTH        64        /* length */
uint8_t SrcArray[TEST_LENGTH];
uint8_t DestArray[TEST_LENGTH];

extern int32_t HID_MainProcess(void);

void Delay(uint32_t delayCnt)
{
    while(delayCnt--)
    {
        __NOP();
        __NOP();
    }
}
///////////////////////////////////////////////////////////////////////////
//SPIDMA初始化
void SPIPDMAInit(void)
{
STR_PDMA_T sPDMA;  
uint32_t  SPIPort;
        /* -------------------------------------------- */
    /* Configure PDMA Channel 0 to receive SPI2 Rx0 */
        /* -------------------------------------------- */
        /* SPI Port = SPI0 Rx0 */
//        SPIPort = SPI0_BASE + 0x10;
        SPIPort = (uint32_t)&SPI0s.RX[0].Regs;
    /* PDMA Init */
    DrvPDMA_Init();
        /* PDMA Setting */
        DrvPDMA_SetCHForAPBDevice(eDRVPDMA_CHANNEL_0, eDRVPDMA_SPI0, eDRVPDMA_READ_APB);
        /* CH0 RX Setting */
        sPDMA.sSrcCtrl.u32Addr                         = SPIPort;
    sPDMA.sDestCtrl.u32Addr                 = (uint32_t)DestArray;   
        sPDMA.u8TransWidth                                 = eDRVPDMA_WIDTH_8BITS;
        sPDMA.u8Mode                                         = eDRVPDMA_MODE_APB2MEM;//SPI->RAM
        sPDMA.sSrcCtrl.eAddrDirection         = eDRVPDMA_DIRECTION_FIXED;
        sPDMA.sDestCtrl.eAddrDirection         = eDRVPDMA_DIRECTION_INCREMENTED;
        sPDMA.i32ByteCnt                = TEST_LENGTH;  
        DrvPDMA_Open(eDRVPDMA_CHANNEL_0, &sPDMA);
       
    /* -------------------------------------------- */
    /* Configure PDMA Channel 1 to receive SPI2 Tx0 */
        /* -------------------------------------------- */
        /* SPI Port = SPI0 Tx0 */
//        SPIPort = SPI0_BASE + 0x20;
        SPIPort = (uint32_t)&SPI0s.TX[0].Regs;
        /* PDMA Setting */
        DrvPDMA_SetCHForAPBDevice(eDRVPDMA_CHANNEL_1, eDRVPDMA_SPI0, eDRVPDMA_WRITE_APB);
        /* CH0 TX Setting */
        sPDMA.sSrcCtrl.u32Addr                         = (uint32_t)SrcArray;
    sPDMA.sDestCtrl.u32Addr                 = SPIPort;   
        sPDMA.u8TransWidth                                 = eDRVPDMA_WIDTH_8BITS;
        sPDMA.u8Mode                                         = eDRVPDMA_MODE_MEM2APB;//RAM->SPI
        sPDMA.sSrcCtrl.eAddrDirection         = eDRVPDMA_DIRECTION_INCREMENTED;
        sPDMA.sDestCtrl.eAddrDirection         = eDRVPDMA_DIRECTION_FIXED;
        sPDMA.i32ByteCnt                = TEST_LENGTH;  
        DrvPDMA_Open(eDRVPDMA_CHANNEL_1, &sPDMA);
}

//SPI接口初始化
void SPIInit(void)
{
    DrvSYS_SetIPClock(E_SYS_SPI0_CLK,1);
    DrvGPIO_InitFunction(E_FUNC_SPI0); // enable SPI funztion and pin
        DrvSPI_Open(eDRVSPI_PORT0, eDRVSPI_MASTER, eDRVSPI_TYPE2, 8,FALSE);
        DrvSPI_SetSlaveSelectActiveLevel(eDRVSPI_PORT0, eDRVSPI_ACTIVE_HIGH_RISING);
        DrvSPI_SetEndian(eDRVSPI_PORT0, eDRVSPI_MSB_FIRST);
//        DrvSPI_DisableAutoSS(eDRVSPI_PORT0);
        DrvSPI_EnableAutoSS(eDRVSPI_PORT0, eDRVSPI_SS0);
//        DrvSPI_SetClockFreq(eDRVSPI_PORT0,  80000,  80000);
//        DrvSPI_SetClockFreq(eDRVSPI_PORT0, 120000, 120000);
        DrvSPI_SetClockFreq(eDRVSPI_PORT0, 180000, 180000);
//        DrvSPI_SetClockFreq(eDRVSPI_PORT0, 200000, 200000);
//        DrvSPI_SetClockFreq(eDRVSPI_PORT0, 220000, 220000);
//        DrvSPI_SetClockFreq(eDRVSPI_PORT0, 240000, 240000);
//        DrvSPI_SetClockFreq(eDRVSPI_PORT0, 300000, 300000);
}

//SPI接口读写数据
uint32_t SPIReadWrite(uint32_t TxData)
{
uint32_t RxData;
//        DrvSPI_SetSS(eDRVSPI_PORT0, eDRVSPI_SS0);
//    SPI0s.SSR.Bits.SSR = eDRVSPI_SS0;

//        DrvSPI_SingleWrite(eDRVSPI_PORT0, &TxData);
//        SPI0s.TX[0].Regs = TxData;
        SPI0s.TX0.Regs = TxData;
        SPI0s.CNTRL.Bits.GO_BUSY = 1;

//        while (DrvSPI_IsBusy(eDRVSPI_PORT0)) {}
        while(SPI0s.CNTRL.Bits.GO_BUSY);


//        DrvSPI_ClrSS(eDRVSPI_PORT0, eDRVSPI_SS0);        
//        SPI0s.SSR.Bits.SSR = eDRVSPI_NONE;
       
//        DrvSPI_DumpRxRegister(eDRVSPI_PORT0, &RxData, 1);
//        RxData = SPI0s.RX[0].Regs;
        RxData = SPI0s.RX0.Regs;
        return RxData;
}

//SPI接口系统初始化
uint32_t SPISysInit(void)
{
uint32_t i, flag = 0;
        for (i = 0; i < 8; i++)
        {
                SPIReadWrite(250);       
        }

        for (i = 0; i < 250; i++)
        {
                if (SPIReadWrite(0x88) == 0x88)
                {
                        flag = 1;
                        break;
                }
        }
        return flag;
}

//SPI接口读出FLASH命令
uint32_t SPIReadFlashCommand(uint32_t num)
{
uint32_t i, flag = 0;
uint8_t str[] = "\x55\xaa\x40";
        str[2] |= num;
        for (i = 0; i < 3; i ++)
        {
                SPIReadWrite((uint32_t)str);
        }
        if (SPIReadWrite(0x55) == 0xaa)
        {
                flag = 1;
        }
        return flag;
}

//SPI接口读出FLASH命令
void SPIReadFlashData(uint8_t *data)
{
uint32_t i;
        for (i = 0; i < 64; i ++)
        {
                data = SPIReadWrite(0x55555555);
        }
        return;
}

//SPI接口PDMA读出FLASH命令
void SPIDMAReadFlashData(uint8_t *data)
{

//        while(DrvPDMA_IsCHBusy(eDRVPDMA_CHANNEL_0));
        while(PDMA0s.CSR.Bits.TRIG_EN);
//        PDMA0->DAR = (uint32_t)data;
        PDMA0s.DAR.Regs = (uint32_t)data;

        /* Trigger PDMA specified Channe0 */
//        DrvPDMA_CHEnableTransfer(eDRVPDMA_CHANNEL_0);
    PDMA0s.CSR.Regs |= (1 << PDMA_CSR_PDMACEN) | (1 << PDMA_CSR_TRIG_EN);


          // enable SPI PDMA
//        DrvSPI_SetPDMA(eDRVSPI_PORT0, eDRVSPI_RX_DMA, TRUE);
//        SPI0s.DMA.Bits.RX_DMA_GO = TRUE;

//        while(DrvPDMA_IsCHBusy(eDRVPDMA_CHANNEL_1));
        while(PDMA1s.CSR.Bits.TRIG_EN);

//        PDMA1->SAR = (uint32_t)SrcArray;
        PDMA1s.SAR.Regs = (uint32_t)SrcArray;

        /* Trigger PDMA specified Channel */
//        DrvPDMA_CHEnableTransfer(eDRVPDMA_CHANNEL_1);
    PDMA1s.CSR.Regs |= (1 << PDMA_CSR_PDMACEN) | (1 << PDMA_CSR_TRIG_EN);

          // enable SPI PDMA
//        DrvSPI_SetPDMA(eDRVSPI_PORT0, eDRVSPI_TX_DMA, TRUE);
//        SPI0s.DMA.Bits.TX_DMA_GO = TRUE;

        SPI0s.DMA.Regs = (1 << SPI_DMA_TX_DMA_GO) | (1 << SPI_DMA_RX_DMA_GO);
///        while(DrvPDMA_IsCHBusy(eDRVPDMA_CHANNEL_0));
        return;
}

//SPI接口写入FLASH命令
uint32_t SPIWriteFlashCommand(uint32_t num)
{
uint32_t i, flag = 0;
uint8_t str[] = "\x55\xaa\x80";
uint8_t ch;
        str[2] |= num;
        for (i = 0; i < 3; i ++)
        {
                ch = SPIReadWrite((uint32_t)str);
        }
        if (ch == 0x55)
        {
                flag = 1;
        }
        return flag;
}


//SPI接口写入FLASH命令
void SPIWriteFlashData(uint8_t *data)
{
uint32_t i;
        for (i = 0; i < 64; i ++)
        {
                SPIReadWrite((uint32_t)data);
        }
        return;
}

//SPI接口PDMA写入FLASH命令
void SPIDMAWriteFlashData(uint8_t *data)
{
//        while(DrvPDMA_IsCHBusy(eDRVPDMA_CHANNEL_1));
        while(PDMA1s.CSR.Bits.TRIG_EN);

//        PDMA1->SAR = (uint32_t)data;
        PDMA1s.SAR.Regs = (uint32_t)data;

        /* Trigger PDMA specified Channel */
//        DrvPDMA_CHEnableTransfer(eDRVPDMA_CHANNEL_1);
    PDMA1s.CSR.Regs |= (1 << PDMA_CSR_PDMACEN) | (1 << PDMA_CSR_TRIG_EN);

          // enable SPI PDMA
//        DrvSPI_SetPDMA(eDRVSPI_PORT0, eDRVSPI_TX_DMA, TRUE);
        SPI0s.DMA.Bits.TX_DMA_GO = TRUE;

//        DrvSPI_SetGo(eDRVSPI_PORT0);
///        while(DrvPDMA_IsCHBusy(eDRVPDMA_CHANNEL_1));

        return;
}

//SPI接口擦除FLASH
uint32_t SPIEraseFlash(uint32_t num)//0~31,32,0x30,0x3f
{
uint32_t i, flag = 0;
uint8_t str[] = "\x55\xaa\x00";
        if (num <= 0x3f)
        {
                str[2] = (uint8_t)num;
                for (i = 0; i < 3; i ++)
                {
                        SPIReadWrite((uint32_t)str);
                }
                for (i = 0; i < 250; i++)
                {
                        if (SPIReadWrite(0x99) >= 0xc0)
                        {
                                for (i = 0; i < 2500; i++)//等待擦除结束
                                {
                                        if (SPIReadWrite(0x99) < 0x80)
                                        {
                                                for (i = 0; i < 250; i++)
                                                {
                                                        if (SPIReadWrite(0x66) == str[2])
                                                        {
                                                                flag = 1;
                                                                break;
                                                        }
                                                }
                                                break;
                                        }
                                }
                                break;
                        }
                }
        }
        return flag;
}

//SPI接口芯片测试
uint32_t SPIChipTest(void)
{
uint32_t i, flag = 0;
        for (i = 0; i < 8; i ++)
        {
                if (SPIReadWrite(0xcc) == 0x03)
                {
                        flag = 1;
                        break;
                }
        }
        return flag;
}

///////////////////////////////////////////////////////////////////////////

/*---------------------------------------------------------------------------------------------------------*/
/*  Main Function                                                                                                                                              */
/*---------------------------------------------------------------------------------------------------------*/
int32_t main (void)
{
        extern uint32_t SystemFrequency;
        uint32_t i;//, j;
        uint8_t FlashData[64];

#ifdef DEBUG
        STR_UART_T sParam;

        /* Set UART Pin */
        DrvGPIO_InitFunction(E_FUNC_UART0);
       
        /* UART Setting */
    sParam.u32BaudRate                 = 115200;
    sParam.u8cDataBits                 = DRVUART_DATABITS_8;
    sParam.u8cStopBits                 = DRVUART_STOPBITS_1;
    sParam.u8cParity                 = DRVUART_PARITY_NONE;
    sParam.u8cRxTriggerLevel= DRVUART_FIFO_1BYTES;

        /* Select UART Clock Source From 12Mhz*/
        DrvSYS_SelectIPClockSource(E_SYS_UART_CLKSRC,0);

        /* Set UART Configuration */
        DrvUART_Open(UART_PORT0,&sParam);
#endif

    UNLOCKREG();

    SYSCLK->PWRCON.XTL12M_EN = 1;
   
    /* Waiting for XTAL stable */
    Delay(1000);

    /* Enable PLL */
        SYSCLK->PLLCON.OE = 0;
    DrvSYS_SetPLLMode(0);
        Delay(1000);

        /* Switch to PLL clock */
        DrvSYS_SelectHCLKSource(2);   

    Delay(100);

    /* The PLL must be 48MHz x N times when using USB */
//    SystemCoreClockUpdate();
        for (i = 0; i < sizeof(SrcArray); i ++)
        {
                SrcArray = 0x55;
        }
        SPIInit();
        if (SPISysInit())
        {
                __NOP();
        }
        SPIPDMAInit();
/*
while(1)
{
for (i = 0; i < sizeof(SrcArray); i ++)
{
        SrcArray = i;
        FlashData = 0;
}
SPIDMAReadFlashData(FlashData);
__NOP();
}
*/
#ifdef DEBUG   
    printf("NUC100 USB HID\n");
#endif
       
    /* Execute HID process */
        HID_MainProcess();

////
/*
        while(1)
        {
                if (SPISysInit())
                {
                        __NOP();
                }
                if  (SPIEraseFlash(0x30))
                {
                        __NOP();
                }
                if (SPISysInit())
                {
                        __NOP();
                }
                if (SPIReadFlashCommand(0x30))
                {
                  __NOP();
                }
                SPIDMAReadFlashData(FlashData);
            __NOP();
                for (i = 0; i < sizeof(FlashData); i ++)
                {
                        FlashData = i;
                }
                if (SPISysInit())
                {
                        __NOP();
                }
                if (SPIWriteFlashCommand(0x30))
                {
                  __NOP();
                }
                SPIDMAWriteFlashData(FlashData);
            __NOP();
                if (SPISysInit())
                {
                        __NOP();
                }
                if (SPIReadFlashCommand(0x30))
                {
                  __NOP();
                }
                SPIDMAReadFlashData(FlashData);
            __NOP();
        }

        SPIInit();
        if (SPISysInit())
        {
                __NOP();
        }
        SPIPDMAInit();
        if  (SPIChipTest())
        {
                __NOP();
        }
        for (i = 0; i < sizeof(SrcArray); i ++)
        {
                SrcArray = 0x55;
        }
        for (i = 0; i < sizeof(FlashData); i ++)
        {
                FlashData = i + 0x30;
        }
        if  (SPIEraseFlash(0))
        {
                __NOP();
        }
        if (SPIChipTest())
        {
                __NOP();
        }
        SPIWriteFlashCommand(0);
        SPIDMAWriteFlashData(FlashData);
//        SPIWriteFlashData(FlashData);
        if (SPISysInit())
        {
                __NOP();
        }
        if (SPIChipTest())
        {
                __NOP();
        }
        __NOP();
        __NOP();
        __NOP();

*/
/*
        for (i = 0; i < sizeof(FlashData); i ++)
        {
                FlashData = i + 0x30;
        }
        if (SPIChipTest())
        {
                __NOP();
        }
        if (SPIWriteFlashCommand(0x3f))
        {
                for (i = 0; i < 512; i ++)
                {
                        SPIWriteFlashData(FlashData);
                }
                __NOP();
        }
        if (SPIChipTest())
        {
                __NOP();
        }
        if (SPIReadFlashCommand(0x3f))
        {
                for (i = 0; i < 512; i ++)
                {
                        SPIReadFlashData(FlashData);
                }
                __NOP();
        }
*/
/*
        if  (SPIEraseFlash(0x30))
        {
                __NOP();
        }
        if  (SPIEraseFlash(0x3f))
        {
                __NOP();
        }

        for (i = 0; i < 33; i ++)
        {
                if  (SPIEraseFlash(i))
                {
                        __NOP();
                }
        }

        if (SPISysInit())
        {
                __NOP();
        }
        if  (SPIEraseFlash(0x3f))
        {
                __NOP();
        }
        if (SPIWriteFlashCommand(0x3f))
        {
                for (i = 0; i < 512; i ++)
                {
                        SPIWriteFlashData(FlashData);
                }
        }
        if (SPISysInit())
        {
                __NOP();
        }
        if  (SPIEraseFlash(0x30))
        {
                __NOP();
        }
        for (i = 0; i < 13; i ++)
        {
                if (SPIWriteFlashCommand(i + 0x30))
                {
                        for (j = 0; j < 96; j ++)
                        {
                                SPIWriteFlashData(FlashData);
                        }
                        __NOP();
                }
        }
        for (i = 0; i < 33; i ++)
        {
                if (SPISysInit())
                {
                        __NOP();
                }
                if  (SPIEraseFlash(i))
                {
                        __NOP();
                }
                if (SPIWriteFlashCommand(i))
                {
                        for (j = 0; j < 8192; j ++)
                        {
                                SPIWriteFlashData(FlashData);
                        }
                        __NOP();
                }
        }
        if (SPIChipTest())
        {
                __NOP();
        }
        if (SPIReadFlashCommand(0x3f))
        {
                for (i = 0; i < 512; i ++)
                {
                        SPIReadFlashData(FlashData);
                }
        }
        if (SPISysInit())
        {
                __NOP();
        }
        for (i = 0; i < 13; i ++)
        {
                if (SPIReadFlashCommand(i + 0x30))
                {
                        for (j = 0; j < 96; j ++)
                        {
                                SPIReadFlashData(FlashData);
                        }
                        __NOP();
                }
        }
        if (SPISysInit())
        {
                __NOP();
        }
        for (i = 0; i < 33; i ++)
        {
                if (SPIReadFlashCommand(i))
                {
                        for (j = 0; j < 8192; j ++)
                        {
                                SPIReadFlashData(FlashData);
                        }
                        __NOP();
                }
        }
*/
#ifdef DEBUG   
    printf("NUC100 USB HID\n");
#endif
       
    /* Execute HID process */
        HID_MainProcess();


}

Rapido

菜农好久没发帖了，我来抢个位坐下学习。

Fire_cow

mark

zzjjhh250

占位

zhifeng

听课

mcu_lover

真的是传说中的hotpower大侠。激动中.....

kupica

支持,顶

erxun

占位 听课

shaozh

听课中！

mowin

前排占位支持，必须的

jamiedu

来学习种菜了～

lixiangwen

哇，菜农都回来了啊，很久没有见到菜农了~~~  热烈欢迎~~~

wkman

好长。。。。。。。。。。。。。。好长。。。。。。。。。。。。打个prg 的 rar包上来好点啊，

bad_fpga

沙发也让楼主占了，不厚道~~~

cargle

顶大侠

R28FA

这个是真的菜农啊，泪流满面

xl7y

都是来看lz的啊

elecboy

很久没见言语风趣的菜农了，占位围观。

Qhjh

呵呵,听说HOTPOWER老师创业去了-做防"毒"软件?

ZRJ8951

学习。

kenluo

置酷

wqhe

大叔，好久没见。。几年了，没有短信问候你，真不好意思！希望常来这里。

hotpower

回复【23楼】wqhe AVR后学者
大叔，好久没见。。几年了，没有短信问候你，真不好意思！希望常来这里。
-----------------------------------------------------------------------
俺也一直想着你~~~
QQ:1270688699,加好友要说明你是谁，干什么，否则不加。
俺主要手机上网，现在好友都快250人了，手都敲痛了。

jordonwu

mark,学习

vvvv50000

不错顶下菜农兄