公交车报站系统在proteus上仿真 原理图 源程序

公交车报站系统的仿真，msp430f2272为中央处理器的键盘扫描，led驱动，7段数码管的控制。isd1420的驱动在proteus仿真的原理图，以及源程序。



单片机代码：

1. /* Main.c file generated by New Project wizard
   
2. *
   
3. * Created:   周一 六月 20 2016
   
4. * Processor: MSP430F2272
   
5. * Compiler:  CodeComposer for MSP430
   
6. */
   
7. 
   
8. #include <msp430.h>
   
9. 
   
10. void main()
    
11. { #include <msp430f2272.h>
    
12. #define CPU_F ((double)8000000)
    
13. #define delay_us(x)  __delay_cycles((long)(CPU_F*(double)x/1000000.0))
    
14. #define delay_ms(x)  __delay_cycles((long)(CPU_F*(double)x/1000.0))
    
15. 
    
16. void Clock_Init()
    
17.         {
    
18.                         unsigned char i;
    
19.                         BCSCTL1&=~XT2OFF;                 //打开XT2振荡器
    
20.                         BCSCTL2|=SELM1+SELS;              //MCLK为8MHZ，SMCLK为8MHZ
    
21.                  do
    
22.                 {
    
23.                          IFG1&=~OFIFG;                   //清除振荡器错误标志
    
24.                          for(i=0;i<100;i++)
    
25.                                  _NOP();
    
26.                 }
    
27.                  while((IFG1&OFIFG)!=0);           //如果标志位1，则继续循环等待
    
28.                          IFG1&=~OFIFG;
    
29. 
    
30.         }
    
31. 
    
32. 
    
33. int main(void)
    
34. {
    
35.         WDTCTL = WDTPW + WDTHOLD;
    
36.         Clock_Init();
    
37. 
    
38.         P1REN|=0xff;          //按键初始化
    
39.         P1OUT |=0xff;
    
40. 
    
41.         P2DIR |= 0x0F;                //控制端口初始化
    
42.         P2OUT |= BIT0+BIT1+BIT2;
    
43. 
    
44. 
    
45.         P3DIR |= 0xff;                        //LED控制端口
    
46. 
    
47.         P4DIR |= 0xff;                        //语音地址端口初始化
    
48. 
    
49.     unsigned int dz1[]={0x50,0x48};
    
50.     unsigned  int dz2[]={0x60};
    
51.     unsigned  int dz3[]={0x68};
    
52.     unsigned  int dz4[]={0x88};
    
53.     unsigned  int dz5[]={0x70};
    
54.     unsigned  int dz6[]={0x58};
    
55.     unsigned  int dz7[]={0x00,0x08,0x10,0x18,0x20,0x28,0x30,0x38,0x40};
    
56. 
    
57.     unsigned int counter1=0;          // ISD地址计数器
    
58.     unsigned int temp;
    
59. 
    
60.     unsigned int flag = 0;                //正反选择标志
    
61.     unsigned int counter3 = 0;        //正反计数器
    
62. 
    
63.     unsigned int buff2[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09};
    
64.     unsigned int counter2=0 ;         // LED地址计数器
    
65.         P3OUT = buff2[counter2];
    
66. 
    
67.         unsigned int counter4=0;        //录音计数器
    
68. while(1)
    
69. {
    
70.         if ((P1IN & BIT0) == 0)          // 录音模式
    
71.                 {
    
72.                         P2OUT&=~BIT0 ;
    
73.                         counter4++;
    
74.                         if(counter4<=14)
    
75.                                 {
    
76.                                         delay_ms(999);
    
77.                                         P2OUT |= BIT0;
    
78.                                 }
    
79.                         if(counter4>14)
    
80.                                 {
    
81.                                         delay_ms(2999);
    
82.                                           P2OUT |= BIT0;
    
83.                                 }
    
84.                         while(((P1IN & BIT0) == 0) );
    
85.                  }
    
86. 
    
87.         while ((P1IN & BIT1) == 0)          // 放音模式
    
88.                 {       
    
89.                         while((flag==0)&((P1IN & BIT1) == 0))
    
90.                                 {
    
91.                                         if ((P1IN&BIT3)==0)          // 报站
    
92.                                                 {
    
93.                                                         pl1:
    
94.                                                         P3OUT|=BIT7;
    
95.                                                         counter2++;
    
96.                                                         P3OUT = buff2[counter2]+BIT7;
    
97.                                                         if(counter1==0)
    
98.                                                                 {
    
99.                                                                         P2OUT&=~BIT1;
    
100.                                                                         P4OUT=dz1[0];
     
101.                                                                         delay_ms(1000);
     
102. 
     
103.                                                                         P2OUT&=~BIT1;
     
104.                                                                         P4OUT = dz7[0];
     
105.                                                                         delay_ms(1000);
     
106. 
     
107.                                                                         P2OUT&=~BIT1;
     
108.                                                                         P4OUT = dz2[0];
     
109.                                                                         delay_ms(1000);
     
110. 
     
111.                                                                         P2OUT&=~BIT1;
     
112.                                                                         P4OUT = dz7[1];
     
113.                                                                         delay_ms(1000);
     
114. 
     
115.                                                                         P2OUT&=~BIT1;
     
116.                                                                         P4OUT = dz3[3];
     
117.                                                                         delay_ms(1000);
     
118. 
     
119.                                                                         P2OUT&=~BIT1;
     
120.                                                                         P4OUT = dz7[1];
     
121.                                                                         delay_ms(1000);
     
122. 
     
123.                                                                         P2OUT&=~BIT1;
     
124.                                                                         P4OUT = dz4[0];
     
125.                                                                         delay_ms(3000);
     
126.                                                                         P2OUT&=~BIT1 ;
     
127.                                                                 }
     
128.                                                         if((8!=counter1)&(0!=counter1))
     
129.                                                                 {
     
130.                                                                         P2OUT&=~BIT1;
     
131.                                                                         P4OUT=dz7[counter1];
     
132.                                                                         delay_ms(1000);
     
133. 
     
134.                                                                         P2OUT&=~BIT1;
     
135.                                                                         P4OUT = dz6[0];
     
136.                                                                         delay_ms(1000);
     
137. 
     
138.                                                                         P2OUT&=~BIT1;
     
139.                                                                         P4OUT = dz5[0];
     
140.                                                                         delay_ms(3000);
     
141. 
     
142.                                                                         P2OUT&=~BIT1;
     
143.                                                                         P4OUT = dz2[0];
     
144.                                                                         delay_ms(1000);
     
145. 
     
146.                                                                         counter1++;
     
147.                                                                         temp = counter1;
     
148.                                                                         counter1--;
     
149. 
     
150.                                                                         P2OUT&=~BIT1;
     
151.                                                                         P4OUT = dz7[temp];
     
152.                                                                         delay_ms(1000);
     
153. 
     
154.                                                                         P2OUT&=~BIT1;
     
155.                                                                         P4OUT = dz3[3];
     
156.                                                                         delay_ms(1000);
     
157. 
     
158.                                                                         P2OUT&=~BIT1;
     
159.                                                                         P4OUT = dz7[temp];
     
160.                                                                         delay_ms(1000);
     
161. 
     
162.                                                                         P2OUT&=~BIT1;
     
163.                                                                         P4OUT = dz4[0];
     
164.                                                                         delay_ms(3000);
     
165.                                                                         P2OUT&=~BIT1 ;
     
166.                                                                 }
     
167.                                                         if(counter1==8)
     
168.                                                                 {
     
169.                                                                         P2OUT&=~BIT1;
     
170.                                                                         P4OUT=dz1[1];
     
171.                                                                         delay_ms(1000);
     
172. 
     
173.                                                                         P2OUT&=~BIT1;
     
174.                                                                         P4OUT=dz7[counter1];
     
175.                                                                         delay_ms(1000);
     
176. 
     
177.                                                                         P2OUT&=~BIT1;
     
178.                                                                         P4OUT=dz6[0];
     
179.                                                                         delay_ms(1000);
     
180. 
     
181.                                                                         P2OUT&=~BIT1;
     
182.                                                                         P4OUT = dz5[0];
     
183.                                                                         delay_ms(3000);
     
184.                                                                         P2OUT&=~BIT1 ;
     
185.                                                                 }
     
186.                                                         counter1++;
     
187.                                                         while((P1IN&BIT3)==0);
     
188.                                                         while((P1IN&BIT5)==0);
     
189.                                                         P3OUT&=~BIT7;
     
190.                                                 }
     
191. 
     
192.                                         if ((P1IN & BIT4) == 0)          // 回退
     
193.                                                 {
     
194.                                                         counter1--;
     
195.                                                         counter2--;
     
196.                                                         P3OUT = buff2[counter2];
     
197.                                                         while((P1IN&BIT4)==0);
     
198.                                                 }
     
199. 
     
200.                                         if ((P1IN & BIT5) == 0)          // 重复报站
     
201.                                                 {
     
202.                                                         P2OUT&=~BIT1;
     
203.                                                         counter1--;
     
204.                                                         counter2--;
     
205.                                                         goto pl1;
     
206.                                                 }
     
207. 
     
208.                                         if ((P1IN & BIT6) == 0)          // 复位
     
209.                                                 {
     
210.                                                         counter1=0;
     
211.                                                         counter2=0;
     
212.                                                         P3OUT = buff2[counter2];
     
213.                                                         while((P1IN&BIT6)==0);
     
214.                                                 }
     
215. 
     
216.                                         if ((P1IN & BIT2) == 0)          // 正反选择
     
217.                                                 {
     
218.                                                         counter3++;
     
219.                                                         if((counter3%2)==0)
     
220.                                                                 {
     
221.                                                                         flag = 0;
     
222.                                                                         P2OUT |=BIT2;
     
223.                                                                         counter1=0;
     
224.                                                                         counter2=0;
     
225.                                                                 }
     
226.                                                         if((counter3%2)==1)
     
227.                                                                 {
     
228.                                                                         flag = 1;
     
229.                                                                         P2OUT &= ~BIT2;
     
230.                                                                         counter1=8;
     
231.                                                                         counter2=10;
     
232.                                                                 }
     
233.                                                         while((P1IN&BIT2)==0);
     
234.                                                 }
     
235. 
     
236.                         }
     
237.                 while((flag==1)&((P1IN & BIT1) == 0))
     
238.                         {
     
239.                                 if ((P1IN&BIT3)==0)          // 报站
     
240.                                         {
     
241.                                                 pl2:
     
242.                                                 P3OUT|=BIT7;
     
243.                                                 counter2--;
     
244.                                                 P3OUT = buff2[counter2]+BIT7;
     
245.                                                 if(counter1==8)
     
246.                                                         {
     
247.                                                                 P2OUT&=~BIT1;
     
248.                                                                 P4OUT = dz1[0];
     
249.                                                                 delay_ms(1000);
     
250. 
     
251.                                                                 P2OUT&=~BIT1;
     
252.                                                                 P4OUT = dz7[8];
     
253.                                                                 delay_ms(1000);
     
254. 
     
255.                                                                 P2OUT&=~BIT1;
     
256.                                                                 P4OUT = dz2[0];
     
257.                                                                 delay_ms(1000);
     
258. 
     
259.                                                                 P2OUT&=~BIT1;
     
260.                                                                 P4OUT = dz7[1];
     
261.                                                                 delay_ms(1000);
     
262. 
     
263.                                                                 P2OUT&=~BIT1;
     
264.                                                                 P4OUT = dz3[3];
     
265.                                                                 delay_ms(1000);
     
266. 
     
267.                                                                 P2OUT&=~BIT1;
     
268.                                                                 P4OUT = dz7[7];
     
269.                                                                 delay_ms(1000);
     
270. 
     
271.                                                                 P2OUT&=~BIT1;
     
272.                                                                 P4OUT = dz4[0];
     
273.                                                                 delay_ms(3000);
     
274.                                                                 P2OUT&=~BIT1 ;
     
275.                                                         }
     
276.                                                 if((1!=counter1) & (8!=counter1))
     
277.                                                         {
     
278.                                                         P2OUT&=~BIT1;
     
279.                                                         P4OUT = dz7[counter1];
     
280.                                                         delay_ms(1000);
     
281. 
     
282.                                                         P2OUT&=~BIT1;
     
283.                                                         P4OUT = dz6[0];
     
284.                                                         delay_ms(1000);
     
285. 
     
286.                                                         P2OUT&=~BIT1;
     
287.                                                         P4OUT = dz5[0];
     
288.                                                         delay_ms(3000);
     
289. 
     
290.                                                         P2OUT&=~BIT1;
     
291.                                                         P4OUT = dz2[0];
     
292.                                                         delay_ms(1000);
     
293. 
     
294.                                                         counter1--;
     
295.                                                         temp = counter1;
     
296.                                                         counter1++;
     
297. 
     
298.                                                         P2OUT&=~BIT1;
     
299.                                                         P4OUT = dz7[temp];
     
300.                                                         delay_ms(1000);
     
301. 
     
302.                                                         P2OUT&=~BIT1;
     
303.                                                         P4OUT = dz3[3];
     
304.                                                         delay_ms(1000);
     
305. 
     
306.                                                         P2OUT&=~BIT1;
     
307.                                                         P4OUT = dz7[temp];
     
308.                                                         delay_ms(1000);
     
309. 
     
310.                                                         P2OUT&=~BIT1;
     
311.                                                         P4OUT = dz4[0];
     
312.                                                         delay_ms(3000);
     
313.                                                         P2OUT&=~BIT1 ;
     
314.                                                 }
     
315.                                         if(counter1==0)
     
316.                                                 {
     
317.                                                         P2OUT&=~BIT1;
     
318.                                                         P4OUT = dz1[1];
     
319.                                                         delay_ms(1000);
     
320. 
     
321.                                                         P2OUT&=~BIT1;
     
322.                                                         P4OUT = dz7[counter1];
     
323.                                                         delay_ms(1000);
     
324. 
     
325.                                                         P2OUT&=~BIT1;
     
326.                                                         P4OUT = dz6[0];
     
327.                                                         delay_ms(1000);
     
328. 
     
329.                                                         P2OUT&=~BIT1;
     
330.                                                         P4OUT = dz5[0];
     
331.                                                         delay_ms(3000);
     
332.                                                         P2OUT&=~BIT1 ;
     
333.                                                 }
     
334. 
     
335.                                         counter1--;
     
336.                                         while((P1IN&BIT3)==0);
     
337.                                         while((P1IN&BIT5)==0);
     
338.                                         P3OUT&=~BIT7;
     
339.                                 }
     
340. 
     
341.                         if ((P1IN & BIT4) == 0)          // 回退
     
342.                                 {
     
343.                                         counter1++;
     
344.                                         counter2++;
     
345.                                         P3OUT = buff2[counter2];
     
346.                                         while((P1IN&BIT4)==0);
     
347.                                 }
     
348. 
     
349.                         if ((P1IN & BIT5) == 0)          // 重复报站
     
350.                                 {
     
351.                                         P2OUT&=~BIT1;
     
352.                                         counter1++;
     
353.                                         counter2++;
     
354.                                         goto pl2;
     
355.                                 }
     
356. 
     
357.                         if ((P1IN & BIT6) == 0)          // 复位
     
358.                                 {
     
359.                                         counter1=9;
     
360.                                         counter2=0;
     
361.                                         P3OUT = buff2[counter2];
     
362.                                         counter2=10;
     
363.                                         while((P1IN&BIT6)==0);
     
364.                                 }
     
365. 
     
366.                         if ((P1IN & BIT2) == 0)          // 正反选择
     
367.                                 {
     
368.                                         counter3++;
     
369.                                         if((counter3%2)==0)
     
370.                                                 {        flag = 0;
     
371.                                                         P2OUT |= BIT2;
     
372.                                                         counter1=0;
     
373.                                                         counter2=0;
     
374.                                                 }
     
375.                                         if((counter3%2)==1)
     
376.                                                 {
     
377.                                                         flag = 1;
     
378.                                                         P2OUT &= ~BIT2;
     
379.                                                         counter1=8;
     
380.                                                         counter2=10;
     
381.                                                 }
     
382.                                         while((P1IN&BIT2)==0);
     
383.                                 }
     
384.                         }
     
385.                 }
     
386. }
     
387. }
     
388. 
     
389. }
     

复制代码

没找到原理图

这个很感兴趣，好好学习一下

没有原理图不完整

原理图呢

要是51单片机的就好了