单片机如何添加定时上报继电器状态功能?

ID:137005 · 发表于 2021-2-4 17:50

各位好，附件想增加定时上报继电器状态功能，需要怎么添加？我自己添加了定时器3代码打印一个状态，但串口只出现AA，然后就死了。请各位指导，看怎么添加定时上报继电器状态功能，谢谢！
void Init_Timer3(void)             //1000微秒@11.0592MHz
{
      T4T3M |= 0x02;             //定时器时钟1T模式
      T3L = 0xCD;             //设置定时初值
      T3H = 0xD4;             //设置定时初值
      T4T3M |= 0x08;             //定时器3开始计时
      IE2 = ET3;                               //使能定时器中断
      EA = 1;
}

void Timer3_isr(void) interrupt 19
{
  unsigned char buf[10];
  unsigned char len=0;
  static INT16U tmr500ms = 0;
  tmr500ms++;
      if(tmr500ms >= 10000)
                                    {
         tmr500ms = 0;
                              buf[0]=0xAA;
                              buf[1]=addr;
                              buf[2]=0xFF;
                              buf[3]=0xFF;
                              buf[4]=0xBB;
                              len=5;
                              UartWrite(buf, len);
                              T3L = 0xCD;             //设置定时初值
                              T3H = 0xD4;             //设置定时初值
                                    }
}
main也添加了       Init_Timer3();

ID:213173 · 发表于 2021-2-4 17:50

由于此标志是放在串口接收中断函数中等发送完成后置位 flagTxd = 1; 楼主在定时器3中断函数中调用UartWrite(buf, len);是等不到 flagTxd = 1，所以只发送一个字节后就死在while (!flagTxd); 。
在不改变原代码的情况下可以另写一个串口发送函数供定时器3中断函数中调用。不过开定时器3似乎多余，完全可以在定时器0里增加一个标志，在主循环中定时发送上报继电器状态。

ID:390416 · 发表于 2021-2-5 08:47

串口打印你必须使用我们这种框架式编程方式，千万不能有死等。
http://www.51hei.com/bbs/dpj-201660-1.html

ID:871393 · 发表于 2021-2-5 09:35

是不是串口发送没有等待发送完成标志位呢

ID:752974 · 发表于 2021-2-5 09:39

波特率是多少？1个毫秒内能发送完这些数据吗！

ID:752974 · 发表于 2021-2-5 10:14

波特率是多少？一个毫秒时间内能发送完这些数据吗！设计程序时有一个问题要特别注意，就是中断服务程序越精简越好，不要在中断服务程序中处理数据。对于定时器定时中断，中断时间内必须能完成中断服务程序的执行。

ID:811405 · 发表于 2021-2-6 11:03

继电器状态变化导致串口通讯出错

ID:137005 · 发表于 2021-2-6 15:13

wulin 发表于 2021-2-6 08:34
由于此标志是放在串口接收中断函数中等发送完成后置位 flagTxd = 1; 楼主在定时器3中断函数中调用UartWrit ...

应该是这样的，我换成LED灯就可以，但换成串口就不行。能示例一下，在定时器0怎么添加实现上报继电器功能吗？

ID:213173 · 发表于 2021-2-6 21:08

molo 发表于 2021-2-6 15:13
应该是这样的，我换成LED灯就可以，但换成串口就不行。能示例一下，在定时器0怎么添加实现上报继电器功能 ...

在定时器0里增加一个10秒标志flag，在主循环中添加Report()函数，定时发送上报继电器状态。

#include <STC8F2K08S2.h>
#include <intrins.h>
#define uchar unsigned char//宏定义无符号字符型
#define uint unsigned int //宏定义无符号整型
typedef unsigned char INT8U;
typedef unsigned int INT16U;
#define ENABLE_ISP 0x82 //系统工作时钟<20MHz 时，对IAP_CONTR 寄存器设置此值
#define WD1 0x5a //使用STC11xx系列单片机时，先写入0x5a，然写入0xa5
#define WD2 0xa5
char IAPAddr=0;
unsigned char T0RH = 0; //T0重载值的高字节
unsigned char T0RL = 0; //T0重载值的低字节
bit flagFrame = 0; //帧接收完成标志，即接收到一帧新数据
bit flagTxd = 0; //单字节发送完成标志，用来替代TXD中断标志位
unsigned char cntRxd = 0; //接收字节计数器
unsigned char pdata bufRxd[50]; //接收字节缓冲区
void UartDriver();//串口驱动函数，监测数据帧的接收，调度功能函数，需在主循环中调用
void UartAction(unsigned char *buf, unsigned char len);//在接收到的数据帧后添加换车换行符后发回
void UartWrite(unsigned char *buf, unsigned char len);//串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度
unsigned char UartRead(unsigned char *buf, unsigned char len);//串口数据读取函数，buf-接收指针，len-指定的读取长度，返回值-实际读到的长度
void UartRxMonitor(unsigned char ms);//串口接收监控，由空闲时间判定帧结束，需在定时中断中调用，ms-定时间隔
bit flagFrame2 = 0; //帧接收完成标志，即接收到一帧新数据
bit flagTxd2 = 0; //单字节发送完成标志，用来替代TXD中断标志位
unsigned char cnt2Rxd = 0; //接收字节计数器
unsigned char pdata buf2Rxd[50]; //接收字节缓冲区
void Uart2Driver();//串口驱动函数，监测数据帧的接收，调度功能函数，需在主循环中调用
void Uart2Action(unsigned char *buf2, unsigned char len2);//在接收到的数据帧后添加换车换行符后发回
void Uart2Write(unsigned char *buf2, unsigned char len2);//串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度
unsigned char UartRead(unsigned char *buf2, unsigned char len2);//串口数据读取函数，buf-接收指针，len-指定的读取长度，返回值-实际读到的长度
void ConfigUART(unsigned int baud);//串口配置函数，baud-通信波特率
void ConfigTimer0(unsigned int ms);//配置并启动T0，ms-T0定时时间
void Report(void);
sbit IN_1 = P3^7;
sbit IN_2 = P3^6;
sbit IN_3 = P3^3;
sbit IN_4 = P3^2;
sbit out1 = P5^5;
sbit out2 = P5^4;
sbit out3 = P1^7;
sbit out4 = P1^6;
bit bz1=0,bz2=0,bz3=0,bz4=0;
bit k=0,k1=0,bk1=0,ks=0,bzw=0;
bit flag=0;
uchar addr=0x00,xx_1=0,xx_2=0,xx_3=0,xx_4=0,zz=0x00;
uchar y_1=0,y_2=0,y_3=0,y_4=0,zy=0x00,zt=0x00;
uint js=0;
/********************************************************************
E2P函数
*********************************************************************/
union union_temp16
{
INT16U un_temp16;
INT8U un_temp8[2];
}my_unTemp16;
INT8U Byte_Read(INT16U add); //读一字节，调用前需打开IAP 功能
void Byte_Program(INT16U add, INT8U ch); //字节编程，调用前需打开IAP 功能
void Sector_Erase(INT16U add); //擦除扇区
void IAP_Disable(); //关闭IAP 功能
void UartAction(unsigned char *buf, unsigned char len){//接收
if((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x01)&&(buf[4] == 0xBB)&&(len==5)) //更改板子地址
{
addr=buf[3];k=1;
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x01;
buf[3] = 0x01;
buf[4] = 0x00;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x02)&&(buf[4] == 0xBB)&&(len==5)) //打开对应输出
{
switch(buf[3])
{
case 1:out1=0;break;
case 2:out2=0;break;
case 3:out3=0;break;
case 4:out4=0;break;
default:break;
}
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x02;
buf[3] = buf[3];
buf[4] = 0xFF;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x03)&&(buf[4] == 0xBB)&&(len==5)) //关闭对应输出
{
switch(buf[3])
{
case 1:out1=1;break;
case 2:out2=1;break;
case 3:out3=1;break;
case 4:out4=1;break;
default:break;
}
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x03;
buf[3] = buf[3];
buf[4] = 0x00;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x04)&&(buf[3] == 0x04)&&(buf[4] == 0xBB)&&(len==5)) //查询输入状态
{
if(IN_1==0){xx_1=0x01;}else{xx_1=0x00;}
if(IN_2==0){xx_2=0x02;}else{xx_2=0x00;}
if(IN_3==0){xx_3=0x04;}else{xx_3=0x00;}
if(IN_4==0){xx_4=0x08;}else{xx_4=0x00;}
zz = ((xx_1)|(xx_2)|(xx_3)|(xx_4));
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x04;
buf[3] = 0x04;
buf[4] = zz;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x05)&&(buf[3] == 0x04)&&(buf[4] == 0xBB)&&(len==5)) //查询输出状态
{
if(out1==0){y_1=0x01;}else{y_1=0x00;}
if(out2==0){y_2=0x02;}else{y_2=0x00;}
if(out3==0){y_3=0x04;}else{y_3=0x00;}
if(out4==0){y_4=0x08;}else{y_4=0x00;}
zy = ((y_1)|(y_2)|(y_3)|(y_4));
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x05;
buf[3] = 0x04;
buf[4] = zy;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
if ((buf[0] == 0xAA)&&(buf[1] == 0x00)&&(buf[2] == 0x07)&&(buf[4] == 0xBB)&&(len==5)) //广播控制输出状态
{
zt=buf[3];
if((zt&0x01)==0x01){out1=0;}else{out1=1;}
if((zt&0x02)==0x02){out2=0;}else{out2=1;}
if((zt&0x04)==0x04){out3=0;}else{out3=1;}
if((zt&0x08)==0x08){out4=0;}else{out4=1;}
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x07;
buf[3] = 0x04;
buf[4] = zt;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
if ((buf[0] == 0xAA)&&(buf[1] == 0x00)&&(buf[2] == 0x00)&&(buf[3] == 0x00)&&(buf[4] == 0xBB)&&(len==5)) //查询板子地址
{
buf[0] = 0xAA;
buf[1] = addr;
buf[2] = 0x00;
buf[3] = 0x01;
buf[4] = 0x00;
buf[5] = 0xBB;
len = 6;
UartWrite(buf,len);
}
}
void Uart2Action(unsigned char *buf2, unsigned char len2)//接收
{
if ((buf2[0] == 0xAA)&&(buf2[1] == addr)&&(buf2[2] == 0x02)&&(buf2[4] == 0xBB)&&(len2==5)) //打开
{
switch(buf2[3])
{
case 1:out1=0;break;
case 2:out2=0;break;
case 3:out3=0;break;
case 4:out4=0;break;
default:break;
}
buf2[0] = 0xAA;
buf2[1] = addr;
buf2[2] = 0x02;
buf2[3] = buf2[3];
buf2[4] = 0xFF;
buf2[5] = 0xBB;
len2 = 6;
Uart2Write(buf2,len2);
}
if ((buf2[0] == 0xAA)&&(buf2[1] == addr)&&(buf2[2] == 0x03)&&(buf2[4] == 0xBB)&&(len2==5)) //关闭
{
switch(buf2[3])
{
case 1:out1=1;break;
case 2:out2=1;break;
case 3:out3=1;break;
case 4:out4=1;break;
default:break;
}
buf2[0] = 0xAA;
buf2[1] = addr;
buf2[2] = 0x03;
buf2[3] = buf2[3];
buf2[4] = 0xFF;
buf2[5] = 0xBB;
len2 = 6;
Uart2Write(buf2,len2);
}
}
void ConfigTimer0(unsigned int ms)//配置并启动T0，ms-T0定时时间
{
unsigned long tmp; //临时变量
tmp = 11059200 / 12; //定时器计数频率
tmp = (tmp * ms) / 1000; //计算所需的计数值
tmp = 65536 - tmp; //计算定时器重载值
tmp = tmp + 33; //补偿中断响应延时造成的误差
T0RH = (unsigned char)(tmp>>8); //定时器重载值拆分为高低字节
T0RL = (unsigned char)tmp;
TMOD &= 0xF0; //清零T0的控制位
TMOD |= 0x01; //配置T0为模式1
TH0 = T0RH; //加载T0重载值
TL0 = T0RL;
ET0 = 1; //使能T0中断
TR0 = 1; //启动T0
}
void ConfigUART(unsigned int baud)//串口配置函数，baud-通信波特率
{
SCON = 0x50; //配置串口为模式1
TMOD &= 0x0F; //清零T1的控制位
TMOD |= 0x20; //配置T1为模式2
TH1 = 256 - (11059200/12/32)/baud; //计算T1重载值
TL1 = TH1; //初值等于重载值
ET1 = 0; //禁止T1中断
TR1 = 1; //启动T1
}
void Config2UART() //串口2配置
{
S2CON = 0x50;
AUXR |= 0x04;
T2L = 0xE0; //65536-11059200/115200/4=0FFE8H
T2H = 0xFE;
AUXR |= 0x10; //启动定时器
IE2 = 0x01;
}
void senddate()//发送输入状态
{
unsigned char buf[10];
unsigned char len=0;
if((k1==1)&&(bk1==0))
{
bk1=1;
if(IN_1 == 0){xx_1 = 0x01;}else{xx_1 = 0x00;}//查询输入状态打开为1，关闭为0
if(IN_2 == 0){xx_2 = 0x02;}else{xx_2 = 0x00;}//查询输入状态打开为1，关闭为0
if(IN_3 == 0){xx_3 = 0x04;}else{xx_3 = 0x00;}//查询输入状态打开为1，关闭为0
if(IN_4 == 0){xx_4 = 0x08;}else{xx_4 = 0x00;}//查询输入状态打开为1，关闭为0
zz = ((xx_1)|(xx_2)|(xx_3)|(xx_4));
buf[0]=0xAA;
buf[1]=addr;
buf[2]=0x06;
buf[3]=0x04;
buf[4]=zz;
buf[5]=0xBB;
len=6;
UartWrite(buf, len);
Uart2Write(buf, len);
k1=0;
ks=1;
}
if(bzw==1){bzw=0;bk1=0;}//消抖延时后清零
}
void main()
{
P1M0 = 0xC0; //
P1M1 = 0x00;
P5M0 = 0xFF; //
P5M1 = 0x00;
EA = 1;ES = 1; //开总中断
ConfigTimer0(1); //配置T0定时1ms
ConfigUART(9600); //配置波特率为9600
Config2UART();
out3=1;out4=1;out1=1;out2=1;//
if(Byte_Read(0X0001)==0xff){addr=0;}//首次读取，如果读到0xFF说明没有存过数据，直接付给00值
else
{
addr=Byte_Read(0X0001);
}
while(1)
{
if((IN_1==0)&&(bz1==0)){bz1=1;k1=1;out1=0;}//点动
if((IN_1==1)&&(bz1==1)){bz1=0;k1=1;out1=1;}
if((IN_2==0)&&(bz2==0)){bz2=1;k1=1;out2=0;}//点动
if((IN_2==1)&&(bz2==1)){bz2=0;k1=1;out2=1;}
if((IN_3==0)&&(bz3==0)){bz3=1;k1=1;out3=0;}//点动
if((IN_3==1)&&(bz3==1)){bz3=0;k1=1;out3=1;}
if((IN_4==0)&&(bz4==0)){bz4=1;k1=1;out4=0;}//点动
if((IN_4==1)&&(bz4==1)){bz4=0;k1=1;out4=1;}
senddate();//发送输入状态
UartDriver(); //调用串口驱动
Uart2Driver();
Report();
if(k==1) //E2P
{
Sector_Erase(0);
Byte_Program(0x0001,addr); //写入扇区
k=0;
}
}
}
void InterruptTimer0() interrupt 1//T0中断服务函数，执行串口接收监控
{
static unsigned int Cnt_1ms;
TH0 = T0RH; //重新加载重载值
TL0 = T0RL;
UartRxMonitor(1); //串口接收监
if(ks==1){js++;if(js==320){js=0;bzw=1;ks=0;}}
Cnt_1ms++;
if(Cnt_1ms >= 10000)//10秒
{
Cnt_1ms = 0;
flag=1;
}
}
void InterruptUART() interrupt 4{//串口中断服务函数
if (RI) { //接收到新字节
RI = 0; //清零接收中断标志位
if (cntRxd < sizeof(bufRxd)) {//接收缓冲区尚未用完时，保存接收字节，并递增计数器
bufRxd[cntRxd++] = SBUF; // cntRxd++这个很重要，一开始 cntRxd < sizeof(bufRxd)当进入函数的次数增加，cntRxd慢慢变大，当传入的数据不满的时候就用时间检测，判断是否是传输完成
}
}
if (TI) { //字节发送完毕
TI = 0; //清零发送中断标志位
flagTxd = 1; //设置字节发送完成标志
}
}
/********************************************************************
串口二(485) 发送接收中断函数
*********************************************************************/
void uart2_isr() interrupt 8
{
if( S2CON & 0x01 )
{
S2CON &= ~0x01;
if (cnt2Rxd < sizeof(buf2Rxd)) {//接收缓冲区尚未用完时，保存接收字节，并递增计数器
buf2Rxd[cnt2Rxd++] = S2BUF; // cntRxd++这个很重要，一开始 cntRxd < sizeof(bufRxd)当进入函数的次数增加，cntRxd慢慢变大，当传入的数据不满的时候就用时间检测，判断是否是传输完成
}
}
if( S2CON & 0x02 )
{
S2CON &= ~0x02;
flagTxd2 = 1; //设置字节发送完成标志
}
}
void UartWrite(unsigned char *buf, unsigned char len)//串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度
{
while (len--) //循环发送所有字节
{
flagTxd = 0; //清零发送标志
SBUF = *buf; //发送一个字节数据
buf++;
while (!flagTxd); //等待该字节发送完成
}
}
void Uart2Write(unsigned char *buf2, unsigned char len2){//串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度
while (len2--){ //循环发送所有字节
flagTxd2 = 0; //清零发送标志
S2BUF = *buf2; //发送一个字节数据
buf2++;
while (!flagTxd2); //等待该字节发送完成
}
}
unsigned char UartRead(unsigned char *buf, unsigned char len){//串口数据读取函数，buf-接收指针，len-指定的读取长度，返回值-实际读到的长度
unsigned char i;
if (len > cntRxd){ //指定读取长度大于实际接收到的数据长度时,读取长度设置为实际接收到的数据长度
len = cntRxd;
}
for (i=0; i<len; i++){ //拷贝接收到的数据到接收指针上
*buf++ = bufRxd[i];
}
cntRxd = 0; //接收计数器清零
return len; //返回实际读取长度
}
unsigned char Uart2Read(unsigned char *buf2, unsigned char len2){//串口数据读取函数，buf-接收指针，len-指定的读取长度，返回值-实际读到的长度
unsigned char i;
if (len2 > cnt2Rxd){ //指定读取长度大于实际接收到的数据长度时,读取长度设置为实际接收到的数据长度
len2 = cnt2Rxd;
}
for (i=0; i<len2; i++){ //拷贝接收到的数据到接收指针上
*buf2++ = buf2Rxd[i];
}
cnt2Rxd = 0; //接收计数器清零
return len2; //返回实际读取长度
}
void UartDriver(){//串口驱动函数，监测数据帧的接收，调度功能函数，需在主循环中调用
unsigned char len;
unsigned char pdata buf[50];
if (flagFrame){ //有命令到达时，读取处理该命令
flagFrame = 0;
len = UartRead(buf, sizeof(buf)-2); //将接收到的命令读取到缓冲区中
UartAction(buf, len); //传递数据帧，调用动作执行函数
}
}
void Uart2Driver(){//串口驱动函数，监测数据帧的接收，调度功能函数，需在主循环中调用
unsigned char len2;
unsigned char pdata buf2[50];
if (flagFrame2){ //有命令到达时，读取处理该命令
flagFrame2 = 0;
len2 = Uart2Read(buf2, sizeof(buf2)-2); //将接收到的命令读取到缓冲区中
Uart2Action(buf2, len2); //传递数据帧，调用动作执行函数
}
}
void UartRxMonitor(unsigned char ms){//串口接收监控，由空闲时间判定帧结束，需在定时中断中调用，ms-定时间隔
static unsigned char cntbkp = 0;
static unsigned char idletmr = 0;
if (cntRxd > 0){ //接收计数器大于零时，监控总线空闲时间
if (cntbkp != cntRxd){ //接收计数器改变，即刚接收到数据时，清零空闲计时
cntbkp = cntRxd;
idletmr = 0;
}else{ //接收计数器未改变，即总线空闲时，累积空闲时间
if (idletmr < 30){ //空闲计时小于30ms时，持续累加
idletmr += ms;
if (idletmr >= 30){ //空闲时间达到30ms时，即判定为一帧接收完毕
flagFrame = 1; //设置帧接收完成标志
}
}
}
}else if(cnt2Rxd > 0){
if (cntbkp != cnt2Rxd){
cntbkp = cnt2Rxd;
idletmr = 0;
}else{
if (idletmr < 30){
idletmr += ms;
if (idletmr >= 30){
flagFrame2 = 1; }}
}
}
else{
cntbkp = 0;
}
}
//读一字节，调用前需打开IAP 功能，入口:DPTR = 字节地址，返回:A = 读出字节
INT8U Byte_Read(INT16U add)
{
IAP_DATA = 0x00;
IAP_CONTR = ENABLE_ISP; //打开IAP 功能, 设置Flash 操作等待时间
IAP_CMD = 0x01; //IAP/ISP/EEPROM 字节读命令
my_unTemp16.un_temp16 = add;
IAP_ADDRH = my_unTemp16.un_temp8[0]; //设置目标单元地址的高8 位地址
IAP_ADDRL = my_unTemp16.un_temp8[1]; //设置目标单元地址的低8 位地址
//EA = 0;
IAP_TRIG = WD1; //先送 WD1,再送WD2 到ISP/IAP 触发寄存器,每次都需如此
IAP_TRIG = WD2; //送完WD2 后，ISP/IAP 命令立即被触发起动
_nop_();
//EA = 1;
IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
//一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
return (IAP_DATA);
}
/*********************************************************************************************/
//字节编程，调用前需打开IAP 功能，入口:DPTR = 字节地址, A= 须编程字节的数据
void Byte_Program(INT16U add, INT8U ch)
{
IAP_CONTR = ENABLE_ISP; //打开 IAP 功能, 设置Flash 操作等待时间
IAP_CMD = 0x02; //IAP/ISP/EEPROM 字节编程命令
my_unTemp16.un_temp16 = add;
IAP_ADDRH = my_unTemp16.un_temp8[0]; //设置目标单元地址的高8 位地址
IAP_ADDRL = my_unTemp16.un_temp8[1]; //设置目标单元地址的低8 位地址
IAP_DATA = ch; //要编程的数据先送进IAP_DATA 寄存器
//EA = 0;
IAP_TRIG = WD1; //先送 WD1,再送WD2 到ISP/IAP 触发寄存器,每次都需如此
IAP_TRIG = WD2; //送完WD2 后，ISP/IAP 命令立即被触发起动
_nop_();
//EA = 1;
IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
//一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
}
/*********************************************************************************************
//擦除扇区, 入口:DPTR = 扇区地址 */
void Sector_Erase(uint addr)
{
IAP_CONTR = ENABLE_ISP; //打开IAP 功能, 设置Flash 操作等待时间
IAP_CMD = 3; //IAP/ISP/EEPROM 扇区擦除命令
// my_unTemp16.un_temp16 = add;
IAP_ADDRH = addr>>8; //设置目标单元地址的高8 位地址
IAP_ADDRL = addr; //设置目标单元地址的低8 位地址
IAP_TRIG = 0x5a; //先送 WD1,再送WD2 到ISP/IAP 触发寄存器,每次都需如此
IAP_TRIG = 0xa5; //送完WD2 后，ISP/IAP 命令立即被触发起动
_nop_();
//EA = 1;
IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
//一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
}
/*********************************************************************************************/
void IAP_Disable()
{
//关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
//一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
IAP_CONTR = 0; //关闭IAP 功能
IAP_CMD = 0; //清命令寄存器,使命令寄存器无命令,此句可不用
IAP_TRIG = 0; //清命令触发寄存器,使命令触发寄存器无触发,此句可不用
IAP_ADDRH = 0x80;
IAP_ADDRL = 0;
}
/*********************************************************************************************/
void Report(void)
{
unsigned char buf[5];
unsigned char i;
if(flag==1)
{
flag=0;
buf[0]=0xAA;
buf[1]=addr;
buf[2]=0xFF;
buf[3]=0xFF;
buf[4]=0xBB;
ES=0; //关串口中断
for(i=0;i<5;i++)
{
SBUF=buf[i];//发送数据
while(!TI); //等待发送中断请求标志位为1
TI=0; //发送中断请求标志位清0
}
ES=1; //开串口中断
}
}

复制代码

ID:137005 · 发表于 2021-2-8 08:17

wulin 发表于 2021-2-6 21:08
在定时器0里增加一个10秒标志flag，在主循环中添加Report()函数，定时发送上报继电器状态。

非常好，这个就是我想要的功能，再次感谢！谢谢！

ID:213173 · 发表于 2021-3-12 14:58

molo 发表于 2021-2-8 08:17
非常好，这个就是我想要的功能，再次感谢！谢谢！

视频.zip (3.91 MB, 下载次数: 5)

帐号		自动登录	找回密码
密码			立即注册

单片机如何添加定时上报继电器状态功能?

最佳答案