标题: 用单片机开发板做了个定时发送命令程序，有些疑问调不通 [打印本页]

---

作者: shui206    时间: 2018-9-30 14:49
标题: 用单片机开发板做了个定时发送命令程序，有些疑问调不通


本人是一个电力从业者，主业为强电，最近想做一个小设备，用51单片机加四个按键和6位共阴极数码管
要求功能是，用定时器中断在设定的时间，循环发送一个分闸脉冲命令  延时后再发送合闸命令，一次循环后计数加1；
分闸和合闸脉冲的延时时间可调，并且在按下设置按键后，数码管分别用3位显示分闸设定时间，3位显示合闸设定时间并且循环先停止
时间可以加减，
在常规循环发送分 合闸命令时  显示的是循环次数
程序写了后，循环信号暂停，但是显示的还是循环次数，本人是野路子  程序贴出来大家俅俅，有时间的帮看下
//程序功能包含分合闸脉冲输出，延时时间可调，及每次输出一轮分合闸信号，计数。
//程序设置参数时 分合闸脉冲输出暂停

单片机源程序如下:

1. #include<reg52.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. sbit hout=P1^0;  //合闸信号输出
   
5. sbit fout=P1^2;  //分闸信号输出
   
6. sbit seth=P1^1;  //分闸延时时间设置时指示
   
7. sbit setf=P1^3;   //合闸延时时间设置指示
   
8. sbit run=P1^7;    //运行指示灯
   
9. sbit s1=P3^2;  //设置键,外部中断位
   
10. sbit s2=P3^5;  //减少键
    
11. sbit s3=P3^6;   //增加键
    
12. sbit s4=P3^7;   //清零键
    
13. sbit dula=P2^6;      //段选
    
14. sbit wela=P2^7;    //位选
    
15. sbit beep=P2^3;  //蜂鸣器
    
16. 
    
17. uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};    //数码管显示数字
    
18. uchar code tablewei[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf};  //六位数码管位选信号
    
19. 
    
20. uchar count1,count2,s1num,numsetf,numseth,miaof,miaoh;
    
21. uint numdis;  //定义循环次数
    
22. void delayms(uchar z)  //12M晶振延时毫秒函数
    
23. {
    
24. uint x,y;
    
25. for(x=z;x>0;x--)
    
26.      for(y=123;y>0;y--);
    
27. }
    
28. 
    
29. //void delay(uchar z)  //12M晶振时秒函数
    
30. //{
    
31. // uint x,y,w;
    
32. //for(x=z;x>0;x--)
    
33.   //   for(y=123;y>0;y--)
    
34. //            for(w=10;y>0;y--);
    
35. 
    
36. //}
    
37. 
    
38. void di()   //蜂鸣器发声函数
    
39. {
    
40.   beep=0;
    
41.   delayms(100);
    
42.   beep=1;
    
43. }
    
44. 
    
45. void display(uint numdis) //显示次数函数
    
46. {
    
47.   uchar wan,qian,bai,shi,ge;
    
48.   wan=numdis/10000;
    
49.   qian=numdis%10000/1000;
    
50.   bai=numdis%1000/100;
    
51.   shi=numdis%100/10;
    
52.   ge=numdis%10;
    
53. 
    
54.   dula=1;
    
55.   P0=table[wan];
    
56.   dula=0;
    
57.   P0=0xff;
    
58.   wela=1;
    
59.   P0=tablewei[1];
    
60.   wela=0;
    
61.   delayms(5);
    
62. 
    
63.   dula=1;
    
64.   P0=table[qian];
    
65.   dula=0;
    
66.   P0=0xff;
    
67.   wela=1;
    
68.   P0=tablewei[2];
    
69.   wela=0;
    
70.   delayms(5);
    
71. 
    
72.   dula=1;
    
73.   P0=table[bai];
    
74.   dula=0;
    
75.   P0=0xff;
    
76.   wela=1;
    
77.   P0=tablewei[3];
    
78.   wela=0;
    
79.   delayms(5);
    
80. 
    
81.   dula=1;
    
82.   P0=table[shi];
    
83.   dula=0;
    
84.   P0=0xff;
    
85.   wela=1;
    
86.   P0=tablewei[4];
    
87.   wela=0;
    
88.   delayms(5);
    
89. 
    
90.   dula=1;
    
91.   P0=table[ge];
    
92.   dula=0;
    
93.   P0=0xff;
    
94.   wela=1;
    
95.   P0=tablewei[5];
    
96.   wela=0;
    
97.   delayms(5);
    
98. }
    
99. 
    
100. void display_setf(uchar numsettf) //显示设置分闸延时时间的函数
     
101. {
     
102.   uchar bai,shi,ge;
     
103.   bai=numsettf%1000/100;
     
104.   shi=numsettf%100/10;
     
105.   ge=numsettf%10;
     
106. 
     
107.   dula=1;
     
108.   P0=table[bai];
     
109.   dula=0;
     
110.   P0=0xff;
     
111.   wela=1;
     
112.   P0=tablewei[3];
     
113.   wela=0;
     
114.   delayms(5);
     
115. 
     
116.   dula=1;
     
117.   P0=table[shi];
     
118.   dula=0;
     
119.   P0=0xff;
     
120.   wela=1;
     
121.   P0=tablewei[4];
     
122.   wela=0;
     
123.   delayms(5);
     
124. 
     
125.   dula=1;
     
126.   P0=table[ge];
     
127.   dula=0;
     
128.   P0=0xff;
     
129.   wela=1;
     
130.   P0=tablewei[5];
     
131.   wela=0;
     
132.   delayms(5);
     
133. }
     
134. 
     
135. void display_seth(uchar numsetth) //显示设置合闸延时时间的函数
     
136. {
     
137.   uchar bai,shi,ge;
     
138.   shi=numsetth%100/10;
     
139.   bai=numsetth%1000/100;
     
140.   ge=numsetth%10;
     
141. 
     
142.   dula=1;
     
143.   P0=table[bai];
     
144.   dula=0;
     
145.   P0=0xff;
     
146.   wela=1;
     
147.   P0=tablewei[0];
     
148.   wela=0;
     
149.   delayms(5);
     
150. 
     
151.   dula=1;
     
152.   P0=table[shi];
     
153.   dula=0;
     
154.   P0=0xff;
     
155.   wela=1;
     
156.   P0=tablewei[1];
     
157.   wela=0;
     
158.   delayms(5);
     
159. 
     
160.   dula=1;
     
161.   P0=table[ge];
     
162.   dula=0;
     
163.   P0=0xff;
     
164.   wela=1;
     
165.   P0=tablewei[2];
     
166.   wela=0;
     
167.   delayms(5);
     
168. }
     
169. 
     
170. 
     
171. 
     
172. void keyscan()   //按键扫描函数
     
173. {
     
174.   if(s1==0)     
     
175.    {
     
176.      delayms(5);
     
177.          if(s1==0)     //设置键启动
     
178.              {
     
179.        s1num++;
     
180.            run=1;
     
181.            while(!s1);
     
182.            di();
     
183.            if(s1num==1)  //按一次设置键
     
184.                {
     
185.                  TR0=0;
     
186.                  TR1=0;
     
187.                  setf=0;       //分闸延时设置指示
     
188.                  seth=1;   
     
189.                  }
     
190.        if(s1num==2)   //按两次设置键
     
191.                 {
     
192.                   setf=1;
     
193.                   seth=0;
     
194.                   }
     
195.        if(s1num==3)    //按三次设置键
     
196.                 {
     
197.                   s1num=0;   //设置按键计数清零
     
198.                   display(numdis);   
     
199.                   run=0;
     
200.                   setf=1;
     
201.                   seth=1;
     
202.                   TR0=1;
     
203.                 }
     
204.           }
     
205.    }
     
206.   if(s1num!=0)
     
207.    {
     
208.       if(s2==0)
     
209.         {
     
210.            delayms(5);
     
211.            if(s2==0)
     
212.              {
     
213.                   while(!s2);
     
214.                   di();
     
215.                   if(s1num==1)
     
216.                    {
     
217.                      display_setf(numsetf);   //显示实时分闸延时时间
     
218.                      numsetf++;               
     
219.                      if(numsetf==201)
     
220.                               numsetf=0;   //分闸延时最长200秒清零   
     
221.                     }
     
222.               if(s1num==2)
     
223.                     {
     
224.                       display_seth(numseth);   //显示实时合闸延时时间
     
225.                       numseth++;               
     
226.                       if(numseth==201)
     
227.                       numseth=0;   //合闸延时最长200秒清零
     
228.                       }
     
229.              }
     
230.          }  
     
231.        if(s3==0)
     
232.            {
     
233.               delayms(5);
     
234.                if(s3==0)
     
235.                  {
     
236.                     while(!s3);
     
237.                     di();
     
238.                    if(s1num==1)
     
239.                       {
     
240.                         display_setf(numsetf);    //显示实时分闸延时时间
     
241.                         numsetf--;               
     
242.                         if(numsetf==0)
     
243.                         numsetf=200;   //分闸延时最长200秒清零   
     
244.                        }
     
245.                    if(s1num==2)
     
246.                        {
     
247.                         display_seth(numseth);   //显示实时合闸延时时间
     
248.                         numseth++;               
     
249.                         if(numseth==0)
     
250.                         numseth=200;   //合闸延时最长200秒清零
     
251.                   }
     
252.               }
     
253.           }  
     
254.        if(s4==0)
     
255.             {
     
256.              delayms(5);
     
257.              if(s4==0)   
     
258.              numdis=0;   //循环计数清零
     
259.               }
     
260.    }
     
261. 
     
262. }
     
263. 
     
264. void init()//初始化函数
     
265. {
     
266.     numdis=0;
     
267.     numsetf=45;
     
268.     numseth=45;
     
269.     count1=0;
     
270.         count2=0;
     
271.         miaof=0;
     
272.         miaoh=0;
     
273.         fout=1;
     
274.         hout=1;
     
275.         run=0;
     
276.         setf=1;
     
277.         seth=1;
     
278.         TMOD=0x11;
     
279.         TH0=(65536-50000)/256;
     
280.         TL0=(65536-50000)%256;
     
281.         EA=1;   //打开总中断
     
282.         ET0=1;
     
283.     ET1=1;
     
284.         TR0=1;
     
285.     TR1=0;
     
286. }
     
287. 
     
288. 
     
289. 
     
290. void main()   //主函数
     
291. {
     
292. init();
     
293. while(1)
     
294.   {
     
295.   keyscan();
     
296.   display(numdis);
     
297.   }
     
298. 
     
299. }
     
300. 
     
301. 
     
302. 
     
303. 
     
304. void T0_time() interrupt 1
     
305. {
     
306.         TH0=(65536-45872)/256;
     
307.         TL0=(65536-45872)%256;
     
308.         count1++;
     
309.     if(count1==2)
     
310.                 {
     
311.                         count1=0;
     
312.                         miaof++;
     
313.                         if(miaof==numsetf)  
     
314.                    {
     
315.                             miaof=0;
     
316.                      fout=0;
     
317.                          delayms(200);
     
318.              fout=1;
     
319.                          TR0=0;
     
320.              TR1=1;         
     
321.                     }
     
322.                 }      
     
323. }
     
324. 
     
325. void T1_time() interrupt 3
     
326. {
     
327.         TH1=(65536-45872)/256;
     
328.         TL1=(65536-45872)%256;
     
329.         count2++;
     
330.     if(count2==2)
     
331.                 {
     
332.                         count2=0;
     
333.                         miaoh++;
     
334.                         if(miaoh==numseth)  
     
335.                    {
     
336.                             miaoh=0;
     
337.                      hout=0;
     
338.                          delayms(200);
     
339.              hout=1;
     
340.                      numdis++;  
     
341.                    TR0=1;
     
342.                          TR1=0;
     
343.                     }
     
344.                 }      
     
345. }
     

复制代码

---

作者: sxhwdz    时间: 2018-9-30 19:37
keyscan函数中显示的内容，到主循环立即被循环次数替代了。
建议去掉 keyscan（）中的显示语句，定义一个变量 xianshi， 设置合闸时， xianshi=1，设置分闸时，xianshi=2，正常工作时，xianshi=0，然后在主循环中，根据变量 xianshi 的值，分别调用三个不同的显示程序。

---

作者: wulin    时间: 2018-10-1 15:43
给你把程序框架调整了并优化了显示程序，用计数法代替软件延时，在TX-1C实验板上验证无误。算是送你的国庆节礼物。

//程序功能包含分合闸脉冲输出，延时时间可调，及每次输出一轮分合闸信号，计数。
//程序设置参数时 分合闸脉冲输出暂停*/
//S1键调整选择,S2键+,长按连+，S3键-，长按连-，S4计数清0

#include<reg52.h>
#define uchar unsigned char
#define uint unsigned int
#define key_S 20                //宏定义短按时间(约20ms)消抖
#define key_L 300        //宏定义长按时间(约2/3s)
#define key_M 150        //宏定义长按间隔(约1/3s)
sbit hout=P1^0;  //合闸信号输出
sbit seth=P1^1;  //合闸延时时间设置指示
sbit fout=P1^2;  //分闸信号输出
sbit setf=P1^3;  //分闸延时时间设置指示
sbit run=P1^7;    //运行指示灯
sbit s1=P3^4;  //设置键
sbit s2=P3^5;  //增加键
sbit s3=P3^6;   //减少键
sbit s4=P3^7;   //清零键
sbit dula=P2^6;      //段选
sbit wela=P2^7;    //位选
sbit beep=P2^3;  //蜂鸣器

uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x39};//数码管显示数字
uchar code tablewei[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf};  //六位数码管位选信号
uchar data dis_buf[6];//循环次数显示缓存
uchar data dis_fh[6];//分合时间设置显示缓存
uchar s1num=0,numsetf,numseth,miaof,miaoh;
uint count=0;
uint numdis;  //定义循环次数
bit beep_sign=0;//蜂鸣器使能标志
bit sec_sign=0;//秒标志
bit half_sign=0;//半秒标志
bit fh_sign=0;//分合标志

void init()//初始化函数
{
        numdis=0;                //循环次数
        numsetf=45;                //分闸设定初始时间
        numseth=45;                //合闸设定初始时间
        run=0;                          //运行指示灯亮
        miaof=numsetf;
        miaoh=numseth;
        TMOD= 0x01;                //设置定时器模式
        TH0 = 0xFC;                //设置定时初值 1毫秒@11.0592MHz
        TL0 = 0x66;                //设置定时初值
        TR0 = 1;                        //定时器0开始计时
        EA=1;                                //开总中断
        ET0=1;                        //开T0中断
}

void keyscan()   //按键扫描函数
{
        static bit key1_sign,key4_sign;                        //按键自锁标志
        static uint count_1,count_2,count_3=0,count_4=0;//消抖计数变量
        if(s1==0)     
        {
                count_1++;
                if((count_1>=key_S)&&(key1_sign==0))     //设置键启动
                {
                        key1_sign=1;                        //按键1自锁标志置1
                        s1num++;
                        run=1;                   //运行指示灯熄灭
                        if(s1num==1)  //按一次设置键
                        {
                                setf=0;       //分闸延时设置指示
                                seth=1;   
                        }
                        if(s1num==2)   //按两次设置键
                        {
                                setf=1;
                                seth=0;       //合闸延时设置指示
                        }
                        if(s1num==3)    //按三次设置键
                        {
                                s1num=0;   //设置按键计数清零  
                                run=0;                //运行指示灯亮
                                setf=1;
                                seth=1;
                                miaof=numsetf;
                                miaoh=numseth;
                        }
                        beep_sign=1; //提示音
                }
        }
        else
        {
                key1_sign=0;                                //按键1自锁标志清0
                count_1=0;                                        //消抖计数count1清0
        }
        if(s1num!=0)
        {
                if(s2==0)
                {
                        count_2++;
                        if(count_2>=key_L)                        //长按快调
                        {
                                if(s1num==1)
                                {
                                        if(numsetf<200)
                                                numsetf++;                  
                                }
                                if(s1num==2)
                                {
                                        if(numseth<200)
                                                numseth++;               
                                }
                                count_2=key_M;
                                beep_sign=1; //提示音
                        }
                }  
                else                                                        //按键抬起
                {  
                        if(count_2>key_S && count_2<key_L)//短按
                        {
                                if(s1num==1)
                                {
                                        if(numsetf<200)
                                                numsetf++;                  
                                }
                                if(s1num==2)
                                {
                                        if(numseth<200)
                                                numseth++;               
                                }
                                beep_sign=1; //提示音
                        }
                        count_2=0;                                        //count_2清0
                }

                if(s3==0)
                {
                        count_3++;
                        if(count_3>=key_L)                        //长按
                        {
                                if(s1num==1)
                                {
                                        if(numsetf>0)
                                                numsetf--;                  
                                }
                                if(s1num==2)
                                {
                                        if(numseth>0)
                                                numseth--;
                                }
                                count_3=key_M;
                                beep_sign=1; //提示音
                        }
                }  
                else                                                        //按键抬起
                {  
                        if(count_3>key_S && count_3<key_L)//短按
                        {

                                if(s1num==1)
                                {
                                        if(numsetf>0)
                                                numsetf--;                  
                                }
                                if(s1num==2)
                                {
                                        if(numseth>0)
                                                numseth--;
                                }
                                beep_sign=1; //提示音
                        }
                        count_3=0;                                        //count_3清0
                }
        }
        if(s4==0)
        {
                count_4++;
                if((count_4>=key_S)&&(key4_sign==0))  
                {
                        key4_sign=1;                        //按键1自锁标志置1
                        numdis=0;                           //循环计数清零
                        beep_sign=1; //提示音
                }
        }
        else
        {
                key4_sign=0;                                //按键4自锁标志清0
                count_4=0;                                        //消抖计数count_4清0
        }
}

void Control()//控制程序
{
        if((sec_sign==1)&&(s1num==0))       
        {
                sec_sign=0;
                if(fh_sign==0)
                {
                        fout=0;                        //分闸信号输出
                        hout=1;                        //合闸信号输出
                        setf=0;                        //分闸指示灯亮
                        seth=1;                        //合闸指示灯熄
                        miaof--;
                        if(miaof==0)
                        {
                                fh_sign=1;
                                miaoh=numseth;
                                numdis++;                //循环次数累加
                                if(numdis>=10000)//限制溢出
                                        numdis=0;
                        }
                }
                else
                {
                        fout=1;                        //分闸信号输出
                        hout=0;                        //合闸信号输出
                        setf=1;                        //分闸指示灯熄
                        seth=0;                        //合闸指示灯亮
                        miaoh--;
                        if(miaoh==0)
                        {
                                fh_sign=0;
                                miaof=numsetf;
                        }
                }
        }
}

void decompose()//数据分解保存
{
        dis_buf[0]=16;//显示C
        dis_buf[1]=numdis/10000;
        dis_buf[2]=numdis%10000/1000;
        dis_buf[3]=numdis%1000/100;
        dis_buf[4]=numdis%100/10;
        dis_buf[5]=numdis%10;

        dis_fh[0]=numsetf/100;
        dis_fh[1]=numsetf%100/10;
        dis_fh[2]=numsetf%10;
        dis_fh[3]=numseth/100;
        dis_fh[4]=numseth%100/10;
        dis_fh[5]=numseth%10;
}

void beep_di()   //蜂鸣器发声函数
{
        static uint count_5;
        if(beep_sign==1)
        {
                beep=0;
                count_5++;
                if(count_5>=100)
                {
                        count_5=0;
                        beep_sign=0;
                        beep=1;
                }
        }
}

void display() //显示函数
{
        static uint i=0;
        P0=0x00;                //送段码消隐
        dula=1;
        dula=0;
/********显示累加合闸次数***********/
        if(s1num==0)//
        {
                P0=tablewei[i];//送位码
                wela=1;
                wela=0;
                if((half_sign==1)&&(i==0))
                {
                        P0=table[dis_buf[i]]|0x80;//送段码+闪点
                        dula=1;
                        dula=0;
                }
                else
                {
                        P0=table[dis_buf[i]];//送段码
                        dula=1;
                        dula=0;
                }
        }
/*******显示设置参数**********/
        else
        {
                P0=tablewei[i];//送位码
                wela=1;
                wela=0;
                if((half_sign==1)&&(i<=2)&&(s1num==1))//显示设置分闸闪点
                {
                        P0=table[dis_fh[i]]|0x80;//送段码+闪点
                        dula=1;
                        dula=0;
                }
                else if((half_sign==1)&&(i>=3)&&(s1num==2))//显示设置合闸闪点
                {
                        P0=table[dis_fh[i]]|0x80;//送段码+点
                        dula=1;
                        dula=0;
                }
                else
                        P0=table[dis_fh[i]];//送段码
                        dula=1;
                        dula=0;
        }
        i++;
        if(i>5)
                i=0;
}

void main()   //主函数
{
        init();                //初始化
        while(1)
        {
                keyscan();//按键扫描
                Control();//控制程序
                decompose();//数据分解保存
                beep_di();//蜂鸣器发声函数
        }
}
void T0_time() interrupt 1
{
        static uint i=0;
        TH0 = 0xFC;                //重装初值 1毫秒@11.0592MHz
        TL0 = 0x66;                //重装初值
        i++;
        if(i==500)
        {
                i=0;
                half_sign=~half_sign;//半秒闪点标志取反
        }
        if(s1num==0)
        {
                count++;
                if(count>=1000)//1秒
                {
                        count=0;
                        sec_sign=1;//秒标志置1
                }
        }      
        display();//显示程序刷新
}

---

作者: shui206    时间: 2019-4-29 09:22
谢谢各支持  从强电转学弱电好多概念不清楚  去年用90C52画了个板子干扰太大，死机。
现在又在试试STC12的单片机  加入24C20存储次数《次数为2万次最高》  可惜存储次数一直调不好，重新上电有时候可以读出上次次数，有时候显示随机数字，闲暇时还在努力

---

作者: wulin    时间: 2019-4-29 11:10

shui206 发表于 2019-4-29 09:22
谢谢各支持  从强电转学弱电好多概念不清楚  去年用90C52画了个板子干扰太大，死机。
现在又在试试STC12的 ...

STC12自带EEPROM，加入24C02纯属蛇足。

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1