zengyuming
/
Weight_Bed
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init 测试创建

This commit is contained in:
zengyuming 2024-05-17 15:11:04 +08:00
commit 736586ed77
12 changed files with 2075 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
ADC_Init.c Normal file
View File

@ -0,0 +1,60 @@
#include "H/Function_Init.H"
void ADC_Init(uint Channel);
unsigned int ADCValue = 0x0000;
bit AdcFlag = 0;
/***********ADC采样口选择*************/
#if (IC_MODEL == SC95F7617B || IC_MODEL == SC95F7616B)
enum Channel {AIN0=0,AIN1,AIN2,AIN3,AIN4,AIN5,AIN6,AIN7,AIN8,AIN9,AIN10,AIN11,AIN12,AIN13,AIN14,AIN15,VDD4=31};
#endif
#if (IC_MODEL == SC95F7615B || IC_MODEL == SC95F7613B)
enum Channel {AIN4=4,AIN5,AIN6,AIN7,AIN12=12,AIN13,AIN14,AIN15,VDD4=31};
#endif
/*****************************************************
*函数名称：void ADC_Test(void)
*函数功能：ADC测试
*入口参数：void
*出口参数：void
*****************************************************/
void ADC_Test(void)
{
ADC_Init(AIN4);
while(1)
{
ADCCON |= 0X40; //开始ADC转换
while(!AdcFlag); //等待 ADC转换完成;
AdcFlag = 0;
ADCValue = (ADCVH<<4)+(ADCVL>>4);
}
}
/*****************************************************
*函数名称：void ADC_Init(uint Channel)
*函数功能：ADC初始化
*入口参数：Channel
*出口参数：void
*****************************************************/
void ADC_Init(uint Channel)
{
ADCCON = 0X80|Channel; //开启ADC，ADC采样频率为2M ,选择Channel位ADC采样口
if(Channel<8)
{
ADCCFG0 = 1<<Channel; //设置Channel作为采样口
}
else
{
ADCCFG1 = 1<<(Channel-8); //设置Channel作为采样口
}
ADCCFG2 = 0x10; //ADC采样时间为三个时钟
IE |= 0X40; //开启ADC中断
EA = 1;
}
void ADC_Interrupt(void) interrupt 6
{
ADCCON &= ~(0X20); //清中断标志位
AdcFlag = 1;
}

853
CS1237.c Normal file
View File

@ -0,0 +1,853 @@
#include "H/Function_Init.H"
//ADC引脚命名
#define ADC_DT0 P44
#define ADC_CLK0 P43
#define ADC_DT1 P05
#define ADC_CLK1 P04
#define ADC_DT2 P26
#define ADC_CLK2 P25
#define ADC_DT3 P02
#define ADC_CLK3 P01
//DOUT方向设置
#define ADC_DT0_IN() {P4CON &= 0xEF;P4PH|=0x10;}
#define ADC_DT0_OUT() {P4CON |= 0X10;}
#define ADC_DT1_IN() { P0CON &= 0xDF;P0PH|=0x20;}
#define ADC_DT1_OUT() { P0CON |= 0x20;}
#define ADC_DT2_IN() { P2CON &= 0xBF;P2PH|=0x40;}
#define ADC_DT2_OUT() { P2CON |= 0x40;}
#define ADC_DT3_IN() {P0CON &= 0xFB;P0PH|=0x04;}
#define ADC_DT3_OUT() {P0CON |= 0x04;}
void CS1237_Init_all(void)
{
CS1237_Init();//CS1237初始化
CS1237_Init_1();
CS1237_Init_2();
CS1237_Init_3();
}
void CS1237_Config_all(void)
{
CS1237_Config();
CS1237_Config_1();
CS1237_Config_2();
CS1237_Config_3();
}
long Read_CS1237_all(uchar num)
{
long ret;
switch(num)
{
case 0:ret = Read_CS1237();break;
case 1:ret = Read_CS1237_1();break;
case 2:ret = Read_CS1237_2();break;
case 3:ret = Read_CS1237_3();break;
default:ret = 0;break;
}
return ret;
}
/**************************************************************
ADC芯片说明：
1、PAG放大倍数选择需要根据输入的模拟型号的最大电压值来确定，灵敏度乘以激励电压就是最大输出；
2、非线性，滞后性，重复性归结为综合误差，一般用%F*S来表示，就是占最大输出电压的百分比；
3、设置输出速率之前，超时时间等长一点，不然可能会超时；
***************************************************************/
//////////////初始化CS1237芯片，先拉高clk进入PowerDown状态
void CS1237_Init(void)
{
ADC_DT0_OUT();
ADC_DT0 = 1;
ADC_CLK0 = 1;
}
//////////////配置CS1237芯片
uchar CS1237_Config(void)
{
uchar i ;
uchar dat ;
uint count_i = 0;
dat =0x0c;//芯片地配置 内部REF 输出40HZ PGA=128 通道A 0X1C
// ADC_DT0_OUT();
// ADC_DT0 = 1;
ADC_DT0_IN();
ADC_CLK0 = 0;
// UART_SendByte(0x22);
while(ADC_DT0 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT0_OUT();
ADC_CLK0 = 1;
ADC_DT0 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK0=1;
Delay(1);
ADC_CLK0=0;
Delay(1);
}
ADC_DT0_OUT();
/////////////////30-36写配置寄存器命令7bit 0X65
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=0;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=0;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=0;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
/////////////////37切换方向
ADC_CLK0 = 1;
Delay(1);
ADC_CLK0 = 0;
Delay(1);
/////////////////38-45 写8位数据，配置参数
for(i=0;i<8;i++)
{
ADC_CLK0 = 1;
Delay(1);
if(dat&0x80)
ADC_DT0=1;
else
ADC_DT0=0;
dat<<=1;
ADC_CLK0 = 0;
Delay(1);
}
ADC_CLK0 = 1;//46
ADC_DT0 = 1 ;
Delay(1);
ADC_CLK0 = 0;
Delay(1);
return 1;
}
//////////////读芯片输出数据
long Read_CS1237(void)
{
uchar i;
unsigned long dat = 0;//读到的数据
uint count_i = 0;//溢出计时器
long temp;
// ADC_DT0_OUT();
// ADC_DT0 = 1;
ADC_DT0_IN();
ADC_CLK0 = 0;
while(ADC_DT0==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT0_OUT();
ADC_CLK0 = 1;
ADC_DT0 = 1;
return 0;
}
}
dat = 0;
for(i=0;i<24;i++)
{
ADC_CLK0 = 1;
Delay(1);
dat<<=1;
if(ADC_DT0==1)
dat++;
ADC_CLK0 = 0;
Delay(1);
}
for(i=0;i<3;i++)//接着前面24个时钟后等3个时钟，DOUT会主动拉高1次
{
ADC_CLK0=1;
Delay(1);
ADC_CLK0=0;
Delay(1);
}
ADC_DT0_OUT();
ADC_DT0=1;
Delay(1);
ADC_DT0_IN();
if(dat &0x00800000)//24位补码转32位，负数需要按位取反(除符号位)，再+1转源码后，填充符号位
{
temp = -(((~dat)&0x007FFFFF)+1);
}
else
temp = dat;
return temp;
}
//////////////读芯片配置数据
uchar Read_Config(void)
{
uchar i;
uchar dat = 0;//读到的数据
uint count_i = 0;//超时溢出计时器
// ADC_DT0_OUT();
// ADC_DT0 = 1;
ADC_DT0_IN();
ADC_CLK0 = 0;
// UART_SendByte(0x22);
while(ADC_DT0 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT0_OUT();
ADC_CLK0 = 1;
ADC_DT0 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK0=1;
Delay(1);
ADC_CLK0=0;
Delay(1);
}
ADC_DT0_OUT();
/////////////////30-36读配置寄存器命令7bit 0X56
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=0;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=0;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=1;ADC_CLK0=0;Delay(1);
ADC_CLK0 = 1;Delay(1);ADC_DT0=0;ADC_CLK0=0;Delay(1);
/////////////////37切换方向
ADC_CLK0 = 1;
Delay(1);
ADC_DT0_IN();
ADC_CLK0 = 0;
Delay(1);
dat = 0;
for(i=0;i<8;i++)/////////38-45,读寄存器配置
{
ADC_CLK0 = 1;
Delay(1);
ADC_CLK0 = 0;
Delay(1);
dat<<=1;
if(ADC_DT0==1)
dat++;
}
ADC_CLK0 = 1;//46
Delay(1);
ADC_DT0_OUT();
ADC_DT0=1;
ADC_CLK0 = 0;
Delay(1);
return dat;
}
//////////////初始化CS1237芯片，先拉高clk进入PowerDown状态
void CS1237_Init_1(void)
{
ADC_DT1_OUT();
ADC_DT1 = 1;
ADC_CLK1 = 1;
}
//////////////配置CS1237芯片
uchar CS1237_Config_1(void)
{
uchar i ;
uchar dat ;
uint count_i = 0;
dat =0x0c;//芯片地配置 内部REF 输出40HZ PGA=128 通道A 0X1C
ADC_DT1_OUT();
ADC_DT1 = 1;
ADC_DT1_IN();
ADC_CLK1 = 0;
// UART_SendByte(0x22);
while(ADC_DT1 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT1_OUT();
ADC_CLK1 = 1;
ADC_DT1 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK1=1;
Delay(1);
ADC_CLK1=0;
Delay(1);
}
ADC_DT1_OUT();
/////////////////30-36写配置寄存器命令7bit 0X65
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=0;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=0;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=0;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
/////////////////37切换方向
ADC_CLK1 = 1;
Delay(1);
ADC_CLK1 = 0;
Delay(1);
/////////////////38-45 写8位数据，配置参数
for(i=0;i<8;i++)
{
ADC_CLK1 = 1;
Delay(1);
if(dat&0x80)
ADC_DT1=1;
else
ADC_DT1=0;
dat<<=1;
ADC_CLK1 = 0;
Delay(1);
}
ADC_CLK1 = 1;//46
ADC_DT1 = 1 ;
Delay(1);
ADC_CLK1 = 0;
Delay(1);
return 1;
}
//////////////读芯片输出数据
long Read_CS1237_1(void)
{
uchar i;
unsigned long dat = 0;//读到的数据
uint count_i = 0;//溢出计时器
long temp;
// ADC_DT1_OUT();
// ADC_DT1 = 1;
ADC_DT1_IN();
ADC_CLK1 = 0;
while(ADC_DT1==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT1_OUT();
ADC_CLK1 = 1;
ADC_DT1 = 1;
return 0;
}
}
dat = 0;
for(i=0;i<24;i++)
{
ADC_CLK1 = 1;
Delay(1);
dat<<=1;
if(ADC_DT1==1)
dat++;
ADC_CLK1 = 0;
Delay(1);
}
for(i=0;i<3;i++)//接着前面24个时钟后等3个时钟，DOUT会主动拉高1次
{
ADC_CLK1=1;
Delay(1);
ADC_CLK1=0;
Delay(1);
}
ADC_DT1_OUT();
ADC_DT1=1;
Delay(1);
ADC_DT1_IN();
if(dat &0x00800000)//24位补码转32位，负数需要按位取反(除符号位)，再+1转源码后，填充符号位
{
temp = -(((~dat)&0x007FFFFF)+1);
}
else
temp = dat;
return temp;
}
//////////////读芯片配置数据
uchar Read_Config_1(void)
{
uchar i;
uchar dat = 0;//读到的数据
uint count_i = 0;//超时溢出计时器
ADC_DT1_OUT();
ADC_DT1 = 1;
ADC_DT1_IN();
ADC_CLK1 = 0;
// UART_SendByte(0x22);
while(ADC_DT1 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT1_OUT();
ADC_CLK1 = 1;
ADC_DT1 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK1=1;
Delay(1);
ADC_CLK1=0;
Delay(1);
}
ADC_DT1_OUT();
/////////////////30-36读配置寄存器命令7bit 0X56
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=0;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=0;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=1;ADC_CLK1=0;Delay(1);
ADC_CLK1 = 1;Delay(1);ADC_DT1=0;ADC_CLK1=0;Delay(1);
/////////////////37切换方向
ADC_CLK1 = 1;
Delay(1);
ADC_DT1_IN();
ADC_CLK1 = 0;
Delay(1);
dat = 0;
for(i=0;i<8;i++)/////////38-45,读寄存器配置
{
ADC_CLK1 = 1;
Delay(1);
ADC_CLK1 = 0;
Delay(1);
dat<<=1;
if(ADC_DT1==1)
dat++;
}
ADC_CLK1 = 1;//46
Delay(1);
ADC_DT1_OUT();
ADC_DT1=1;
ADC_CLK1 = 0;
Delay(1);
return dat;
}
//////////////初始化CS1237芯片，先拉高clk进入PowerDown状态
void CS1237_Init_2(void)
{
ADC_DT2_OUT();
ADC_DT2 = 1;
ADC_CLK2 = 1;
}
//////////////配置CS1237芯片
uchar CS1237_Config_2(void)
{
uchar i ;
uchar dat ;
uint count_i = 0;
dat =0x0c;//芯片地配置 内部REF 输出40HZ PGA=128 通道A 0X1C
// ADC_DT2_OUT();
// ADC_DT2 = 1;
ADC_DT2_IN();
ADC_CLK2 = 0;
// UART_SendByte(0x22);
while(ADC_DT2 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT2_OUT();
ADC_CLK2 = 1;
ADC_DT2 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK2=1;
Delay(1);
ADC_CLK2=0;
Delay(1);
}
ADC_DT2_OUT();
/////////////////30-36写配置寄存器命令7bit 0X65
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=0;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=0;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=0;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
/////////////////37切换方向
ADC_CLK2 = 1;
Delay(1);
ADC_CLK2 = 0;
Delay(1);
/////////////////38-45 写8位数据，配置参数
for(i=0;i<8;i++)
{
ADC_CLK2 = 1;
Delay(1);
if(dat&0x80)
ADC_DT2=1;
else
ADC_DT2=0;
dat<<=1;
ADC_CLK2 = 0;
Delay(1);
}
ADC_CLK2 = 1;//46
ADC_DT2 = 1 ;
Delay(1);
ADC_CLK2 = 0;
Delay(1);
return 1;
}
//////////////读芯片输出数据
long Read_CS1237_2(void)
{
uchar i;
unsigned long dat = 0;//读到的数据
uint count_i = 0;//溢出计时器
long temp;
// ADC_DT2_OUT();
// ADC_DT2 = 1;
ADC_DT2_IN();
ADC_CLK2 = 0;
while(ADC_DT2==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT2_OUT();
ADC_CLK2 = 1;
ADC_DT2 = 1;
return 0;
}
}
dat = 0;
for(i=0;i<24;i++)
{
ADC_CLK2 = 1;
Delay(1);
dat<<=1;
if(ADC_DT2==1)
dat++;
ADC_CLK2 = 0;
Delay(1);
}
for(i=0;i<3;i++)//接着前面24个时钟后等3个时钟，DOUT会主动拉高1次
{
ADC_CLK2=1;
Delay(1);
ADC_CLK2=0;
Delay(1);
}
ADC_DT2_OUT();
ADC_DT2=1;
Delay(1);
ADC_DT2_IN();
if(dat &0x00800000)//24位补码转32位，负数需要按位取反(除符号位)，再+1转源码后，填充符号位
{
temp = -(((~dat)&0x007FFFFF)+1);
}
else
temp = dat;
return temp;
}
//////////////读芯片配置数据
uchar Read_Config_2(void)
{
uchar i;
uchar dat = 0;//读到的数据
uint count_i = 0;//超时溢出计时器
ADC_DT2_OUT();
ADC_DT2 = 1;
ADC_DT2_IN();
ADC_CLK2 = 0;
// UART_SendByte(0x22);
while(ADC_DT2 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT2_OUT();
ADC_CLK2 = 1;
ADC_DT2 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK2=1;
Delay(1);
ADC_CLK2=0;
Delay(1);
}
ADC_DT2_OUT();
/////////////////30-36读配置寄存器命令7bit 0X56
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=0;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=0;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=1;ADC_CLK2=0;Delay(1);
ADC_CLK2 = 1;Delay(1);ADC_DT2=0;ADC_CLK2=0;Delay(1);
/////////////////37切换方向
ADC_CLK2 = 1;
Delay(1);
ADC_DT2_IN();
ADC_CLK2 = 0;
Delay(1);
dat = 0;
for(i=0;i<8;i++)/////////38-45,读寄存器配置
{
ADC_CLK2 = 1;
Delay(1);
ADC_CLK2 = 0;
Delay(1);
dat<<=1;
if(ADC_DT2==1)
dat++;
}
ADC_CLK2 = 1;//46
Delay(1);
ADC_DT2_OUT();
ADC_DT2=1;
ADC_CLK2 = 0;
Delay(1);
return dat;
}
//////////////初始化CS1237芯片，先拉高clk进入PowerDown状态
void CS1237_Init_3(void)
{
ADC_DT3_OUT();
ADC_DT3 = 1;
ADC_CLK3 = 1;
}
//////////////配置CS1237芯片
uchar CS1237_Config_3(void)
{
uchar i ;
uchar dat ;
uint count_i = 0;
dat =0x0c;//芯片地配置 内部REF 输出40HZ PGA=128 通道A 0X1C
ADC_DT3_OUT();
ADC_DT3 = 1;
ADC_DT3_IN();
ADC_CLK3 = 0;
// UART_SendByte(0x22);
while(ADC_DT3 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT3_OUT();
ADC_CLK3 = 1;
ADC_DT3 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK3=1;
Delay(1);
ADC_CLK3=0;
Delay(1);
}
ADC_DT3_OUT();
/////////////////30-36写配置寄存器命令7bit 0X65
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=0;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=0;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=0;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
/////////////////37切换方向
ADC_CLK3 = 1;
Delay(1);
ADC_CLK3 = 0;
Delay(1);
/////////////////38-45 写8位数据，配置参数
for(i=0;i<8;i++)
{
ADC_CLK3 = 1;
Delay(1);
if(dat&0x80)
ADC_DT3=1;
else
ADC_DT3=0;
dat<<=1;
ADC_CLK3 = 0;
Delay(1);
}
ADC_CLK3 = 1;//46
ADC_DT3 = 1 ;
Delay(1);
ADC_CLK3 = 0;
Delay(1);
return 1;
}
//////////////读芯片输出数据
long Read_CS1237_3(void)
{
uchar i;
unsigned long dat = 0;//读到的数据
uint count_i = 0;//溢出计时器
long temp;
ADC_DT3_OUT();
ADC_DT3 = 1;
ADC_DT3_IN();
ADC_CLK3 = 0;
while(ADC_DT3==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT3_OUT();
ADC_CLK3 = 1;
ADC_DT3 = 1;
return 0;
}
}
dat = 0;
for(i=0;i<24;i++)
{
ADC_CLK3 = 1;
Delay(1);
dat<<=1;
if(ADC_DT3==1)
dat++;
ADC_CLK3 = 0;
Delay(1);
}
for(i=0;i<3;i++)//接着前面24个时钟后等3个时钟，DOUT会主动拉高1次
{
ADC_CLK3=1;
Delay(1);
ADC_CLK3=0;
Delay(1);
}
ADC_DT3_OUT();
ADC_DT3=1;
Delay(1);
ADC_DT3_IN();
if(dat &0x00800000)//24位补码转32位，负数需要按位取反(除符号位)，再+1转源码后，填充符号位
{
temp = -(((~dat)&0x007FFFFF)+1);
}
else
temp = dat;
return temp;
}
//////////////读芯片配置数据
uchar Read_Config_3(void)
{
uchar i;
uchar dat = 0;//读到的数据
uint count_i = 0;//超时溢出计时器
// ADC_DT3_OUT();
// ADC_DT3 = 1;
ADC_DT3_IN();
ADC_CLK3 = 0;
// UART_SendByte(0x22);
while(ADC_DT3 ==1)
{
Delay1ms();
count_i++;
if(count_i>350)
{
ADC_DT3_OUT();
ADC_CLK3 = 1;
ADC_DT3 = 1;
return 0; //超时，退出程序
}
}
for(i=0;i<29;i++)//1-29
{
ADC_CLK3=1;
Delay(1);
ADC_CLK3=0;
Delay(1);
}
ADC_DT3_OUT();
/////////////////30-36读配置寄存器命令7bit 0X56
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=0;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=0;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=1;ADC_CLK3=0;Delay(1);
ADC_CLK3 = 1;Delay(1);ADC_DT3=0;ADC_CLK3=0;Delay(1);
/////////////////37切换方向
ADC_CLK3 = 1;
Delay(1);
ADC_DT3_IN();
ADC_CLK3 = 0;
Delay(1);
dat = 0;
for(i=0;i<8;i++)/////////38-45,读寄存器配置
{
ADC_CLK3 = 1;
Delay(1);
ADC_CLK3 = 0;
Delay(1);
dat<<=1;
if(ADC_DT3==1)
dat++;
}
ADC_CLK3 = 1;//46
Delay(1);
ADC_DT3_OUT();
ADC_DT3=1;
ADC_CLK3 = 0;
Delay(1);
return dat;
}

79
EX_Init.c Normal file
View File

@ -0,0 +1,79 @@
#include "H/Function_Init.H"
void EX_Init(void);
uchar INT1_flag = 0x00;
/*****************************************************
*函数名称：void EXTI_Test(void)
*函数功能：外部中断测试
*入口参数：void
*出口参数：void
*****************************************************/
void EXTI_Test(void)
{
EX_Init();
while(1)
{
}
}
/*****************************************************
*函数名称：void EX_Init(void)
*函数功能：外部中断初始化
*入口参数：void
*出口参数：void
*****************************************************/
void EX_Init(void)
{
//配置中断口INT07、INT11/10、INT20/21
P0CON &= 0X7F; //中断IO口设置为高阻输入
P0PH |= 0x80; //中断IO口设置为高阻带上拉
P4CON &= 0XFC; //中断IO口设置为高阻输入
P4PH |= 0x03; //中断IO口设置为高阻带上拉
P2CON &= 0XFC; //中断IO口设置为高阻输入
P2PH |= 0x03; //中断IO口设置为高阻带上拉
//配置INT07上升沿中断、INT11/10下降沿中断、INT20/21双沿中断
//下降沿设置
INT0F = 0X00 ; //0关闭 1使能
INT1F = 0X03 ; //0关闭 1使能
INT2F = 0X03 ; //0关闭 1使能
//上升沿设置
INT0R = 0X80 ; //0关闭 1使能
INT1R = 0X00 ; //0关闭 1使能
INT2R = 0X03 ; //0关闭 1使能
//外部中断优先级设置
IE |= 0x05; //外部中断0，1中断使能
IE1 |= 0x08; //外部中断2中断使能
IP |= 0X00; //配置中断优先级
IP1 |= 0X00;
EA = 1;
}
/*****************************************************
*函数名称：void EX0/1/2() interrupt 0/2/10
*函数功能：外部中断函数
*入口参数：void
*出口参数：void
*****************************************************/
void INT0Interrupt() interrupt 0
{
P04 = ~P04;
}
void INT1Interrupt() interrupt 2
{
P05 = ~P05;
if(P40 == 0)
{
INT1_flag = 0x10; //INT10产生中断
}
if(P41 == 0)
{
INT1_flag = 0x20; //INT11产生中断
}
}
void INT2Interrupt() interrupt 10
{
P06 = ~P06;
}

94
IAP_Init.c Normal file
View File

@ -0,0 +1,94 @@
#include "H/Function_Init.H"
#include "IAP_Lib/IAP_Option_EW.h"
unsigned char code* POINT; //该指针指向0x0000
#define IAP_APROM 0x00
#define IAP_UniqueID 0x01
#define IAP_EEPROM 0x02
#define IAP_LDROM 0x03
unsigned char IAP_Read(unsigned long IAP_IapAddr, unsigned char area);
void IAP_Test(void)
{
unsigned char IapReadData1,IapReadData2; //定义储存读出数据的变量
IAP_CodeSectorEraseOption(0xFFFE); //往CODE 0x1FFFE地址块擦
IAP_CodeProgramByteOption(0xFFFE, 0x55); //往CODE 0x1FFFE地址写入0x55
IapReadData1 = IAP_Read(0xFFFE, IAP_APROM); //读取CODE 0x1FFFE地址数据
IAP_EEPROMSectorEraseOption(0x1000); //往EEPROM 0x1000地址块擦
IAP_EEPROMProgramByteOption(0x1000, 0xAA); //往EEPROM 0x1000地址写入0xAA
IapReadData2 = IAP_Read(0x1000, IAP_EEPROM); //读取EEPROM 0x1000地址数据
while(1)
{
if((IapReadData1 == 0x55) && (IapReadData2 == 0xAA))
{
P02 = ~P02;
}
else
{
P03 = ~P03;
}
}
}
/**************************************************
*函数名称：unsigned char IAP_Read(unsigned long Add,unsigned char ADER)
*函数功能：单Byte读取
*入口参数：Add ：需要擦除的地址(0X00~0X1FFFF（FLASH物理地址）
* Data：要写入的Byte,ADER:操作对象 APROM为00,EEPROM为02
*出口参数：void
**************************************************/
unsigned char IAP_Read(unsigned long Add, unsigned char Iapade)
{
unsigned char IAP_IapData;
//保存ROMBNK、IAPADE、EA
unsigned char tempADER = IAPADE;
unsigned char tempEA = EA;
unsigned char code* point = 0;
EA = 0;//关闭中断
IAPADE = Iapade;
IAP_IapData = *(point + Add);
//操作结束恢复ROMBNK、IAPADE、EA，避免MOVC位置出错
IAPADE = tempADER;
EA = tempEA;
return IAP_IapData;
}
void EEPROM_Write_k(long Dat)
{
uchar i;
uchar temp[4];
temp[0] = (Dat >> 24) & 0xFF;
temp[1] = (Dat >> 16) & 0xFF;
temp[2] = (Dat >> 8) & 0xFF;
temp[3] = Dat & 0xFF;
IAP_EEPROMSectorEraseOption(0x1600); //往EEPROM 0x1000地址块擦!!!!注意擦除是按页擦，不是按字节，一次擦除一页（512Bytes）
for(i=0;i<4;i++)
{
IAP_EEPROMProgramByteOption(0x1600+i,temp[i]); //往EEPROM 0x1000地址写入0xAA
}
}
long EEPROM_Read_k(void)
{
uchar i;
uchar buff;
long dat =0;
for(i=0;i<4;i++)
{
buff = IAP_Read(0x1600+i, IAP_EEPROM);
dat |= (long)buff<<24-i*8;
}
return dat;
}

39
IO_Init.c Normal file
View File

@ -0,0 +1,39 @@
#include "H/Function_Init.H"
/*****************************************************
*函数名称：void IO_Init(void)
*函数功能：IO初始化,CLK输出，DT输入
*入口参数：void
*出口参数：void
*****************************************************/
void IO_Init(void)
{
P0CON = 0x12; ////7 , 6 DT1, 5 , 4 .CLK1, 3 , 2 DT3, 1 .CLK3, 0
P0PH = 0x00;
P1CON = 0xFF; //7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
P1PH = 0x00;
P2CON = 0x20; //7 大按钮 , 6 DT2, 5 .CLK2, 4 小按钮, 3 , 2 , 1 , 0
P2PH = 0x90;
P3CON = 0xFF; //7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
P3PH = 0x00;
P4CON = 0x08; //7 , 6 , 5 , 4 DT0, 3 .CLK0, 2 , 1 , 0
P4PH = 0x00;
P5CON = 0xFF; //7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
P5PH = 0x00;
SC95F7616B_NIO_Init(); //未引出IO口配置
}
void Delay(unsigned long time)
{
while(time--);//4.3us
}
void Delay1ms(void)
{
Delay(585);
}
void Delay_ms(unsigned long time)
{
while(time--)
Delay1ms();
}

104
Multiplication_Division.c Normal file
View File

@ -0,0 +1,104 @@
#include "H/Function_Init.H"
unsigned long product = 0;//乘积
unsigned long quotient = 0;//商
unsigned int remainder = 0;//余数
typedef struct
{
unsigned char MDU_EXA3Reg; //EXA3寄存器
unsigned char MDU_EXA2Reg; //EXA2寄存器
unsigned char MDU_EXA1Reg; //EXA1寄存器
unsigned char MDU_EXA0Reg; //EXA0寄存器
} MDU_EXAxReg_Typedef;
typedef union
{
MDU_EXAxReg_Typedef MDU_EXAxReg;
unsigned long MDU_Temp;
} MDU_Temp_Union;
//Result_union result;
void Multiplication(unsigned int faciend, unsigned int Multiplier);
void Division(unsigned long dividend,unsigned int divisor);
void Multiplier_Divider_Test()
{
while(1)
{
Multiplication(15,16);
if(product == 240)
{
P03 = ~P03;
}
Division(16,5);
if((quotient == 3) && (remainder == 1))
{
P04 = ~P04;
}
}
}
/****************************************************
*函数名称：Multiplication(unsigned int faciend, unsigned int Multiplier)
*函数功能：乘法运算
*入口参数：faciend，Multiplier
*出口参数：无
****************************************************/
void Multiplication(unsigned int faciend, unsigned int Multiplier)
{
MDU_Temp_Union MDU_ProductTemp;
OPERCON &= ~0x40; //选择乘法
EXA0 = faciend;
EXA1 = faciend>>8;
EXBL = Multiplier;
EXBH = Multiplier>>8;
OPERCON |= 0x80; //开始计算
while(OPERCON & 0x80); //等待计算完成
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA0Reg = EXA0;
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA1Reg = EXA1;
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA2Reg = EXA2;
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA3Reg = EXA3;
product = MDU_ProductTemp.MDU_Temp; //获取乘积
}
/****************************************************
*函数名称：Division(unsigned long dividend,unsigned int divisor)
*函数功能：除法运算
*入口参数：dividend，divisor
*出口参数：无
****************************************************/
void Division(unsigned long dividend,unsigned int divisor)
{
MDU_Temp_Union MDU_ProductTemp;
MDU_ProductTemp.MDU_Temp = dividend;
OPERCON &= ~0x40;
OPERCON |= 0x40; //选择除法
EXA0 = MDU_ProductTemp.MDU_EXAxReg.MDU_EXA0Reg; //输入除数
EXA1 = MDU_ProductTemp.MDU_EXAxReg.MDU_EXA1Reg;
EXA2 = MDU_ProductTemp.MDU_EXAxReg.MDU_EXA2Reg;
EXA3 = MDU_ProductTemp.MDU_EXAxReg.MDU_EXA3Reg;
EXBL = divisor; //输入被除数
EXBH = divisor>>8;
OPERCON |= 0xC0; //开始计算
while(OPERCON & 0x80); //等待计算完成
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA0Reg = EXA0;
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA1Reg = EXA1;
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA2Reg = EXA2;
MDU_ProductTemp.MDU_EXAxReg.MDU_EXA3Reg = EXA3;
remainder = EXBH*256+ EXBL; //余数
quotient = MDU_ProductTemp.MDU_Temp; //商
}

72
Timer_Init.c Normal file
View File

@ -0,0 +1,72 @@
#include "H/Function_Init.H"
void Timer_Init(void);
uint Time_Key0_Press;//按键0保持时间
uint Time_Key1_Press;//按键1保持时间
/*****************************************************
*函数名称：void Timer_Test(void);
*函数功能：T0/T1/T2测试
*入口参数：void
*出口参数：void
*****************************************************/
void Timer_Test(void)
{
Timer_Init();
Time_Key0_Press = 0;
Time_Key1_Press = 0;
}
/*****************************************************
*函数名称：void Timer_Init(void)
*函数功能：T0/T1/T2初始化
*入口参数：void
*出口参数：void
*****************************************************/
void Timer_Init(void)
{
TMCON = 0X01; //------111 ;Timer0、Tiemr1和Tiemr2选择时钟Fsys
//T0设置，现象：P02输出频率为1K的方波(主频：32M)
TMOD |= 0x01; //0000 0001;Timer0设置工作方式1
TL0 = (65536 - 32000)%256; //时钟为Fsys，则溢出时间=16000*（1/Fsys）;
TH0 = (65536 - 32000)/256;
TR0 = 0;
ET0 = 1;//定时器0允许
TR0 = 1;//打开定时器0
}
/**************************************************
*函数名称：void timer0/1/2/3/4() interrupt 1/3/5/13/14
*函数功能：定时器中断产生方波
*入口参数：void
*出口参数：void
**************************************************/
void timer0() interrupt 1
{
TL0 = (65536 - 32000)%256; //手动重装载值低8位
TH0 = (65536 - 32000)/256; //手动重装载值高8位
if(!Key0)
Time_Key0_Press++;
else
Time_Key0_Press=0;
if(Time_Key0_Press>=3000)//等三秒让数据收拢
{
Time_Key0_Press = 0;
Key0_flag = 1;
}
if(!Key1)
Time_Key1_Press++;
else
Time_Key1_Press=0;
if(Time_Key1_Press>=3000)
{
Time_Key1_Press = 0;
Key1_flag = 1;
}
}

58
USCI0_Init.c Normal file
View File

@ -0,0 +1,58 @@
#include "H/Function_Init.H"
#define USCI0_Mode SPI0
void Uart0_Init(uint Freq,unsigned long int baud);
void TWI0_Init(void);
void SPI0_Init(void);
bit Uart0SendFlag = 0; //Uart0发送中断标志位
bit Uart0ReceiveFlag = 0; //Uart0接收中断标志位
bit SPI0Flag = 0; //SPI0数据传输完成标志位
bit TWI0Flag = 0; //TWI0中断标志位
/*****************************************************
*函数名称：void USCI0_Test(void)
*函数功能：USCI0测试
*入口参数：void
*出口参数：void
*****************************************************/
void USCI0_Test(void)
{
SPI0_Init();
while(1)
{
US0CON2 = 0xAA;
while(!SPI0Flag);
SPI0Flag = 0;
Delay(1000);
}
}
/*****************************************************
*函数名称：void SPI0_Init(void)
*函数功能：SPI0初始化
*入口参数：void
*出口参数：void
*****************************************************/
void SPI0_Init(void)
{
OTCON |= 0X10; //选择SPI0模式
US0CON0 = 0x3F; //设置SPI0为主设备，SCK空闲时间为高电平，SCK周期第二沿采集数据，时钟速率为Fsys/128
US0CON1 = 0x01; //MSB优先发送，8位传输，允许发送中断
US0CON0 |= 0x80; //开启SPI0
IE1 |= 0x01;
EA = 1;
}
void Spi0_Int(void) interrupt 7 //SPI0中断函数
{
if(US0CON1&0X08) //发送缓存器空标志判断
{
US0CON1 &= ~0X08;
}
if(US0CON1&0X80) //数据传输标志位判断
{
US0CON1 &= ~0X80;
SPI0Flag = 1;
}
}

64
USCI1_Init.c Normal file
View File

@ -0,0 +1,64 @@
#include "H/Function_Init.H"
void SPI1_Init(void);
bit Uart1SendFlag = 0; //Uart1发送中断标志位
bit Uart1ReceiveFlag = 0; //Uart1接收中断标志位
bit SPI1Flag = 0; //SPI1数据传输完成标志位
bit TWI1Flag = 0; //TWI1中断标志位
/*****************************************************
*函数名称：void USCI1_Test(void)
*函数功能：USCI1测试
*入口参数：void
*出口参数：void
*****************************************************/
void USCI1_Test(void)
{
SPI1_Init();
while(1)
{
US1CON2 = 0xAA;
while(!SPI1Flag);
SPI1Flag = 0;
Delay(1000);
}
}
/*****************************************************
*函数名称：void SPI1_Init(void)
*函数功能：SPI1初始化
*入口参数：void
*出口参数：void
*****************************************************/
void SPI1_Init(void)
{
OTCON |= 0X40; //选择SPI1模式
US1CON0 = 0x3F; //设置SPI1为主设备，SCK空闲时间为高电平，SCK周期第二沿采集数据，时钟速率为Fsys/128
US1CON1 = 0x01; //MSB优先发送，8位传输，允许发送中断
US1CON0 |= 0x80; //开启SPI1
IE2 |= 0x01;
EA = 1;
}
/*****************************************************
*函数名称：void TWI1/PI/UART1_Int() interrupt 7
*函数功能：USCI1中断函数
*入口参数：void
*出口参数：void
*****************************************************/
#if (USCI1_Mode == SPI1)
void Spi1_Int(void) interrupt 15 //SPI1中断函数
{
if(US1CON1&0X08) //发送缓存器空标志判断
{
US1CON1 &= ~0X08;
}
if(US1CON1&0X80) //数据传输标志位判断
{
US1CON1 &= ~0X80;
SPI1Flag = 1;
}
}
#endif

358
USCIX_Init.c Normal file
View File

@ -0,0 +1,358 @@
#include "H/Function_Init.H"
//选择三合一模块：
#define USCI2 2
#define USCI3 3
#define USCI4 4
#define USCI5 5
//选择三合一模式：
#define UartX 0
#define TWIX 1
#define SPIX 2
#define USCIX_Select USCI3
#define USCIX_Mode 2
void UARTX_Init(uint Freq, unsigned long int baud);
void TWIX_Init(void);
void SPIX_Init(void);
bit UartXSendFlag = 0; //UartX发送中断标志位
bit UartXReceiveFlag = 0; //UartX接收中断标志位
bit SPIXFlag = 0; //SPIX数据传输完成标志位
bit TWIXFlag = 0; //TWIX中断标志位
/*****************************************************
*函数名称：void USCIX_Test(void)
*函数功能：USCIX测试
*入口参数：void
*出口参数：void
*****************************************************/
void USCIX_Test(void)
{
USXINX = USCIX_Select; //USCIX寄存器指向对应的USCI
//判断三合一模式
#if (USCIX_Mode == UartX)
{
UARTX_Init(32, 9600); //初始化串口，输入主频和波特兰
while(1)
{
USXCON3 = 0xAA; //发送0xAA
while(!UartXSendFlag); //等待发送完成标志位置起
UartXSendFlag = 0; //清除发送标志位
}
}
#elif (USCIX_Mode == TWIX)
{
TWIX_Init();
while(1)
{
USXCON1 |= 0x20; //产生起始条件
while(!TWIXFlag);
TWIXFlag = 0;
USXCON3 = 0x10; //发送地址及写命令
while(!TWIXFlag);
TWIXFlag = 0;
USXCON3 = 0x55;
while(!TWIXFlag);
TWIXFlag = 0;
Delay(100);
USXCON1 |= 0x10; //发送结束信号
Delay(100);
}
}
#elif (USCIX_Mode == SPIX)
{
SPIX_Init();
while(1)
{
USXCON2 = 0xAA;
while(!SPIXFlag);
SPIXFlag = 0;
Delay(1000);
}
}
#endif
}
/*****************************************************
*函数名称：void UARTX_Init(uint Freq,unsigned long int baud)
*函数功能：UartX中断初始化
*入口参数：Freq-主频，baud-波特率
*出口参数：void
*****************************************************/
void UARTX_Init(uint Freq, unsigned long int baud)
{
TMCON |= 0xC0; //串行接口USCIX选择Uart通信
#if (USCIX_Select == USCI2)
P4CON &= ~0x30;
P4PH |= 0x30;
IE2 |= 0x02; //开启中断
#elif (USCIX_Select == USCI3)
P2CON &= ~0xC0;
P2PH |= 0xC0;
IE2 |= 0x04; //开启中断
#elif (USCIX_Select == USCI4)
P4CON &= ~0xC0;
P4PH |= 0xC0;
IE2 |= 0x08; //开启中断
#elif (USCIX_Select == USCI5)
P0CON &= ~0x0C;
P0PH |= 0x0C;
IE2 |= 0x10; //开启中断
#endif
USXCON0 = 0x50; //设置通信方式为模式一，允许接收
USXCON1 = Freq * 1000000 / baud; //波特率低位控制
USXCON2 = (Freq * 1000000 / baud) >> 8; //波特率高位控制
EA = 1;
}
/*****************************************************
*函数名称：void TWIX_Init(void)
*函数功能：TWIX初始化
*入口参数：void
*出口参数：void
*****************************************************/
void TWIX_Init(void)
{
TMCON |= 0x80; //串行接口USCIX选择TWI通信
#if (USCIX_Select == USCI2)
P4CON &= ~0x18;
P4PH |= 0x18;
IE2 |= 0x02; //开启中断
#elif (USCIX_Select == USCI3)
P2CON &= ~0x60;
P2PH |= 0x60;
IE2 |= 0x04; //开启中断
#elif (USCIX_Select == USCI4)
P5CON &= ~0x20;
P5PH |= 0x20;
P4CON &= ~0x70;
P4PH |= 0x70;
IE2 |= 0x08; //开启中断
#elif (USCIX_Select == USCI5)
P0CON &= ~0x06;
P0PH |= 0x06;
IE2 |= 0x10; //开启中断
#endif
TMCON |= 0x80; //选择TWIX模式
USXCON0 = 0x80; //主模式， 使能应答标志位
USXCON1 = 0x05; //---- xxxx x为时钟速率
IE2 |= 1 << (USCIX_Select - 1); //开启中断
EA = 1;
}
/*****************************************************
*函数名称：void SPIX_Init(void)
*函数功能：SPIX初始化
*入口参数：void
*出口参数：void
*****************************************************/
void SPIX_Init(void)
{
TMCON |= 0x40; //串行接口USCIX选择SPI通信
#if (USCIX_Select == USCI2)
P4CON &= ~0x38;
P4PH |= 0x38;
IE2 |= 0x02; //开启中断
#elif (USCIX_Select == USCI3)
P2CON &= ~0xE0;
P2PH |= 0xE0;
IE2 |= 0x04; //开启中断
#elif (USCIX_Select == USCI4)
P5CON &= ~0x20;
P5PH |= 0x20;
P4CON &= ~0xC0;
P4PH |= 0xC0;
IE2 |= 0x08; //开启中断
#elif (USCIX_Select == USCI5)
P0CON &= ~0x0E;
P0PH |= 0x0E;
IE2 |= 0x10; //开启中断
#endif
TMCON |= 0X40; //选择SPIX模式
USXCON0 = 0x3F; //设置SPIX为主设备，SCK空闲时间为高电平，SCK周期第二沿采集数据，时钟速率为Fsys/128
USXCON1 = 0x01; //MSB优先发送，8位传输，允许发送中断
USXCON0 |= 0x80; //开启SPIX
IE2 |= 1 << (USCIX_Select - 1); //开启中断
EA = 1;
}
#if (USCIX_Select == USCI2)
/*****************************************************
*函数名称：void TWI2/SPI2/UART2_Int() interrupt 7
*函数功能：USCI2中断函数
*入口参数：void
*出口参数：void
*****************************************************/
#if (USCIX_Mode == UartX)
void UART2_Int() interrupt 16 //UartX中断函数
{
if(USXCON0 & 0x02) //发送标志位判断
{
USXCON0 &= 0xFE;
UartXSendFlag = 1;
}
if((USXCON0 & 0x01)) //接收标志位判断
{
USXCON0 &= 0xFD;
UartXReceiveFlag = 1;
}
}
#elif (USCIX_Mode == TWIX)
void TWI2_Int() interrupt 16 //TWIX中断函数
{
if(USXCON0 & 0x40)
{
USXCON0 &= 0xbf; //中断清零
TWIXFlag = 1;
}
}
#elif (USCIX_Mode == SPIX)
void SPI2Int(void) interrupt 16 //SPIX中断函数
{
if(USXCON1 & 0X08) //发送缓存器空标志判断
{
USXCON1 &= ~0X08;
}
if(USXCON1 & 0X80) //数据传输标志位判断
{
USXCON1 &= ~0X80;
SPIXFlag = 1;
}
}
#endif
#elif (USCIX_Select == USCI3)
/*****************************************************
*函数名称：void TWI3/SPI3/UART3_Int() interrupt 7
*函数功能：USCI2中断函数
*入口参数：void
*出口参数：void
*****************************************************/
#if (USCIX_Mode == UartX)
void UART3_Int() interrupt 17 //UartX中断函数
{
if(USXCON0 & 0x02) //发送标志位判断
{
USXCON0 &= 0xFE;
UartXSendFlag = 1;
}
if((USXCON0 & 0x01)) //接收标志位判断
{
USXCON0 &= 0xFD;
UartXReceiveFlag = 1;
}
}
#elif (USCIX_Mode == TWIX)
void TWI3_Int() interrupt 17 //TWIX中断函数
{
if(USXCON0 & 0x40)
{
USXCON0 &= 0xbf; //中断清零
TWIXFlag = 1;
}
}
#elif (USCIX_Mode == SPIX)
void SPI3_Int(void) interrupt 17 //SPIX中断函数
{
if(USXCON1 & 0X08) //发送缓存器空标志判断
{
USXCON1 &= ~0X08;
}
if(USXCON1 & 0X80) //数据传输标志位判断
{
USXCON1 &= ~0X80;
SPIXFlag = 1;
}
}
#endif
#elif (USCIX_Select == USCI4)
/*****************************************************
*函数名称：void TWI4/SPI4/UART4_Int() interrupt 7
*函数功能：USCI2中断函数
*入口参数：void
*出口参数：void
*****************************************************/
#if (USCIX_Mode == UartX)
void UART4_Int() interrupt 18 //UartX中断函数
{
if(USXCON0 & 0x02) //发送标志位判断
{
USXCON0 &= 0xFE;
UartXSendFlag = 1;
}
if((USXCON0 & 0x01)) //接收标志位判断
{
USXCON0 &= 0xFD;
UartXReceiveFlag = 1;
}
}
#elif (USCIX_Mode == TWIX)
void TWI4_Int() interrupt 18 //TWIX中断函数
{
if(USXCON0 & 0x40)
{
USXCON0 &= 0xbf; //中断清零
TWIXFlag = 1;
}
}
#elif (USCIX_Mode == SPIX)
void SPI4_Int(void) interrupt 18 //SPIX中断函数
{
if(USXCON1 & 0X08) //发送缓存器空标志判断
{
USXCON1 &= ~0X08;
}
if(USXCON1 & 0X80) //数据传输标志位判断
{
USXCON1 &= ~0X80;
SPIXFlag = 1;
}
}
#endif
#elif (USCIX_Select == USCI5)
#if (USCIX_Mode == UartX)
void UART5_Int() interrupt 19 //UartX中断函数
{
if(USXCON0 & 0x02) //发送标志位判断
{
USXCON0 &= 0xFE;
UartXSendFlag = 1;
}
if((USXCON0 & 0x01)) //接收标志位判断
{
USXCON0 &= 0xFD;
UartXReceiveFlag = 1;
}
}
#elif (USCIX_Mode == TWIX)
void TWI5_Int() interrupt 19 //TWIX中断函数
{
if(USXCON0 & 0x40)
{
USXCON0 &= 0xbf; //中断清零
TWIXFlag = 1;
}
}
#elif (USCIX_Mode == SPIX)
void SPI5_Int(void) interrupt 19 //SPIX中断函数
{
if(USXCON1 & 0X08) //发送缓存器空标志判断
{
USXCON1 &= ~0X08;
}
if(USXCON1 & 0X80) //数据传输标志位判断
{
USXCON1 &= ~0X80;
SPIXFlag = 1;
}
}
#endif
#endif

156
Uart_Init.c Normal file
View File

@ -0,0 +1,156 @@
#include "H/Function_Init.H"
void Uart_Init(uint Freq,unsigned long int baud);
long Cclt_Power(uchar a, long b);
bit UartSendFlag = 0; //发送中断标志位
bit UartReceiveFlag = 0; //接收中断标志位
//乘方a幂，b底
long Cclt_Power(uchar a, long b)
{
uchar i;
long temp;
temp = 1;
for(i=0;i<a;i++)
temp = temp*b;
return temp;
}
/*****************************************************
*函数名称：void Uart_Test(void)
*函数功能：Uart测试
*入口参数：void
*出口参数：void
*****************************************************/
void Uart_Test(void)
{
Uart_Init(32,9600);
}
/*****************************************************
*函数名称：void Uart_Init(uint Freq,unsigned long int baud)
*函数功能：Uart中断初始化
*入口参数：Freq-主频，baud-波特率
*出口参数：void
*****************************************************/
void Uart_Init(uint Freq,unsigned long int baud) //选择Timer1作为波特率信号发生器
{
P2CON &= 0xFC; //TX/RX设置为输入带上拉
P2PH |= 0x03;
SCON |= 0X50; //设置通信方式为模式一，允许接收
TXCON |= 0X03; //UART0时钟来源为定时器1
TH1 = (Freq*1000000/baud)>>8; //波特率为T1的溢出时间；
TL1 = Freq*1000000/baud;
TR1 = 0; //SC95F761xB系列UARTO使用定时器1作为时钟源，TR1为0
ET1 = 0;
EUART = 1; //开启Uart中断
EA = 1;
}
/*
void Uart_Init(uint Freq,unsigned long int baud) //选择Timer2作为波特率信号发生器
{
P2CON &= 0xFC; //TX/RX设置为输入带上拉
P2PH |= 0x03;
SCON |= 0X50; //设置通信方式为模式一，允许接收
TXINX = 0x02;
TMCON |= 0X04;
TXMOD = 0X00;
TXCON = 0X30;
RCAPXH = Freq*1000000/baud/256;
RCAPXL = Freq*1000000/baud%256;
TRX = 0;
ET2 = 0;
EUART = 1; //开启Uart中断
EA = 1;
}
*/
/*****************************************************
*函数名称：void UartInt(void) interrupt 4
*函数功能：Uart中断函数
*入口参数：void
*出口参数：void
*****************************************************/
void UartInt(void) interrupt 4
{
if(TI) //UART0发送中断
{
TI = 0;
UartSendFlag = 1;
}
if(RI) //UART0接收中断
{
RI = 0;
UartReceiveFlag = 1;
}
}
void UART_SendByte(uchar Byte)//字节发送
{
SBUF = Byte;
while(!UartSendFlag);
UartSendFlag = 0;
}
void UART_SendLong(long Dat)//32位从高到低发送
{
uchar i;
uchar temp[4];
temp[0] = (Dat >> 24) & 0xFF;
temp[1] = (Dat >> 16) & 0xFF;
temp[2] = (Dat >> 8) & 0xFF;
temp[3] = Dat & 0xFF;
for(i=0;i<4;i++)
{
UART_SendByte(temp[i]);
}
}
void UART_Send_VOFA(long uart_buff)
{
uchar j;
uchar buff;
uchar vofa_buff[8];
bit negative=0;
if(uart_buff<0)//负数补码转源码
{
uart_buff=~uart_buff+1;
negative = 1;
}
for(j=0;j<8;j++)
{
vofa_buff[j] = (uart_buff % Cclt_Power(j+1,10)) / Cclt_Power(j,10);//16进制数转10进制，采用小端法存，低位在低字节
}
if(negative)
UART_SendByte(45);//输出负数
for(j=0;j<8;j++)
{
buff = vofa_buff[7-j]+48;//输出为字符串，需要先送高位
UART_SendByte(buff);
}
}
void UART_SendAll(long* Dat)//4个传感器原始数据都发送
{
uchar i,j;
uchar temp[4];
for(j=0;j<4;j++)
{
temp[0] = (Dat[j] >> 24) & 0xFF;
temp[1] = (Dat[j] >> 16) & 0xFF;
temp[2] = (Dat[j] >> 8) & 0xFF;
temp[3] = Dat[j] & 0xFF;
for(i=0;i<4;i++)
{
UART_SendByte(temp[i]);
}
}
}

138
main.c Normal file
View File

@ -0,0 +1,138 @@
/*
* Copyright (c) 2011 ITE Tech. Inc. All Rights Reserved.
*/
/**
* @author Jim Tan
* @version 1.0
*/
#include "H/Function_Init.H"
#define STANDAED_K 0.069849
#define Maxsize 3
/**************************************************************
传感器相关参数输入
#define Max_Weight 300000 //最大工作重量单位 g
#define Sensitivity 2 //灵敏度 mv/v
#define Ex_U 5 //激励电压,adc默认选择内部vcc为激励 v
#define ADC_PGA 128 //ADC芯片运放倍数
#define ADC_MAX_NUM 7FFFFF //ADC输出范围
STANDAED_K = (Ex_U/2/ADC_PGA/ADC_MAX_NUM) /(Sensitivity*Ex_U)*Max_Weight //为了避免精度丢失，请用计算器计算再手动输入
***************************************************************/
bit Key0_flag = 0;//全局变量，定义在Function_Init.H,这里赋初值
bit Key1_flag = 0;
/////////////中值滤波3
long Bubble_Sort_3(long* Data)
{
uchar i,j;
long temp;
for(i=0;i<2;i++)
{
for(j=0;j<2-i;j++)
{
if(Data[j]>Data[j+1])
{
temp = Data[j];
Data[j] = Data[j+1];
Data[j+1] = temp;
}
}
}
return Data[1];
}
void main(void)
{
//////////////该部分代码为采集ADC读数初始值 原始数据
// long read_buff[4];
//
// IO_Init();
// Uart_Test();
//
// CS1237_Init_all();//ADC初始化
// Delay_ms(300);//等待ADC芯片复位
// CS1237_Config_all();//ADC配置
//
// while(1)
// {
// for(i=0;i<4;i++)
// {
// send_buff[i] = zero_buff[i];
// }
// UART_SendAll(send_buff);
// }
//////////////该部分代码为采集并观察4路传感器的读数
long send_buff[4];
long zero_buff[4];
long data_buff[4];
long queue[4][3];
int queue_p;
float k = STANDAED_K; //传感器系数
long uart_buff[4]=0;
// uchar function_ret = 0;
// long zero_sort[9];
uchar i,j;
uchar a = 20; //一阶滤波系数，（1-100）越小越平滑，灵敏度越低 设置为50 1s就可以接近到千分之999 设置为20需要等待3s左右才能接近千分之999
IO_Init(); //IO初始化,先将默认的所有未使用引脚到设置成强推挽输出，
Uart_Test(); //串口初始化
Timer_Test(); //定时器初始化
CS1237_Init_all();//ADC初始化
Delay_ms(300);//等待ADC芯片建立时间
CS1237_Config_all();//ADC配置
for(i=0;i<4;i++)
{
zero_buff[i] = Read_CS1237_all(i);
send_buff[i] = zero_buff[i];
}
for(i=0;i<4;i++)
{
for(j=0;j<Maxsize;j++)
{
queue[i][j] = Read_CS1237_all(i);
}
}
while(1)
{
for(i=0;i<4;i++)
{
queue[i][queue_p] = Read_CS1237_all(i);
data_buff[i] = Bubble_Sort_3(queue[i]);
}
queue_p = (queue_p+1)%3;
for(i=0;i<4;i++)
{
send_buff[i] = ((100-a)*send_buff[i] + a*data_buff[i])/100; //一阶滤波
}
if(Key0_flag)//去皮，长按3s
{
Key0_flag=0;
for(i=0;i<4;i++)
{
zero_buff[i] = send_buff[i];
}
}
for(i=0;i<4;i++)
{
uart_buff[i] =(send_buff[i]-zero_buff[i])*k;
UART_Send_VOFA(uart_buff[i]);
if(i<3)
UART_SendByte(44);//','逗号分隔
}
UART_SendByte(10);//'\r'加回车符
UART_SendByte(13);//'\n'加换行符
}
}