標(biāo)題: 公交車報(bào)站系統(tǒng)在proteus上仿真 原理圖 源程序 [打印本頁]
作者: laoliu6    時(shí)間: 2016-6-22 10:35
標(biāo)題: 公交車報(bào)站系統(tǒng)在proteus上仿真 原理圖 源程序
公交車報(bào)站系統(tǒng)的仿真，msp430f2272為中央處理器的鍵盤掃描，led驅(qū)動(dòng)，7段數(shù)碼管的控制。isd1420的驅(qū)動(dòng)在proteus仿真的原理圖，以及源程序。



單片機(jī)代碼：
  1. /* Main.c file generated by New Project wizard
  2. *
  3. * Created:   周一 六月 20 2016
  4. * Processor: MSP430F2272
  5. * Compiler:  CodeComposer for MSP430
  6. */

  8. #include <msp430.h>

  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))

  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;                   //清除振蕩器錯(cuò)誤標(biāo)志
  24.                          for(i=0;i<100;i++)
  25.                                  _NOP();
  26.                 }
  27.                  while((IFG1&OFIFG)!=0);           //如果標(biāo)志位1，則繼續(xù)循環(huán)等待
  28.                          IFG1&=~OFIFG;

  30.         }


  33. int main(void)
  34. {
  35.         WDTCTL = WDTPW + WDTHOLD;
  36.         Clock_Init();

  38.         P1REN|=0xff;          //按鍵初始化
  39.         P1OUT |=0xff;

  41.         P2DIR |= 0x0F;                //控制端口初始化
  42.         P2OUT |= BIT0+BIT1+BIT2;


  45.         P3DIR |= 0xff;                        //LED控制端口

  47.         P4DIR |= 0xff;                        //語音地址端口初始化

  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};

  57.     unsigned int counter1=0;          // ISD地址計(jì)數(shù)器
  58.     unsigned int temp;

  60.     unsigned int flag = 0;                //正反選擇標(biāo)志
  61.     unsigned int counter3 = 0;        //正反計(jì)數(shù)器

  63.     unsigned int buff2[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09};
  64.     unsigned int counter2=0 ;         // LED地址計(jì)數(shù)器
  65.         P3OUT = buff2[counter2];

  67.         unsigned int counter4=0;        //錄音計(jì)數(shù)器
  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.                  }

  87.         while ((P1IN & BIT1) == 0)          // 放音模式
  88.                 {       
  89.                         while((flag==0)&((P1IN & BIT1) == 0))
  90.                                 {
  91.                                         if ((P1IN&BIT3)==0)          // 報(bào)站
  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);

  103.                                                                         P2OUT&=~BIT1;
  104.                                                                         P4OUT = dz7[0];
  105.                                                                         delay_ms(1000);

  107.                                                                         P2OUT&=~BIT1;
  108.                                                                         P4OUT = dz2[0];
  109.                                                                         delay_ms(1000);

  111.                                                                         P2OUT&=~BIT1;
  112.                                                                         P4OUT = dz7[1];
  113.                                                                         delay_ms(1000);

  115.                                                                         P2OUT&=~BIT1;
  116.                                                                         P4OUT = dz3[3];
  117.                                                                         delay_ms(1000);

  119.                                                                         P2OUT&=~BIT1;
  120.                                                                         P4OUT = dz7[1];
  121.                                                                         delay_ms(1000);

  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);

  134.                                                                         P2OUT&=~BIT1;
  135.                                                                         P4OUT = dz6[0];
  136.                                                                         delay_ms(1000);

  138.                                                                         P2OUT&=~BIT1;
  139.                                                                         P4OUT = dz5[0];
  140.                                                                         delay_ms(3000);

  142.                                                                         P2OUT&=~BIT1;
  143.                                                                         P4OUT = dz2[0];
  144.                                                                         delay_ms(1000);

  146.                                                                         counter1++;
  147.                                                                         temp = counter1;
  148.                                                                         counter1--;

  150.                                                                         P2OUT&=~BIT1;
  151.                                                                         P4OUT = dz7[temp];
  152.                                                                         delay_ms(1000);

  154.                                                                         P2OUT&=~BIT1;
  155.                                                                         P4OUT = dz3[3];
  156.                                                                         delay_ms(1000);

  158.                                                                         P2OUT&=~BIT1;
  159.                                                                         P4OUT = dz7[temp];
  160.                                                                         delay_ms(1000);

  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);

  173.                                                                         P2OUT&=~BIT1;
  174.                                                                         P4OUT=dz7[counter1];
  175.                                                                         delay_ms(1000);

  177.                                                                         P2OUT&=~BIT1;
  178.                                                                         P4OUT=dz6[0];
  179.                                                                         delay_ms(1000);

  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.                                                 }

  192.                                         if ((P1IN & BIT4) == 0)          // 回退
  193.                                                 {
  194.                                                         counter1--;
  195.                                                         counter2--;
  196.                                                         P3OUT = buff2[counter2];
  197.                                                         while((P1IN&BIT4)==0);
  198.                                                 }

  200.                                         if ((P1IN & BIT5) == 0)          // 重復(fù)報(bào)站
  201.                                                 {
  202.                                                         P2OUT&=~BIT1;
  203.                                                         counter1--;
  204.                                                         counter2--;
  205.                                                         goto pl1;
  206.                                                 }

  208.                                         if ((P1IN & BIT6) == 0)          // 復(fù)位
  209.                                                 {
  210.                                                         counter1=0;
  211.                                                         counter2=0;
  212.                                                         P3OUT = buff2[counter2];
  213.                                                         while((P1IN&BIT6)==0);
  214.                                                 }

  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.                                                 }

  236.                         }
  237.                 while((flag==1)&((P1IN & BIT1) == 0))
  238.                         {
  239.                                 if ((P1IN&BIT3)==0)          // 報(bào)站
  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);

  251.                                                                 P2OUT&=~BIT1;
  252.                                                                 P4OUT = dz7[8];
  253.                                                                 delay_ms(1000);

  255.                                                                 P2OUT&=~BIT1;
  256.                                                                 P4OUT = dz2[0];
  257.                                                                 delay_ms(1000);

  259.                                                                 P2OUT&=~BIT1;
  260.                                                                 P4OUT = dz7[1];
  261.                                                                 delay_ms(1000);

  263.                                                                 P2OUT&=~BIT1;
  264.                                                                 P4OUT = dz3[3];
  265.                                                                 delay_ms(1000);

  267.                                                                 P2OUT&=~BIT1;
  268.                                                                 P4OUT = dz7[7];
  269.                                                                 delay_ms(1000);

  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);

  282.                                                         P2OUT&=~BIT1;
  283.                                                         P4OUT = dz6[0];
  284.                                                         delay_ms(1000);

  286.                                                         P2OUT&=~BIT1;
  287.                                                         P4OUT = dz5[0];
  288.                                                         delay_ms(3000);

  290.                                                         P2OUT&=~BIT1;
  291.                                                         P4OUT = dz2[0];
  292.                                                         delay_ms(1000);

  294.                                                         counter1--;
  295.                                                         temp = counter1;
  296.                                                         counter1++;

  298.                                                         P2OUT&=~BIT1;
  299.                                                         P4OUT = dz7[temp];
  300.                                                         delay_ms(1000);

  302.                                                         P2OUT&=~BIT1;
  303.                                                         P4OUT = dz3[3];
  304.                                                         delay_ms(1000);

  306.                                                         P2OUT&=~BIT1;
  307.                                                         P4OUT = dz7[temp];
  308.                                                         delay_ms(1000);

  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);

  321.                                                         P2OUT&=~BIT1;
  322.                                                         P4OUT = dz7[counter1];
  323.                                                         delay_ms(1000);

  325.                                                         P2OUT&=~BIT1;
  326.                                                         P4OUT = dz6[0];
  327.                                                         delay_ms(1000);

  329.                                                         P2OUT&=~BIT1;
  330.                                                         P4OUT = dz5[0];
  331.                                                         delay_ms(3000);
  332.                                                         P2OUT&=~BIT1 ;
  333.                                                 }

  335.                                         counter1--;
  336.                                         while((P1IN&BIT3)==0);
  337.                                         while((P1IN&BIT5)==0);
  338.                                         P3OUT&=~BIT7;
  339.                                 }

  341.                         if ((P1IN & BIT4) == 0)          // 回退
  342.                                 {
  343.                                         counter1++;
  344.                                         counter2++;
  345.                                         P3OUT = buff2[counter2];
  346.                                         while((P1IN&BIT4)==0);
  347.                                 }

  349.                         if ((P1IN & BIT5) == 0)          // 重復(fù)報(bào)站
  350.                                 {
  351.                                         P2OUT&=~BIT1;
  352.                                         counter1++;
  353.                                         counter2++;
  354.                                         goto pl2;
  355.                                 }

  357.                         if ((P1IN & BIT6) == 0)          // 復(fù)位
  358.                                 {
  359.                                         counter1=9;
  360.                                         counter2=0;
  361.                                         P3OUT = buff2[counter2];
  362.                                         counter2=10;
  363.                                         while((P1IN&BIT6)==0);
  364.                                 }

  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. }

  389. }
復(fù)制代碼


proteus上鍵盤掃描.zip

70.24 KB, 下載次數(shù): 109, 下載積分: 黑幣 -5

仿真源程序，原理圖
作者: 5達(dá)go    時(shí)間: 2016-12-27 22:48
沒找到原理圖
作者: 喜悅的春天    時(shí)間: 2016-12-28 19:45
這個(gè)很感興趣，好好學(xué)習(xí)一下
作者: 喜悅的春天    時(shí)間: 2016-12-28 19:46
沒有原理圖不完整
作者: 劉新    時(shí)間: 2018-7-1 15:53
原理圖呢

作者: 會(huì)飛的豬A    時(shí)間: 2020-2-29 19:22
要是51單片機(jī)的就好了




歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1