【ADI低功耗2k代码】基于ADuCM4050的ADXL363、TMP75的加速度、温度检测及串口打印、蜂鸣器播放音乐（孤勇者）

【ADI低功耗2k代码】基于ADuCM4050的ADXL363、TMP75的加速度、温度检测及串口打印、蜂鸣器播放音乐（孤勇者）

蜂鸣器部分参考：
https://blog.csdn.net/weixin_53403301/article/details/125726952
https://blog.csdn.net/weixin_53403301/article/details/125821049

资源：
https://download.csdn.net/download/weixin_53403301/86393887

该工程内 预留了定时器中断和外部中断 但没有用上

TMP75通信是用GPIO模拟I2C ADXL363通信使用SPI实现

ADXL363部分要先往POWER_CTL中写入0x02才能使能

发送命令为WRITE_REGISTER+POWER_CTL+0x02
读取则为READ_REGISTER

TMP75部分只需要向从机地址+1（如1001000，加一位1，就是0x91）中读取0x00寄存器

这两个东西都是12位有效数据 最高位表示正负 为1取补码

ADXL363测出来的加速度单位为mg，温度*0.25为摄氏度

TMP75温度*0.0625为摄氏度

主函数：

#include 
#include "ADuCM4050.h"
#include "drivers/gpio/adi_gpio.h"
#include "drivers/i2c/adi_i2c.h"
#include "drivers/uart/adi_uart.h"
#include "drivers/xint/adi_xint.h "
#include "drivers/tmr/adi_tmr.h"
#include "drivers/spi/adi_spi.h"
#include "drivers/pwr/adi_pwr.h"
#include "GPIO.h"
#include "DELAY.h"
#include "PITCH.h"
#include "MUSIC_NOTE.h"
#include "I2C0.h"
#include "ADF7023_CMD.h"
#include "ADXL363_CMD.h"

unsigned char GPIO_MemorySize[ADI_GPIO_MEMORY_SIZE]; //16b
unsigned char XINT_MemorySize[ADI_XINT_MEMORY_SIZE]; //48b
unsigned char I2C_MemorySize[ADI_I2C_MEMORY_SIZE]; //48b
unsigned char SPI_MemorySize[ADI_SPI_MEMORY_SIZE]; //48b
unsigned char UART_MemorySize[ADI_UART_BIDIR_MEMORY_SIZE]; //双向内存

ADI_I2C_HANDLE handle_I2C0;
ADI_SPI_HANDLE handle_SPI2;

//外部中断回调函数
void callback_XINT0(void	*pCBParam,uint32_t	Event,void	*pArg);
//定时中断回调函数
void callback_TIM0(void	*pCBParam,uint32_t	Event,void	*pArg);

void callback_UART0(void	*pCBParam,uint32_t	Event,void	*pArg);

void callback_SPI2(void	*pCBParam,uint32_t	Event,void	*pArg);

float global_tmp=0.0;

void init_GPIO(void)
{
	adi_gpio_Init(&GPIO_MemorySize,ADI_GPIO_MEMORY_SIZE);
	adi_gpio_OutputEnable(Port0,Pin0,true);
	adi_gpio_PullUpEnable(Port0,Pin0,true);	
	adi_gpio_DriveStrengthEnable(Port0,Pin0,true);
	adi_gpio_InputEnable(Port0,Pin1,true);  //使能输入
	
	adi_gpio_OutputEnable(Port0,Pin9|Pin8|Pin4|Pin5|Pin13,true);
	adi_gpio_PullUpEnable(Port0,Pin9|Pin8|Pin4|Pin5|Pin13,true);
	adi_gpio_DriveStrengthEnable(Port0,Pin9|Pin8|Pin4|Pin5|Pin13,true);
	
	adi_gpio_InputEnable(Port2,Pin9,true);  //使能输入
	
	adi_gpio_SetGroupInterruptPins(Port0,ADI_GPIO_INTA_IRQ,Pin1);
//	adi_gpio_SetGroupInterruptPolarity(Port0,Pin1);
	adi_gpio_GroupInterruptPolarityEnable(Port0,Pin1,false);
}


void init_XINT(void)
{
	adi_xint_Init(&XINT_MemorySize,ADI_XINT_MEMORY_SIZE);
	adi_xint_EnableIRQ(ADI_XINT_EVENT_INT0,ADI_XINT_IRQ_FALLING_EDGE); //下降沿触发
	adi_xint_RegisterCallback(ADI_XINT_EVENT_INT0,callback_XINT0,NULL);
}

void init_TIM(void)
{	
	adi_tmr_Init(ADI_TMR_DEVICE_GP0,callback_TIM0,NULL,true);  //回调函数定时中断
	ADI_TMR_CONFIG config_TIM0;
	
	config_TIM0.bCountingUp=true;  //是否向上计数
	config_TIM0.bPeriodic=true;  //计数值 输入或自由运行（0xffff）
	config_TIM0.ePrescaler=ADI_TMR_PRESCALER_256;  //分频值  每1个时钟源计数一次
	config_TIM0.eClockSource=ADI_TMR_CLOCK_PCLK; //时钟源 PCLK 26MHz
	config_TIM0.nLoad=26000;  //26个计数 1ms*256
//	config_TIM0.nAsyncLoad=5000;  //异步计数值
	config_TIM0.bReloading=true;  //开启自动重载（到达计数值清零） 开启bPeriodic时有效
	config_TIM0.bSyncBypass=true;  //开启同步旁路	
	adi_tmr_ConfigTimer(ADI_TMR_DEVICE_GP0,&config_TIM0);  //在定时器未开启时使用
	
	adi_tmr_Enable(ADI_TMR_DEVICE_GP0,true);
	
	adi_tmr_Reload(ADI_TMR_DEVICE_GP0);	
}

void init_I2C(void)
{
	mux_GPIO(0,4,0x1);
	mux_GPIO(0,5,0x1);
//	uint32_t HwErrors_I2C0;
	
	adi_i2c_Open(0,&I2C_MemorySize,ADI_I2C_MEMORY_SIZE,&handle_I2C0);
	
//	adi_i2c_ReadWrite(handle_I2C0,&transaction_I2C0,HwErrors_I2C0);  //阻塞
	
	adi_i2c_Reset(handle_I2C0);
	adi_i2c_SetBitRate(handle_I2C0,400000);
	adi_i2c_SetSlaveAddress(handle_I2C0,0x48);
//	adi_i2c_IssueGeneralCall(handle_I2C0,pData_I2C0,1,&HwErrors_I2C0);
	adi_i2c_SetBusClear(handle_I2C0,false,true);

	uint32_t DataCount_I2C0;
	adi_i2c_GetNumberOfDataProcessed(handle_I2C0,&DataCount_I2C0);  //获取数据大小
}

void init_UART(void)
{	
	ADI_UART_HANDLE handle_UART0;
	adi_uart_Open(0,ADI_UART_DIR_BIDIRECTION,&UART_MemorySize,ADI_UART_BIDIR_MEMORY_SIZE,&handle_UART0);
	
	uint16_t pBuffer_TX;  //发送
	uint16_t pBuffer_RX;  //接收
	adi_uart_SubmitTxBuffer(handle_UART0,&pBuffer_TX,1,true);  //非阻塞发送
	adi_uart_SubmitRxBuffer(handle_UART0,&pBuffer_RX,1,true);  //非阻塞接收
	
	adi_uart_EnableLoopBack(handle_UART0,true);
	
	uint32_t* pAutobaudErrors_UART0;
	adi_uart_EnableAutobaud(handle_UART0,true,pAutobaudErrors_UART0);
	
	adi_uart_SetRxFifoTriggerLevel(handle_UART0,ADI_UART_RX_FIFO_TRIG_LEVEL_1BYTE);
	adi_uart_EnableFifo(handle_UART0,true);
	
	adi_uart_SetConfiguration(handle_UART0,ADI_UART_NO_PARITY,ADI_UART_ONE_STOPBIT,ADI_UART_WORDLEN_8BITS);  //0校验 1停止 8带宽
	
	adi_uart_FlushTxFifo(handle_UART0);
	adi_uart_FlushRxFifo(handle_UART0);
	
	adi_uart_RegisterCallback(handle_UART0,callback_UART0,NULL);
}

void init_SPI(void)
{
	mux_GPIO(1,2,0x1);
	mux_GPIO(1,3,0x1);
	mux_GPIO(1,4,0x1);
//	mux_GPIO(1,5,0x1);
	mux_GPIO(2,10,0x2);
	adi_spi_Open(2,&SPI_MemorySize,ADI_SPI_MEMORY_SIZE,&handle_SPI2);
//	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
//	uint8_t pTransmitter;
//	uint8_t pReceiver;
//	Xfr_SPI2.pTransmitter=&pTransmitter;
//	Xfr_SPI2.pReceiver=&pReceiver;
//	Xfr_SPI2.TransmitterBytes=1;
//	Xfr_SPI2.ReceiverBytes=1;
//	Xfr_SPI2.nTxIncrement=0;
//	Xfr_SPI2.nRxIncrement=0;
//	Xfr_SPI2.bDMA=true;
//	Xfr_SPI2.bRD_CTL=true;
//	adi_spi_MasterReadWrite(handle_SPI2,&Xfr_SPI2);  //阻塞
	
	adi_spi_SetMasterMode(handle_SPI2,true);
//	adi_spi_SlaveReadWrite(handle_SPI2,&Xfr_SPI2);
//	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);  //非阻塞
//	adi_spi_SlaveSubmitBuffer(handle_SPI2,&Xfr_SPI2);
//	adi_spi_RegisterCallback(handle_SPI2,callback_SPI2,NULL);
	adi_spi_SetClockPhase(handle_SPI2,false);
	adi_spi_SetClockPolarity(handle_SPI2,false);
	bool bComplete;
	adi_spi_isBufferAvailable(handle_SPI2,&bComplete);
	adi_spi_SetContinuousMode(handle_SPI2,true);
//	adi_spi_SetLoopback(handle_SPI2,true);
//	adi_spi_SetIrqmode(handle_SPI2,0);
	adi_spi_SetReceiveOverflow(handle_SPI2,true);
	adi_spi_SetTransmitUnderflow(handle_SPI2,true);
	adi_spi_SetBitrate(handle_SPI2,100000);
	adi_spi_SetChipSelect(handle_SPI2,ADI_SPI_CS2);
}

void play_NOTE(uint32_t freq_t,float play_time)
{
	int i=24.0/25.0*play_time*2*freq_t/100000;	
	int j=1.0/25.0*play_time*1000;
	while(i--)
	{
		adi_gpio_Toggle(Port0,Pin8);
		delay_us(100000000000/freq_t/2);
	}
	delay_ms(j);
}

void GYZ(void)
{
	delay_ms(1000*NOTE_8);play_NOTE(A4,NOTE_16);play_NOTE(B4,NOTE_16);
	
	play_NOTE(C5,NOTE_16);play_NOTE(D5,NOTE_16);play_NOTE(B4,NOTE_16);play_NOTE(C5,NOTE_16);
	play_NOTE(C5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(B4,NOTE_16);
	play_NOTE(C5,NOTE_16);play_NOTE(D5,NOTE_16);play_NOTE(B4,NOTE_16);play_NOTE(C5,NOTE_16);
	play_NOTE(C5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(D5,NOTE_16);
	
	play_NOTE(E5,NOTE_16);play_NOTE(D5,NOTE_16);play_NOTE(E5,NOTE_16);play_NOTE(D5,NOTE_16);
	play_NOTE(E5,NOTE_8);play_NOTE(E5,NOTE_16);play_NOTE(D5,NOTE_16);
	play_NOTE(E5,NOTE_8);play_NOTE(G5,NOTE_8);
	play_NOTE(E5,NOTE_8);play_NOTE(A4,NOTE_16);play_NOTE(B4,NOTE_16);
	
	play_NOTE(C5,NOTE_16);play_NOTE(D5,NOTE_16);play_NOTE(B4,NOTE_16);play_NOTE(C5,NOTE_16);
	play_NOTE(C5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(B4,NOTE_16);
	play_NOTE(C5,NOTE_16);play_NOTE(D5,NOTE_16);play_NOTE(B4,NOTE_16);play_NOTE(C5,NOTE_16);
	play_NOTE(C5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(D5,NOTE_16);

	play_NOTE(E5,NOTE_16);play_NOTE(D5,NOTE_16);play_NOTE(E5,NOTE_16);play_NOTE(D5,NOTE_16);
	play_NOTE(E5,NOTE_8);play_NOTE(E5,NOTE_16);play_NOTE(D5,NOTE_16);
	play_NOTE(E5,NOTE_8);play_NOTE(G5,NOTE_8);
	play_NOTE(E5,NOTE_8);play_NOTE(G5,NOTE_8);
	
	play_NOTE(E5,NOTE_8*1.5);play_NOTE(G5,NOTE_16);
	play_NOTE(E5,NOTE_8*1.5);play_NOTE(G5,NOTE_16);
	play_NOTE(E5,NOTE_16);play_NOTE(G5,NOTE_16);play_NOTE(A5,NOTE_16);play_NOTE(E5,NOTE_16);
	play_NOTE(G5,NOTE_8);play_NOTE(G5,NOTE_8);
	
	play_NOTE(E5,NOTE_8*1.5);play_NOTE(G5,NOTE_16);
	play_NOTE(E5,NOTE_8*1.5);play_NOTE(G5,NOTE_16);
	play_NOTE(E5,NOTE_16);play_NOTE(G5,NOTE_16);play_NOTE(A5,NOTE_16);play_NOTE(E5,NOTE_16);
	play_NOTE(G5,NOTE_8);play_NOTE(G5,NOTE_16);play_NOTE(G5,NOTE_16);
	
	play_NOTE(E5,NOTE_8);play_NOTE(D5,NOTE_8);
	play_NOTE(D5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(E5,NOTE_16+NOTE_8);play_NOTE(D5,NOTE_8);
	play_NOTE(D5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(A4,NOTE_16+NOTE_4);
	
	delay_ms(NOTE_2*1000);
	delay_ms(1000*NOTE_8);play_NOTE(G5,NOTE_16);play_NOTE(G5,NOTE_16);
	
	play_NOTE(E5,NOTE_8);play_NOTE(D5,NOTE_8);
	play_NOTE(D5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(E5,NOTE_16+NOTE_8);play_NOTE(D5,NOTE_8);
	play_NOTE(D5,NOTE_8);play_NOTE(C5,NOTE_16);play_NOTE(A4,NOTE_16+NOTE_4);
	
	delay_ms(1000*NOTE_4*3);
}

void init_PWR(void)
{
	adi_pwr_Init();
	adi_pwr_SetClockDivider(ADI_CLOCK_HCLK,1);
	adi_pwr_SetClockDivider(ADI_CLOCK_PCLK,1);
}

void init_DMA(void)
{
	adi_dma_Init();
	adi_dma_Enable(true);
}

uint8_t I2C0_Send_Byte_API(uint8_t txd)
{
	adi_i2c_SetBusClear(handle_I2C0,false,true);
	
	ADI_I2C_TRANSACTION transaction_I2C0;
	uint8_t Data_I2C0 = txd;
	transaction_I2C0.pPrologue = 0;
	transaction_I2C0.nPrologueSize=0;
	transaction_I2C0.pData=&Data_I2C0;
	transaction_I2C0.nDataSize=1;
	transaction_I2C0.bReadNotWrite=false;
	transaction_I2C0.bRepeatStart=true;
	
	adi_i2c_SubmitBuffer(handle_I2C0,&transaction_I2C0);  //非阻塞传输
	
	bool pbCompletionState = false;
	int i;
	while(pbCompletionState == false)
	{
		adi_i2c_IsBufferAvailable(handle_I2C0,&pbCompletionState); //查询是否完成
		if(pbCompletionState==true){return 1;}
		else{i++;delay_us(20);}
		if(i>5){printf("I2C0 Send Error:%x\n",txd);return 0;}
	}
	return 1;
}

int16_t I2C0_Read_Byte_API(void)
{
	ADI_I2C_TRANSACTION transaction_I2C0;
	uint8_t Data_I2C0 = 0;
	transaction_I2C0.pPrologue = 0;
	transaction_I2C0.nPrologueSize=0;
	transaction_I2C0.pData=&Data_I2C0;
	transaction_I2C0.nDataSize=2;
	transaction_I2C0.bReadNotWrite=true;
	transaction_I2C0.bRepeatStart=true;
	
	adi_i2c_SubmitBuffer(handle_I2C0,&transaction_I2C0);  //非阻塞传输
	
	bool pbCompletionState = false;
	int i;
	while(pbCompletionState == false)
	{
		adi_i2c_IsBufferAvailable(handle_I2C0,&pbCompletionState); //查询是否完成
		if(pbCompletionState==true){return Data_I2C0;}
		else{i++;delay_us(20);}
		if(i>5){printf("I2C0 Read Error:%x\n",Data_I2C0);return -1;}
	}
	return Data_I2C0;
}

uint8_t SPI2_Send_Byte_API(uint8_t byte)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter = byte;
	uint8_t pReceiver;
	Xfr_SPI2.pTransmitter=&pTransmitter;
	Xfr_SPI2.pReceiver=&pReceiver;
	Xfr_SPI2.TransmitterBytes=1;
	Xfr_SPI2.ReceiverBytes=1;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return 1;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x\n",byte);return 0;}
	}
	return 1;
}

uint8_t SPI2_Send_Word_API(uint8_t Word1,uint8_t Word0)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter[2];
	pTransmitter[0] = Word1;
	pTransmitter[1] = Word0;
	
	uint8_t pReceiver;
	Xfr_SPI2.pTransmitter=pTransmitter;
	Xfr_SPI2.pReceiver=&pReceiver;
	Xfr_SPI2.TransmitterBytes=2;
	Xfr_SPI2.ReceiverBytes=2;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return 1;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x,%x\n",Word1,Word0);return 0;}
	}
	return 1;
}

int16_t SPI2_Read_Byte_API(void)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter;
	uint8_t pReceiver;
	Xfr_SPI2.pTransmitter=&pTransmitter;
	Xfr_SPI2.pReceiver=&pReceiver;
	Xfr_SPI2.TransmitterBytes=1;
	Xfr_SPI2.ReceiverBytes=1;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return pReceiver;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x\n",pReceiver);return -1;}
	}	
	return pReceiver;
}

int32_t SPI2_Read_Word_API(void)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint16_t Receiver_Word=0;
	uint8_t pTransmitter;
	uint8_t pReceiver[2];
	Xfr_SPI2.pTransmitter=&pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=2;
	Xfr_SPI2.ReceiverBytes=2;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	Receiver_Word = (pReceiver[0] << 8) + pReceiver[1];
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return Receiver_Word;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x\n",Receiver_Word);return -1;}
	}	
	return Receiver_Word;
}

int32_t SPI2_Send_Byte_Read_Byte_API(uint8_t Word0)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter = Word0;
	
	uint8_t pReceiver;
	Xfr_SPI2.pTransmitter=&pTransmitter;
	Xfr_SPI2.pReceiver=&pReceiver;
	Xfr_SPI2.TransmitterBytes=1;
	Xfr_SPI2.ReceiverBytes=1;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return pReceiver;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x\n",Word0);return -1;}
	}
	return pReceiver;
}

int32_t SPI2_Send_Word_Read_Byte_API(uint8_t Word1,uint8_t Word0)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter[2];
	pTransmitter[0] = Word1;
	pTransmitter[1] = Word0;
	
	uint8_t pReceiver[3];
	Xfr_SPI2.pTransmitter=pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=3;
	Xfr_SPI2.ReceiverBytes=3;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return pReceiver[2];}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x,%x\n",Word1,Word0);return -1;}
	}
	return pReceiver[2];
}

int32_t SPI2_Send_Word_Read_Word_API(uint8_t Word1,uint8_t Word0)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter[2];
	pTransmitter[0] = Word1;
	pTransmitter[1] = Word0;
	
	uint16_t Receiver_Word=0;
	uint8_t pReceiver[2];
	Xfr_SPI2.pTransmitter=pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=4;
	Xfr_SPI2.ReceiverBytes=4;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	Receiver_Word = (pReceiver[0] << 8) + pReceiver[1];
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return Receiver_Word;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x\n",Receiver_Word);return -1;}
	}	
	return Receiver_Word;
}

int32_t SPI2_Send_Byte_Read_Word_API(uint8_t Word0)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	
	uint8_t pTransmitter = Word0;
	
	uint16_t Receiver_Word=0;
	uint8_t pReceiver[2];
	Xfr_SPI2.pTransmitter=&pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=3;
	Xfr_SPI2.ReceiverBytes=3;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	Receiver_Word = (pReceiver[0] << 8) + pReceiver[1];
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int i;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return Receiver_Word;}
		else{i++;delay_us(20);}
		if(i>5){printf("SPI2 Send Error:%x\n",Receiver_Word);return -1;}
	}	
	return Receiver_Word;
}

uint8_t SPI2_Send_x(uint8_t x,uint32_t word)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	uint8_t i;
	uint8_t pTransmitter[4];
	uint8_t pReceiver[4];	
	
	for(i=0;i<x;i++)
	{
		pTransmitter[i]=0xFF&(word>>((x-i-1)*8));
	}
	
	Xfr_SPI2.pTransmitter=pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=x;
	Xfr_SPI2.ReceiverBytes=x;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int j;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return 1;}
		else{j++;delay_us(20);}
		if(j>5){printf("SPI2 Error:%x\n",word);return 0;}
	}
	return 1;
}

int16_t SPI2_Send_x_Read_1(uint8_t x,uint32_t word)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	uint8_t i;
	uint8_t pTransmitter[4];
	uint8_t pReceiver[4];	
	
	for(i=0;i<x;i++)
	{
		pTransmitter[i]=0xFF&(word>>((x-i-1)*8));
	}
	
	Xfr_SPI2.pTransmitter=pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=x+1;
	Xfr_SPI2.ReceiverBytes=x+1;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);
	
	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	int j;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return pReceiver[x];}
		else{j++;delay_us(20);}
		if(j>5){printf("SPI2 Error:%x\n",pReceiver[x]);return -1;}
	}
	return pReceiver[x];
}

int32_t SPI2_Send_x_Read_2(uint8_t x,uint32_t word)
{
	ADI_SPI_TRANSCEIVER Xfr_SPI2;
	uint16_t Receiver_Word = 0;
	uint8_t i;
	uint8_t pTransmitter[4];
	uint8_t pReceiver[4];	
	
	for(i=0;i<x;i++)
	{
		pTransmitter[i]=0xFF&(word>>((x-i-1)*8));
	}
	
	Xfr_SPI2.pTransmitter=pTransmitter;
	Xfr_SPI2.pReceiver=pReceiver;
	Xfr_SPI2.TransmitterBytes=x+2;
	Xfr_SPI2.ReceiverBytes=x+2;
	Xfr_SPI2.nTxIncrement=1;
	Xfr_SPI2.nRxIncrement=1;
	Xfr_SPI2.bDMA=true;
	Xfr_SPI2.bRD_CTL=false;
	adi_spi_MasterSubmitBuffer(handle_SPI2,&Xfr_SPI2);

	uint32_t pHWErrors_SPI2;
	adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2);
	
	Receiver_Word = (0xFFFF&(pReceiver[x] << 8)) + pReceiver[x+1];
	int j;
	while(pHWErrors_SPI2 != ADI_SPI_SUCCESS)
	{
		adi_spi_GetBuffer(handle_SPI2,&pHWErrors_SPI2); //查询是否完成
		if(pHWErrors_SPI2 == ADI_SPI_SUCCESS){return Receiver_Word;}
		else{j++;delay_us(20);}
		if(j>5){printf("SPI2 Error:%x\n",Receiver_Word);return -1;}
	}
	return Receiver_Word;
}

uint16_t read_TMP75(void)
{	
	uint16_t tmp=0;	
	
//	adi_i2c_Reset(handle_I2C0);
//	adi_i2c_SetSlaveAddress(handle_I2C0,0x91);	
//	uint16_t tempH=0;
//	uint16_t tempL=0;
//	I2C0_Send_Byte_API(0x91);   
//	I2C0_Send_Byte_API(0x00); 
//	I2C0_Send_Byte_API(0x91|0x00);
//	tempH=I2C0_Read_Byte_API();
// 
//	tempL=I2C0_Read_Byte_API();
//	tmp = (tempH << 8) | tempL ;
//	tmp = (tmp >> 4); 
	
	tmp = TMP75_ReadOneWord(0x91,0x00);
	return tmp;
}

float count_TMP75(void)
{
	float real_tmp =0;
	uint16_t tmp = read_TMP75();	
	if (tmp<0x800)
	{
		real_tmp = tmp*0.0625;
	}
	else if (tmp>=0x800 && tmp <0x1000)
	{
		tmp = 0x1000 - tmp;
		real_tmp = -(tmp*0.0625);
	}
	else
	{
		real_tmp = -273.15;
	}
	return real_tmp;
}

void init_ADF7023(void)
{
	int dat;
	SPI2_Send_Byte_API(SPI_MEMR_WR+(BBRAM_REG_INTERRUPT_MASK_0>>8));
	SPI2_Send_Byte_API(0xFF&(0x0FF&BBRAM_REG_INTERRUPT_MASK_0));
	SPI2_Send_Byte_API(0xAA);
	SPI2_Send_Byte_API(SPI_MEMR_RD+(BBRAM_REG_INTERRUPT_MASK_0>>8));
	SPI2_Send_Byte_API(0xFF&(0x0FF&BBRAM_REG_INTERRUPT_MASK_0));
	SPI2_Send_Word_API(0xFF,0xFF);
	SPI2_Send_Byte_API(0xFF);
	dat = SPI2_Read_Word_API();
	printf("dat:%x\n",dat);
	dat = SPI2_Read_Byte_API();
	printf("dat:%x\n",dat);
}

void init_ADXL363(void)
{
//	uint16_t data_FIFO;
	SPI2_Send_x(3,(((WRITE_REGISTER<<8)+FIFO_CONTROL)<<8)+0x0E);
	SPI2_Send_x(3,(((WRITE_REGISTER<<8)+POWER_CTL)<<8)+0x02);
	SPI2_Send_x(3,(((WRITE_REGISTER<<8)+FIFO_CONTROL)<<8)+0x0E);
	SPI2_Send_x(3,(((WRITE_REGISTER<<8)+POWER_CTL)<<8)+0x02);
	
//	while(1){
//	data_FIFO=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+TEMP_L);
//	printf("FIFO:%x\n",data_FIFO);delay_ms(500);
	data_FIFO=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+ZDATA_H);
	printf("FIFO:%x\n",data_FIFO);delay_ms(500);
//	}
//	data_FIFO=SPI2_Send_x_Read_2(1,READ_FIFO);
//	printf("FIFO:%x\n",data_FIFO);delay_ms(500);
}

void count_ADXL363(void)
{
	uint8_t data_H = 0;
	uint8_t data_L = 0;
	uint16_t data_x = 0;
	uint16_t data_y = 0;
	uint16_t data_z = 0;
	uint16_t data_t = 0;

	float real_x = 0.0;
	float real_y = 0.0;
	float real_z = 0.0;
	float real_t = 0.0;
	
	data_H=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+XDATA_H);
	data_L=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+XDATA_L);
	
	data_H = data_H & 0x0F;
	data_L = data_L & 0xFF;
	
	data_x = ((data_H<<8)+data_L)&0xFFF;
	
	if(((data_H>>3)&0xFF)>0)
	{
		data_x = 0x1000 - data_x;
		real_x = -(data_x/1000.0);
	}
	else
	{
		real_x = data_x/1000.0;
	}
	data_H = 0;
	data_L = 0;
	
	
	data_H=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+YDATA_H);
	data_L=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+YDATA_L);
	
	data_H = data_H & 0x0F;
	data_L = data_L & 0xFF;
	
	data_y = ((data_H<<8)+data_L)&0xFFF;
	
	if(((data_H>>3)&0xFF)>0)
	{
		data_y = 0x1000 - data_y;
		real_y = -(data_y/1000.0);
	}
	else
	{
		real_y = data_y/1000.0;
	}
	data_H = 0;
	data_L = 0;
	
	
	data_H=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+ZDATA_H);
	data_L=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+ZDATA_L);
	
	data_H = data_H & 0x0F;
	data_L = data_L & 0xFF;
	
	data_z = ((data_H<<8)+data_L)&0xFFF;
	
	if(((data_H>>3)&0xFF)>0)
	{
		real_z = -(data_z/1000.0);
	}
	else
	{
		real_z = data_z/1000.0;
	}
	data_H = 0;
	data_L = 0;
	
	
	data_H=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+TEMP_H);
	data_L=SPI2_Send_x_Read_1(2,0xFFFF&(READ_REGISTER<<8)+TEMP_L);
	
	data_H = data_H & 0x0F;
	data_L = data_L & 0xFF;
	
	data_t = ((data_H<<8)+data_L)&0xFFF;
	
	if(((data_H>>3)&0xFF)>0)
	{
		data_t = 0x1000 - data_t;
		real_t = -(data_t*0.25);
	}
	else
	{
		data_t = data_t;
		real_t = data_t*0.25;
	}
	data_H = 0;
	data_L = 0;
	
	printf("X:%0.4f,Y:%0.4f,Z:%0.4f,T:%0.2f\n",real_x,real_y,real_z,real_t);
}

int main(void)
{
	MUSIC_BPM=60;
	init_PWR();	
	init_DMA();
	delay_ms(10);
	delay_us(10);	
	printf("启动ing！Hello, world!\n");
	init_GPIO();
	P0_BUS_O(0xffff);	
	init_TIM();
	init_XINT();
//	init_UART();
//	init_I2C();  
	init_SPI();
//  init_ADF7023();
	init_ADXL363();
	P0_BUS_O(0xffff);	
	int i=0;
	while(1)
	{
		delay_ms(1000);
		count_ADXL363();
		if (P2_I(9)==0){adi_gpio_Toggle(Port0,Pin8);adi_gpio_Toggle(Port0,Pin13);}
		i++;
		printf("%d\n",i);
		global_tmp = count_TMP75();
		printf("Temp:%0.4f\n",global_tmp);	
	}			
}

//外部中断回调函数
void callback_XINT0(void	*pCBParam,uint32_t	Event,void	*pArg)
{
	adi_gpio_Toggle(Port0,Pin0);  //切换电平状态
}

//定时中断回调函数
void callback_TIM0(void	*pCBParam,uint32_t	Event,void	*pArg)
{
//	adi_gpio_Toggle(Port0,Pin8);  //切换电平状态
}

void callback_UART0(void	*pCBParam,uint32_t	Event,void	*pArg)
{
//	adi_gpio_Toggle(Port0,Pin0);  //切换电平状态
}

void callback_SPI2(void	*pCBParam,uint32_t	Event,void	*pArg)
{
//	adi_gpio_Toggle(Port0,Pin0);  //切换电平状态
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883

GPIO.c

#include "ADuCM4050.h"
#include "drivers/gpio/adi_gpio.h"
#include "GPIO.h"

void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag)
{
	switch(port)
	{
		case 0:{
			switch(pin)
			{
				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));};break;
				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));};break;
				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));};break;
				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));};break;
				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));};break;
				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));};break;
				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));};break;
				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));};break;
				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));};break;
				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));};break;
				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));};break;
				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));};break;
				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));};break;
				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));};break;
				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));};break;
				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));};break;
				default:pin=0;break;
			}
		}break;
		
		case 1:{
			switch(pin)
			{
				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));};break;
				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));};break;
				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));};break;
				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));};break;
				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));};break;
				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));};break;
				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));};break;
				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));};break;
				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));};break;
				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));};break;
				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));};break;
				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));};break;
				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));};break;
				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));};break;
				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));};break;
				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));};break;
				default:pin=0;break;
			}
		}break;
		
		case 2:{
			switch(pin)
			{
				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));};break;
				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));};break;
				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));};break;
				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));};break;
				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));};break;
				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));};break;
				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));};break;
				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));};break;
				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));};break;
				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));};break;
				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));};break;
				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));};break;
				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));};break;
				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));};break;
				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));};break;
				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));};break;
				default:pin=0;break;
			}
		}break;
		
		case 3:{
			switch(pin)
			{
				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));};break;
				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));};break;
				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));};break;
				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));};break;
				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));};break;
				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));};break;
				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));};break;
				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));};break;
				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));};break;
				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));};break;
				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));};break;
				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));};break;
				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));};break;
				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));};break;
				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));};break;
				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));};break;
				default:pin=0;break;
			}
		}break;
		
		default:port=0;break;
	}	
}

void GPIO_BUS_OUT(unsigned int port,unsigned int num)  //num最大为0xffff
{
	int i;
	for(i=0;i<16;i++)
	{
		GPIO_OUT(port,i,(num>>i)&0x0001);
	}
}


void P0_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
{
	int i;
	for(i=0;i<16;i++)
	{
		P0_O(i)=(num>>i)&0x0001;
	}
}
unsigned int P0_BUS_I(void)  //输出值num最大为0xFFFF
{
	unsigned int num;
	int i;
	for(i=0;i<16;i++)
	{
		num=num+(P0_I(i)<<i)&0xFFFF;
	}
	return num;
}

void P1_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
{
	int i;
	for(i=0;i<16;i++)
	{
		P1_O(i)=(num>>i)&0x0001;
	}
}
unsigned int P1_BUS_I(void)  //输出值num最大为0xFFFF
{
	unsigned int num;
	int i;
	for(i=0;i<16;i++)
	{
		num=num+(P1_I(i)<<i)&0xFFFF;
	}
	return num;
}

void P2_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
{
	int i;
	for(i=0;i<16;i++)
	{
		P2_O(i)=(num>>i)&0x0001;
	}
}
unsigned int P2_BUS_I(void)  //输出值num最大为0xFFFF
{
	unsigned int num;
	int i;
	for(i=0;i<16;i++)
	{
		num=num+(P2_I(i)<<i)&0xFFFF;
	}
	return num;
}

void P3_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
{
	int i;
	for(i=0;i<16;i++)
	{
		P3_O(i)=(num>>i)&0x0001;
	}
}
unsigned int P3_BUS_I(void)  //输出值num最大为0xFFFF
{
	unsigned int num;
	int i;
	for(i=0;i<16;i++)
	{
		num=num+(P3_I(i)<<i)&0xFFFF;
	}
	return num;
}

void mux_GPIO(uint8_t ports,uint8_t pins,uint8_t mux)
{
	uint8_t a,b;
	a = pins*2+1;
	b = pins*2;
	uint8_t c,d;
	c=mux>>1;
	c=0x01 & c;
	d=0x01 & mux;
	if(ports == 0)
	{
		P0_M(a) = c;
		P0_M(b) = d;
	}
	else if(ports == 1)
	{
		P1_M(a) = c;
		P1_M(b) = d;
	}
	else if(ports == 2)
	{
		P2_M(a) = c;
		P2_M(b) = d;
	}
	else if(ports == 3)
	{
		P3_M(a) = c;
		P3_M(b) = d;
	}
	else{}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

GPIO.h

#ifndef __GPIO_H__
#define __GPIO_H__
#include "ADuCM4050.h"
#include "drivers/gpio/adi_gpio.h"

#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum))

#define GPIO0_MUL_Addr    (ADI_GPIO0_BASE+0) //0x40020000
#define P0_M(n)						BIT_ADDR(GPIO0_MUL_Addr,n)   

#define GPIO1_MUL_Addr    (ADI_GPIO1_BASE+0) //0x40020000
#define P1_M(n)						BIT_ADDR(GPIO1_MUL_Addr,n) 

#define GPIO2_MUL_Addr    (ADI_GPIO2_BASE+0) //0x40020000
#define P2_M(n)						BIT_ADDR(GPIO2_MUL_Addr,n) 

#define GPIO3_MUL_Addr    (ADI_GPIO3_BASE+0) //0x40020000
#define P3_M(n)						BIT_ADDR(GPIO3_MUL_Addr,n) 

#define GPIO0_ODR_Addr    (ADI_GPIO0_BASE+20) //0x40020014
#define GPIO0_IDR_Addr    (ADI_GPIO0_BASE+16) //0x40020010

#define GPIO1_ODR_Addr    (ADI_GPIO1_BASE+20) //0x40020054
#define GPIO1_IDR_Addr    (ADI_GPIO1_BASE+16) //0x40020050

#define GPIO2_ODR_Addr    (ADI_GPIO2_BASE+20) //0x40020094
#define GPIO2_IDR_Addr    (ADI_GPIO2_BASE+16) //0x40020090

#define GPIO3_ODR_Addr    (ADI_GPIO3_BASE+20) //0x400200D4
#define GPIO3_IDR_Addr    (ADI_GPIO3_BASE+16) //0x400200D0

#define P0_O(n)   	BIT_ADDR(GPIO0_ODR_Addr,n)  //输出 
#define P0_I(n)    	BIT_ADDR(GPIO0_IDR_Addr,n)  //输入 

#define P1_O(n)   	BIT_ADDR(GPIO1_ODR_Addr,n)  //输出 
#define P1_I(n)    	BIT_ADDR(GPIO1_IDR_Addr,n)  //输入 

#define P2_O(n)   	BIT_ADDR(GPIO2_ODR_Addr,n)  //输出 
#define P2_I(n)    	BIT_ADDR(GPIO2_IDR_Addr,n)  //输入 

#define P3_O(n)   	BIT_ADDR(GPIO3_ODR_Addr,n)  //输出 
#define P3_I(n)    	BIT_ADDR(GPIO3_IDR_Addr,n)  //输入 

#define Port0			(ADI_GPIO_PORT0)
#define Port1			(ADI_GPIO_PORT1)
#define Port2			(ADI_GPIO_PORT2)
#define Port3			(ADI_GPIO_PORT3)

#define Pin0			(ADI_GPIO_PIN_0)
#define Pin1			(ADI_GPIO_PIN_1)
#define Pin2			(ADI_GPIO_PIN_2)
#define Pin3			(ADI_GPIO_PIN_3)
#define Pin4			(ADI_GPIO_PIN_4)
#define Pin5			(ADI_GPIO_PIN_5)
#define Pin6			(ADI_GPIO_PIN_6)
#define Pin7			(ADI_GPIO_PIN_7)
#define Pin8			(ADI_GPIO_PIN_8)
#define Pin9			(ADI_GPIO_PIN_9)
#define Pin10			(ADI_GPIO_PIN_10)
#define Pin11			(ADI_GPIO_PIN_11)
#define Pin12			(ADI_GPIO_PIN_12)
#define Pin13			(ADI_GPIO_PIN_13)
#define Pin14			(ADI_GPIO_PIN_14)
#define Pin15			(ADI_GPIO_PIN_15)

void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag);
void GPIO_BUS_OUT(unsigned int port,unsigned int num);

void P0_BUS_O(unsigned int num);
unsigned int P0_BUS_I(void);

void P1_BUS_O(unsigned int num);
unsigned int P1_BUS_I(void);

void P2_BUS_O(unsigned int num);
unsigned int P2_BUS_I(void);

void P3_BUS_O(unsigned int num);
unsigned int P3_BUS_I(void);
 
void mux_GPIO(uint8_t ports,uint8_t pins,uint8_t mux);

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

DELAY.c

#include "ADuCM4050.h"

void delay_ms(unsigned int ms)
{
	SysTick->LOAD = 26000000/1000-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
	while(ms--)
	{
		while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
	}
	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
}
void delay_us(unsigned int us)
{
	SysTick->LOAD = 26000000/1000/1000-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
	while(us--)
	{
		while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
	}
	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

DELAY.h

#ifndef __DELAY_H__
#define __DELAY_H__

void delay_ms(unsigned int ms);
void delay_us(unsigned int us);

#endif

1
2
3
4
5
6
7
8

I2C0.c

#include "ADuCM4050.h"
#include "GPIO.h"
#include "DELAY.h"
#include "I2C0.h"

void SDA_OUT(void)
{
	adi_gpio_InputEnable(Port0,Pin5,false);
	adi_gpio_OutputEnable(Port0,Pin5,true);
	adi_gpio_PullUpEnable(Port0,Pin5,true);
	adi_gpio_DriveStrengthEnable(Port0,Pin5,true);
}

void SDA_IN(void)
{
	adi_gpio_OutputEnable(Port0,Pin5,false);
	adi_gpio_InputEnable(Port0,Pin5,true);
}

void I2C_Start(void)
{
	SDA_OUT();
	I2C_SDA=1;	  	  
	I2C_SCL=1;
	delay_us(4);
 	I2C_SDA=0;
	delay_us(4);
	I2C_SCL=0;
}

void I2C_Stop(void)
{
	SDA_OUT();
	I2C_SCL=0;
	I2C_SDA=0;
 	delay_us(4);
	I2C_SCL=1; 
	I2C_SDA=1;
	delay_us(4);							   	
}

uint8_t I2C_Wait_Ack(void)
{
	uint8_t ucErrTime=0;
	SDA_IN();       
	I2C_SDA=1;delay_us(1);	   
	I2C_SCL=1;delay_us(1);	 
	while(READ_SDA)
	{
		ucErrTime++;
		delay_us(1);
		if(ucErrTime>250)
		{
			I2C_Stop();
			return 1;
		}
	}
		I2C_SCL=0;	   
	return 0;  
} 

void I2C_Ack(void)
{
	I2C_SCL=0;
	SDA_OUT();
	I2C_SDA=0;
	delay_us(2);
	I2C_SCL=1;
	delay_us(2);
	I2C_SCL=0;
}

void I2C_No_Ack(void)
{
	I2C_SCL=0;
	SDA_OUT();
	I2C_SDA=1;
	delay_us(2);
	I2C_SCL=1;
	delay_us(2);
	I2C_SCL=0;
}

void I2C_Send_Byte(uint8_t txd)
{                        
  uint8_t t;   
  SDA_OUT(); 	    
  I2C_SCL=0;//数据开始传输的时候需要拉低时钟线
  for(t=0;t<8;t++)
  {              
    I2C_SDA=(txd&0x80)>>7;
    txd<<=1; 
		delay_us(2);   // 不同的器件有不同的要求，根据要求进行配置
		I2C_SCL=1;
		delay_us(2); 
		I2C_SCL=0;	
		delay_us(2);
  }	 
} 

uint8_t I2C_Read_Byte(void)
{
	unsigned char i,receive=0;
	SDA_IN();
  for(i=0;i<8;i++ )
	{
    I2C_SCL=0; 
    delay_us(2);
		I2C_SCL=1;
    receive<<=1;
    if(READ_SDA) receive|=0x01;   
		delay_us(1); 
  }					 
  return receive;
}

void 	TMP75_WriteOneByte(uint8_t DeviceAdd,uint8_t PointAddr,uint8_t DataToWrite)
{				
	I2C_Start();  
	I2C_Send_Byte(DeviceAdd);   	 
	I2C_Wait_Ack();	   
	I2C_Send_Byte(PointAddr);   
	I2C_Wait_Ack();
	I2C_SDA=1;
	I2C_Send_Byte(DataToWrite);
	I2C_Wait_Ack();
	I2C_Stop(); 
	delay_ms(30);	 
}

void 	TMP75_WriteOneWord(uint8_t DeviceAdd,uint8_t PointAddr,uint16_t DataToWrite)
{					
	I2C_Start();  
	I2C_Send_Byte(DeviceAdd);    
	I2C_Wait_Ack();	   
	I2C_Send_Byte(PointAddr);   
	I2C_Wait_Ack();
	I2C_SDA=1;
	I2C_Send_Byte((DataToWrite>>8)&0xff);
	I2C_Wait_Ack();
	I2C_Send_Byte(DataToWrite&0xff);
	I2C_Wait_Ack(); 
	I2C_Stop();
	delay_ms(30);	 
} 

uint8_t TMP75_ReadOneByte(uint8_t DeviceAdd, uint8_t PointAddr)
{
	uint8_t temp=0;
	I2C_Start();  
	I2C_Send_Byte(DeviceAdd);   
	I2C_Wait_Ack();
	I2C_Send_Byte(PointAddr);
	I2C_Wait_Ack();
	I2C_Start();
	I2C_Send_Byte(DeviceAdd|0x00);
	I2C_Wait_Ack();    
	temp=I2C_Read_Byte();
	I2C_Stop();
	return temp;
}

uint16_t TMP75_ReadOneWord(uint8_t DeviceAdd, uint8_t PointAddr)
{				  
	uint16_t tempH=0;
	uint16_t tempL=0;
	uint16_t temp=0;
	I2C_Start();  
	I2C_Send_Byte(DeviceAdd);   
	I2C_Wait_Ack();
	I2C_Send_Byte(PointAddr); 
	I2C_Wait_Ack();
 
	I2C_Start();
	I2C_Send_Byte(DeviceAdd|0x00);  
	I2C_Wait_Ack();    
	tempH=I2C_Read_Byte();
	I2C_Ack();
	I2C_SDA=1;    
	tempL=I2C_Read_Byte();
	I2C_No_Ack();
	I2C_Stop();
	temp = (tempH << 8) | tempL ;
	temp = (temp >> 4); 
	return temp;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

I2C0.h

#ifndef __I2C0_H__
#define __I2C0_H__

#include "ADuCM4050.h"
#include "GPIO.h"
#include "DELAY.h"

#define I2C_SDA P0_O(5)
#define I2C_SCL P0_O(4)
#define READ_SDA P0_I(5)

void SDA_OUT(void);
void SDA_IN(void);
void I2C_Start(void);
void I2C_Stop(void);
uint8_t I2C_Wait_Ack(void);
void I2C_Ack(void);
void I2C_No_Ack(void);
void I2C_Send_Byte(uint8_t txd);
uint8_t I2C_Read_Byte(void);

void TMP75_WriteOneByte(uint8_t DeviceAdd,uint8_t PointAddr,uint8_t DataToWrite);
void TMP75_WriteOneWord(uint8_t DeviceAdd,uint8_t PointAddr,uint16_t DataToWrit);
uint8_t TMP75_ReadOneByte(uint8_t DeviceAdd, uint8_t PointAddr);
uint16_t TMP75_ReadOneWord(uint8_t DeviceAdd, uint8_t PointAddr);

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

MUSIC_NOTE.h

#ifndef __MUSIC_NOTE_H__
#define __MUSIC_NOTE_H__

unsigned int MUSIC_BPM=120;
#define	NOTE_4	(60.0/MUSIC_BPM)
#define	NOTE_8	(30.0/MUSIC_BPM)
#define	NOTE_16	(15.0/MUSIC_BPM)
#define	NOTE_32	(7.5/MUSIC_BPM)
#define	NOTE_64	(3.75/MUSIC_BPM)
#define	NOTE_2	(120.0/MUSIC_BPM)
#define	NOTE_1	(240.0/MUSIC_BPM)

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14

PITCH.h

#ifndef __PITCH_H__
#define __PITCH_H__

#define    C0    (1635159)
#define    Db0    (1732391)
#define    D0    (1835404)
#define    Eb0    (1944543)
#define    E0    (2060172)
#define    F0    (2182676)
#define    Gb0    (2312465)
#define    G0    (2449971)
#define    Ab0    (2595654)
#define    A0    (2750000)
#define    Bb0    (2913523)
#define    B0    (3086770)

#define    C1    (3270319)
#define    Db1    (3464782)
#define    D1    (3670809)
#define    Eb1    (3889087)
#define    E1    (4120344)
#define    F1    (4365352)
#define    Gb1    (4624930)
#define    G1    (4899942)
#define    Ab1    (5191308)
#define    A1    (5500000)
#define    Bb1    (5827047)
#define    B1    (6173541)

#define    C2    (6540639)
#define    Db2    (6929565)
#define    D2    (7341619)
#define    Eb2    (7778174)
#define    E2    (8240688)
#define    F2    (8730705)
#define    Gb2    (9249860)
#define    G2    (9799885)
#define    Ab2    (10382617)
#define    A2    (11000000)
#define    Bb2    (11654094)
#define    B2    (12347082)

#define    C3    (13081278)
#define    Db3    (13859131)
#define    D3    (14683238)
#define    Eb3    (15556349)
#define    E3    (16481377)
#define    F3    (17461411)
#define    Gb3    (18499721)
#define    G3    (19599771)
#define    Ab3    (20765234)
#define    A3    (22000000)
#define    Bb3    (23308188)
#define    B3    (24694165)

#define    C4    (26162556)
#define    Db4    (27718263)
#define    D4    (29366476)
#define    Eb4    (31112698)
#define    E4    (32962755)
#define    F4    (34922823)
#define    Gb4    (36999442)
#define    G4    (39199543)
#define    Ab4    (41530469)
#define    A4    (44000000)
#define    Bb4    (46616376)
#define    B4    (49388330)

#define    C5    (52325113)
#define    Db5    (55436526)
#define    D5    (58732953)
#define    Eb5    (62225396)
#define    E5    (65925511)
#define    F5    (69845646)
#define    Gb5    (73998884)
#define    G5    (78399087)
#define    Ab5    (83060939)
#define    A5    (88000000)
#define    Bb5    (93232752)
#define    B5    (98776660)

#define    C6    (104650226)
#define    Db6    (110873052)
#define    D6    (117465907)
#define    Eb6    (124450793)
#define    E6    (131851022)
#define    F6    (139691292)
#define    Gb6    (147997769)
#define    G6    (156798174)
#define    Ab6    (166121879)
#define    A6    (176000000)
#define    Bb6    (186465504)
#define    B6    (197553320)

#define    C7    (209300452)
#define    Db7    (221746104)
#define    D7    (234931814)
#define    Eb7    (248901586)
#define    E7    (263702045)
#define    F7    (279382585)
#define    Gb7    (295995538)
#define    G7    (313596348)
#define    Ab7    (332243758)
#define    A7    (352000000)
#define    Bb7    (372931009)
#define    B7    (395106641)

#define    C8    (418600904)
#define    Db8    (443492209)
#define    D8    (469863628)
#define    Eb8    (497803173)
#define    E8    (527404091)
#define    F8    (558765170)
#define    Gb8    (591991076)
#define    G8    (627192697)
#define    Ab8    (664487516)
#define    A8    (704000000)
#define    Bb8    (745862018)
#define    B8    (790213282)

#define    C9    (837201808)
#define    Db9    (886984419)
#define    D9    (939727257)
#define    Eb9    (995606347)
#define    E9    (1054808182)
#define    F9    (1117530340)
#define    Gb9    (1183982152)
#define    G9    (1254385395)
#define    Ab9    (1328975032)
#define    A9    (1408000000)
#define    Bb9    (1491724036)
#define    B9    (1580426564)

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

ADXL36_CMD.h

#ifndef __ADXL363_CMD_H__
#define __ADXL363_CMD_H__

#include "ADuCM4050.h"

#define WRITE_REGISTER  	0x0A
#define READ_REGISTER 	 	0x0B
#define READ_FIFO			  	0x0D

#define ADXL_363_DEVID_AD						0x00
#define ADXL_363_DEVID_MST					0x01
#define ADXL_363_DEVID							0x02
#define ADXL_363_REVID							0x03

#define XDATA        			0x08
#define YDATA        	 		0x09
#define ZDATA           	0x0A

#define STATUS 						0x0B

#define FIFO_ENTRIES_L    0x0C
#define FIFO_ENTRIES_H    0x0D

#define XDATA_L	      		0x0E
#define XDATA_H	      		0x0F
#define YDATA_L	      		0x10
#define YDATA_H	      		0x11
#define ZDATA_L	      		0x12
#define ZDATA_H	      		0x13
#define TEMP_L	      		0x14
#define TEMP_H	      		0x15
#define ADC_DATA_L	      0x16
#define ADC_DATA_H	      0x17

#define SOFT_RESET     		0x1F
#define THRESH_ACT_L	    0x20
#define THRESH_ACT_H	    0x21
#define TIME_ACT	       	0x22
#define THRESH_INACT_L	  0x23
#define THRESH_INACT_H	  0x24
#define TIME_INACT_L	    0x25
#define TIME_INACT_H	    0x26

#define ACT_INACT_CTL	    0x27
#define FIFO_CONTROL	    0x28
#define FIFO_SAMPLES	    0x29
#define INTMAP1				    0x2A
#define INTMAP2				    0x2B
#define FILTER_CTL				0x2C

#define POWER_CTL         0x2D
#define SELF_TEST         0x2E

#endif // _ADXL363_CMD_H_

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

ADF7023_CMD.h

#ifndef __ADF7023_CMD_H__
#define __ADF7023_CMD_H__

#include "ADuCM4050.h"

/* Status Word */
#define STATUS_SPI_READY  (0x1 << 7)
#define STATUS_IRQ_STATUS (0x1 << 6)
#define STATUS_CMD_READY  (0x1 << 5)
#define STATUS_FW_STATE   (0x1F << 0)

/* FW_STATE Description */
#define FW_STATE_INIT             0x0F
#define FW_STATE_BUSY             0x00
#define FW_STATE_PHY_OFF          0x11
#define FW_STATE_PHY_ON           0x12
#define FW_STATE_PHY_RX           0x13
#define FW_STATE_PHY_TX           0x14
#define FW_STATE_PHY_SLEEP        0x06
#define FW_STATE_GET_RSSI         0x05
#define FW_STATE_IR_CAL           0x07
#define FW_STATE_AES_DECRYPT_INIT 0x08
#define FW_STATE_AES_DECRYPT      0x09
#define FW_STATE_AES_ENCRYPT      0x0A
#define FW_STATE_HW_RESET	      	0x0B

/* SPI Memory Access Commands SPI命令*/
#define SPI_MEM_WR  0x18 // Write data to packet RAM sequentially.  
/*
00011xxxb =
0x18 (包 RAM) 
0x19 (BBRAM) 
0x1B (MCR) 
0x1E (程序 RAM)
按顺序将数据写入BBRAM、MCR或包RAM存储器。
使用11位地址来识别存储器位置。地址的3个MSB纳入命令中(xxxb)。
地址的其余8位跟在命令之后，再后面是要写入的数据字节。
*/
#define SPI_MEM_RD  0x38 // Read data from packet RAM sequentially.
/*
00111xxxb = 
0x38 (包 RAM) 
0x39 (BBRAM) 
0x3B (MCR) 
按顺序从BBRAM、MCR或包RAM存储器读取数据。
使用11位地址来识别存储器位置。地址的3个MSB纳入命令中(xxxb)。
地址的其余8位跟在命令之后，再后面是适当数量的SPI_NOP命令。
*/
#define SPI_MEMR_WR 0x08 // Write data to packet RAM nonsequentially. 
/*
00001xxxb = 
0x08 (包 RAM) 
0x09 (BBRAM) 
0x0B (MCR) 
将数据以非顺序方式写入BBRAM、MCR或包RAM存储器
*/
#define SPI_MEMR_RD 0x28 // Read data from packet RAM nonsequentially.
/*
00101xxxb = 
0x28 (包 RAM) 
0x29 (BBRAM) 
0x2B (MCR)
以非顺序方式从BBRAM、MCR或包RAM存储器读取数据。
*/
#define SPI_NOP     0xFF // No operation. 无操作。轮询状态字时，用于伪写操作；读取存储器时，也用作伪数据。

/* Radio Controller Commands  无线电控制器命令*/
#define CMD_SYNC             0xA2 // This is an optional command. It is not necessary to use it during device initialization 这是一个可选命令，器件初始化期间无需使用。
#define CMD_PHY_OFF          0xB0 // Performs a transition of the device into the PHY_OFF state. 使器件跃迁到PHY_OFF状态。
#define CMD_PHY_ON           0xB1 // Performs a transition of the device into the PHY_ON state. 使器件跃迁到PHY_ON状态。
#define CMD_PHY_RX           0xB2 // Performs a transition of the device into the PHY_RX state. 使器件跃迁到PHY_RX状态。
#define CMD_PHY_TX           0xB5 // Performs a transition of the device into the PHY_TX state. 使器件跃迁到PHY_TX状态。
#define CMD_PHY_SLEEP        0xBA // Performs a transition of the device into the PHY_SLEEP state. 使器件跃迁到PHY_SLEEP状态。
#define CMD_CONFIG_DEV       0xBB // Configures the radio parameters based on the BBRAM values. 根据BBRAM值配置无线电参数。
#define CMD_GET_RSSI         0xBC // Performs an RSSI measurement. 执行RSSI测量。
#define CMD_BB_CAL           0xBE // Performs a calibration of the IF filter. 执行IF滤波器校准。 
#define CMD_HW_RESET         0xC8 // Performs a full hardware reset. The device enters the PHY_SLEEP state.  执行全硬件复位。器件进入PHY_SLEEP状态。
#define CMD_RAM_LOAD_INIT    0xBF // Prepares the program RAM for a firmware module download.  使程序RAM准备好进行固件模块下载。
#define CMD_RAM_LOAD_DONE    0xC7 // Performs a reset of the communications processor after download of a firmware module to program RAM. 将固件模块下载到程序RAM之后复位通信处理器。
#define CMD_IR_CAL           0xBD // Initiates an image rejection calibration routine.  初始化镜像抑制校准程序。 为使此命令发挥作用，必须将镜像抑制校准固件模块载入程序RAM。
#define CMD_AES_ENCRYPT      0xD0 // Performs an AES encryption on the transmit payload data stored in packet RAM.  对包RAM中存储的发送有效载荷数据执行AES加密。 为使此命令发挥作用，必须将AES固件模块载入程序RAM。
#define CMD_AES_DECRYPT      0xD2 // Performs an AES decryption on the received payload data stored in packet RAM.  对包RAM中存储的接收有效载荷数据执行AES解密。 为使此命令发挥作用，必须将AES固件模块载入程序RAM。
#define CMD_AES_DECRYPT_INIT 0xD1 // Initializes the internal variables required for AES decryption.  初始化AES解密所需的内部变量。
#define CMD_RS_ENCODE_INIT   0xD1 // Initializes the internal variables required for the Reed Solomon encoding. 初始化Reed Solomon编码所需的内部变量.为使此命令发挥作用，必须将Reed Solomon编码固件模块载入程序RAM。
#define CMD_RS_ENCODE        0xD0 // Calculates and appends the Reed Solomon check bytes to the transmit payload data stored in packet RAM. 计算Reed Solomon校验字节并将其追加到包RAM中存储的发送有效载荷数据。为使此命令发挥作用，必须将Reed Solomon编码固件模块载入程序RAM。
#define CMD_RS_DECODE        0xD2 // Performs a Reed Solomon error correction on the received payload data stored in packet RAM. 对包RAM中存储的接收有效载荷数据执行Reed Solomon纠错。 为使此命令发挥作用，必须将Reed Solomon编码固件模块载入程序RAM。

/* Battery Backup Memory (BBRAM) 备用电池存储器(BBRAM) */
#define BBRAM_REG_INTERRUPT_MASK_0                  0x100
#define BBRAM_REG_INTERRUPT_MASK_1                  0x101
#define BBRAM_REG_NUMBER_OF_WAKEUPS_0               0x102
#define BBRAM_REG_NUMBER_OF_WAKEUPS_1               0x103
#define BBRAM_REG_NUMBER_OF_WAKEUPS_IRQ_THRESHOLD_0 0x104
#define BBRAM_REG_NUMBER_OF_WAKEUPS_IRQ_THRESHOLD_1 0x105
#define BBRAM_REG_RX_DWELL_TIME                     0x106
#define BBRAM_REG_PARMTIME_DIVIDER                  0x107
#define BBRAM_REG_SWM_RSSI_THRESH                   0x108
#define BBRAM_REG_CHANNEL_FREQ_0                    0x109
#define BBRAM_REG_CHANNEL_FREQ_1                    0x10A
#define BBRAM_REG_CHANNEL_FREQ_2                    0x10B
#define BBRAM_REG_RADIO_CFG_0                       0x10C
#define BBRAM_REG_RADIO_CFG_1                       0x10D
#define BBRAM_REG_RADIO_CFG_2                       0x10E
#define BBRAM_REG_RADIO_CFG_3                       0x10F
#define BBRAM_REG_RADIO_CFG_4                       0x110
#define BBRAM_REG_RADIO_CFG_5                       0x111
#define BBRAM_REG_RADIO_CFG_6                       0x112
#define BBRAM_REG_RADIO_CFG_7                       0x113
#define BBRAM_REG_RADIO_CFG_8                       0x114
#define BBRAM_REG_RADIO_CFG_9                       0x115
#define BBRAM_REG_RADIO_CFG_10                      0x116
#define BBRAM_REG_RADIO_CFG_11                      0x117
#define BBRAM_REG_IMAGE_REJECT_CAL_PHASE            0x118
#define BBRAM_REG_IMAGE_REJECT_CAL_AMPLITUDE        0x119
#define BBRAM_REG_MODE_CONTROL                      0x11A
#define BBRAM_REG_PREAMBLE_MATCH                    0x11B
#define BBRAM_REG_SYMBOL_MODE                       0x11C
#define BBRAM_REG_PREAMBLE_LEN                      0x11D
#define BBRAM_REG_CRC_POLY_0                        0x11E
#define BBRAM_REG_CRC_POLY_1                        0x11F
#define BBRAM_REG_SYNC_CONTROL                      0x120
#define BBRAM_REG_SYNC_BYTE_0                       0x121
#define BBRAM_REG_SYNC_BYTE_1                       0x122
#define BBRAM_REG_SYNC_BYTE_2                       0x123
#define BBRAM_REG_TX_BASE_ADR                       0x124
#define BBRAM_REG_RX_BASE_ADR                       0x125
#define BBRAM_REG_PACKET_LENGTH_CONTROL             0x126
#define BBRAM_REG_PACKET_LENGTH_MAX                 0x127
#define BBRAM_REG_STATIC_REG_FIX                    0x128
#define BBRAM_REG_ADDRESS_MATCH_OFFSET              0x129
#define BBRAM_REG_ADDRESS_LENGTH                    0x12A
#define BBRAM_REG_ADDRESS_FILTERING_0               0x12B
#define BBRAM_REG_ADDRESS_FILTERING_1               0x12C
#define BBRAM_REG_ADDRESS_FILTERING_2               0x12D
#define BBRAM_REG_ADDRESS_FILTERING_3               0x12E
#define BBRAM_REG_ADDRESS_FILTERING_4               0x12F
#define BBRAM_REG_ADDRESS_FILTERING_5               0x130
#define BBRAM_REG_ADDRESS_FILTERING_6               0x131
#define BBRAM_REG_ADDRESS_FILTERING_7               0x132
#define BBRAM_REG_ADDRESS_FILTERING_8               0x133
#define BBRAM_REG_ADDRESS_FILTERING_9               0x134
#define BBRAM_REG_ADDRESS_FILTERING_10              0x135
#define BBRAM_REG_ADDRESS_FILTERING_11              0x136
#define BBRAM_REG_ADDRESS_FILTERING_12              0x137
#define BBRAM_REG_RSSI_WAIT_TIME                    0x138
#define BBRAM_REG_TESTMODES                         0x139
#define BBRAM_REG_TRANSITION_CLOCK_DIV              0x13A
#define BBRAM_REG_RESERVED_0                        0x13B
#define BBRAM_REG_RESERVED_1                        0x13C
#define BBRAM_REG_RESERVED_2                        0x13D
#define BBRAM_REG_RX_SYNTH_LOCK_TIME                0x13E
#define BBRAM_REG_TX_SYNTH_LOCK_TIME                0x13F

//BBRAM寄存器描述
/* BBRAM_REG_INTERRUPT_MASK_0 - 0x100 */
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_NUM_WAKEUPS     (0x1 << 7)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_SWM_RSSI_DET    (0x1 << 6)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_AES_DONE        (0x1 << 5)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_TX_EOF          (0x1 << 4)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_ADDRESS_MATCH   (0x1 << 3)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_CRC_CORRECT     (0x1 << 2)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_SYNC_DETECT     (0x1 << 1)
#define BBRAM_INTERRUPT_MASK_0_INTERRUPT_PREMABLE_DETECT (0x1 << 0)

/* BBRAM_REG_INTERRUPT_MASK_1 - 0x101*/
#define BBRAM_INTERRUPT_MASK_1_BATTERY_ALARM (0x1 << 7)
#define BBRAM_INTERRUPT_MASK_1_CMD_READY     (0x1 << 6)
#define BBRAM_INTERRUPT_MASK_1_WUC_TIMEOUT   (0x1 << 4)
#define BBRAM_INTERRUPT_MASK_1_SPI_READY     (0x1 << 1)
#define BBRAM_INTERRUPT_MASK_1_CMD_FINISHED  (0x1 << 0)

/* BBRAM_REG_RADIO_CFG_0 - 0x10C */
#define BBRAM_RADIO_CFG_0_DATA_RATE_7_0(x) ((x & 0xFF) << 0)

/* BBRAM_REG_RADIO_CFG_1 - 0x10D */
#define BBRAM_RADIO_CFG_1_FREQ_DEVIATION_11_8(x) ((x & 0xF) << 4)
#define BBRAM_RADIO_CFG_1_DATA_RATE_11_8(x)      ((x & 0xF) << 0)

/* BBRAM_REG_RADIO_CFG_2 - 0x10E */
#define BBRAM_RADIO_CFG_2_FREQ_DEVIATION_7_0(x) ((x & 0xFF) << 0)

/* BBRAM_REG_RADIO_CFG_6 - 0x112 */
#define BBRAM_RADIO_CFG_6_SYNTH_LUT_CONFIG_0(x) ((x & 0x3F) << 2)
#define BBRAM_RADIO_CFG_6_DISCRIM_PHASE(x)      ((x & 0x3) << 0)

/* BBRAM_REG_RADIO_CFG_7 - 0x113 */
#define BBRAM_RADIO_CFG_7_AGC_LOCK_MODE(x)      ((x & 0x3) << 6)
#define BBRAM_RADIO_CFG_7_SYNTH_LUT_CONTROL(x)  ((x & 0x3) << 4)
#define BBRAM_RADIO_CFG_7_SYNTH_LUT_CONFIG_1(x) ((x & 0xF) << 0)

/* BBRAM_REG_RADIO_CFG_8 - 0x114 */
#define BBRAM_RADIO_CFG_8_PA_SINGLE_DIFF_SEL (0x1 << 7)
#define BBRAM_RADIO_CFG_8_PA_LEVEL(x)        ((x & 0xF) << 3)
#define BBRAM_RADIO_CFG_8_PA_RAMP(x)         ((x & 0x7) << 0)

/* BBRAM_REG_RADIO_CFG_9 - 0x115 */
#define BBRAM_RADIO_CFG_9_IFBW(x)         ((x & 0x3) << 6)
#define BBRAM_RADIO_CFG_9_MOD_SCHEME(x)   ((x & 0x7) << 3)
#define BBRAM_RADIO_CFG_9_DEMOD_SCHEME(x) ((x & 0x7) << 0)

/* BBRAM_REG_RADIO_CFG_10 - 0x116 */
#define BBRAM_RADIO_CFG_10_AFC_POLARITY     (0x0 << 4)
#define BBRAM_RADIO_CFG_10_AFC_SCHEME(x)    ((x & 0x3) << 2)
#define BBRAM_RADIO_CFG_10_AFC_LOCK_MODE(x) ((x & 0x3) << 0)

/* BBRAM_REG_RADIO_CFG_11 - 0x117 */
#define BBRAM_RADIO_CFG_11_AFC_KP(x) ((x & 0xF) << 4)
#define BBRAM_RADIO_CFG_11_AFC_KI(x) ((x & 0xF) << 0)

/* BBRAM_REG_MODE_CONTROL - 0x11A */
#define BBRAM_MODE_CONTROL_SWM_EN                        (0x1 << 7)
#define BBRAM_MODE_CONTROL_BB_CAL                        (0x1 << 6)
#define BBRAM_MODE_CONTROL_SWM_RSSI_QUAL                 (0x1 << 5)
#define BBRAM_MODE_CONTROL_TX_TO_RX_AUTO_TURNAROUND      (0x1 << 4)
#define BBRAM_MODE_CONTROL_RX_TO_TX_AUTO_TURNAROUND      (0x1 << 3)
#define BBRAM_MODE_CONTROL_CUSTOM_TRX_SYNTH_LOCK_TIME_EN (0x1 << 2)
#define BBRAM_MODE_CONTROL_EXT_LNA_EN                    (0x1 << 1)
#define BBRAM_MODE_CONTROL_EXT_PA_EN                     (0x1 << 0)

/* BBRAM_REG_SYMBOL_MODE - 0x11C */
#define BBRAM_SYMBOL_MODE_MANCHESTER_ENC   (0x1 << 6)
#define BBRAM_SYMBOL_MODE_PROG_CRC_EN      (0x1 << 5)
#define BBRAM_SYMBOL_MODE_EIGHT_TEN_ENC    (0x1 << 4)
#define BBRAM_SYMBOL_MODE_DATA_WHITENING   (0x1 << 3)
#define BBRAM_SYMBOL_MODE_SYMBOL_LENGTH(x) ((x & 0x7) << 0)

/* BBRAM_REG_SYNC_CONTROL - 0x120 */
#define BBRAM_SYNC_CONTROL_SYNC_ERROR_TOL(x)   ((x & 0x3) << 6)
#define BBRAM_SYNC_CONTROL_SYNC_WORD_LENGTH(x) ((x & 0x1F) << 0)

/* BBRAM_REG_PACKET_LENGTH_CONTROL - 0x126 */
#define BBRAM_PACKET_LENGTH_CONTROL_DATA_BYTE        (0x1 << 7)
#define BBRAM_PACKET_LENGTH_CONTROL_PACKET_LEN       (0x1 << 6)
#define BBRAM_PACKET_LENGTH_CONTROL_CRC_EN           (0x1 << 5)
#define BBRAM_PACKET_LENGTH_CONTROL_DATA_MODE(x)     ((x & 0x3) << 3)
#define BBRAM_PACKET_LENGTH_CONTROL_LENGTH_OFFSET(x) ((x & 0x7) << 0)

/* BBRAM_REG_TESTMODES - 0x139 */
#define BBRAM_TESTMODES_EXT_PA_LNA_ATB_CONFIG (0x1 << 7)
#define BBRAM_TESTMODES_PER_IRQ_SELF_CLEAR    (0x1 << 3)
#define BBRAM_TESTMODES_PER_ENABLE            (0x1 << 2)
#define BBRAM_TESTMODES_CONTINUOUS_TX         (0x1 << 1)
#define BBRAM_TESTMODES_CONTINUOUS_RX         (0x1 << 0)

/* Modem Configuration Memory (MCR)  调制解调器配置存储器(MCR)*/
#define MCR_REG_PA_LEVEL_MCR                      0x307
#define MCR_REG_WUC_CONFIG_HIGH                   0x30C
#define MCR_REG_WUC_CONFIG_LOW                    0x30D
#define MCR_REG_WUC_VALUE_HIGH                    0x30E
#define MCR_REG_WUC_VALUE_LOW                     0x30F
#define MCR_REG_WUC_FLAG_RESET                    0x310
#define MCR_REG_WUC_STATUS                        0x311
#define MCR_REG_RSSI_READBACK                     0x312
#define MCR_REG_MAX_AFC_RANGE                     0x315
#define MCR_REG_IMAGE_REJECT_CAL_CONFIG           0x319
#define MCR_REG_CHIP_SHUTDOWN                     0x322
#define MCR_REG_POWERDOWN_RX                      0x324
#define MCR_REG_POWERDOWN_AUX                     0x325
#define MCR_REG_ADC_READBACK_HIGH                 0x327
#define MCR_REG_ADC_READBACK_LOW                  0x328
#define MCR_REG_BATTERY_MONITOR_THRESHOLD_VOLTAGE 0x32D
#define MCR_REG_EXT_UC_CLK_DIVIDE                 0x32E
#define MCR_REG_AGC_CLK_DIVIDE                    0x32F
#define MCR_REG_INTERRUPT_SOURCE_0                0x336
#define MCR_REG_INTERRUPT_SOURCE_1                0x337
#define MCR_REG_CALIBRATION_CONTROL               0x338
#define MCR_REG_CALIBRATION_STATUS                0x339
#define MCR_REG_RXBB_CAL_CALWRD_READBACK          0x345
#define MCR_REG_RXBB_CAL_CALWRD_OVERWRITE         0x346
#define MCR_REG_RCOSC_CAL_READBACK_HIGH           0x34F
#define MCR_REG_RCOSC_CAL_READBACK_LOW            0x350
#define MCR_REG_ADC_CONFIG_LOW                    0x359
#define MCR_REG_ADC_CONFIG_HIGH                   0x35A
#define MCR_REG_AGC_OOK_CONTROL                   0x35B
#define MCR_REG_AGC_CONFIG                        0x35C
#define MCR_REG_AGC_MODE                          0x35D
#define MCR_REG_AGC_LOW_THRESHOLD                 0x35E
#define MCR_REG_AGC_HIGH_THRESHOLD                0x35F
#define MCR_REG_AGC_GAIN_STATUS                   0x360
#define MCR_REG_AGC_ADC_WORD                      0x361
#define MCR_REG_FREQUENCY_ERROR_READBACK          0x372
#define MCR_REG_VCO_BAND_OVRW_VAL                 0x3CB
#define MCR_REG_VCO_AMPL_OVRW_VAL                 0x3CC
#define MCR_REG_VCO_OVRW_EN                       0x3CD
#define MCR_REG_VCO_CAL_CFG                       0x3D0
#define MCR_REG_OSC_CONFIG                        0x3D2
#define MCR_REG_VCO_BAND_READBACK                 0x3DA
#define MCR_REG_VCO_AMPL_READBACK                 0x3DB
#define MCR_REG_ANALOG_TEST_BUS                   0x3F8
#define MCR_REG_RSSI_TSTMUX_SEL                   0x3F9
#define MCR_REG_GPIO_CONFIGURE                    0x3FA
#define MCR_REG_TEST_DAC_GAIN                     0x3FD

/*
包RAM存储器
地址						寄存器												R/W 
0x000						VAR_COMMAND										R/W 	
0x001 					产品代码，最高有效字节 = 0x70 R 		仅在上电或从PHY_SLEEP状态唤醒时有效，因为退出PHY_ON状态时，通信处理器会覆盖这些值。
0x002 					产品代码，最低有效字节 = 0x23 R 		仅在上电或从PHY_SLEEP状态唤醒时有效，因为退出PHY_ON状态时，通信处理器会覆盖这些值。
0x003 					芯片版本代码，最高有效字节 		R 		仅在上电或从PHY_SLEEP状态唤醒时有效，因为退出PHY_ON状态时，通信处理器会覆盖这些值。
0x004 					芯片版本代码，最低有效字节 		R 		仅在上电或从PHY_SLEEP状态唤醒时有效，因为退出PHY_ON状态时，通信处理器会覆盖这些值。
0x005 to 0x00B 	保留 													R 
0x00D 					VAR_TX_MODE 									R/W 
0x00E to 0x00F 	保留													R
*/

struct adf7023_bbram {
	uint8_t interrupt_mask0;                  // 0x100
	uint8_t interrupt_mask1;                  // 0x101
	uint8_t number_of_wakeups0;               // 0x102
	uint8_t number_of_wakeups1;               // 0x103
	uint8_t number_of_wakeups_irq_threshold0; // 0x104
	uint8_t number_of_wakeups_irq_threshold1; // 0x105
	uint8_t rx_dwell_time;                    // 0x106
	uint8_t parmtime_divider;                 // 0x107
	uint8_t swm_rssi_thresh;                  // 0x108
	uint8_t channel_freq0;                    // 0x109
	uint8_t channel_freq1;                    // 0x10A
	uint8_t channel_freq2;                    // 0x10B
	uint8_t radio_cfg0;                       // 0x10C
	uint8_t radio_cfg1;                       // 0x10D
	uint8_t radio_cfg2;                       // 0x10E
	uint8_t radio_cfg3;                       // 0x10F
	uint8_t radio_cfg4;                       // 0x110
	uint8_t radio_cfg5;                       // 0x111
	uint8_t radio_cfg6;                       // 0x112
	uint8_t radio_cfg7;                       // 0x113
	uint8_t radio_cfg8;                       // 0x114
	uint8_t radio_cfg9;                       // 0x115
	uint8_t radio_cfg10;                      // 0x116
	uint8_t radio_cfg11;                      // 0x117
	uint8_t image_reject_cal_phase;           // 0x118
	uint8_t image_reject_cal_amplitude;       // 0x119
	uint8_t mode_control;                     // 0x11A
	uint8_t preamble_match;                   // 0x11B
	uint8_t symbol_mode;                      // 0x11C
	uint8_t preamble_len;                     // 0x11D
	uint8_t crc_poly0;                        // 0x11E
	uint8_t crc_poly1;                        // 0x11F
	uint8_t syncControl;                      // 0x120
	uint8_t sync_byte0;                       // 0x121
	uint8_t sync_byte1;                       // 0x122
	uint8_t sync_byte2;                       // 0x123
	uint8_t tx_base_adr;                      // 0x124
	uint8_t rx_base_adr;                      // 0x125
	uint8_t packet_length_control;            // 0x126
	uint8_t packet_length_max;                // 0x127
	uint8_t static_reg_fix;                   // 0x128
	uint8_t address_match_offset;             // 0x129
	uint8_t address_length;                   // 0x12A
	uint8_t address_filtering0;               // 0x12B
	uint8_t address_filtering1;               // 0x12C
	uint8_t address_filtering2;               // 0x12D
	uint8_t address_filtering3;               // 0x12E
	uint8_t address_filtering4;               // 0x12F
	uint8_t address_filtering5;               // 0x130
	uint8_t address_filtering6;               // 0x131
	uint8_t address_filtering7;               // 0x132
	uint8_t address_filtering8;               // 0x133
	uint8_t address_filtering9;               // 0x134
	uint8_t address_filtering10;              // 0x135
	uint8_t address_filtering11;              // 0x136
	uint8_t address_filtering12;              // 0x137
	uint8_t rssi_wait_time;                   // 0x138
	uint8_t testmodes;                        // 0x139
	uint8_t transition_clock_div;             // 0x13A
	uint8_t reserved0;                        // 0x13B
	uint8_t reserved1;                        // 0x13C
	uint8_t reserved2;                        // 0x13D
	uint8_t rx_synth_lock_time;               // 0x13E
	uint8_t tx_synth_lock_time;               // 0x13F
};

//#define ADF7023_TX_BASE_ADR 0x10
//#define ADF7023_RX_BASE_ADR 0x10

///******************************************************************************/
///************************ Functions Declarations ******************************/
///******************************************************************************/

//class adf7023
//{
//  public:
//    adf7023(int slaveSelectPin, int misoPin, int spiClockDivider=SPI_CLOCK_DIV32, SPIClass *spiinterface=&SPI);
//	
//	/* Transfers one byte of data. */
//	void write_read_byte(uint8_t write_byte,
//			     uint8_t* read_byte);
//				 
//    /* Initializes the ADF7023. */
//	int32_t init();

//	/* Free the resources allocated by adf7023_init(). */
//	int32_t remove();

//	/* Reads the status word of the ADF7023. */
//	void get_status(uint8_t* status);

//	/* Initiates a command. */
//	void set_command(uint8_t command);

//	/* Sets a FW state and waits until the device enters in that state. */
//	void set_fw_state(uint8_t fw_state);

//	/* Reads data from the RAM. */
//	void get_ram(uint32_t address,
//				 uint32_t length,
//				 uint8_t* data);

//	/* Writes data to RAM. */
//	void set_ram(uint32_t address,
//				 uint32_t length,
//				 uint8_t* data);

//	/* Receives one packet. */
//	void receive_packet(uint8_t* packet,
//					uint8_t* length);

//	/* Transmits one packet. */
//	void transmit_packet(uint8_t* packet,
//					 uint8_t length);

//	/* Sets the channel frequency. */
//	void set_channel_frequency(uint32_t ch_freq);

//	/* Sets the data rate. */
//	void set_data_rate(uint32_t data_rate);

//	/* Sets the frequency deviation. */
//	void set_frequency_deviation(uint32_t freq_dev);
//	
//	/* More than 0 when Packet Received and CRC is correct */
//	int32_t available();
//	
//	/* More than 0 when Preamble Detected */
//	int32_t preambleDetected();
//	
//	/* RSSI Measurement with CMD_GET_RSSI */
//	int readRSSI_PHY_ON();
//	
//	/* RSSI Measurement at PHY_RX state */
//	float readRSSI_PHY_RX();
//	
//  private:
//	int _slaveSelectPin;
//	int _misoPin;
//	int _spiClockDivider = SPI_CLOCK_DIV32;
//	SPIClass* _lspi = &SPI;
//	adf7023_bbram adf7023_bbram_current;
//};

#endif // __ADF7023_CMD_H__

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453