面试题(C语言版转过来的)

fjiahao

面试题(C语言版转过来的) [复制链接]

我妹妹的一个面试题，让写这个程序的详细功能，和对这个程序做出优化。

我妹理解的：本程序功能：检测信号，当检测时间超过25s时，表示有系统故障，将p2拉高，延时12*42s。当检测到上升沿到来时，LED灯显示，且读取p2口对应12个地址状态（数组中定义）。


对方嫌不满意，不详细， 各位高手，帮忙看看这个程序吧。


#include "reg52.H"
#include "intrins.h"
#define uchar unsigned char
#define uint unsigned int

sbit P0_0 = 0x80;
sbit P0_1 = 0x81;
sbit P0_2 = 0x82;
sbit P0_3 = 0x83;
sbit P0_4 = 0x84;
sbit P0_5 = 0x85;
sbit P1_5 = 0x95;
sbit P2_7 = 0xA7;
sbit IntSignal=0xB5;
sfr  WDT_CONTR=0xe1;
sbit CS=0xe9;
uchar Addr;
uint msCount;

uchar SignalTimeOut;
uchar SignalTime;
uint ProcLEDTime;
uchar State_p2;
bit erro=0;
bit StateTime=0;
bit RSState=0;
uint ClockMs,ClockS;
uint TempClockS;
uchar S_State,M_State,E_State;
uchar Move_State;
uchar State;
bit Erro_ri=0;
bit SignalState;
bit rise;
bit ProcStop;


uchar code StateTab[12]={0xbe,0xde,0xee,0xf6,
0xbd,0xdd,0xed,0xf5,
0xbb,0xdb,0xeb,0xf3,};

/*__________________________
读取P2口状态
----------------------------*/
void Statecode(uchar State_code)
{
switch (State_code)
{  case 0xbe: State_p2=0; break;
  case 0xde: State_p2=1; break;
  case 0xee: State_p2=2; break;
  case 0xf6: State_p2=3; break;
  case 0xbd: State_p2=4; break;
  case 0xdd: State_p2=5; break;
  case 0xed: State_p2=6; break;
  case 0xf5: State_p2=7; break;
  case 0xbb: State_p2=8; break;
  case 0xdb: State_p2=9; break;
  case 0xeb: State_p2=10; break;
  case 0xf3: State_p2=11; break;
  default: break;
  }
}

void mDelay(uint Dat)
{
uint j;
for (;Dat>0;Dat--)
{for (j=42;j>0;j--);WDT_CONTR=0x38;}
}

void Delay10m() //10分钟延时，600秒
{
ClockMs=0;
ClockS=0;
while(ClockS <600) ;
}

/*——————————————————————————————————
故障状态
------------------------------------*/
void Error()
{
ET0=0;
P2=0xff;
mDelay(12);
P0_0=1;
erro=1;
P0_4=1;
P0_5=0;
while(1)
{
P0_3=~P0_3;
mDelay(500);
}
}

/*______________________
P2_7
-----------------------*/
void SignalCheck()
{
if(SignalTimeOut>25) Error(); //20ms内监测
else erro=0;
rise=0;
if(SignalState!=P2_7)
{
SignalState=P2_7;
rise=SignalState;
SignalTimeOut=0;
}

if(rise) SignalTime+=1;
if(P0_4&&(SignalTime==100)){P0_4=0;SignalTime=0;}
if((!P0_4)&&(SignalTime==50)){P0_4=1;SignalTime=0;}
}

/*_________________________________
P0_3
---------------------------------*/
void ProcLED()
{
if(ProcStop) {P0_3=1;return;}
ProcLEDTime+=1;
if(ProcLEDTime==2000) {P0_3=~P0_3;ProcLEDTime=0;}
}

void Timer0() interrupt 1 using 0  
{

TL0=0x9a; //
TH0=0xfe;      //
SignalTimeOut+=1;
msCount+=1;
ClockMs+=1;
if(ClockMs==1000){ClockMs=0;ClockS+=1;}
SignalCheck();  //检测上升沿
  ProcLED();
WDT_CONTR=0x38;
}

/*________________________________

--------------------------------*/
void StateProc(uchar delay)  
{
uchar i;
if(delay)
{
for(i=5;i>0;i--) { msCount=0;while(msCount <60000);} //5分钟延时
}
else
{
msCount=0;
while(msCount <20000);  //20秒延时
}

while(!rise);//检上升沿到来
msCount=0;
while(msCount <1);//延1ms
P2=0xff;//置高
    msCount=0;
while(msCount <10);//2008-03-04修10ms

/*while(!rise);//检上升沿到*/

    P2=StateTab[State];//执行
}


void IntProc()
{
if(IntSignal)return;
E_State= P1>>5;
ProcStop=0;
while(!(IntSignal&&(State==M_State)))
{
if(IntSignal)
{
if(State {State+=1;StateProc(0);}
}
else
{
if(State==E_State) while(!IntSignal);
else {State-=1;StateProc(0);}
}
}
ProcStop=1;
}
/*-------------------------------------
等待延时
-------------------------------------*/
void mDelay0(register uchar n)
{
for(n;n>1;n--) WDT_CONTR=0x38;
}

/*-------------------------------
发送地址
------------------------------*/
void SendsAddr()
{
WDT_CONTR=0x38;
TB8=0;
CS=0;
mDelay0(10);
P0_1=0;
SBUF=Addr;
while(!TI);
TI=0;
mDelay0(15);
SM2=0;
CS=1;
mDelay0(5);
}

/*------------------------------
发送数据
-----------------------------*/
void SendsData()
{
uchar temp;
WDT_CONTR=0x38;
    TB8=0;
CS=0;
mDelay0(10);
temp=P2;
Statecode(temp);
    if(!erro) SBUF=State_p2;
else SBUF=13;
while(!TI);
TI=0;
mDelay0(15);
SM2=1;
CS=1;
mDelay0(5);
   
}
/*-------------------------------
执行P0口命令
--------------------------------*/
void D_Move()
{
mDelay(1000);
WDT_CONTR=0x38;
if(State>Move_State)
{  ProcStop=0;
Erro_ri=0;
do
{
State-=1;
StateProc(0);
}
while(State>Move_State);
        ProcStop=1;
}
else if(State     {
Erro_ri=0;
ProcStop=0;
do
{
State+=1;
StateProc(0);
}while(State ProcStop=1;
}
else { Erro_ri=0; StateProc(0); }
mDelay(1000);

}
/*--------------------------------
串口中断
---------------------------------*/
void Uart() interrupt 4 using 1
{

if(RI==1)
{  uchar temp;
    uchar temp0;
    uchar Sbuftemp;
    RI=0;
Sbuftemp=SBUF;
Erro_ri=1;
mDelay0(15);
if(SM2==0)
{   

temp=Sbuftemp&0x0f;
if(temp>11) { RSState=0; Move_State=11; }
else
{  Addr=P1&0xc0;
  temp0=Sbuftemp&0xc0;
  if((temp0==Addr)||(temp0==0x00)) {  RSState=1; Move_State=temp; }
   
}
SendsData();

}

else
{

Addr=P1&0xc0;
if(Sbuftemp==Addr) SendsAddr();
else
{
SM2=1;
P0_1=1;
CS=1;

}
    }
    }
  else TI=0;
}


void main()
{
P2=0xff;P0=0xff;P1=0xff;P3=0xff;
mDelay(1000); //启动延迟时间
    SCON=0x90;
    PCON=0x00;
SM2=1;
    TH0=0xfe; //
TL0=0xa2;    //晶振4.194304 MHz  1ms定时
TMOD=0x01;      //
TR0=1;
IP=0x10;
    EA=1;
    ES=1;
ET0=1;
  Addr=P1&0xc0;
SignalState=P2_7;
WDT_CONTR=0x38;

S_State=7; //启动端口
State=S_State;

while(!rise);
P0_0=0;
ProcStop=0;
P2=StateTab[State];
   
do
{
Erro_ri=0;
State+=1;
StateProc(0);
}
while(State <11);
ProcStop=1;
    Delay10m();  //10分钟
    /*mDelay(2000);*/
M_State=11-((P1>>3)&0x3);

ProcStop=0;
while(State>M_State)
{
Erro_ri=0;
State-=1;
StateProc(0);
}
ProcStop=1;
retu: mDelay(5000);
while(Erro_ri&RSState) D_Move();
ClockMs=0;
ClockS=0;
while(ClockS <14400)        //延时4小时,14400秒
{
  if(Erro_ri&RSState) goto retu;
if(!IntSignal)
{
mDelay(1000);
if(!IntSignal)
{
TempClockS=ClockS;
IntProc();  
ClockS=TempClockS;
}
}
}
Erro_ri=0;
S_State=P1&0x07;
if(State>S_State)
{
ProcStop=0;
do
{
if(Erro_ri&RSState) goto retu;
State-=1;
StateProc(1);
}
while(State>S_State);
        ProcStop=1;
}
else if(State     {

ProcStop=0;
do
{
    if(Erro_ri&RSState) goto retu;
State+=1;
StateProc(1);
}
while(State ProcStop=1;
}
else {  if(Erro_ri&RSState) goto retu; StateProc(1); }

while(1) if(Erro_ri&RSState) goto retu;  
}

rebor03

功能好说，关键是优化部分

dongdongbo119

1. 
   
2. #include "reg52.H"
   
3. #include "intrins.h"
   
4. #define uchar unsigned char
   
5. #define uint unsigned int
   
6. 
   
7. sbit P0_0 = 0x80;
   
8. sbit P0_1 = 0x81;
   
9. sbit P0_2 = 0x82;
   
10. sbit P0_3 = 0x83;
    
11. sbit P0_4 = 0x84;
    
12. sbit P0_5 = 0x85;
    
13. sbit P1_5 = 0x95;
    
14. sbit P2_7 = 0xA7;
    
15. sbit IntSignal=0xB5;
    
16. sfr  WDT_CONTR=0xe1;
    
17. sbit CS=0xe9;
    
18. uchar Addr;
    
19. uint msCount;
    
20. 
    
21. uchar SignalTimeOut;
    
22. uchar SignalTime;
    
23. uint ProcLEDTime;
    
24. uchar State_p2;
    
25. bit erro=0;
    
26. bit StateTime=0;
    
27. bit RSState=0;
    
28. uint ClockMs,ClockS;
    
29. uint TempClockS;
    
30. uchar S_State,M_State,E_State;
    
31. uchar Move_State;
    
32. uchar State;
    
33. bit Erro_ri=0;
    
34. bit SignalState;
    
35. bit rise;
    
36. bit ProcStop;
    
37. 
    
38. 
    
39. uchar code StateTab[12]={0xbe,0xde,0xee,0xf6,0xbd,0xdd,0xed,0xf5,0xbb,0xdb,0xeb,0xf3,};
    
40. 
    
41. /*__________________________
    
42. 读取P2口状态
    
43. ----------------------------*/
    
44. void Statecode(uchar State_code)
    
45. {
    
46.         switch (State_code)
    
47.         {
    
48.                 case 0xbe: State_p2=0; break;
    
49.                 case 0xde: State_p2=1; break;
    
50.                 case 0xee: State_p2=2; break;
    
51.                 case 0xf6: State_p2=3; break;
    
52.                 case 0xbd: State_p2=4; break;
    
53.                 case 0xdd: State_p2=5; break;
    
54.                 case 0xed: State_p2=6; break;
    
55.                 case 0xf5: State_p2=7; break;
    
56.                 case 0xbb: State_p2=8; break;
    
57.                 case 0xdb: State_p2=9; break;
    
58.                 case 0xeb: State_p2=10; break;
    
59.                 case 0xf3: State_p2=11; break;
    
60.                 default: break;
    
61.         }
    
62. }
    
63. 
    
64. void mDelay(uint Dat)
    
65. {
    
66.         uint j;
    
67.         for(;Dat>0;Dat--)
    
68.         {
    
69.                 for(j=42;j>0;j--)
    
70.                         ;
    
71.                 WDT_CONTR=0x38;
    
72.         }
    
73. }
    
74. 
    
75. void Delay10m() //10分钟延时，600秒
    
76. {
    
77.         ClockMs=0;
    
78.         ClockS=0;
    
79.         while(ClockS <600)
    
80.                 ;
    
81. }
    
82. 
    
83. /*——————————————————————————————————
    
84. 故障状态
    
85. ------------------------------------*/
    
86. void Error()
    
87. {
    
88.         ET0=0;
    
89.         P2=0xff;
    
90.         mDelay(12);
    
91.         P0_0=1;
    
92.         erro=1;
    
93.         P0_4=1;
    
94.         P0_5=0;
    
95.         while(1)
    
96.         {
    
97.                 P0_3=~P0_3;
    
98.                 mDelay(500);
    
99.         }
    
100. }
     
101. 
     
102. /*______________________
     
103. P2_7
     
104. -----------------------*/
     
105. void SignalCheck()
     
106. {
     
107.         if(SignalTimeOut>25)
     
108.                 Error(); //20ms内监测
     
109.         else
     
110.                 erro=0;
     
111.         rise=0;
     
112.         if(SignalState!=P2_7)
     
113.         {
     
114.                 SignalState=P2_7;
     
115.                 rise=SignalState;
     
116.                 SignalTimeOut=0;
     
117.         }
     
118. 
     
119.         if(rise)
     
120.                 SignalTime+=1;
     
121.         if(P0_4&&(SignalTime==100))
     
122.                 {
     
123.                         P0_4=0;
     
124.                         SignalTime=0;
     
125.                 }
     
126.         if((!P0_4)&&(SignalTime==50))
     
127.         {
     
128.                 P0_4=1;
     
129.                 SignalTime=0;
     
130.         }
     
131. }
     
132. 
     
133. /*_________________________________
     
134. P0_3
     
135. ---------------------------------*/
     
136. void ProcLED()
     
137. {
     
138.         if(ProcStop)
     
139.         {
     
140.                 P0_3=1;
     
141.                 return;
     
142.         }
     
143.         ProcLEDTime+=1;
     
144.         if(ProcLEDTime==2000)
     
145.         {
     
146.                 P0_3=~P0_3;
     
147.                 ProcLEDTime=0;
     
148.         }
     
149. }
     
150. 
     
151. void Timer0() interrupt 1 using 0
     
152. {
     
153.         TL0=0x9a; //
     
154.         TH0=0xfe;      //
     
155.         SignalTimeOut+=1;
     
156.         msCount+=1;
     
157.         ClockMs+=1;
     
158.         if(ClockMs==1000)
     
159.         {
     
160.                 ClockMs=0;
     
161.                 ClockS+=1;
     
162.         }
     
163.         SignalCheck();  //检测上升沿
     
164.         ProcLED();
     
165.         WDT_CONTR=0x38;
     
166. }
     
167. 
     
168. /*________________________________
     
169. 
     
170. --------------------------------*/
     
171. void StateProc(uchar delay)
     
172. {
     
173.         uchar i;
     
174.         if(delay)
     
175.         {
     
176.                 for(i=5;i>0;i--)
     
177.                 {
     
178.                         msCount=0;
     
179.                         while(msCount <60000);
     
180.                 } //5分钟延时
     
181.         }
     
182.         else
     
183.         {
     
184.                 msCount=0;
     
185.                 while(msCount <20000)
     
186.                         ;  //20秒延时
     
187.         }
     
188. 
     
189.         while(!rise)
     
190.                 ;//检上升沿到来
     
191. 
     
192.         msCount=0;
     
193.         while(msCount <1)
     
194.                 ;//延1ms
     
195. 
     
196.         P2=0xff;//置高
     
197.         msCount=0;
     
198.         while(msCount <10)
     
199.                 ;//2008-03-04修10ms
     
200. 
     
201.         /*while(!rise);//检上升沿到*/
     
202.         P2=StateTab[State];//执行
     
203. }
     
204. 
     
205. 
     
206. void IntProc()
     
207. {
     
208.         if(IntSignal)
     
209.                 return;
     
210.         E_State= P1>>5;
     
211.         ProcStop=0;
     
212.         while(!(IntSignal&&(State==M_State)))
     
213.         {
     
214.                 if(IntSignal)
     
215.                 {
     
216.                         if(State
217.                         {
     
218.                                 State+=1;
     
219.                                 StateProc(0);
     
220.                         }
     
221.                 }
     
222.                 else
     
223.                 {
     
224.                         if(State==E_State)
     
225.                                 while(!IntSignal)
     
226.                                         ;
     
227.                         else
     
228.                         {
     
229.                                 State-=1;
     
230.                                 StateProc(0);
     
231.                         }
     
232.                 }
     
233.         }
     
234.         ProcStop=1;
     
235. }
     
236. 
     
237. /*-------------------------------------
     
238. 等待延时
     
239. -------------------------------------*/
     
240. void mDelay0(register uchar n)
     
241. {
     
242.         for(n;n>1;n--)
     
243.                 WDT_CONTR=0x38;
     
244. }
     
245. 
     
246. /*-------------------------------
     
247. 发送地址
     
248. ------------------------------*/
     
249. void SendsAddr()
     
250. {
     
251.         WDT_CONTR=0x38;
     
252.         TB8=0;
     
253.         CS=0;
     
254.         mDelay0(10);
     
255.         P0_1=0;
     
256.         SBUF=Addr;
     
257.         while(!TI);
     
258.         TI=0;
     
259.         mDelay0(15);
     
260.         SM2=0;
     
261.         CS=1;
     
262.         mDelay0(5);
     
263. }
     
264. 
     
265. /*------------------------------
     
266. 发送数据
     
267. -----------------------------*/
     
268. void SendsData()
     
269. {
     
270.         uchar temp;
     
271.         WDT_CONTR=0x38;
     
272.         TB8=0;
     
273.         CS=0;
     
274.         mDelay0(10);
     
275.         temp=P2;
     
276.         Statecode(temp);
     
277.         if(!erro)
     
278.                 SBUF=State_p2;
     
279.         else
     
280.                 SBUF=13;
     
281. 
     
282.         while(!TI)
     
283.                 ;
     
284.         TI=0;
     
285.         mDelay0(15);
     
286.         SM2=1;
     
287.         CS=1;
     
288.         mDelay0(5);
     
289. }
     
290. 
     
291. /*-------------------------------
     
292. 执行P0口命令
     
293. --------------------------------*/
     
294. void D_Move()
     
295. {
     
296.         mDelay(1000);
     
297.         WDT_CONTR=0x38;
     
298.         if(State>Move_State)
     
299.         {
     
300.                 ProcStop=0;
     
301.                 Erro_ri=0;
     
302.                 do
     
303.                 {
     
304.                         State-=1;
     
305.                         StateProc(0);
     
306.                 }
     
307.                 while(State>Move_State);
     
308.                 ProcStop=1;
     
309.         }
     
310.         else if(State
311.         {
     
312.                 Erro_ri=0;
     
313.                 ProcStop=0;
     
314.                 do
     
315.                 {
     
316.                         State+=1;
     
317.                         StateProc(0);
     
318.                 }while(State
319.                 ProcStop=1;
     
320.         }
     
321.         else
     
322.         {
     
323.                 Erro_ri=0;
     
324.                 StateProc(0);
     
325.         }
     
326.         mDelay(1000);
     
327. }
     
328. 
     
329. /*--------------------------------
     
330. 串口中断
     
331. ---------------------------------*/
     
332. void Uart() interrupt 4 using 1
     
333. {
     
334.         if(RI==1)
     
335.         {
     
336.                 uchar temp;
     
337.                 uchar temp0;
     
338.                 uchar Sbuftemp;
     
339.                 RI=0;
     
340.                 Sbuftemp=SBUF;
     
341.                 Erro_ri=1;
     
342.                 mDelay0(15);
     
343.                 if(SM2==0)
     
344.                 {
     
345.                         temp=Sbuftemp&0x0f;
     
346.                         if(temp>11)
     
347.                         {
     
348.                                 RSState=0;
     
349.                                 Move_State=11;
     
350.                         }
     
351.                         else
     
352.                         {
     
353.                                 Addr=P1&0xc0;
     
354.                                 temp0=Sbuftemp&0xc0;
     
355.                                 if((temp0==Addr)||(temp0==0x00))
     
356.                                 {
     
357.                                         RSState=1;
     
358.                                         Move_State=temp;
     
359.                                 }
     
360.                         }
     
361.                         SendsData();
     
362.                 }
     
363.                 else
     
364.                 {
     
365.                         Addr=P1&0xc0;
     
366.                         if(Sbuftemp==Addr)
     
367.                                 SendsAddr();
     
368.                         else
     
369.                         {
     
370.                                 SM2=1;
     
371.                                 P0_1=1;
     
372.                                 CS=1;
     
373.                         }
     
374.                 }
     
375.         }
     
376.         else
     
377.                 TI=0;
     
378. }
     
379. 
     
380. 
     
381. void main()
     
382. {
     
383.         P2=0xff;P0=0xff;P1=0xff;P3=0xff;
     
384.         mDelay(1000); //启动延迟时间
     
385.         SCON=0x90;
     
386.         PCON=0x00;
     
387.         SM2=1;
     
388.         TH0=0xfe; //
     
389.         TL0=0xa2;    //晶振4.194304 MHz  1ms定时
     
390.         TMOD=0x01;      //
     
391.         TR0=1;
     
392.         IP=0x10;
     
393.         EA=1;
     
394.         ES=1;
     
395.         ET0=1;
     
396.         Addr=P1&0xc0;
     
397.         SignalState=P2_7;
     
398.         WDT_CONTR=0x38;
     
399.         S_State=7; //启动端口
     
400.         State=S_State;
     
401.         while(!rise);
     
402.         P0_0=0;
     
403.         ProcStop=0;
     
404.         P2=StateTab[State];
     
405.         do
     
406.         {
     
407.                 Erro_ri=0;
     
408.                 State+=1;
     
409.                 StateProc(0);
     
410.         }while(State <11);
     
411.         ProcStop=1;
     
412.         Delay10m();  //10分钟
     
413.         /*mDelay(2000);*/
     
414.         M_State=11-((P1>>3)&0x3);
     
415.         ProcStop=0;
     
416.         while(State>M_State)
     
417.         {
     
418.                 Erro_ri=0;
     
419.                 State-=1;
     
420.                 StateProc(0);
     
421.         }
     
422.         ProcStop=1;
     
423. 
     
424. retu: mDelay(5000);
     
425.         while(Erro_ri&RSState)
     
426.                 D_Move();
     
427.         ClockMs=0;
     
428.         ClockS=0;
     
429.         while(ClockS <14400)        //延时4小时,14400秒
     
430.         {
     
431.                 if(Erro_ri&RSState)
     
432.                         goto retu;
     
433.                 if(!IntSignal)
     
434.                 {
     
435.                         mDelay(1000);
     
436.                         if(!IntSignal)
     
437.                         {
     
438.                                 TempClockS=ClockS;
     
439.                                 IntProc();
     
440.                                 ClockS=TempClockS;
     
441.                         }
     
442.                 }
     
443.         }
     
444.         Erro_ri=0;
     
445.         S_State=P1&0x07;
     
446.         if(State>S_State)
     
447.         {
     
448.                 ProcStop=0;
     
449.                 do
     
450.                 {
     
451.                         if(Erro_ri&RSState) goto retu;
     
452.                         State-=1;
     
453.                         StateProc(1);
     
454.                 }while(State>S_State);
     
455.                 ProcStop=1;
     
456.         }
     
457.         else if(State
458.         {
     
459.                 ProcStop=0;
     
460.                 do
     
461.                 {
     
462.                         if(Erro_ri&RSState)
     
463.                                 goto retu;
     
464.                         State+=1;
     
465.                         StateProc(1);
     
466.                 }
     
467.                 while(State
468.                 ProcStop=1;
     
469.         }
     
470.         else
     
471.         {
     
472.                 if(Erro_ri&RSState)
     
473.                         goto retu;
     
474.                 StateProc(1);
     
475.         }
     
476.         while(1)
     
477.                 if(Erro_ri&RSState)
     
478.                         goto retu;
     
479. }
     

复制代码

Nechi

至少也得把延迟优化一下吧？难道这么久的延迟就让CPU在那里光等着？放到定时中断里判断延迟吧。

adsl50681

本程序功能：检测信号，当检测时间超过25s时，表示有系统故障，将p2拉高，延时12*42s。当检测到上升沿到来时，LED灯显示，且读取p2口对应12个地址状态（数组中定义）。

我读出来的结果是

把这两个信号想办法挂到两个中断上

用定时器处理时间,

主程跑状态

代码量不到LZ发的一半

zoujy518

学习。

luhuitian

"对方嫌不满意，不详细".
太多的立即数（magic number）！

flay

你妹很强大,,,

zoling

嘿嘿，好像以前写程序都是乱写的，现在回去看看，真想抽自己耳光。