久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 6784|回復: 5
收起左側

公交車報站系統在proteus上仿真 原理圖 源程序

[復制鏈接]
ID:127642 發表于 2016-6-22 10:35 | 顯示全部樓層 |閱讀模式
公交車報站系統的仿真，msp430f2272為中央處理器的鍵盤掃描，led驅動，7段數碼管的控制。isd1420的驅動在proteus仿真的原理圖，以及源程序。

0.png

單片機代碼：
  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;                   //清除振蕩器錯誤標志
  24.                          for(i=0;i<100;i++)
  25.                                  _NOP();
  26.                 }
  27.                  while((IFG1&OFIFG)!=0);           //如果標志位1，則繼續循環等待
  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地址計數器
  58.     unsigned int temp;

  60.     unsigned int flag = 0;                //正反選擇標志
  61.     unsigned int counter3 = 0;        //正反計數器

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

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

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

  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)          // 重復報站
  201.                                                 {
  202.                                                         P2OUT&=~BIT1;
  203.                                                         counter1--;
  204.                                                         counter2--;
  205.                                                         goto pl1;
  206.                                                 }

  208.                                         if ((P1IN & BIT6) == 0)          // 復位
  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)          // 報站
  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)          // 重復報站
  350.                                 {
  351.                                         P2OUT&=~BIT1;
  352.                                         counter1++;
  353.                                         counter2++;
  354.                                         goto pl2;
  355.                                 }

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

  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. }
復制代碼


proteus上鍵盤掃描.zip

70.24 KB, 下載次數: 109, 下載積分: 黑幣 -5

仿真源程序，原理圖

評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

回復

使用道具 舉報

ID:157748 發表于 2016-12-27 22:48 | 顯示全部樓層
沒找到原理圖
回復

使用道具 舉報

ID:158453 發表于 2016-12-28 19:45 | 顯示全部樓層
這個很感興趣，好好學習一下
回復

使用道具 舉報

ID:158453 發表于 2016-12-28 19:46 | 顯示全部樓層
沒有原理圖不完整
回復

使用道具 舉報

ID:362549 發表于 2018-7-1 15:53 | 顯示全部樓層
原理圖呢

回復

使用道具 舉報

ID:699117 發表于 2020-2-29 19:22 | 顯示全部樓層
要是51單片機的就好了
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板： 亚洲区中文字幕 | 97超碰中文网 | 亚洲欧美一区二区三区视频 | 久久久久久久一区 | 91精品久久久久久久久 | 国产精品成人一区二区三区夜夜夜 | 日本不卡在线视频 | 国产精品一区二区三 | 一级毛片色一级 | 国产高清一区二区三区 | 91九色麻豆 | 中文字幕日韩欧美一区二区三区 | 亚洲精品视频二区 | 中文字幕人成乱码在线观看 | 女人牲交视频一级毛片 | 国产在线精品一区二区 | 91私密视频 | 巨大荫蒂视频欧美另类大 | 亚洲国产aⅴ成人精品无吗 综合国产在线 | 日韩中文一区二区三区 | 国产在线1 | 黄视频网址 | 日日夜夜免费精品视频 | 久草资源在线 | 国产日韩久久 | 国产一区二区在线免费视频 | 在线观看黄色电影 | 国产成人av在线播放 | 国产精品久久国产精品 | 亚洲区一区二区 | 国内精品视频一区二区三区 | 日韩精品一区二区三区中文在线 | www.黄色网| 在线免费观看黄网 | 国内自拍偷拍 | 国产精品久久久久久婷婷天堂 | 日本精品一区二区三区在线观看 | 国产丝袜一区二区三区免费视频 | 欧美自拍日韩 | 伊人春色成人 | 水蜜桃亚洲一二三四在线 |