菜农NUC100学习笔记1(一切从红杏出墙做起)

/*-------------------------------------------------------------------------------

文 件 名 : 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__ */

/*---------------------------------------------------------------------------------------------------------*/

/*                                                                                                         */

/* Copyright(c) 2009 Nuvoton Technology Corp. All rights reserved.                                         */

/*                                                                                                         */

/*---------------------------------------------------------------------------------------------------------*/

#include <stdio.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[i]);

        }

        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[i] = 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[i]);

        }

        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[i]);

        }

        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[i]);

                }

                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[i] = 0x55;

        }

        SPIInit();

        if (SPISysInit())

        {

                __NOP();

        }

        SPIPDMAInit();

/*

while(1)

{

for (i = 0; i < sizeof(SrcArray); i ++)

{

        SrcArray[i] = i;

        FlashData[i] = 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] = 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[i] = 0x55;

        }

        for (i = 0; i < sizeof(FlashData); i ++)

        {

                FlashData[i] = 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] = 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();





}