#include "stm32f10x.h"
#include "usart.h"
#include "rtc.h"
#include "IO.h"
#include "ds18b20.h"
#include "adc.h"
#include "exti.h"
#include "timer.h"
//#include "uart2.h"
#include "control.h"
#define Phz (u32)3*Pmax //功率频率值上限实际为3*Pmax/100;为了减少误差,放大100倍 此计算为500微欧采样电阻值
#define USART_IAP_LEN 10*1024+3 //定义最大接收字节数 10K+3字节 固件更新分3次接收
//IO方向设置
//#define DS18B20_IO_IN() {GPIOB->CRL&=0XFFFFFF0F;GPIOB->CRL|=0x00000080;} //PB1 CRL控制的是低8位 CRH控制的是高8位
//#define DS18B20_IO_OUT() {GPIOB->CRL&=0XFFFFFF0F;GPIOB->CRL|=0x00000030;}
//////////////////////////////////////////////////////////////////////////////////
//XXXX智能插座主程序
//author:WEN BO RUI (WEN K)
//Q:406650447
//修改日期:2014/5/16
//版本：V1.0
//Copyright(C) 沈阳XXXX公司 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
//u8 USART1_RX_BUF[USART_IAP_LEN] __attribute__ ((at(0X20001000)));//接收缓冲,最大USART_IAP_LEN个字节,起始地址为0X20001000.
u8 USART1_RX_BUF[USART_IAP_LEN]; //串口1数据接收缓冲字节
u8 rtcbuffer[8]={0}; //实时时钟数组
u16 flashBUF[512]; //定义FLASH存储参数缓存；共512*2=1024个字节，1K字节存储。因为STM32内部FLASH存取为半字(u16)读写，参数为功率和定时组合
u8 Param[204]; //204定义一个8位的参数数组，用于读取、写入参数到FLASH的转化；
u8 TEMPBUF[206]; //临时缓冲区数组
u8 T50F=0,T1000F=0,VDIF=0; //定时器T3定时100毫秒和1秒标志位，语音按键标志位
u8 t3count=0; //T3定时器计数器
u8 SREF=0,NREFLAG=0,GettimeF=0; //SREF串口接收服务器数据标志位;NREFLAG为恢复出厂状态标志位；GettimeF校时功能位
u8 overload = 0; //overload过载标志位，当等于1时表示过载，断继电器电源
u8 CRCF,HELLOF =0;; //数据累加和
u32 PSUM; //累积功率
u32 Pmax; //最大使用功率设置上限
u32 Pvio; //用于语音播放时时功率转换
u16 ADCValue;
u16 j1=0,pj=0;
u16 m,n;
u16 flashCN;
//u16 aplen1,iaplen2,iaplen3; //三段IAP长度
float ADtemp,ADJDQ; //检测继电器状态变量
u8 TEMH,TEML,TEM,V5H,V5L; //温度 电压检测值
struct
{
vu8 powstaF; //开关状态位，增加此变量可以用于服务器对继电器状态查询时返回开关状态，开关工作方式（off auto on）
vu8 runF;
vu8 pv1; //u8 pv1,pv2,pv3,pv4; //32位的功率变为4个8位的
vu8 pv2;
vu8 pv3;
vu8 pv4;
// vu8 yearTH; //上次清零功率时的时间
// vu8 yearTL;
// vu8 monT; //
// vu8 dateT;
// vu8 hourT;
// vu8 minT;
// vu8 secT;
// vu8 timT; //时区
}sta;
struct
{
u8 Time1;u8 Time2;u8 Time3;u8 Time4;
u8 Time5;u8 Time6;u8 Time7;u8 Time8;
}work; //定时操作结构体
void COM1SEND (u8 com1)
{
USART_SendData(USART1,com1);
while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
}
void send1()
{
COM1SEND(0x1e);
COM1SEND(0xba);
COM1SEND(0x00);
COM1SEND(0x00);
COM1SEND(CRCF);
}
//向串口发送一个字符串，strlen为该字符串长度
//void send_string_com1(u8 *str,u8 strlen)
//{
// u8 k=0;
// for(k=0;k<strlen;k++)
// {
// COM1SEND(*(str + k));
// }
//}
//CRC8校验函数
#define POLY 0xB2
unsigned crc8_slow(unsigned crc, unsigned char *data, size_t len)
{
unsigned char *end;
if (len == 0)
return crc;
crc ^= 0xff;
end = data + len;
do {
crc ^= *data++;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
} while (data < end);
return crc ^ 0xff;
}
void HELLO(void) //WIFI上电准备完成后发送消息给服务器
{
u8 i;
u8 inbuf1[32]={"hahahahahahahahahahahahahah00000"};
CRCF = 0;
TEMPBUF[0] = 0x24;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa1;
for(i=3;i<35;i++)
{
TEMPBUF=inbuf1[i-3];
}
TEMPBUF[35] = 0x00;
TEMPBUF[36] = 0x10;
TEMPBUF[37] = 0x00;
TEMPBUF[38] = 0x11;
CRCF=crc8_slow(CRCF,TEMPBUF,39);
send1(); //发送1e ba 00 00 crc
for(i=0;i<39;i++)
{
COM1SEND(TEMPBUF);
}
CRCF = 0;
}
void IDEL(void) //WIFI每分钟发送一次给服务器，防止链接断开
{
u8 i;
u8 idel1[7] = {0x04,0x00,0xa2,0x00,0x00,0x00,0x00}; //链接数据
CRCF = 0;
CRCF=crc8_slow(CRCF,idel1,7); //CRC8校验
send1();
for(i=0;i<7;i++)
{
COM1SEND (idel1);
}
}
void SHUTDOWN(void) //发送断电信息给服务器
{
u8 i;
u8 shut1[7] = {0x04,0x00,0xa3,0x00,0x00,0x00,0x00}; //断电数据
CRCF = 0;
CRCF=crc8_slow(CRCF,shut1,7); //CRC8校验
send1();
for(i=0;i<7;i++)
{
COM1SEND (shut1);
}
}
//*********************************************
//函数名: ONE_LINE(U16 COM_data)
//功能说明:发送一个一线串口命令
//入口参数:COM_data 为语音地址或者命令
//出口参数:无
//*********************************************
void ONE_LINE(u16 COM_data)
{
u8 i;
u8 high_data; //高八位
u8 low_data; //低八位
low_data = COM_data &0x00ff;
high_data = (COM_data>>8) & 0x00ff;
//while(!BUSY) //判断非忙，再发地址数据
{
DATA = 0;
delay_ms(5); //拉低数据线5毫秒
for(i=0;i<8;i++) //发送高八位
{
if(high_data &0x80) //数据位为 1
{
DATA = 1;
delay_us(600); //延时 600us
DATA = 0;
delay_us(200); //延时 200us
}
else //数据位为 0
{
DATA = 1;
delay_us(200); //延时 200us
DATA = 0;
delay_us(600); //延时 600us
}
high_data <<=1; //循环左移一位
}
for(i=0;i<8;i++) //发送低八位
{
if(low_data &0x80) //数据位为 1
{
DATA = 1;
delay_us(600); //延时 600us
DATA = 0;
delay_us(200); //延时 200us
}
else //数据位为 0
{
DATA = 1;
delay_us(200); //延时 200us
DATA = 0;
delay_us(600); //延时 600us
}
low_data <<=1; //循环左移一位
}
DATA =1;
}
}
//*************写参数到内部FLASH函数**************/
void FLASHWR()
{
u8 i,j = 0;
for(i=0;i<193;i+=2) //串口接收的数据存入16位的数组，准备写入FLASH
{
flashBUF[j] = ((Param&&0xff)<<8)+Param[i+1];
j++;
}
j = 0;
flashBUF[101] = PSUM; //当前功率累加值送入FLASH缓存，准备保存 小端在前
flashBUF[102] = PSUM>>16; //当前功率累加值送入FLASH缓存，准备保存
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
FLASH_ErasePage(0x800fc00); //先擦后写，FLASH存参数地址为从0x800fc00开始的1K字节；
for(flashCN=0;flashCN<128;flashCN++) //256字节数据
{
FLASH_ProgramHalfWord((0x800fc00 +flashCN*2),flashBUF[flashCN]); //flash 为一个字节存储，16位数据必须地址加2
}
FLASH_Lock();
}
//**************返回服务器全部参数设置状态函数*********************/
void STAall()
{
u8 i;
TEMPBUF[0] = 0xcb;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0xff;
TEMPBUF[4] = 0xff;
TEMPBUF[5] = sta.powstaF; //开关状态位
TEMPBUF[6] = sta.runF; //运行方式位
TEMPBUF[7] = Param[10]; //虚拟值
TEMPBUF[8] = Param[4]; //限制使用功率上限值
TEMPBUF[9] = Param[5];
TEMPBUF[10] = Param[6];
TEMPBUF[11] = Param[7];
TEMPBUF[12] = PSUM; //数据封装小端模式，低位在前
TEMPBUF[13] = PSUM>>8;
TEMPBUF[14] = PSUM>>16;
TEMPBUF[15] = PSUM>>24;
TEMPBUF[16] = Param[193]; //上次功率清零时间
TEMPBUF[17] = Param[194];
TEMPBUF[18] = Param[195];
TEMPBUF[19] = Param[196];
TEMPBUF[20] = Param[197];
TEMPBUF[21] = Param[198];
TEMPBUF[22] = Param[199];
for(i=11;i<193;i++) //本次设定值返回
{
TEMPBUF[i+12] = Param;
}
TEMPBUF[205] = Param[8]; //最后一个字节声音提示与否
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,206); //CRC8校验
send1(); //
for(i=0;i<206;i++) //本次设定值返回
{
COM1SEND(TEMPBUF);
}
CRCF = 0;
}
//**************软复位程序，用于固件更新重启单片机**********************/
void SoftReset(void) //软复位程序
{
__set_FAULTMASK(1); // 关闭所有中端
NVIC_SystemReset(); // 复位 以上两个函数位于 core_cm3.h 文件中
}
//********************主函数开始**********************/
int main(void)
{
//u8 inbuf1[10]={"opencloner"};
//u8 inbuf1[22]={"感谢使用XXXX智能插座\n"};
u8 i,j,Tchange,WifiF;
u8 FproV=0x78; //掉电时FLASH 写保护标识，防止多次写入
u8 FproT=0x78; //每天时间到了写次Flash，写保护标识，防止多次写入
u16 COM1F; //接收服务器数据状态查询字节
short TEM18B20;
u8 vdio[10]; //语音播报功率值时各个位置上的数值
//SCB->VTOR = FLASH_BASE | 0x1400; //使用IAP更新功能， VTOR寄存器存放的是新的中断向量表的起始地址复位从0x8001400开始
delay_init(); //延时函数初始化
IO_Init(); //GPIO初始化
NVIC_Configuration(); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
//uart2_Init(115200); //串口2初始化
RTC_Init(); //RTC初始化
EXTIX_Init(); //外部中断初始化
Adc_Init(); //ADC初始化
uart_init(115200);
DS18B20_Init();
TIM3_Init(249,7199); //10Khz的计数频率，计数到250为25ms Tout= ((249+1)*( 7199+1))/72=25000us=25ms
// RTC_Set(2014,6,10,10,36,10); //测试用，实际代码中要去掉
for(flashCN=0;flashCN<128;flashCN++) //上电后读取参数
{
flashBUF[flashCN]= *(u16*)(0x800f800 + flashCN*2); //读取FLASH数据
}
if(flashBUF[102] == 0xffff) //第一次上电读出，累积置零
{
flashBUF[101] = 0;
flashBUF[102] = 0;
}
j = 0;
PSUM =(flashBUF[102]<<16)+flashBUF[101]; //累积功率送PSUM 小端在前（低位在前）
for(i=0;i<102;i++)
{
Param[j] = flashBUF>>8; //高8位在前
Param[j+1] = flashBUF;
j+=2;
}
j = 0; //清j
if((Param[7]==0xff)||(Param[6]==0xff)||(Param[5]==0xff))
{
// Pmax = 1100; //如果功率使用上限为0XFF。认为没有设置，自动设置为默认为1100W(美国功率限制)
// Pmax = 2200; //自动设置为默认为2200W(中国功率限制)
Pmax = 2500; //考虑用户使用心理，设置可稍高些
Param[7] = 0; //功率设定值送给对应数组，留保存
Param[6] = 0;
Param[5] = Pmax>>8;
Param[4] = Pmax; //最低位在前
}
else
{
Pmax = (Param[7]<<24)+(Param[6]<<16)+(Param[5]<<8)+Param[4];//最大使用上限读出来
}
// Pmax = 300; //测试用，实际代码中要去掉
// Param[192]=0x08; //测试用，实际代码中要去掉
// Param[131]=0x07; //测试用，实际代码中要去掉
// Param[183]=0x06; //测试用，实际代码中要去掉
// Param[11]=0x05; //测试用，实际代码中要去掉
while(1)
{
//****************以下WiFi模块初始化完成程序*****暂时可以不用,上电一直循环发送HELLO给服务器*****************************************
// if((WifiRDY==0)&&(WifiF==0)) //WifiRDY为wifi模块的READY引脚，接STM32 IO引脚 ，上拉输入
// { //当为低电平时WIFI模块上电正常
// WifiF = 1; //发送一次后不再发送
// HELLO(); //发送给服务器进行握手，
// }
// if(WifiRDY) //WifiRDY=1表示高电平;表示WIFI模块断了;这时清WifiF，为了下一次握手
// {
// WifiF = 0; //清WifiF
// }
//****************以下恢复出厂状态处理程序*************************************************
if(NREFLAG) //如果恢复出厂状态标志位被置高了
{
NREFLAG = 0;
TEMPBUF[0] = 0x01;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa5;
TEMPBUF[3] = 0x03;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,4); //CRC8校验
send1();
for(i=0;i<4;i++)
{
COM1SEND(TEMPBUF); //过载信息发给服务器
}
for(i=0;i<128;i++) //将0xffff，准备写入FLASH
{
flashBUF = 0xffff;
}
flashBUF[101] = 0; //功率参数直接清零
flashBUF[102] = 0;
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
FLASH_ErasePage(0x800fc00); //先擦后写，FLASH存参数起始地址
for(flashCN=0;flashCN<128;flashCN++) //256字节数据
{
FLASH_ProgramHalfWord((0x800fc00 +flashCN*2),flashBUF[flashCN]); //flash 为一个字节存储，16位数据必须地址加2
}
FLASH_Lock();
delay_ms(10);
for(flashCN=0;flashCN<128;flashCN++) //延时一段时间后读取参数
{
flashBUF[flashCN]= *(u16*)(0x800f800 + flashCN*2); //读取FLASH数据
}
j = 0;
for(i=0;i<102;i++)
{
Param[j] = flashBUF>>8; //高8位在前
Param[j+1] = flashBUF;
j+=2;
}
j = 0;
}
//****************以下接收服务器指令处理程序***********************************************
switch(SREF)
{
case 0xB1: //SERVER_WELCOME 服务器欢迎数据 当前固定为 "opencloner"+时间
{
SREF = 0; //暂无内容返回（PLUG主动发HELLO给服务器，服务器返回这个数据包，PLUG不在发送数据）
HELLOF = 1; //服务器收到插座的HELLO，返回相应值，职位HELLOF,插座不再发HELLO函数
STAall(); //返回所有状态
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
break;
case 0xB2: //SERVER_INQUIRY状态查询（PLUG收到查询请求后需要根据数据位标识码返回PLUG_STATUS）
{
SREF = 0;
COM1F = (USART1_RX_BUF[3]<<8)+USART1_RX_BUF[2]; //两个字节的Mask标志位，低位在前高位在后；如0x01;接收的位01,00
switch(COM1F)
{
case 0xffff: //所有状态查询 (已OK)
{
STAall(); //返回所有状态
}break;
case 0x01: //开关状态查询，开还是关(已OK)
{
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x01;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = sta.powstaF;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x02: //开关运行方式查询，一直开。自动，一直关
{
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x02;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = sta.runF;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x03: //开关状态和运行方式查询，一直开。自动，一直关(已OK)
{
TEMPBUF[0] = 0x04;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x03;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = sta.powstaF;
TEMPBUF[6] = sta.runF;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,7); //CRC8校验
send1();
for(i=0;i<7;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x04: //虚拟设定值 (已OK)
{
//位于flashBUF[5]的高8位--->Param[10]
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x04;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = Param[10];
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x08: //限制功率上限值 (具体值及相应功能程序未完成)
{
TEMPBUF[0] = 0x06;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x08;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = Param[4];
TEMPBUF[6] = Param[5];
TEMPBUF[7] = Param[6];
TEMPBUF[8] = Param[7];
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,9); //CRC8校验
send1();
for(i=0;i<9;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x10: //当前累积电量查询 (已OK)
{
TEMPBUF[0] = 0x06;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x10;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = PSUM;
TEMPBUF[6] = PSUM>>8;
TEMPBUF[7] = PSUM>>16;
TEMPBUF[8] = PSUM>>24;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,9); //CRC8校验 需加上数据长度两字节和标志位1字节
send1();
for(i=0;i<9;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x20: //定时数据状态 (具体值及相应功能程序也已经完成)
{
TEMPBUF[0] = 0x7b; //123个字节
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x20;
TEMPBUF[4] = 0x00;
for(i=11;i<132;i++) //定时数据从Param[11]到Param[131]
{
TEMPBUF[i-6]= Param;
}
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,126); //CRC8校验需加上数据长度两字节和标志位1字节
send1();
for(i=0;i<126;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x40: //温度设定状态返回是否有效位+温控数据 （已OK）
{
TEMPBUF[0] = 0x33; //51个字节
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x40;
TEMPBUF[4] = 0x00;
for(i=132;i<184;i++) //定时数据从Param[11]到Param[131]
{
TEMPBUF[i-127]= Param;
}
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,54); //CRC8校验 需加上数据长度两字节和标志位1字节
send1();
for(i=0;i<54;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x80: //???没明白是什么意思时间设定有效否，返回是否有效位
{
//位于flashBUF[92]的高8位字节--->Param[184] 暂定时区设定
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x80;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = Param[184];
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x100: //声音设定有效否 (已完成)
{
//位于flashBUF[4]的高8位字节--->Param[8]
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x00;
TEMPBUF[4] = 0x10;
TEMPBUF[5] = Param[8];
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}break;
case 0x200: //是否时间自动校正
{
//时间自动校正位于flashBUF[97]的高8位字节--->Param[192]
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x00;
TEMPBUF[4] = 0x20;
TEMPBUF[5] = Param[192];
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}break;
}
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
break;
case 0xB3: //SERVER_SWITCH（服务器发送此指令进行开关操作， plug收到后返回PLUG_STATUS（数据位mask=01））
{
SREF = 0;
if(USART1_RX_BUF[2]==1)
{
sta.powstaF = 1; //继电器状态查询时返回开关状态 1表示吸合 0断开
AUTO = 1; //开继电器
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x01;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = sta.powstaF;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}
if(!USART1_RX_BUF[2])
{
sta.powstaF = 0; //继电器状态查询时返回开关状态 1表示吸合 0断开
AUTO =0; //关继电器
TEMPBUF[0] = 0x03;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa4;
TEMPBUF[3] = 0x01;
TEMPBUF[4] = 0x00;
TEMPBUF[5] = sta.powstaF;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,6); //CRC8校验
send1();
for(i=0;i<6;i++)
{
COM1SEND(TEMPBUF);
}
}
USART_ITConfig(USART1,USART_IT_RXNE, ENABLE);
}
break;
case 0xB4: //SERVER_SETUP（参数设置）
{
SREF = 0;
for(i=0;i<193;i++) //串口接收的数据存入16位的数组，准备写入FLASH
{
Param = USART1_RX_BUF;
}
STAall(); //发送所有参数给服务器
Pmax = (Param[7]<<24)+(Param[6]<<16)+(Param[5]<<8)+Param[4];//最大使用上限读出来
//FLASHWR(); //参数写入FLASH
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启串口中断
}
break;
case 0xB5: //SERVER_UPGRADE（固件升级，暂未调试）
{
SREF = 0;
if(USART1_RX_BUF[2]==0x01) //第一段升级程序，一共三段
{
// USART1_RX_BUF[1023]=0x01; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[1024]=0x02; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[1025]=0x03; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[1026]=0x04; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[2049]=0x05; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[2050]=0x06; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[3073]=0x09; //测试用，正常程序屏蔽掉
// USART1_RX_BUF[3074]=0x0a; //测试用，正常程序屏蔽掉
//iaplen1 = USART1_RX_BUF[0]; //长度取过来,暂时未用
//第一段写入地址为0x08008800~0x0800afff(10k字节)
for(i=0;i<10;i++) //写10次
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
m=0;
FLASH_ErasePage(0x8008800+i*1024); //先擦后写，每次擦除一页地址(1K);擦10K;FLASH存参数起始地址
for(n=0;n<1024;n+=2) //串口接收的数据存入16位的数组，准备写入FLASH
{
flashBUF[m] = (USART1_RX_BUF[n+4+i*1024]<<8)+USART1_RX_BUF[n+3+i*1024];
m++;
}
m = 0;
for(flashCN=0;flashCN<512;flashCN++) //10k字节数据,分10次写入，每次写1K，因为RAM不够
{
FLASH_ProgramHalfWord((0x8008800 +flashCN*2+i*1024),flashBUF[flashCN]);//flash 为一个字节存储，16位数据必须地址加2
}
FLASH_Lock();
}
}
if(USART1_RX_BUF[2]==0x02) //第二段升级程序，一共三段
{
//iaplen2 = USART1_RX_BUF[0]; //长度取过来
//第二段写入地址为0x0800b000~0x0800d7ff(10k字节)
for(i=0;i<10;i++) //写10次
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
m=0;
FLASH_ErasePage(0x800b000+i*1024); //先擦后写，每次擦除一页地址(1K);擦10K;FLASH存参数起始地址
for(n=0;n<1024;n+=2) //串口接收的数据存入16位的数组，准备写入FLASH
{
flashBUF[m] = (USART1_RX_BUF[n+4+i*1024]<<8)+USART1_RX_BUF[n+3+i*1024];
m++;
}
m = 0;
for(flashCN=0;flashCN<512;flashCN++) //10k字节数据,分10次写入，每次写1K，因为RAM不够
{
FLASH_ProgramHalfWord((0x800b000 +flashCN*2+i*1024),flashBUF[flashCN]);//flash 为一个字节存储，16位数据必须地址加2
}
FLASH_Lock();
}
for(m=0;m<USART_IAP_LEN;m++) //第二次接收完后把串口缓存全部置为0xff,防止第三次接收后
{ //接收的不是整K的长度，写到FLASH的值不定
USART1_RX_BUF[m]=0xff;
}
}
if(USART1_RX_BUF[2]==0x03) //第三段升级程序，一共三段
{
//iaplen3 = USART1_RX_BUF[0]; //长度送过来
//第3段写入地址为0x0800d800~0x0800fbff(9k字节)
for(i=0;i<9;i++) //写9次
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
m=0;
FLASH_ErasePage(0x800d800+i*1024); //先擦后写，每次擦除一页地址(1K);擦10K;FLASH存参数起始地址
for(n=0;n<1024;n+=2) //串口接收的数据存入16位的数组，准备写入FLASH
{
flashBUF[m] = (USART1_RX_BUF[n+4+i*1024]<<8)+USART1_RX_BUF[n+3+i*1024];
m++;
}
m = 0;
if(i==8) //最后一次写入时，置一个更新标志位存到FLASH
{
flashBUF[511]=0x7777; //地址0x0800fbff存入0x77，以便IAP判断
}
for(flashCN=0;flashCN<512;flashCN++) //9k字节数据,分9次写入，每次写1K，因为RAM不够
{
FLASH_ProgramHalfWord((0x800d800 +flashCN*2+i*1024),flashBUF[flashCN]);//flash 为一个字节存储，16位数据必须地址加2
}
FLASH_Lock();
}
TEMPBUF[0] = 0x01; //第三次写完后发送准备固件更新消息
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa5;
TEMPBUF[3] = 0x04;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,4); //CRC8校验
send1();
for(i=0;i<4;i++) //准备固件更新信息返回服务器
{
COM1SEND(TEMPBUF);
}
SoftReset(); //接收和存储完固件更新文件后软复位程序，转IAP程序开始更新，
}
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
break;
case 0xB6: //SERVER_TIME，用于回应plug的PLUG_TIME指令。
{
SREF = 0;
COM1F = (USART1_RX_BUF[4]<<8)+USART1_RX_BUF[3]; //USART1_RX_BUF[1]是标志位0XB6;USART1_RX_BUF[2]接收的是时区，
//所以时间从USART1_RX_BUF[3]开始 3,4为年份需合并成16位的格式
GettimeF = 1; //低字节在前，高字节在后，如2014年=07DE,接收顺序为DE 07
RTC_Set(COM1F,USART1_RX_BUF[5],USART1_RX_BUF[6],USART1_RX_BUF[7],USART1_RX_BUF[8],USART1_RX_BUF[9]);
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
break;
case 0xB7: //SERVER_IDLE，用于回应plug的PLUG_IDLE,无实际意义。
{
SREF = 0;
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
break;
case 0xB8: //用于接收手机端设置的一些定时参数。
{
SREF = 0;
for(i=0;i<193;i++) //串口接收的数据存入16位的数组，准备写入FLASH
{
Param = USART1_RX_BUF;
}
STAall(); //发送所有参数给服务器
Pmax = (Param[7]<<24)+(Param[6]<<16)+(Param[5]<<8)+Param[4];//最大使用上限读出来
TEMPBUF[0] = 0x01;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa5;
TEMPBUF[3] = 0x05;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,4); //CRC8校验
send1();
COM1SEND(0x01);
COM1SEND(0x00);
COM1SEND(0xa5); //返回服务器PLUG_ALERM 返回05 告知本地设置改变
COM1SEND(0x05);
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
break;
default:
{
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}break;
}
//****************以下过载报警程序********************************************
if(overload) //过载标志
{
overload = 0;
AUTO = 0; //关掉继电器
TEMPBUF[0] = 0x01;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa5;
TEMPBUF[3] = 0x01;
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,4); //CRC8校验
send1();
COM1SEND(0x01);
COM1SEND(0x00);
COM1SEND(0xa5); //返回服务器PLUG_ALERM 返回01 告知过载
COM1SEND(0x01);
}
//****************以下语音模块处理程序,地址1~9存放的数字1~9语音，地址10存放“0”语音,*******************************************
if(VDIF == 1) //语音按键标志位等于1播放当前时刻
{ //
// ONE_LINE(0x0B); //地址11存放的”当前时刻“语句
// delay_ms(180); //经验时间，等待BUSY变成1
// while(BUSY); //一直等待上个语句播放完成
ONE_LINE(0x02); //播放下一条语句
delay_ms(180);
while(BUSY); //一直等待上个语句播放完成
ONE_LINE(0x01);
VDIF = 0;
}
if(VDIF == 2) //语音按键标志位等于2播放当前已消耗功率
{
vdio[0] = PSUM/1000000000; //最高位(第10位)数值
Pvio = PSUM-vdio[0]*1000000000;
vdio[1] = Pvio/100000000; //(第9位)数值
Pvio = Pvio-vdio[1]*100000000;
vdio[2] = Pvio/10000000; //(第8位)数值
Pvio = Pvio-vdio[2]*10000000;
vdio[3] = Pvio/1000000; //(第7位)数值
Pvio = Pvio-vdio[3]*1000000;
vdio[4] = Pvio/100000; //(第6位)数值
Pvio = Pvio-vdio[4]*100000;
vdio[5] = Pvio/10000; //(第5位)数值
Pvio = Pvio-vdio[5]*10000;
vdio[6] = Pvio/1000; //(第4位)数值
Pvio = Pvio-vdio[6]*1000;
vdio[7] = Pvio/100; //(第3位)数值
Pvio = Pvio-vdio[7]*100;
vdio[8] = Pvio/10; //(第2位)数值
Pvio = Pvio-vdio[8]*10;
vdio[9] = Pvio%10; //(第1位)数值
ONE_LINE(0x0c); //地址12存放的“已使用功率“语音
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
if(vdio[0]) //最高位不为0;从最高位播放
{
for(i=0;i<10;i++)
{
ONE_LINE(vdio); //播放最高位
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else //最高位为0，判断第9位，以此类推
{
if(vdio[1]) //最9位不为0;从9位播放
{
for(i=1;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[2]) //最8位不为0;从8位播放
{
for(i=2;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[3]) //最7位不为0;从7位播放
{
for(i=3;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[4]) //最6位不为0;从6位播放
{
for(i=4;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[5]) //最5位不为0;从5位播放
{
for(i=5;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[6]) //最4位不为0;从4位播放
{
for(i=6;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[7]) //最3位不为0;从3位播放
{
for(i=7;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
if(vdio[8]) //最2位不为0;从2位播放
{
for(i=8;i<10;i++)
{
ONE_LINE(vdio); //播放
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
else
{
ONE_LINE(vdio[9]); //播放第一位
delay_ms(180); //经验时间，等待BUSY变成1
while(BUSY);
}
}
}
}
}
}
}
}
}
VDIF = 0; //清播放标志位
}
//***************以下电压采集及断电处理程序25毫秒检测一次***********************************************
if(T50F) //目前25毫米取一次AD采样值，用以判断是否断电
{ //小于4.75V认为出现断电或异常，保存参数，送出警告
T50F = 0;
ADCValue = Get_Adc_Average(ADC_Channel_1 ,3); //采集3次取平均值 为了减少损耗时间
ADtemp = (float)ADCValue*(3.3/4096);
V5H = ADtemp;
V5L = (ADtemp-V5H)*100;
if(ADtemp<=1.87) //小于4.75V认为出现断电或异常，保存参数，送出警告
{ //正常时1.90，差0.03V
SHUTDOWN(); //发送断电信息给服务器
if(FproV==0x78) //Fprotect==0x78，才写入一次FLASH,
{ //防止断电延迟时间过长，多次写入FLASH
// FLASHWR(); //参数写入FLASH
FproV = 0; //写入一次后不再写入，重上电后恢复。
}
}
}
//***************以下读取时间,温度,继电器工作状态检测,定时处理及发送程序********************************************
if(T1000F) //定时1秒时间读次时间，温度并发送给服务器
{ //清除标志位
T1000F = 0;
//****************以下开启校时模式程序**********************************************
if((Param[192]==1)&&(GettimeF==0)) //是否需要校时，接收到服务器的校时数据后，置位GettimeF ，不再发送申请命令
{ //
TEMPBUF[0] = 0x01;
TEMPBUF[1] = 0x00;
TEMPBUF[2] = 0xa6;
TEMPBUF[3] = Param[184];
CRCF = 0;
CRCF=crc8_slow(CRCF,TEMPBUF,4); //CRC8校验
send1();
COM1SEND(0x01);
COM1SEND(0x00);
COM1SEND(0xa6);
COM1SEND(Param[184]);
}
//****************以下获取温度程序**********************************************
TEM18B20=DS18B20_Get_Temp(); //获取温度
if(TEM18B20<0)
{
TEM18B20=-TEM18B20; //转为正数
TEM = 1; //表示负温度
}
else
{
TEM = 0;
}
TEMH = TEM18B20/10; //显示正数部分
TEML = TEM18B20%10; //显示小数部
//******继电器工作方式检测
ADCValue = Get_Adc_Average(ADC_Channel_7 ,5); //ADC 7通道采集5次继电器控制端电压
ADJDQ = (float)ADCValue*(3.3/4096);
if(ADJDQ>3.2) //大于3.2V工作在自动运行的吸合状态
{
if(WifiRDY==0) //WiFi正常
{
LEDR = 0; //wifi正常且继电器有输出，红灯亮
LEDG = 1;
}
if(WifiRDY) //WiFi异常
{
LEDR = ~LEDR; //wifi异常且继电器有输出，红灯闪
LEDG = 1;
}
sta.powstaF = 1; //继电器状态查询时返回开关状态 1表示吸合 0断开
sta.runF = 1; //继电器运行方式 1表示自动运行
}
if(ADJDQ<0.2) //小于0.2V工作在自动运行的断开状态
{
if(WifiRDY==0) //WiFi正常
{
LEDR = 1; //wifi正常且继电器无输出，绿灯亮
LEDG = 0;
}
if(WifiRDY) //WiFi异常
{
LEDR = 1; //wifi异常且继电器无输出，绿灯闪
LEDG = ~LEDG;
}
sta.powstaF = 0; //增加此变量可以用于服务器对继电器状态查询时返回开关状态
sta.runF = 1; //继电器运行方式 1表示自动运行
}
if((ADJDQ>2.8)&&(ADJDQ<3.1)) //工作在一直吸合状态 LED指示灯为橙色
{
LEDR=LEDG=0; //橙色
sta.powstaF = 1; //增加此变量可以用于服务器对继电器状态查询时返回开关状态
sta.runF = 0; //继电器运行方式 0常闭状态
}
if((ADJDQ>0.3)&&(ADJDQ<0.6)) //工作在一直断开状态
{
sta.powstaF = 0; //增加此变量可以用于服务器对继电器状态查询时返回开关状态
sta.runF = 2; //继电器运行方式 2表示常开状态
}
//RTC读取及处理
RTC_Get(); //获取时间
rtcbuffer[0]=calendar.w_year/0xff; //年份的高8位
rtcbuffer[1]=calendar.w_year; //年份的低8位
rtcbuffer[2]=calendar.w_month;
rtcbuffer[3]=calendar.w_date;
rtcbuffer[4]=calendar.hour;
if(calendar.min!=rtcbuffer[5]) //如果分钟变了；
{
Tchange = 1; //每分钟发次IDEL();给服务器，防止链接断开
}
rtcbuffer[5]=calendar.min;
rtcbuffer[6]=calendar.sec;
rtcbuffer[7]=calendar.week;
if((rtcbuffer[4]==0x13)&&(FproT==0x78)) //每天19点写一次FLASH，保护参数。
{
FLASHWR();
FproT = 0;
}
if(Tchange) //每分钟发次IDEL();给服务器，防止链接断开
{
Tchange = 0;
IDEL();
}
//**********定时开关检测***************************
if(Param[11]==1) //定时开关使能
{
timeJC(work.Time1,12); //Param[12]~Param[26]
timeJC(work.Time2,27); //Param[27]~Param[41]
timeJC(work.Time3,42); //Param[42]~Param[56]
timeJC(work.Time4,57); //Param[57]~Param[71]
timeJC(work.Time5,72); //Param[72]~Param[86]
timeJC(work.Time6,87); //Param[87]~Param[101]
timeJC(work.Time7,102); //Param[102]~Param[116]
timeJC(work.Time8,117); //Param[117]~Param[131]
}
//**********温度开关简单模式使能********************
if(Param[132]==1)
{
Tsimple(133);
}
//**********温度开关编程模式使能********************
if(Param[132]==2)
{
Tprog(136);
Tprog(142);
Tprog(148);
Tprog(154);
Tprog(160);
Tprog(166);
Tprog(172);
Tprog(178);
}
// sta.pv4 = PSUM; //低8位
// sta.pv3 = PSUM>>8;
// sta.pv2 = PSUM>>16;
// sta.pv1 = PSUM>>24;
// for(i=0;i<8;i++)
// {
// COM1SEND (rtcbuffer);
// }
// COM1SEND(V5H);
// COM1SEND(V5L);
// COM1SEND((j1>>8));
// COM1SEND(j1);
// COM1SEND(PSUM>>24);
// COM1SEND(PSUM>>16);
// COM1SEND(PSUM>>8);
// COM1SEND(PSUM);
if(!HELLOF) //如果服务器未返回值一直发送HELLO函数
{
HELLO();
}
COM1SEND((j1>>8));
COM1SEND(j1);
COM1SEND(PSUM>>24);
COM1SEND(PSUM>>16);
COM1SEND(PSUM>>8);
COM1SEND(PSUM);
// COM1SEND (PSUM);
// COM1SEND (PJ);
// COM1SEND (overload);
// COM1SEND (FproV); //读Flash，用于测试
// COM1SEND (FproT); //读Flash，用于测试
// COM1SEND (aj); //读Flash，用于测试
COM1SEND (*(u8*)(0x8008800)); //读Flash，用于测试
COM1SEND (*(u8*)(0x8008801));
COM1SEND (*(u8*)(0x8008bfc)); //读Flash，用于测试
COM1SEND (*(u8*)(0x8008bfd)); //读Flash，用于测试
COM1SEND (*(u8*)(0x8008bfe));
COM1SEND (*(u8*)(0x8008bff)); //读Flash，用于测试
COM1SEND (*(u8*)(0x8008ffe)); //读Flash，用于测试
COM1SEND (*(u8*)(0x8008fff)); //读Flash，用于测试
COM1SEND (*(u8*)(0x80093fe)); //读Flash，用于测试
COM1SEND (*(u8*)(0x80093ff));
COM1SEND (*(u8*)(0x800fbfe));
COM1SEND (*(u8*)(0x800fbff));
}
}
}
void USART1_IRQHandler(void) //串口1中断服务程序
{
static u8 receY=0,i=0;
static u16 j=0,LEN = 0;
static u8 Rav[7];
//static u8 k=0;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断
{
USART_ClearITPendingBit(USART1,USART_IT_RXNE); //清除中断标志
if((i<7)&&(receY==0)) //接受完数据包头1E BA 00 00 和CRC 和数据长度（7个字节）
{
Rav=USART_ReceiveData(USART1); //读取接收到的首字节数据
if((Rav[0]==0x1E)) //首字节为0X00;
{
i++; //
if((Rav[1]==0xBA))
{
if((Rav[2]==0x00))
{
if((Rav[3]==0x00))
{
if(i == 7)
{
i = 0;
receY = 1; //是要接收的数据包
LEN = Rav[6];
LEN=(LEN<<8)+Rav[5]+2; //获得数据长度值 数据包长度需加2，因为紧跟着的标识位没算数据长度而且后续接收j先加1了
//LEN = ((Rav[5]&0x00ff)<<8)+Rav[6]+2; //而且数据长度的低字节当receY有效时，紧接着又送一遍到USART_RX_BUF[0]
// for(k=0;k<7;k++)
// {
// Rav = 0xaf;
// }
}
}
}
}
if(i==7){i = 0;} //i加到5，确没有被清零，表明接收到错误数据，自动清零
}
}
if(receY) //开始接收数据包
{
USART1_RX_BUF[j]=USART_ReceiveData(USART1);
if(j<LEN)
{
j++;
}
if(j==LEN) //接收完成,开始处理数据
{
SREF = USART1_RX_BUF[1]; //标识位送REVF
USART1_RX_BUF[0] = LEN-3; //为了得到固件更新时每次的数据长度 减去开头重复接收的一个数据，标识位及包标识位
j = 0; //这样USART1_RX_BUF[0]为数据长度，USART1_RX_BUF[1]为标识
receY = 0; //USART1_RX_BUF[2]为第几包，后面为更新的数据
LEN = 0;
USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); //关闭接收中断
}
}
}
if(USART_GetFlagStatus(USART1,USART_FLAG_ORE) == SET) //溢出
{
USART_ClearFlag(USART1,USART_FLAG_ORE); //读SR
USART_ReceiveData(USART1); //读DR
}
USART_ReceiveData(USART1);
}
//外部中断5-9服务程序
void EXTI9_5_IRQHandler(void)
{
//static u16 j1;
j1++;
pj++;
if(j1==130) //1300个脉冲对应1W 6毫欧时为1300;500微欧为110个脉冲
{
j1 = 0;
PSUM++; //一个脉冲到来时1W功率
}
EXTI_ClearITPendingBit(EXTI_Line9); //清除LINE9上的中断标志位
}
//外部中断10-15服务程序
void EXTI15_10_IRQHandler(void)
{
static u8 av;
av++;
if(av == 1)
{
VDIF = 1;
}
if(av == 2)
{
av = 0;
VDIF = 2;
}
EXTI_ClearITPendingBit(EXTI_Line13); //清除LINE13上的中断标志位
}
//定时器3中断服务程序
void TIM3_IRQHandler(void) //TIM3中断 25毫秒中断
{
static u8 Pcount,nrecount;
if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET) //检查TIM3更新中断发生与否
{
T50F = 1;
t3count++;
Pcount++; //功率判断开始计时，1秒
LEDG = ~LEDG;
if(Pcount==39) //1秒到了
{
Pcount = 0;
if((pj*100) >Phz) //判断PJ的计数值是否超过预设功率上限对应的参数
{
overload = 1; //超过则认为过载
}
pj = 0; //清除该计数为了下一次判断
}
if(NRE==0) //出厂设置键被按下
{
nrecount++;
if(nrecount>121)
{
nrecount = 0;
NREFLAG = 1; //置高恢复出厂状态标志位
}
}
else nrecount = 0; //按键未按下或时间不到抬起了，清计数器
if(t3count==200) //5秒时间
{
t3count = 0;
T1000F = 1;
LEDR = ~LEDR;
}
TIM_ClearITPendingBit(TIM3, TIM_IT_Update ); //清除TIMx更新中断标志
}
}
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂