想用单片机制作一个pcb自动曝光灯。遇到点问题，求大神帮帮忙。

这个是坛友的程序改的。已经改好四位共阳数码管显示曝光时间。设定好时间后按启动开始曝光。时间到后蜂鸣器报警一会继电器关闭曝光。想改成按下启动后继电器吸合开启曝光，时间到后继电器关闭。蜂鸣器报警一会。
复位后可以再次工作。

单片机源程序如下:
//头文件
#include <reg51.h>
#include <intrins.h>
//宏定义
#define uchar  unsigned char
#define uint   unsigned int
uint a;
//数码管段码端口
#define PP  P0
//共阳极数码管段码
uchar code SEG7[]={/*0,1,2,3,4,5,6,7,8,9,*/
0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,};
//数码管显示缓冲
uchar num[]={1,2,3,4};
//数码管位码端口
sbit      q1=P2^0;
sbit      q2=P2^1;
sbit      q3=P2^2;
sbit      q4=P2^3;
//复位开始停止加1减1按键
sbit      k1=P1^0;
sbit      k2=P1^1;
sbit      k3=P1^2;
sbit      k4=P1^3;
sbit      k5=P1^4;

sbit      kaiguan=P3^7;
sbit     buzz=P2^5;
//延时函数ms
void _delay_ms(uint t)
{
   uint i,j;
   for(i=0;i<t;i++)
     for(j=0;j<120;j++);
}
//数码管显示
void dis()
{
//------------------  
//显示第1位
  PP=num[0];
  q1=1;
  _delay_ms(2);
  q1=0;
//显示第2位
  PP=num[1];
  q2=1;
  _delay_ms(2);
  q2=0;
  //显示第3位
  PP=num[2];
  q3=1;
  _delay_ms(2);
  q3=0;
  //显示第4位
  PP=num[3];
  q4=1;
  _delay_ms(2);
  q4=0;
}
//计时变量
uint jishu1s=300;  //复位默认秒
uint jishu1=300; //开机默认秒
uint jishu2;
//开始停止变量
uint  bz;
//显示控制
void dispaly()
{
   num[0]=SEG7[jishu1%10];

给你改写了一下程序，程序构架与你原程序变化较大，现仿真正常，做实物还需要再完善，主要是数码管位驱动要加晶体管放大。 999s倒计时+仿真.zip (114.4 KB, 下载次数: 6)

2019-10-8 11:30 上传

点击文件名下载附件

1. //头文件
   
2. #include <reg51.h>
   
3. #include <intrins.h>
   
4. //宏定义
   
5. #define uchar  unsigned char
   
6. #define uint   unsigned int
   
7. #define key_S 20                                        //宏定义短按(20ms)
   
8. #define key_L 500                                        //宏定义长按(0.5s)
   
9. #define key_M 300                                        //宏定义连按间隔(0.2s)
   
10. 
    
11. //共阳极数码管段码
    
12. uchar code SEG7[]={/*0,1,2,3,4,5,6,7,8,9,*/
    
13. 0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,};
    
14. //数码管显示缓冲
    
15. uchar num[]={1,2,3,4};
    
16. //数码管位码端口
    
17. /*
    
18. sbit q1=P2^0;
    
19. sbit q2=P2^1;
    
20. sbit q3=P2^2;
    
21. sbit q4=P2^3;
    
22. */
    
23. //复位开始停止加1减1按键
    
24. sbit k1=P1^0;
    
25. sbit k2=P1^1;
    
26. sbit k3=P1^2;
    
27. sbit k4=P1^3;
    
28. sbit OUT=P3^7;
    
29. sbit buzz=P3^5;
    
30. uint Cnt1s=35,sec=0,count=0;
    
31. char Cnt100ms=0;
    
32. uchar Choice,Cnt1ms=0,Cnt250us=0;
    
33. bit sign=0,buzzer=0;
    
34. bit flag1=0,flag2;
    
35. 
    
36. void Timer0Init()//250微秒@12.000MHz
    
37. {
    
38.         TMOD |= 0x02;                //设置定时器模式
    
39.         TL0 = 0x06;                //设置定时初值
    
40.         TH0 = 0x06;                //设置定时重载值
    
41.         TF0 = 0;                //清除TF0标志
    
42.         TR0 = 1;                //定时器0开始计时
    
43. }
    
44. //显示控制
    
45. void dispaly()
    
46. {
    
47.         if(flag1==0)
    
48.         {
    
49.                 num[0]=SEG7[sec/100%10];//显示十位
    
50.                 num[1]=SEG7[sec/10%10]; //显示小数位
    
51.                 num[2]=SEG7[sec%10]&0x7f;//显示个位加点
    
52.                 num[3]=SEG7[Cnt100ms%10];//显示十分位
    
53.         }
    
54.         else
    
55.         {
    
56.                 num[0]=SEG7[Cnt1s/100%10];//显示十位
    
57.                 num[1]=SEG7[Cnt1s/10%10]; //显示小数位
    
58.                 num[2]=SEG7[Cnt1s%10]&0x7f;//显示个位加点
    
59.                 num[3]=0xbf;//显示-
    
60.         }
    
61. }
    
62. 
    
63. //数码管显示
    
64. void dis()
    
65. {
    
66.         static i=0;
    
67.         P0=0xff;
    
68.         switch(i)
    
69.         {
    
70.                 case 0: P2=0xf1; break;
    
71.                 case 1: P2=0xf2; break;
    
72.                 case 2: P2=0xf4; break;
    
73.                 case 3: P2=0xf8; break;
    
74.         }
    
75.         P0=num[i];
    
76.         i++;
    
77.         i%=4;
    
78. }
    
79. 
    
80. //按键扫描
    
81. void key_scan()
    
82. {
    
83.         static bit key1_sign,key4_sign;                        //按键自锁标志变量
    
84.         static uint count1,count2,count3=0,count4=0;//消抖计数变量                       
    
85. 
    
86.         if(k1==0 && Choice==0)                                                //检测按键1按下与K4互锁
    
87.         {
    
88.                 count1++;                                        //消抖计数1自+1
    
89.                 if((count1>=key_S)&&(key1_sign==0))//检测消抖计数与按键1自锁标志
    
90.                 {                       
    
91.                         key1_sign=1;                        //按键1自锁标志置1
    
92.                         flag1=~flag1;
    
93.                         if(flag1==0)
    
94.                                 sec=Cnt1s;
    
95.                 }
    
96.         }
    
97.         else
    
98.         {
    
99.                 key1_sign=0;                                //按键1自锁标志清0
    
100.                 count1=0;                                        //消抖计数count1清0
     
101.         }
     
102. 
     
103.         if(flag1)                                                //调整时间
     
104.         {                               
     
105.                 if(!k2)                                                        //检测按键2按下   
     
106.                 {  
     
107.                         count2++;  
     
108.                         if(count2>=key_L)                        //长按快调
     
109.                         {
     
110.                                 if(Cnt1s<999)
     
111.                                         Cnt1s++;
     
112.                                 count2=key_M;
     
113.                         }
     
114.                 }  
     
115.                 else                                                        //按键抬起
     
116.                 {  
     
117.                         if(count2>key_S && count2<key_L)//短按
     
118.                         {
     
119.                                 if(Cnt1s<999)
     
120.                                         Cnt1s++;
     
121.                         }
     
122.                         count2=0;                                        //count2清0
     
123.                 }   
     
124.                 if(!k3)                                                        //检测按键3按下
     
125.                 {  
     
126.                         count3++;  
     
127.                         if(count3>=key_L)                        //长按快调
     
128.                         {
     
129.                                 if(Cnt1s>0)
     
130.                                         Cnt1s--;
     
131.                                 count3=key_M;
     
132.                         }
     
133.                 }  
     
134.                 else                                                        //按键抬起
     
135.                 {  
     
136.                         if(count3>key_S && count3<key_L)//短按
     
137.                         {
     
138.                                 if(Cnt1s>0)
     
139.                                         Cnt1s--;
     
140.                         }
     
141.                         count3=0;                                        //count3清0
     
142.                 }   
     
143.         }
     
144.         if(k4==0 && flag1==0)                        //检测按键4按下与k1互锁
     
145.         {
     
146.                 count4++;                                        //消抖计数4自+1
     
147.                 if((count4>=key_S)&&(key4_sign==0))//检测消抖计数与按键4自锁标志
     
148.                 {                       
     
149.                         key4_sign=1;                        //按键4自锁标志置1
     
150.                         Choice++;
     
151.                         if(Choice==1)                        //开始       
     
152.                         {
     
153.                                 OUT=0;
     
154.                                 Cnt1ms=0;
     
155.                                 Cnt100ms=0;
     
156.                         }
     
157.                         if(Choice==2)                        //停止
     
158.                                 OUT=1;
     
159.                         if(Choice>=3)                        //复位
     
160.                         {
     
161.                                 Choice=0;
     
162.                                 Cnt1ms=0;
     
163.                                 Cnt100ms=0;
     
164.                                 sec=Cnt1s;
     
165.                         }
     
166.                 }
     
167.         }
     
168.         else
     
169.         {
     
170.                 key4_sign=0;                                //按键4自锁标志清0
     
171.                 count4=0;                                        //消抖计数count4清0
     
172.         }
     
173. }
     
174. 
     
175. //报警程序
     
176. void Alarm()
     
177. {
     
178.         if(sign==1 && Cnt100ms==0 && sec==0)
     
179.         {
     
180.                 sign=0;
     
181.                 OUT=1;
     
182.                 Choice=0;
     
183.                 buzzer=1;
     
184.         }
     
185.         if(buzzer)
     
186.         {
     
187.                 buzz=~buzz;
     
188.                 count++;
     
189.                 if(count>=1000)
     
190.                 {
     
191.                         count=0;
     
192.                         buzzer=0;
     
193.                         buzz=1;
     
194.                         sec=Cnt1s;
     
195.                 }
     
196.         }
     
197. }
     
198. 
     
199. //-----------------------
     
200. void main()   
     
201. {       
     
202.         Timer0Init();
     
203.         sec=Cnt1s;
     
204.         OUT=1;
     
205.         buzz=1;
     
206.         while(1)
     
207.         {
     
208.                 if(TF0==1)
     
209.                 {
     
210.                         TF0=0;       
     
211.                         Alarm();
     
212.                         Cnt250us++;
     
213.                         if(Cnt250us>=4)//1ms
     
214.                         {
     
215.                                 Cnt250us=0;
     
216.                                 key_scan();        //按键扫描
     
217.                                 dis();                 //显示刷新                 
     
218.                                 if(Choice==1)//启动倒计时
     
219.                                 {
     
220.                                         Cnt1ms++;
     
221.                                         if(Cnt1ms>=100)
     
222.                                         {
     
223.                                                 Cnt1ms=0;
     
224.                                                 Cnt100ms--;
     
225.                                                 if(Cnt100ms<0)
     
226.                                                 {
     
227.                                                         Cnt100ms=9;       
     
228.                                                         sec--;
     
229.                                                         if(sec==0)
     
230.                                                                 sign=1;
     
231.                                                 }
     
232.                                         }
     
233.                                 }
     
234.                         }
     
235.                 }
     
236.                 dispaly();//显示控制
     
237.         }
     
238. }  

复制代码

//头文件
#include <reg51.h>
#include <intrins.h>
//宏定义
#define uchar  unsigned char
#define uint   unsigned int
uint a;
//数码管段码端口
#define PP  P0
//共阳极数码管段码
uchar code SEG7[]={/*0,1,2,3,4,5,6,7,8,9,*/
0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,};
//数码管显示缓冲
uchar num[]={1,2,3,4};
//数码管位码端口
sbit      q1=P2^0;
sbit      q2=P2^1;
sbit      q3=P2^2;
sbit      q4=P2^3;
//复位开始停止加1减1按键
sbit      k1=P1^0;
sbit      k2=P1^1;
sbit      k3=P1^2;
sbit      k4=P1^3;
sbit      k5=P1^4;

sbit      kaiguan=P3^7;
sbit     buzz=P2^5;
//延时函数ms
void _delay_ms(uint t)
{
   uint i,j;
   for(i=0;i<t;i++)
     for(j=0;j<120;j++);
}
//数码管显示
void dis()
{
//------------------  
//显示第1位
  PP=num[0];
  q1=1;
  _delay_ms(2);
  q1=0;
//显示第2位
  PP=num[1];
  q2=1;
  _delay_ms(2);
  q2=0;
  //显示第3位
  PP=num[2];
  q3=1;
  _delay_ms(2);
  q3=0;
  //显示第4位
  PP=num[3];
  q4=1;
  _delay_ms(2);
  q4=0;
}
//计时变量
uint jishu1s=300;  //复位默认秒
uint jishu1=300; //开机默认秒
uint jishu2;
//开始停止变量
uint  bz;
//显示控制
void dispaly()
{
   num[0]=SEG7[jishu1%10];        //显示个位
   num[1]=SEG7[jishu1/10%10]; //显示小数位
   num[2]=SEG7[jishu1/100%10];//显示十位
   num[3]=SEG7[jishu1/1000%10]; //显示千位

}
//按键处理
void key()
{
  if(k1==0){jishu1=jishu1s;while(k1==0);}//复位
  if(k2==0)
          {
                bz=1;
                while(k2==0);
        }
         //开始
  if(k3==0){bz=0;while(k3==0);}//停止
  if(bz==0)
  {
    if(k4==0){if(jishu1s<9999)jishu1s=jishu1s+30;jishu1=jishu1s;while(k4==0);} //+1
    if(k5==0){if(jishu1s>0 )jishu1s=jishu1s-30;jishu1=jishu1s;while(k5==0);} //-1
  }
}
//蜂鸣器子程序
void Alarm()
        {
        if(jishu1<=0)
                {
                for(a>0;a<10000;a++)
                {
                buzz=~buzz;
                }
                   }
        }
void sw()
        {
         if(k2==0)
                 {
                 kaiguan=1;
                }
                else
                        {
                        kaiguan=0;
                        }
        }

//-----------------------
void main()   
{       
        buzz=0;
  _delay_ms(10);  
   //定时器0配置方式1 16
  TMOD=0x01;       
  //使能定时器0
  ET0=1;
  //定时器的初值
  TH0=(65536-50000)/256;
  TL0=(65536-50000)%256;
  //停止开启定时器0
  TR0=1;
  EA=1;
          
  while(1)
  {
   dispaly();//显示控制
   dis(); //显示
   key();//按键
   Alarm();//蜂鸣器
   sw();
  }
}  

//----T0 计数                 
void  Time0() interrupt 1
{
  //重装初值50ms;
  TH0=(65536-50000)/256;  
  TL0=(65536-50000)%256;
  //开始
  if(bz==1)
  {
   jishu2=jishu2+1;
   //到达1s
   if(jishu2==20)
   {
     jishu2=0;
     if(jishu1>0)jishu1=jishu1-1;//减1s
     if(jishu1==0)bz=0;//结束
   }
  }
  
}

你只要能看懂程序的流程就可以了，不要简单的复制代码，然后又不知道所以然。看看那个I/O控制继电器哪个控制蜂鸣器。按照流程图更改一下就可以了。

wulin 发表于 2019-10-6 19:47
给你改写了一下程序，程序构架与你原程序变化较大，现仿真正常，做实物还需要再完善，主要是数码管位驱动要 ...

谢谢，仿真了一下比原来的程序好很多