欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

<table id="eum2g"></table><code id="eum2g"><dl id="eum2g"></dl></code>

<tbody id="eum2g"><dfn id="eum2g"></dfn></tbody>

<em id="eum2g"></em>

<noframes id="eum2g">

標題: 單片機如何添加定時上報繼電器狀態功能? [打印本頁]

---

作者: molo    時間: 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();

GYJ-0314測試程序.rar

2021-2-4 17:50 上傳

點擊文件名下載附件

76.47 KB, 下載次數: 4

---

作者: wulin    時間: 2021-2-4 17:50
由于此標志是放在串口接收中斷函數中等發送完成后置位 flagTxd = 1;  樓主在定時器3中斷函數中調用UartWrite(buf, len);是等不到 flagTxd = 1，所以只發送一個字節后就死在while (!flagTxd); 。
在不改變原代碼的情況下可以另寫一個串口發送函數供定時器3中斷函數中調用。不過開定時器3似乎多余，完全可以在定時器0里增加一個標志，在主循環中定時發送上報繼電器狀態。

---

作者: 人人學會單片機    時間: 2021-2-5 08:47
串口打印  你必須使用我們這種框架式編程方式，千萬不能有死等。
http://m.raoushi.com/bbs/dpj-201660-1.html

---

作者: 77599585    時間: 2021-2-5 09:35
是不是串口發送沒有等待發送完成標志位呢

---

作者: munuc_w    時間: 2021-2-5 09:39
波特率是多少？1個毫秒內能發送完這些數據嗎！

---

作者: munuc_w    時間: 2021-2-5 10:14
波特率是多少？一個毫秒時間內能發送完這些數據嗎！設計程序時有一個問題要特別注意，就是中斷服務程序越精簡越好，不要在中斷服務程序中處理數據。對于定時器定時中斷，中斷時間內必須能完成中斷服務程序的執行。

---

作者: 學生1    時間: 2021-2-6 11:03
繼電器狀態變化導致串口通訊出錯

---

作者: molo    時間: 2021-2-6 15:13

wulin 發表于 2021-2-6 08:34
由于此標志是放在串口接收中斷函數中等發送完成后置位 flagTxd = 1;  樓主在定時器3中斷函數中調用UartWrit ...

應該是這樣的，我換成LED燈就可以，但換成串口就不行。能示例一下，在定時器0怎么添加實現上報繼電器功能嗎？

---

作者: wulin    時間: 2021-2-6 21:08

molo 發表于 2021-2-6 15:13
應該是這樣的，我換成LED燈就可以，但換成串口就不行。能示例一下，在定時器0怎么添加實現上報繼電器功能 ...

在定時器0里增加一個10秒標志flag，在主循環中添加Report()函數，定時發送上報繼電器狀態。

1. #include <STC8F2K08S2.h>
   
2. #include <intrins.h>
   
3. #define uchar unsigned char//宏定義無符號字符型
   
4. #define uint unsigned int  //宏定義無符號整型
   
5. 
   
6. typedef unsigned char  INT8U;
   
7. typedef unsigned int   INT16U;
   
8. #define ENABLE_ISP 0x82 //系統工作時鐘<20MHz 時，對IAP_CONTR 寄存器設置此值
   
9. #define WD1        0x5a        //使用STC11xx系列單片機時，先寫入0x5a，然寫入0xa5
   
10. #define WD2        0xa5
    
11. char IAPAddr=0;
    
12. 
    
13. unsigned char T0RH = 0;  //T0重載值的高字節
    
14. unsigned char T0RL = 0;  //T0重載值的低字節
    
15. bit flagFrame = 0;  //幀接收完成標志，即接收到一幀新數據
    
16. bit flagTxd = 0;    //單字節發送完成標志，用來替代TXD中斷標志位
    
17. unsigned char cntRxd = 0;   //接收字節計數器
    
18. unsigned char pdata bufRxd[50];  //接收字節緩沖區
    
19. void UartDriver();//串口驅動函數，監測數據幀的接收，調度功能函數，需在主循環中調用
    
20. void UartAction(unsigned char *buf, unsigned char len);//在接收到的數據幀后添加換車換行符后發回
    
21. void UartWrite(unsigned char *buf, unsigned char len);//串口數據寫入，即串口發送函數，buf-待發送數據的指針，len-指定的發送長度
    
22. unsigned char UartRead(unsigned char *buf, unsigned char len);//串口數據讀取函數，buf-接收指針，len-指定的讀取長度，返回值-實際讀到的長度
    
23. void UartRxMonitor(unsigned char ms);//串口接收監控，由空閑時間判定幀結束，需在定時中斷中調用，ms-定時間隔
    
24. 
    
25. bit flagFrame2 = 0;  //幀接收完成標志，即接收到一幀新數據
    
26. bit flagTxd2 = 0;    //單字節發送完成標志，用來替代TXD中斷標志位
    
27. unsigned char cnt2Rxd = 0;   //接收字節計數器
    
28. unsigned char pdata buf2Rxd[50];  //接收字節緩沖區
    
29. void Uart2Driver();//串口驅動函數，監測數據幀的接收，調度功能函數，需在主循環中調用
    
30. void Uart2Action(unsigned char *buf2, unsigned char len2);//在接收到的數據幀后添加換車換行符后發回
    
31. void Uart2Write(unsigned char *buf2, unsigned char len2);//串口數據寫入，即串口發送函數，buf-待發送數據的指針，len-指定的發送長度
    
32. unsigned char UartRead(unsigned char *buf2, unsigned char len2);//串口數據讀取函數，buf-接收指針，len-指定的讀取長度，返回值-實際讀到的長度
    
33. 
    
34. void ConfigUART(unsigned int baud);//串口配置函數，baud-通信波特率
    
35. void ConfigTimer0(unsigned int ms);//配置并啟動T0，ms-T0定時時間
    
36. void Report(void);
    
37. 
    
38. sbit IN_1  = P3^7;
    
39. sbit IN_2  = P3^6;
    
40. sbit IN_3  = P3^3;
    
41. sbit IN_4  = P3^2;
    
42. sbit out1  = P5^5;
    
43. sbit out2  = P5^4;
    
44. sbit out3  = P1^7;
    
45. sbit out4  = P1^6;
    
46. 
    
47. bit bz1=0,bz2=0,bz3=0,bz4=0;
    
48. bit k=0,k1=0,bk1=0,ks=0,bzw=0;
    
49. bit flag=0;
    
50. uchar addr=0x00,xx_1=0,xx_2=0,xx_3=0,xx_4=0,zz=0x00;
    
51. uchar y_1=0,y_2=0,y_3=0,y_4=0,zy=0x00,zt=0x00;
    
52. uint js=0;
    
53. /********************************************************************
    
54.                             E2P函數
    
55. *********************************************************************/
    
56. union union_temp16
    
57. {
    
58.     INT16U un_temp16;
    
59.     INT8U  un_temp8[2];
    
60. }my_unTemp16;
    
61. 
    
62. INT8U Byte_Read(INT16U add);              //讀一字節，調用前需打開IAP 功能
    
63. void Byte_Program(INT16U add, INT8U ch);  //字節編程，調用前需打開IAP 功能
    
64. void Sector_Erase(INT16U add);            //擦除扇區
    
65. void IAP_Disable();                       //關閉IAP 功能
    
66. 
    
67. void UartAction(unsigned char *buf, unsigned char len){//接收  
    
68.            if((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x01)&&(buf[4] == 0xBB)&&(len==5)) //更改板子地址
    
69.                  {
    
70.                           addr=buf[3];k=1;
    
71.                           buf[0] = 0xAA;
    
72.                     buf[1] = addr;
    
73.                     buf[2] = 0x01;
    
74.                                 buf[3] = 0x01;
    
75.                           buf[4] = 0x00;
    
76.                                 buf[5] = 0xBB;
    
77.                     len = 6;
    
78.                     UartWrite(buf,len);
    
79.                  }
    
80.            if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x02)&&(buf[4] == 0xBB)&&(len==5))  //打開對應輸出
    
81.         {
    
82.                                   switch(buf[3])
    
83.                                         {
    
84.                                                 case 1:out1=0;break;
    
85.                                                 case 2:out2=0;break;
    
86.                                                 case 3:out3=0;break;
    
87.                                                 case 4:out4=0;break;
    
88.                                                 default:break;
    
89.                                         }
    
90.                 buf[0] = 0xAA;
    
91.                      buf[1] = addr;
    
92.                      buf[2] = 0x02;
    
93.                                  buf[3] = buf[3];
    
94.                                  buf[4] = 0xFF;
    
95.                                  buf[5] = 0xBB;
    
96.                      len = 6;
    
97.                      UartWrite(buf,len);
    
98.         }
    
99.                  if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x03)&&(buf[4] == 0xBB)&&(len==5))  //關閉對應輸出
    
100.         {                                         
     
101.                                         switch(buf[3])
     
102.                                         {
     
103.                                                 case 1:out1=1;break;
     
104.                                                 case 2:out2=1;break;
     
105.                                                 case 3:out3=1;break;
     
106.                                                 case 4:out4=1;break;
     
107.                                                 default:break;
     
108.                                         }
     
109.                                  
     
110.                 buf[0] = 0xAA;
     
111.                      buf[1] = addr;
     
112.                      buf[2] = 0x03;
     
113.                                  buf[3] = buf[3];
     
114.                                  buf[4] = 0x00;
     
115.                                  buf[5] = 0xBB;
     
116.                      len = 6;
     
117.                      UartWrite(buf,len);
     
118.         }
     
119.                                
     
120.                         if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x04)&&(buf[3] == 0x04)&&(buf[4] == 0xBB)&&(len==5))  //查詢輸入狀態
     
121.         {                                         
     
122.                             if(IN_1==0){xx_1=0x01;}else{xx_1=0x00;}
     
123.                                         if(IN_2==0){xx_2=0x02;}else{xx_2=0x00;}
     
124.                                         if(IN_3==0){xx_3=0x04;}else{xx_3=0x00;}
     
125.                                         if(IN_4==0){xx_4=0x08;}else{xx_4=0x00;}
     
126.                                  zz = ((xx_1)|(xx_2)|(xx_3)|(xx_4));
     
127.                 buf[0] = 0xAA;
     
128.                      buf[1] = addr;
     
129.                      buf[2] = 0x04;                       
     
130.                                  buf[3] = 0x04;
     
131.                                  buf[4] = zz;
     
132.                                  buf[5] = 0xBB;
     
133.                      len = 6;
     
134.                      UartWrite(buf,len);
     
135.         }
     
136.                                
     
137.                         if ((buf[0] == 0xAA)&&(buf[1] == addr)&&(buf[2] == 0x05)&&(buf[3] == 0x04)&&(buf[4] == 0xBB)&&(len==5))  //查詢輸出狀態
     
138.         {                                         
     
139.                             if(out1==0){y_1=0x01;}else{y_1=0x00;}
     
140.                                         if(out2==0){y_2=0x02;}else{y_2=0x00;}
     
141.                                         if(out3==0){y_3=0x04;}else{y_3=0x00;}
     
142.                                         if(out4==0){y_4=0x08;}else{y_4=0x00;}
     
143.                                  zy = ((y_1)|(y_2)|(y_3)|(y_4));
     
144.                 buf[0] = 0xAA;
     
145.                      buf[1] = addr;
     
146.                      buf[2] = 0x05;                       
     
147.                                  buf[3] = 0x04;
     
148.                                  buf[4] = zy;
     
149.                                  buf[5] = 0xBB;
     
150.                      len = 6;
     
151.                      UartWrite(buf,len);
     
152.         }
     
153.                                
     
154.                  if ((buf[0] == 0xAA)&&(buf[1] == 0x00)&&(buf[2] == 0x07)&&(buf[4] == 0xBB)&&(len==5))  //廣播控制輸出狀態
     
155.         {               
     
156.                                         zt=buf[3];
     
157.           if((zt&0x01)==0x01){out1=0;}else{out1=1;}
     
158.                                         if((zt&0x02)==0x02){out2=0;}else{out2=1;}
     
159.                                         if((zt&0x04)==0x04){out3=0;}else{out3=1;}
     
160.                                         if((zt&0x08)==0x08){out4=0;}else{out4=1;}
     
161.                 buf[0] = 0xAA;
     
162.                      buf[1] = addr;
     
163.                      buf[2] = 0x07;                       
     
164.                                  buf[3] = 0x04;
     
165.                                  buf[4] = zt;
     
166.                                  buf[5] = 0xBB;
     
167.                      len = 6;
     
168.                      UartWrite(buf,len);
     
169.         }
     
170.                                
     
171.                                 if ((buf[0] == 0xAA)&&(buf[1] == 0x00)&&(buf[2] == 0x00)&&(buf[3] == 0x00)&&(buf[4] == 0xBB)&&(len==5))  //查詢板子地址
     
172.                                 {
     
173.                                  buf[0] = 0xAA;
     
174.                      buf[1] = addr;
     
175.                      buf[2] = 0x00;
     
176.                                  buf[3] = 0x01;
     
177.                                  buf[4] = 0x00;
     
178.                                  buf[5] = 0xBB;
     
179.                      len = 6;
     
180.                      UartWrite(buf,len);
     
181.                                 }
     
182. }
     
183. 
     
184. void Uart2Action(unsigned char *buf2, unsigned char len2)//接收
     
185. {
     
186.         if ((buf2[0] == 0xAA)&&(buf2[1] == addr)&&(buf2[2] == 0x02)&&(buf2[4] == 0xBB)&&(len2==5))  //打開
     
187.         {
     
188.                 switch(buf2[3])
     
189.                 {
     
190.                         case 1:out1=0;break;
     
191.                         case 2:out2=0;break;
     
192.                         case 3:out3=0;break;
     
193.                         case 4:out4=0;break;
     
194.                         default:break;
     
195.                 }
     
196.                 buf2[0] = 0xAA;
     
197.                 buf2[1] = addr;
     
198.                 buf2[2] = 0x02;
     
199.                 buf2[3] = buf2[3];
     
200.                 buf2[4] = 0xFF;
     
201.                 buf2[5] = 0xBB;
     
202.                 len2 = 6;
     
203.                 Uart2Write(buf2,len2);
     
204.         }
     
205.         if ((buf2[0] == 0xAA)&&(buf2[1] == addr)&&(buf2[2] == 0x03)&&(buf2[4] == 0xBB)&&(len2==5))  //關閉
     
206.         {                                         
     
207.                 switch(buf2[3])
     
208.                 {
     
209.                         case 1:out1=1;break;
     
210.                         case 2:out2=1;break;
     
211.                         case 3:out3=1;break;
     
212.                         case 4:out4=1;break;
     
213.                         default:break;
     
214.                 }                                 
     
215.                 buf2[0] = 0xAA;
     
216.                 buf2[1] = addr;
     
217.                 buf2[2] = 0x03;
     
218.                 buf2[3] = buf2[3];
     
219.                 buf2[4] = 0xFF;
     
220.                 buf2[5] = 0xBB;
     
221.                 len2 = 6;
     
222.                 Uart2Write(buf2,len2);
     
223.         }
     
224. }
     
225. 
     
226. void ConfigTimer0(unsigned int ms)//配置并啟動T0，ms-T0定時時間
     
227. {
     
228.   unsigned long tmp;  //臨時變量   
     
229.     tmp = 11059200 / 12;      //定時器計數頻率
     
230.     tmp = (tmp * ms) / 1000;  //計算所需的計數值
     
231.     tmp = 65536 - tmp;        //計算定時器重載值
     
232.     tmp = tmp + 33;           //補償中斷響應延時造成的誤差
     
233.     T0RH = (unsigned char)(tmp>>8);  //定時器重載值拆分為高低字節
     
234.     T0RL = (unsigned char)tmp;
     
235.     TMOD &= 0xF0;   //清零T0的控制位
     
236.     TMOD |= 0x01;   //配置T0為模式1
     
237.     TH0 = T0RH;     //加載T0重載值
     
238.     TL0 = T0RL;
     
239.     ET0 = 1;        //使能T0中斷
     
240.     TR0 = 1;        //啟動T0
     
241. }
     
242. 
     
243. void ConfigUART(unsigned int baud)//串口配置函數，baud-通信波特率                                 
     
244. {
     
245.     SCON  = 0x50;  //配置串口為模式1
     
246.     TMOD &= 0x0F;  //清零T1的控制位
     
247.     TMOD |= 0x20;  //配置T1為模式2
     
248.     TH1 = 256 - (11059200/12/32)/baud;  //計算T1重載值
     
249.     TL1 = TH1;     //初值等于重載值
     
250.     ET1 = 0;       //禁止T1中斷         
     
251.     TR1 = 1;       //啟動T1
     
252.        
     
253. }
     
254. void Config2UART()         //串口2配置
     
255. {
     
256.         S2CON = 0x50;
     
257.         AUXR |= 0x04;
     
258.         T2L = 0xE0;                                 //65536-11059200/115200/4=0FFE8H
     
259.         T2H = 0xFE;
     
260.         AUXR |= 0x10;                                //啟動定時器
     
261.         IE2 = 0x01;
     
262. }
     
263. void senddate()//發送輸入狀態
     
264. {
     
265.                 unsigned char  buf[10];
     
266.    unsigned char len=0;
     
267.         if((k1==1)&&(bk1==0))
     
268.         {
     
269.                 bk1=1;
     
270.          if(IN_1 == 0){xx_1 = 0x01;}else{xx_1 = 0x00;}//查詢輸入狀態打開為1，關閉為0
     
271.          if(IN_2 == 0){xx_2 = 0x02;}else{xx_2 = 0x00;}//查詢輸入狀態打開為1，關閉為0
     
272.          if(IN_3 == 0){xx_3 = 0x04;}else{xx_3 = 0x00;}//查詢輸入狀態打開為1，關閉為0
     
273.          if(IN_4 == 0){xx_4 = 0x08;}else{xx_4 = 0x00;}//查詢輸入狀態打開為1，關閉為0
     
274.          zz = ((xx_1)|(xx_2)|(xx_3)|(xx_4));
     
275.          buf[0]=0xAA;
     
276.          buf[1]=addr;
     
277.          buf[2]=0x06;
     
278.          buf[3]=0x04;
     
279.          buf[4]=zz;
     
280.          buf[5]=0xBB;
     
281.          len=6;
     
282.          UartWrite(buf, len);
     
283.          Uart2Write(buf, len);
     
284.          k1=0;
     
285.          ks=1;
     
286.         }
     
287.         if(bzw==1){bzw=0;bk1=0;}//消抖延時后清零
     
288. }
     
289. void main()
     
290. {
     
291.         P1M0 = 0xC0;   //
     
292.         P1M1 = 0x00;
     
293.         P5M0 = 0xFF;   //
     
294.         P5M1 = 0x00;
     
295.         EA = 1;ES  = 1;     //開總中斷
     
296.         ConfigTimer0(1);   //配置T0定時1ms
     
297.         ConfigUART(9600);  //配置波特率為9600
     
298.         Config2UART();
     
299.         out3=1;out4=1;out1=1;out2=1;//
     
300.         if(Byte_Read(0X0001)==0xff){addr=0;}//首次讀取，如果讀到0xFF說明沒有存過數據，直接付給00值
     
301.         else
     
302.         {
     
303.                 addr=Byte_Read(0X0001);
     
304.         }
     
305.         while(1)
     
306.         {
     
307.                 if((IN_1==0)&&(bz1==0)){bz1=1;k1=1;out1=0;}//點動
     
308.                 if((IN_1==1)&&(bz1==1)){bz1=0;k1=1;out1=1;}
     
309.                
     
310.                 if((IN_2==0)&&(bz2==0)){bz2=1;k1=1;out2=0;}//點動
     
311.                 if((IN_2==1)&&(bz2==1)){bz2=0;k1=1;out2=1;}
     
312.                
     
313.                 if((IN_3==0)&&(bz3==0)){bz3=1;k1=1;out3=0;}//點動
     
314.                 if((IN_3==1)&&(bz3==1)){bz3=0;k1=1;out3=1;}
     
315.                
     
316.                 if((IN_4==0)&&(bz4==0)){bz4=1;k1=1;out4=0;}//點動
     
317.                 if((IN_4==1)&&(bz4==1)){bz4=0;k1=1;out4=1;}
     
318.                
     
319.                 senddate();//發送輸入狀態
     
320.                 UartDriver();  //調用串口驅動
     
321.                 Uart2Driver();
     
322.                 Report();               
     
323.                 if(k==1)        //E2P
     
324.                 {
     
325.                         Sector_Erase(0);
     
326.                         Byte_Program(0x0001,addr);  //寫入扇區
     
327.                         k=0;
     
328.                 }
     
329. 
     
330.         }
     
331. }
     
332. void InterruptTimer0() interrupt 1//T0中斷服務函數，執行串口接收監控
     
333. {
     
334.         static unsigned int Cnt_1ms;
     
335.         TH0 = T0RH;  //重新加載重載值
     
336.         TL0 = T0RL;
     
337.         UartRxMonitor(1);  //串口接收監
     
338.         if(ks==1){js++;if(js==320){js=0;bzw=1;ks=0;}}       
     
339.         Cnt_1ms++;
     
340.         if(Cnt_1ms >= 10000)//10秒
     
341.         {
     
342.                 Cnt_1ms = 0;               
     
343.                 flag=1;
     
344.         }
     
345. }
     
346. void InterruptUART() interrupt 4{//串口中斷服務函數
     
347.     if (RI) { //接收到新字節
     
348.         RI = 0;  //清零接收中斷標志位
     
349.         if (cntRxd < sizeof(bufRxd)) {//接收緩沖區尚未用完時，保存接收字節，并遞增計數器
     
350.             bufRxd[cntRxd++] = SBUF;        // cntRxd++這個很重要，一開始 cntRxd < sizeof(bufRxd)當進入函數的次數增加，cntRxd慢慢變大，當傳入的數據不滿的時候就        用時間檢測，判斷是否是傳輸完成
     
351.         }
     
352.     }
     
353.     if (TI) { //字節發送完畢
     
354.         TI = 0;   //清零發送中斷標志位
     
355.         flagTxd = 1;  //設置字節發送完成標志
     
356.     }
     
357. }
     
358. 
     
359. /********************************************************************
     
360.                          串口二(485) 發送接收中斷函數
     
361. *********************************************************************/
     
362. void uart2_isr()  interrupt 8
     
363. {
     
364.         if( S2CON & 0x01 )
     
365.         {
     
366.                 S2CON &= ~0x01;
     
367.            if (cnt2Rxd < sizeof(buf2Rxd)) {//接收緩沖區尚未用完時，保存接收字節，并遞增計數器
     
368.             buf2Rxd[cnt2Rxd++] = S2BUF;        // cntRxd++這個很重要，一開始 cntRxd < sizeof(bufRxd)當進入函數的次數增加，cntRxd慢慢變大，當傳入的數據不滿的時候就        用時間檢測，判斷是否是傳輸完成
     
369.         }
     
370.         }
     
371.         if( S2CON & 0x02 )
     
372.         {
     
373.                 S2CON &= ~0x02;
     
374.                 flagTxd2 = 1;  //設置字節發送完成標志
     
375.         }
     
376. }
     
377. 
     
378. void UartWrite(unsigned char *buf, unsigned char len)//串口數據寫入，即串口發送函數，buf-待發送數據的指針，len-指定的發送長度
     
379. {
     
380.         while (len--)   //循環發送所有字節
     
381.         {
     
382.                 flagTxd = 0;      //清零發送標志
     
383.                 SBUF = *buf;    //發送一個字節數據
     
384.                 buf++;
     
385.                 while (!flagTxd); //等待該字節發送完成
     
386.         }
     
387. }
     
388. 
     
389. void Uart2Write(unsigned char *buf2, unsigned char len2){//串口數據寫入，即串口發送函數，buf-待發送數據的指針，len-指定的發送長度
     
390.     while (len2--){   //循環發送所有字節
     
391.         flagTxd2 = 0;      //清零發送標志
     
392.         S2BUF = *buf2;    //發送一個字節數據
     
393.                 buf2++;
     
394.         while (!flagTxd2); //等待該字節發送完成
     
395.     }
     
396. }
     
397. 
     
398. unsigned char UartRead(unsigned char *buf, unsigned char len){//串口數據讀取函數，buf-接收指針，len-指定的讀取長度，返回值-實際讀到的長度
     
399.     unsigned char i;
     
400.     if (len > cntRxd){  //指定讀取長度大于實際接收到的數據長度時,讀取長度設置為實際接收到的數據長度
     
401.         len = cntRxd;
     
402.     }
     
403. 
     
404.     for (i=0; i<len; i++){  //拷貝接收到的數據到接收指針上
     
405.         *buf++ = bufRxd[i];
     
406.     }
     
407. 
     
408.     cntRxd = 0;  //接收計數器清零
     
409.     return len;  //返回實際讀取長度
     
410. }
     
411. 
     
412. unsigned char Uart2Read(unsigned char *buf2, unsigned char len2){//串口數據讀取函數，buf-接收指針，len-指定的讀取長度，返回值-實際讀到的長度
     
413.     unsigned char i;
     
414.     if (len2 > cnt2Rxd){  //指定讀取長度大于實際接收到的數據長度時,讀取長度設置為實際接收到的數據長度
     
415.         len2 = cnt2Rxd;
     
416.     }
     
417. 
     
418.     for (i=0; i<len2; i++){  //拷貝接收到的數據到接收指針上
     
419.         *buf2++ = buf2Rxd[i];
     
420.     }
     
421. 
     
422.     cnt2Rxd = 0;  //接收計數器清零
     
423.     return len2;  //返回實際讀取長度
     
424. }
     
425. 
     
426. void UartDriver(){//串口驅動函數，監測數據幀的接收，調度功能函數，需在主循環中調用
     
427.     unsigned char len;
     
428.     unsigned char pdata buf[50];
     
429.     if (flagFrame){ //有命令到達時，讀取處理該命令
     
430.         flagFrame = 0;
     
431.         len = UartRead(buf, sizeof(buf)-2); //將接收到的命令讀取到緩沖區中
     
432.         UartAction(buf, len);  //傳遞數據幀，調用動作執行函數
     
433.     }
     
434. }
     
435. 
     
436. void Uart2Driver(){//串口驅動函數，監測數據幀的接收，調度功能函數，需在主循環中調用
     
437.     unsigned char len2;
     
438.     unsigned char pdata buf2[50];
     
439.     if (flagFrame2){ //有命令到達時，讀取處理該命令
     
440.         flagFrame2 = 0;
     
441.         len2 = Uart2Read(buf2, sizeof(buf2)-2); //將接收到的命令讀取到緩沖區中
     
442.         Uart2Action(buf2, len2);  //傳遞數據幀，調用動作執行函數
     
443.     }
     
444. }
     
445. 
     
446. void UartRxMonitor(unsigned char ms){//串口接收監控，由空閑時間判定幀結束，需在定時中斷中調用，ms-定時間隔
     
447.     static unsigned char cntbkp = 0;
     
448.     static unsigned char idletmr = 0;
     
449.     if (cntRxd > 0){  //接收計數器大于零時，監控總線空閑時間
     
450.         if (cntbkp != cntRxd){  //接收計數器改變，即剛接收到數據時，清零空閑計時
     
451.             cntbkp = cntRxd;
     
452.             idletmr = 0;
     
453.         }else{                   //接收計數器未改變，即總線空閑時，累積空閑時間
     
454.             if (idletmr < 30){  //空閑計時小于30ms時，持續累加
     
455.                 idletmr += ms;
     
456.                 if (idletmr >= 30){  //空閑時間達到30ms時，即判定為一幀接收完畢
     
457.                     flagFrame = 1;  //設置幀接收完成標志
     
458.                 }
     
459.             }
     
460.         }
     
461.     }else if(cnt2Rxd > 0){
     
462.         if (cntbkp != cnt2Rxd){
     
463.             cntbkp = cnt2Rxd;
     
464.             idletmr = 0;
     
465.         }else{
     
466.             if (idletmr < 30){
     
467.                 idletmr += ms;
     
468.                 if (idletmr >= 30){  
     
469.                     flagFrame2 = 1; }}
     
470.         }               
     
471.         }
     
472.         else{
     
473.         cntbkp = 0;
     
474.     }
     
475. }
     
476. //讀一字節，調用前需打開IAP 功能，入口:DPTR = 字節地址，返回:A = 讀出字節
     
477. INT8U Byte_Read(INT16U add)
     
478. {
     
479.     IAP_DATA = 0x00;
     
480.     IAP_CONTR = ENABLE_ISP;         //打開IAP 功能, 設置Flash 操作等待時間
     
481.     IAP_CMD = 0x01;                 //IAP/ISP/EEPROM 字節讀命令
     
482. 
     
483.     my_unTemp16.un_temp16 = add;
     
484.     IAP_ADDRH = my_unTemp16.un_temp8[0];    //設置目標單元地址的高8 位地址
     
485.     IAP_ADDRL = my_unTemp16.un_temp8[1];    //設置目標單元地址的低8 位地址
     
486. 
     
487.     //EA = 0;
     
488.     IAP_TRIG = WD1;   //先送 WD1,再送WD2 到ISP/IAP 觸發寄存器,每次都需如此
     
489.     IAP_TRIG = WD2;   //送完WD2 后，ISP/IAP 命令立即被觸發起動
     
490.     _nop_();
     
491.     //EA = 1;
     
492.     IAP_Disable();  //關閉IAP 功能, 清相關的特殊功能寄存器,使CPU 處于安全狀態,
     
493.                     //一次連續的IAP 操作完成之后建議關閉IAP 功能,不需要每次都關
     
494.     return (IAP_DATA);
     
495. }
     
496. /*********************************************************************************************/
     
497. //字節編程，調用前需打開IAP 功能，入口:DPTR = 字節地址, A= 須編程字節的數據
     
498. void Byte_Program(INT16U add, INT8U ch)
     
499. {
     
500.     IAP_CONTR = ENABLE_ISP;         //打開 IAP 功能, 設置Flash 操作等待時間
     
501.     IAP_CMD = 0x02;                 //IAP/ISP/EEPROM 字節編程命令
     
502. 
     
503.     my_unTemp16.un_temp16 = add;
     
504.     IAP_ADDRH = my_unTemp16.un_temp8[0];    //設置目標單元地址的高8 位地址
     
505.     IAP_ADDRL = my_unTemp16.un_temp8[1];    //設置目標單元地址的低8 位地址
     
506. 
     
507.     IAP_DATA = ch;                  //要編程的數據先送進IAP_DATA 寄存器
     
508.     //EA = 0;
     
509.     IAP_TRIG = WD1;   //先送 WD1,再送WD2 到ISP/IAP 觸發寄存器,每次都需如此
     
510.     IAP_TRIG = WD2;   //送完WD2 后，ISP/IAP 命令立即被觸發起動
     
511.     _nop_();
     
512.     //EA = 1;
     
513.     IAP_Disable();  //關閉IAP 功能, 清相關的特殊功能寄存器,使CPU 處于安全狀態,
     
514.                     //一次連續的IAP 操作完成之后建議關閉IAP 功能,不需要每次都關
     
515. }
     
516. /*********************************************************************************************
     
517. //擦除扇區, 入口:DPTR = 扇區地址 */
     
518. void Sector_Erase(uint addr)
     
519. {
     
520.     IAP_CONTR = ENABLE_ISP;         //打開IAP 功能, 設置Flash 操作等待時間
     
521.     IAP_CMD = 3;                 //IAP/ISP/EEPROM 扇區擦除命令
     
522. 
     
523. //    my_unTemp16.un_temp16 = add;
     
524.     IAP_ADDRH = addr>>8;    //設置目標單元地址的高8 位地址
     
525.     IAP_ADDRL = addr;    //設置目標單元地址的低8 位地址
     
526. 
     
527.     IAP_TRIG = 0x5a;   //先送 WD1,再送WD2 到ISP/IAP 觸發寄存器,每次都需如此
     
528.     IAP_TRIG = 0xa5;   //送完WD2 后，ISP/IAP 命令立即被觸發起動
     
529.     _nop_();
     
530.     //EA = 1;
     
531.     IAP_Disable();  //關閉IAP 功能, 清相關的特殊功能寄存器,使CPU 處于安全狀態,
     
532.                     //一次連續的IAP 操作完成之后建議關閉IAP 功能,不需要每次都關
     
533. }
     
534. /*********************************************************************************************/
     
535. void IAP_Disable()
     
536. {
     
537.     //關閉IAP 功能, 清相關的特殊功能寄存器,使CPU 處于安全狀態,
     
538.     //一次連續的IAP 操作完成之后建議關閉IAP 功能,不需要每次都關
     
539.     IAP_CONTR = 0;      //關閉IAP 功能
     
540.     IAP_CMD   = 0;      //清命令寄存器,使命令寄存器無命令,此句可不用
     
541.     IAP_TRIG  = 0;      //清命令觸發寄存器,使命令觸發寄存器無觸發,此句可不用
     
542.     IAP_ADDRH = 0x80;
     
543.     IAP_ADDRL = 0;
     
544. }
     
545. /*********************************************************************************************/
     
546. 
     
547. void Report(void)
     
548. {
     
549.         unsigned char buf[5];
     
550.         unsigned char i;
     
551.         if(flag==1)
     
552.         {
     
553.                 flag=0;
     
554.                 buf[0]=0xAA;
     
555.                 buf[1]=addr;
     
556.                 buf[2]=0xFF;
     
557.                 buf[3]=0xFF;
     
558.                 buf[4]=0xBB;
     
559.                 ES=0;                //關串口中斷
     
560.                 for(i=0;i<5;i++)
     
561.                 {
     
562.                         SBUF=buf[i];//發送數據
     
563.                         while(!TI);        //等待發送中斷請求標志位為1
     
564.                         TI=0;                //發送中斷請求標志位清0
     
565.                 }
     
566.                 ES=1;                //開串口中斷
     
567.         }
     
568. }
     

復制代碼

---

作者: molo    時間: 2021-2-8 08:17

wulin 發表于 2021-2-6 21:08
在定時器0里增加一個10秒標志flag，在主循環中添加Report()函數，定時發送上報繼電器狀態。

非常好，這個就是我想要的功能，再次感謝！謝謝！

---

作者: wulin    時間: 2021-3-12 14:58

molo 發表于 2021-2-8 08:17
非常好，這個就是我想要的功能，再次感謝！謝謝！

視頻.zip (3.91 MB, 下載次數: 5)

2021-3-12 14:58 上傳

點擊文件名下載附件

---

歡迎光臨 (http://m.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影

<samp id="4qwga"></samp>

<fieldset id="4qwga"><strike id="4qwga"></strike></fieldset>

<fieldset id="4qwga"><sup id="4qwga"></sup></fieldset>

<object id="4qwga"></object>

<code id="4qwga"><tfoot id="4qwga"></tfoot></code>

<rt id="4qwga"><samp id="4qwga"></samp></rt>