亚洲春色中文字幕久久久-三上亚,一吻二脱三床四吻胸,国产真实伦对白视频全集,在线毛片观看,精品成品入口黄网,国产毛aⅴ片久久久,亚洲AV色香蕉一区二区三区老师,萧皇后A级艳片,色情日本视频更新,99久久亚洲精品日本无码

標題: 單片機上位機控制下位機顯示聯合 Proteus仿真程序 [打印本頁]
作者: 寄語    時間: 2020-10-21 13:43
標題: 單片機上位機控制下位機顯示聯合 Proteus仿真程序
還有很多不足的地方，多多包容
仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


目前程序還無法正常運行,求大神幫忙修改：
矩陣鍵盤 點陣 上位機 數碼管 蜂鳴器聯合仿真.zip (325.64 KB, 下載次數: 15)


作者: 寄語    時間: 2020-10-21 13:50
標題: RE: 上位機控制下位機顯示聯合仿真。
主機代碼如下，下屬還有兩個從機代碼。
//主機
  1. #include<reg51.h>
  2. #include<string.h>

  4. #define _SUCC_   0x0f//數據傳送成功
  5. #define _ERR_    0xf0//數據傳送失敗
  6. unsigned char Table[50]={
  7.                                                  0x01, 0x01, 0xd6, 0x93, 0x91, 0xff,0x01,0x01,
  8.                                                  0x01, 0x40, 0x4c, 0x66, 0x72, 0x5e,0x4c,0x40,
  9.                                                  0xc4, 0xc6, 0xc3, 0xff, 0xff, 0xc0,0xc0,0xc0,
  10.                                                  0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,0x82,0xf8};//要發送的數據

  12. unsigned char Table0[8]={0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,0x82,0xf8};
  13. unsigned char Buff[50];  //數據緩沖區
  14. unsigned char temp=0xff;
  15. sbit KEY1=P1^0;//開關一號
  16. sbit KEY2=P1^1;//開關二號
  17. //unsigned char addr;                                                                                                                                          

  19. //延時1ms函數
  20. void delay_1ms(unsigned int t)
  21. {
  22.         unsigned int x,y;
  23.         for(x=t;x>0;x--)
  24.           for(y=110;y>0;y--);
  25. }
  26. //緩沖區初始化
  27. void Buff_init()
  28. {
  29.         unsigned char i;    //將Table里的數據放到緩沖區里
  30. //        for(i=0;i<20;i++)
  31.          for(i=0;i<50;i++)
  32.         {
  33.           Buff[i]= Table[i];//將Table里的數據放到Buffp[]里
  34.           delay_1ms(100);//延時100ms
  35.         }
  36. }

  38. //緩沖區初始化0
  39. void Buff_init0()
  40. {
  41.         unsigned char i;    //將Table里的數據放到緩沖區里
  42.         for(i=0;i<20;i++)  
  43.         {
  44.           Buff[i]= Table0[i];//將Table里的數據放到Buffp[]里
  45.           delay_1ms(100);//延時100ms
  46.         }
  47. }

  49. //串口初始化函數
  50. void serial_init()
  51. {
  52.         TMOD=0x20; //定時器1工作于方式2(00100000)M1=1,M0=0
  53.         TH1=0xfd;//定時器賦初值  
  54.         TL1=0xfd; //波特率為9600
  55.         PCON=0;//波特率正常
  56.         SCON=0xd0;  //串口工作于方式3  11010000
  57.         TR1=1;  //開啟定時器
  58.         TI=0;//開啟發送數據
  59.         RI=0;//開啟接受數據
  60. }
  61. //發送數據函數
  62. void SEND_data(unsigned char *Buff)//Buff數據緩沖區
  63. {
  64.         unsigned char i;
  65.         unsigned char lenth;
  66.         unsigned char check;
  67.         lenth=strlen(Buff);   //計算數據長度
  68.         check=lenth;
  69.         
  70.         TI=0;       //開啟發送
  71.         TB8=0;      //發送數據幀
  72.         SBUF=lenth;//發送數據長度   sbuf：串行口數據緩沖寄存器
  73.         while(!TI);//此時ti==0
  74.         TI=0;//開啟發送
  75.                  
  76.         for(i=0;i<lenth;i++)  //發送數據
  77.         {
  78.           check=check^Buff[i];//按位異或，同為一不同為零，
  79.           TB8=0;
  80.           SBUF=Buff[i]; //將Buff[i]中的數據存入單片機數據緩存區  
  81.           while(!TI);
  82.           TI=0;//開啟發送
  83.         }
  84.         //發送校驗字節
  85.         TB8=0;      
  86.         SBUF=check;   
  87.         while(!TI);
  88.         TI=0;     
  89. }
  90. //向指定從機地址發送數據
  91. void ADDR_data(unsigned addr)
  92. {
  93.         while(temp!=addr) //主機等待從機返回其地址作為應答信號
  94.         {
  95.           TI=0;    //發送從機地址
  96.           TB8=1;    //發送地址幀
  97.           SBUF=addr;
  98.           while(!TI);
  99.           TI=0;
  100.          
  101.           RI=0;//開始接受數據
  102.           while(!RI);
  103.           temp=SBUF;
  104.           RI=0;
  105.         }
  106.         
  107.         temp=_ERR_;   //主機等待從機數據接收成功信號
  108.         while(temp!=_SUCC_)//當發送成功時
  109.         {
  110.           SEND_data(Buff);
  111.           RI=0;
  112.           while(!RI);
  113.           temp=SBUF;
  114.           RI=0;
  115.         }
  116. }


  119. void chushihua()
  120. {
  121.         Buff_init();//先進行緩沖區初始化
  122.         serial_init();//串口初始化
  123.         while(1)
  124.         {
  125.           if(KEY1==0)//開關一按下
  126.           {
  127.                    delay_1ms(5);//延時5ms確認是否誤判
  128.                    if(KEY1==0)        //如果沒有誤判
  129.                    {
  130.                     while(!KEY1);
  131.                     ADDR_data(0x01);//發送從機地址
  132.                    }
  133.           }
  134.         }
  135. }



  139. void chushihua0()
  140. {
  141.         Buff_init0();//先進行緩沖區初始化
  142.         serial_init();//串口初始化
  143.         while(1)
  144.         {
  145.           if(KEY1==0)//開關一按下
  146.           {
  147.                    delay_1ms(5);//延時5ms確認是否誤判
  148.                    if(KEY1==0)        //如果沒有誤判
  149.                    {
  150.                     while(!KEY1);
  151.                     ADDR_data(0x01);//發送從機地址
  152.                    }
  153.           }
  154.         }
  155. }

  157.       
  158. void main()
  159. {
  160.         Buff_init();//先進行緩沖區初始化
  161.         serial_init();//串口初始化
  162.         while(1)
  163.         {
  164.         ADDR_data(0x01);//發送從機地址
  165.         ADDR_data(0x02);//發送從機地址
  166.         }
  167. }
  168. 從機1號
  169. //從機
  170. #include<reg51.h>
  171. #include<string.h>

  173. #define addr     0x01//從機1的地址
  174. #define _SUCC_   0x0f//數據傳送成功
  175. #define _ERR_    0xf0//數據傳送失敗


  178. sbit k1=P3^2;
  179. sbit k2=P3^3;
  180. sbit k3=P3^4;

  182. sbit D1=P3^5;
  183. sbit D2=P3^6;
  184. sbit D3=P3^7;

  186. unsigned char x;
  187. //延時1ms函數
  188. void delay_1ms(unsigned int t)
  189. {
  190.         unsigned int x,y;
  191.         for(x=t;x>0;x--)
  192.           for(y=110;y>0;y--);
  193. }



  197. unsigned char aa=0xff;//主機與從機之間通信標志
  198. //unsigned char Buff[20];//數據緩沖區
  199. unsigned char Buff[50];//數據緩沖區

  201. //串口初始化函數
  202. void serial_init()
  203. {
  204.         TMOD=0x20; //定時器1工作于方式2          波特率為9600
  205.         TH1=0xfd;  
  206.         TL1=0xfd; //定時器初值
  207.         PCON=0;
  208.         SCON=0xd0;  //串口工作于方式3
  209.         TR1=1;  //開啟定時器
  210.         TI=0;
  211.         RI=0;
  212. }
  213. //接收數據函數
  214. unsigned char RECE_data(unsigned char *Buff)
  215. {
  216.         unsigned char i,temp;
  217.         unsigned char lenth;
  218.         unsigned char check;
  219.         
  220.         RI=0;     //開啟接收數據（長度）
  221.         while(!RI);
  222.         if(RB8==1)    //若接收到地址幀，則返回0xfe
  223.           return 0xfe;
  224.         lenth=SBUF;
  225.         RI=0; //開啟再次接收數據   
  226.         
  227.         check=lenth;
  228.         for(i=0;i<lenth;i++) //接收數據
  229.         {
  230.           while(!RI);
  231.           if(RB8==1)   //若接收到地址幀，則返回0xfe
  232.            return 0xfe;
  233.           Buff[i]=SBUF;   
  234.           check=check^(Buff[i]);//按位異或
  235.           RI=0;
  236.         }

  238.         while(!RI);    //接收校驗字節
  239.         if(RB8==1)    //若接收到地址幀，則返回0xfe
  240.           return 0xfe;
  241.         temp=SBUF;
  242.         RI=0;
  243.               
  244.         check=temp^check;  //將從主機接收到的校驗碼與自己計算的校驗碼比對（同為零，不同則大于零）
  245.         if(check!=0)   //校驗碼不一致，表明數據接收錯誤，向主機發送錯誤信號，函數返回0xff
  246.         {
  247.           TI=0;
  248.           TB8=0;
  249.           SBUF=_ERR_; //把錯誤信號賦值到緩沖區待發送
  250.           while(!TI); //發送完畢時跳出循環
  251.           TI=0;
  252.           return 0xff;
  253.         }
  254.         TI=0;           //校驗碼一致，表明數據接收正確，向主機發送成功信號，函數返回0x00
  255.         TB8=0;
  256.         SBUF=_SUCC_;
  257.         while(!TI);                 //發送成功的信號給主機
  258.         TI=0;
  259.         return 0;
  260. }
  261. const unsigned char CharCode0[8]={0xff,0x81,0x81,0x81,0x81,0x81,0x81,0xff};//P2口代碼
  262. unsigned  char  DispBuff[25]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
  263. void chuang1()
  264. {
  265. static char CurPosi;    //定義當前輸出位置
  266. D1=0;
  267. P2=Buff[DispBuff[CurPosi]+16]; //輸出當前字符顯示編碼到 P2 口
  268.         switch (CurPosi++)     //當前輸出位置加 1   
  269.         {
  270.                 case 0:P1=0x00;break;   //P1.0 置低   
  271.                 case 1:P1=0x20;break; //P1.1 置低   
  272.                 case 2:P1=0x40;break;   //開一點窗   
  273.                 case 3:P1=0x60;break;    //開一半
  274.                 case 4:P1=0x80;break;//開大半
  275.                 case 5:P1=0xa0;break;         //全關
  276.                 case 6:P1=0xc0;break;        //全開
  277.                 case 7:P1=0xe0;break;
  278.         }   
  279.         if(CurPosi>7)  
  280.         CurPosi=0;   //當前輸出位置大于 7 則重頭開始
  281.         
  282. }
  283. void chuang2()
  284. {
  285. static char CurPosi;    //定義當前輸出位置
  286. D2=0;
  287. P2=Buff[DispBuff[CurPosi]+8]; //輸出當前字符顯示編碼到 P2 口
  288.         switch (CurPosi++)     //當前輸出位置加 1   
  289.         {
  290.                 case 0:P1=0x00;break;   //P1.0 置低   
  291.                 case 1:P1=0x20;break; //P1.1 置低   
  292.                 case 2:P1=0x40;break;   //開一點窗   
  293.                 case 3:P1=0x60;break;    //開一半
  294.                 case 4:P1=0x80;break;//開大半
  295.                 case 5:P1=0xa0;break;         //全關
  296.                 case 6:P1=0xc0;break;        //全開
  297.                 case 7:P1=0xe0;break;
  298.         }   
  299.         if(CurPosi>7)  
  300.         CurPosi=0;   //當前輸出位置大于 7 則重頭開始
  301.         
  302. }
  303. void chuang3()
  304. {
  305. static char CurPosi;    //定義當前輸出位
  306. D3=0;
  307. P2=Buff[DispBuff[CurPosi]]; //輸出當前字符顯示編碼到 P2 口
  308.         switch (CurPosi++)     //當前輸出位置加 1   
  309.         {
  310.                 case 0:P1=0x00;break;   //P1.0 置低   
  311.                 case 1:P1=0x20;break; //P1.1 置低   
  312.                 case 2:P1=0x40;break;   //開一點窗   
  313.                 case 3:P1=0x60;break;    //開一半
  314.                 case 4:P1=0x80;break;//開大半
  315.                 case 5:P1=0xa0;break;         //全關
  316.                 case 6:P1=0xc0;break;        //全開
  317.                 case 7:P1=0xe0;break;
  318.         }   
  319.         if(CurPosi>7)  
  320.         CurPosi=0;   //當前輸出位置大于 7 則重頭開始

  322. }
  323. //中斷函數
  324. void  T0_INTProc(void)  interrupt  1   //T0 定時中斷函數
  325. {
  326.         P1=0xff;       //關閉所有顯示，消隱
  327.          
  328.         TH0=0xec;     
  329.         TL0=0x78;        //重裝計數值   
  330.         TR0=1;     //重啟計數，為顯示下一字符作準備  
  331. if(k1==0)  
  332. chuang1();
  333. else
  334. D1=1;               
  335. if(k2==0)
  336. chuang2();
  337. else
  338. D2=1;
  339. if(k3==0)  
  340. chuang3();
  341. else
  342. D3=1;
  343. }
  344. void main()
  345. {
  346.         serial_init();          //串口初始化
  347.         while(1)
  348.         {
  349.           SM2=1;            //開啟接收地址幀
  350.           while(aa!=addr)  //從機等待主機請求自己的地址
  351.           {
  352.                    RI=0;
  353.                    while(!RI);
  354.                    aa=SBUF;
  355.                    RI=0;
  356.           }
  357.         
  358.           TI=0;     //一旦被請求，從機返回自己地址作為應答，等待接收數據
  359.           TB8=0;
  360.           SBUF=addr;
  361.           while(!TI);
  362.           TI=0;
  363.         
  364.           SM2=0;                  //接收數據幀
  365.           aa=0xff;                                    //從機接收數據，并將數據保存到數據緩沖區
  366.           while(aa==0xff)
  367.           {
  368.                    aa=RECE_data(Buff);                //接收數據
  369.           }
  370.           if(aa==0xfe)
  371.            continue;
  372.                 TMOD=0x01;      //設定 T0 工作在定時方式 1，16位計數  
  373.                 TH0=0xec;     //裝入計數值高字節（中斷時間）  
  374.                 TL0=0x78;      //裝入計數值低字節  
  375.                 EA=1;    //開總中斷  
  376.                 ET0=1;       //開 T0 中斷  
  377.                 TR0=1;       //啟動 T0 計數  
  378.                 while(1);      //無限循環等待中斷發生
  379.                
  380.         }
  381. }
復制代碼

從機2號
//從機2
  1. #include<reg51.h>
  2. #include<string.h>

  4. #define addr     0x02//從機1的地址
  5. #define _SUCC_   0x0f//數據傳送成功
  6. #define _ERR_    0xf0//數據傳送失敗
  7. unsigned char a;
  8. unsigned char x;
  9. //延時1ms函數
  10. void delay_1ms(unsigned int t)
  11. {
  12.         unsigned int x,y;
  13.         for(x=t;x>0;x--)
  14.           for(y=110;y>0;y--);
  15. }
  16. unsigned char aa=0xff;//主機與從機之間通信標志
  17. unsigned char Buff[50];//數據緩沖區

  19. //串口初始化函數
  20. void serial_init()
  21. {
  22.         TMOD=0x20; //定時器1工作于方式2          波特率為9600
  23.         TH1=0xfd;  
  24.         TL1=0xfd; //定時器初值
  25.         PCON=0;
  26.         SCON=0xd0;  //串口工作于方式3
  27.         TR1=1;  //開啟定時器
  28.         TI=0;
  29.         RI=0;
  30. }
  31. //接收數據函數
  32. unsigned char RECE_data(unsigned char *Buff)
  33. {
  34.         unsigned char i,temp;
  35.         unsigned char lenth;
  36.         unsigned char check;
  37.         
  38.         RI=0;     //開啟接收數據（長度）
  39.         while(!RI);
  40.         if(RB8==1)    //若接收到地址幀，則返回0xfe
  41.           return 0xfe;
  42.         lenth=SBUF;
  43.         RI=0; //開啟再次接收數據   
  44.         
  45.         check=lenth;
  46.         for(i=0;i<lenth;i++) //接收數據
  47.         {
  48.           while(!RI);
  49.           if(RB8==1)   //若接收到地址幀，則返回0xfe
  50.            return 0xfe;
  51.           Buff[i]=SBUF;   
  52.           check=check^(Buff[i]);//按位異或
  53.           RI=0;
  54.         }

  56.         while(!RI);    //接收校驗字節
  57.         if(RB8==1)    //若接收到地址幀，則返回0xfe
  58.           return 0xfe;
  59.         temp=SBUF;
  60.         RI=0;
  61.               
  62.         check=temp^check;  //將從主機接收到的校驗碼與自己計算的校驗碼比對（同為零，不同則大于零）
  63.         if(check!=0)   //校驗碼不一致，表明數據接收錯誤，向主機發送錯誤信號，函數返回0xff
  64.         {
  65.           TI=0;
  66.           TB8=0;
  67.           SBUF=_ERR_; //把錯誤信號賦值到緩沖區待發送
  68.           while(!TI); //發送完畢時跳出循環
  69.           TI=0;
  70.           return 0xff;
  71.         }
  72.         TI=0;           //校驗碼一致，表明數據接收正確，向主機發送成功信號，函數返回0x00
  73.         TB8=0;
  74.         SBUF=_SUCC_;
  75.         while(!TI);                 //發送成功的信號給主機
  76.         TI=0;
  77.         return 0;
  78. }
  79. #define uchar unsigned char//宏定義無符號字符型
  80. #define uint unsigned int  //宏定義無符號整型

  82. //定義分別表示8255A各口的變量
  83. volatile unsigned char xdata Aport _at_ 0x8000;
  84. volatile unsigned char xdata Bport _at_ 0x8001;
  85. volatile unsigned char xdata Cport _at_ 0x8002;
  86. volatile unsigned char xdata Ctrlport _at_ 0x8003;
  87. const unsigned char CharCode1[10]= {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,0x82,0xf8, 0x80,0x90};//晶體管真值碼
  88. unsigned char code seg7code[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90 };//鍵盤真值碼
  89. unsigned char k;


  92. void delay10ms(void) //延時程序
  93. {
  94.         unsigned char i,j;
  95.         for(i=20;i>0;i--)
  96.         for(j=248;j>0;j--);
  97. }

  99. //行掃描獲取鍵盤函數     
  100. void Getch ( )        //取鍵值函數
  101. {
  102. unsigned char X,Y,Z;
  103. Bport=0x0f; //先對P3 置數 行掃描
  104. if(Bport!=0x0f) //判斷是否有鍵按下
  105.         {
  106.         delay10ms(); //延時,軟件去干擾
  107.         if(Bport!=0x0f) //確認按鍵按下
  108.                 {
  109.                 X=Bport; //保存行掃描時有鍵按下時狀態
  110.                 Bport=0xf0; //列掃描
  111.                 Y=Bport;    //保存列掃描時有鍵按下時狀態
  112.                 Z=X|Y; //取出鍵值

  114. //獲取鍵盤值函數
  115. switch ( Z ) //判斷鍵值（那一個鍵按下）
  116.                         {
  117.                                 case 0x77: k=0; break; //對鍵值賦值
  118.                                 case 0x7b: k=1; break;
  119.                                 case 0x7d: k=2; break;
  120.                                 case 0x7e: k=3; break;
  121.                                 case 0xb7: k=4; break;
  122.                                 case 0xbb: k=5; break;
  123.                                 /*  case 0xbd: k=6; break;
  124.                                 case 0xbe: k=7;
  125.                                 case 0xd7: k=8; break;
  126.                                 case 0xdb: k=9; break;
  127.                                 case 0xdd: k=10;break;
  128.                                 case 0xde: k=11;break;
  129.                                 case 0xe7: k=12;break;
  130.                                 case 0xeb: k=13;break;
  131.                                 case 0xed: k=14;break;
  132.                                 case 0xee: k=15;break;*/
  133.                         }
  134.                  }
  135.         }
  136. }
  137. void main()
  138. {
  139.         serial_init();          //串口初始化
  140.         while(1)
  141.         {
  142.           SM2=1;            //開啟接收地址幀
  143.           while(aa!=addr)  //從機等待主機請求自己的地址
  144.           {
  145.                    RI=0;
  146.                    while(!RI);
  147.                    aa=SBUF;
  148.                    RI=0;
  149.           }
  150.         
  151.           TI=0;     //一旦被請求，從機返回自己地址作為應答，等待接收數據
  152.           TB8=0;
  153.           SBUF=addr;
  154.           while(!TI);
  155.           TI=0;
  156.         
  157.           SM2=0;                  //接收數據幀
  158.           aa=0xff;                                    //從機接收數據，并將數據保存到數據緩沖區
  159.           while(aa==0xff)
  160.           {
  161.                    aa=RECE_data(Buff);                //接收數據
  162.           }
  163.           if(aa==0xfe)
  164.            continue;
  165.         while(1){
  166.         a=1;
  167.         while(a)
  168.         {
  169.                 Bport=0xff;
  170.                 Getch();             //調用取鍵值函數
  171.                 Aport=Buff[k+24]; //查表LED輸出

  173.                                 if(k==5)
  174.                                 P1=0x00;
  175.                                 if(P1==0x02)
  176.                                 {
  177.                                 P1=0X01;
  178.                                 a=0;
  179.                                 }
  180.                   }
  181.         }
  182.                
  183.         }
  184. }
復制代碼






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