STM32之智能家居

#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更新中断标志 
}
}