设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机电梯设计内外机程序源码
返回列表 发新帖
查看: 356|回复: 0
打印 上一主题 下一主题
收起左侧

基于51单片机电梯设计内外机程序源码

[复制链接]
跳转到指定楼层
楼主
ID:578150 发表于 2025-11-28 16:17 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
内机:

  1. /**********************************
  2. 包含头文件
  3. **********************************/
  4. #include "main.h"
  5. #include "key.h"
  6. #include "tube.h"
  7. #include "timer.h"
  8. #include "uart.h"
  9. #include "interrupt.h"


  12. /**********************************
  13. 变量定义
  14. **********************************/
  15. uchar key_num = 0;                                                                                        //按键扫描标志位
  16. uint time_num = 0;                                                                                        //10ms计时变量

  18. bit flag_send = 0;                      //发送标志位

  20. bit flag_abnormal = 0;                  //电梯异常标志位

  22. uchar current_old = 0;                  //上次当前楼层
  23. uchar current_floor = 1;                //当前楼层
  24. uint target_floor = 1;                  //目标楼层
  25. uchar flag_floor_u[10] = {0};           //楼层上标志位
  26. uchar flag_floor_d[10] = {0};           //楼层下标志位
  27. bit flag_stop = 1;                      //到达目标楼层停留完成否标志位

  29. extern bit flag_door;                   //电梯门的状态
  30. uint flag_lift = 0;                     //当前升降标志位
  31. extern bit flag_bujin_1_o;                                                        //升降步进电机正转标志位
  32. extern bit flag_bujin_1_c;                                                        //升降步进电机反转标志位
  33. extern bit flag_bujin_2_o;                                                        //门步进电机正转标志位
  34. extern bit flag_bujin_2_c;                                                        //门步进电机反转标志位

  36. bit flag_maopi = 0;                                                                            //第一次毛皮重量标志位
  37. ulong weight_maopi = 0;                                                                  //毛皮重量
  38. uint  weight_value = 0;                                                                  //重量值
  39. uint  weight_test = 0;                                                                  //重量值

  41. uchar send_buf[10]={0x99,0x00};         //发送数组;

  43. extern uchar uart_buf[16];              //串口接收缓存区
  44. extern uchar uart_count;                //串口接收计数

  46. extern bit flag_timer_begin;                                                //计时开始标志位
  47. extern bit flag_time;                                                                //定时1s完成标志位

  49. extern bit flag_timer_begin_s;          //停留时间开始标志位
  50. extern bit flag_time_s;                 //停留时间到达标志位
  51. extern uint timer1_count_s;             //停留时间计数

  53. extern uchar Speed;

  55. extern bit Stop_Flag ;                                                                                                                        //升降步进电机停止标志位
  56. extern bit speed_alarm;                                                                                //速度
  57. extern bit Stop;                                                                                                                        //升降步进电机停止标志位

  59. /**********************************
  60. 函数声明
  61. **********************************/
  62. void Delay_function(uint x);                                                //延时函数(ms)
  63. void Key_function(void);                                                        //按键函数
  64. void Monitor_function(void);                                                //监测函数
  65. void Display_function(void);                                                //显示函数
  66. void Manage_function(void);                                                        //处理函数


  69. /****
  70. *******        主函数
  71. *****/
  72. void main()
  73. {
  74.   Timer0_Init();                                                       //定时器0初使化函数
  75.   Delay_function(50);                                                          //延时50ms
  76.   Uart_Init();                                                                      //串口初始化函数
  77.   Delay_function(50);                   //延时50ms
  78.   Exter0_Init();                                                                  //外部中断0初使化函数
  79.   Delay_function(50);                   //延时50ms
  80.   
  81.         while(1)
  82.         {
  83.                 Key_function();                                                                                //按键函数
  84. //                Monitor_function();                                                                        //监测函数
  85.                 Display_function();                                                                        //显示函数
  86.                 Manage_function();                                                                        //处理函数
  87.    
  88.                 Delay_function(10);                                                                        //延时10ms
  89.                 time_num++;                                                                                        //计时变量+1
  90.                 if(time_num == 5000)
  91.                 {
  92.                         time_num = 0;
  93.                 }
  94.         }
  95. }

  97. /****
  98. *******        延时 x ms函数
  99. *****/
  100. void Delay_function(uint x)
  101. {
  102.         uint m,n;
  103.         for(m=x;m>0;m--)
  104.     for(n=110;n>0;n--);
  105. }

  107. /****
  108. *******按键函数
  109. *****/
  110. void Key_function(void)
  111. {
  112.         key_num = Matrix_Keyboard_Scan();                   //按键扫描
  113.         if(key_num != 0xff)                                                                                //有按键按下
  114.         {
  115.                 switch(key_num)
  116.                 {
  117.                         case 1:                                                                                                                //按键1，一楼按下
  118.         if(current_floor > 1)       //如果当前楼层高于一楼，标记一楼下
  119.           flag_floor_d[1] = 1;
  120.         else if(current_floor < 1)  //如果当前楼层低于一楼，标记一楼上
  121.           flag_floor_u[1] = 1;
  122.                                 
  123.                                 Stop = 0;
  124.                         break;

  126.                         case 2:                                                                                                                //按键2，二楼按下
  127.         if(current_floor > 2)       //如果当前楼层高于二楼，标记二楼下
  128.           flag_floor_d[2] = 2;
  129.         else if(current_floor < 2)  //如果当前楼层低于二楼，标记二楼上
  130.           flag_floor_u[2] = 2;
  131.                                 
  132.                                 Stop = 0;
  133.                         break;

  135.                         case 3:                                                                                                                //按键3，三楼按下
  136.         if(current_floor > 3)       //如果当前楼层高于三楼，标记三楼下
  137.           flag_floor_d[3] = 3;
  138.         else if(current_floor < 3)  //如果当前楼层低于三楼，标记三楼上
  139.           flag_floor_u[3] = 3;
  140.                                 
  141.                                 Stop = 0;
  142.                         break;

  144.       case 4:                                                                                                        //按键4，开门
  145.         if(flag_bujin_1_o == 0 && flag_bujin_1_c == 0) //当前电梯未运行
  146.         {
  147.           flag_stop = 0;                  //标记未停留完成
  148.           if(flag_bujin_2_c == 1)         //如果正在关门，将门打开
  149.           {
  150.             flag_door = 0;
  151.           }
  152.           else                           //还没关门，清除停留时间计数
  153.           {
  154.             timer1_count_s = 0;
  155.           }
  156.         }
  157.                         break;

  159.       case 5:                                                                                                        //按键5，关门
  160.         if(flag_bujin_1_o == 0 && flag_bujin_1_c == 0 && YL==1 && INFRARED == 0) //当前电梯未运行
  161.         {
  162.           if(flag_bujin_2_o == 1)         //如果正在开，将门关闭
  163.           {
  164.             flag_stop = 1;
  165.             flag_door = 1;
  166.           }
  167.           else                            //如果门未在运动，直接停留完成
  168.           {
  169.             timer1_count_s = 3000;
  170.           }
  171.         }
  172.                         break;

  174.                         case 6:                                                                                                        //按键6,呼叫
  175.         RELAY = ~RELAY;
  176.                         RELAY = 0;
  177. //                                while(key_num==6);
  178.                         break;

  180.                         case 7:                                                                                                        //按键7，停止
  181.                                 Stop = ~Stop;
  182. //                                while(key_num==7);
  183.                         break;

  185.                         case 8:                                                                                                        
  186.                                 if(Speed==3)
  187.                                         Speed=0;
  188.                                 else
  189.                                         Speed=3;
  190. //                                while(key_num==8);
  191.                         break;
  192.                         
  193.                         case 9:                                                                                                        

  195.                         break;
  196.                                 
  197.                         default:
  198.                         break;
  199.                 }
  200.         }
  201. }

  203. /****
  204. *******监测函数
  205. *****/
  206. void Monitor_function(void)
  207. {
  208.   if(uart_count >= 2)         //如果接收到两个字节，标记相应楼层
  209.   {
  210.     if(uart_buf[1] == 0x11)
  211.     {
  212.       flag_floor_d[1] = 1;
  213.                         if(current_floor==1)
  214.                         {
  215.                                 flag_stop = 0;                  //标记未停留完成
  216.                                 if(flag_bujin_2_c == 1)         //如果正在关门，将门打开
  217.                                 {
  218.                                         flag_door = 0;
  219.                                 }
  220.                                 else                           //还没关门，清除停留时间计数
  221.                                 {
  222.                                         timer1_count_s = 0;
  223.                                 }
  224.                         }
  225.                         
  226.                         Stop = 0;
  227.     }
  228.     else if(uart_buf[1] == 0x21)
  229.     {
  230.       flag_floor_u[2] = 2;
  231.                         if(current_floor==2)
  232.                         {
  233.                                 flag_stop = 0;                  //标记未停留完成
  234.                                 if(flag_bujin_2_c == 1)         //如果正在关门，将门打开
  235.                                 {
  236.                                         flag_door = 0;
  237.                                 }
  238.                                 else                           //还没关门，清除停留时间计数
  239.                                 {
  240.                                         timer1_count_s = 0;
  241.                                 }
  242.                         }
  243.                         
  244.                         Stop = 0;
  245.     }
  246.     else if(uart_buf[1] == 0x22)
  247.     {
  248.       flag_floor_d[2] = 2;
  249.                         if(current_floor==2)
  250.                         {
  251.                                 flag_stop = 0;                  //标记未停留完成
  252.                                 if(flag_bujin_2_c == 1)         //如果正在关门，将门打开
  253.                                 {
  254.                                         flag_door = 0;
  255.                                 }
  256.                                 else                           //还没关门，清除停留时间计数
  257.                                 {
  258.                                         timer1_count_s = 0;
  259.                                 }
  260.                         }
  261.                         
  262.                         Stop = 0;
  263.     }
  264.     else if(uart_buf[1] == 0x31)
  265.     {
  266.       flag_floor_u[3] = 3;
  267.                         if(current_floor==3)
  268.                         {
  269.                                 flag_stop = 0;                  //标记未停留完成
  270.                                 if(flag_bujin_2_c == 1)         //如果正在关门，将门打开
  271.                                 {
  272.                                         flag_door = 0;
  273.                                 }
  274.                                 else                           //还没关门，清除停留时间计数
  275.                                 {
  276.                                         timer1_count_s = 0;
  277.                                 }
  278.                         }
  279.                         
  280.                         Stop = 0;
  281.     }
  282.     else if(uart_buf[1] == 0x32)
  283.     {
  284.       flag_floor_d[3] = 3;
  285.                         if(current_floor==3)
  286.                         {
  287.                                 flag_stop = 0;                  //标记未停留完成
  288.                                 if(flag_bujin_2_c == 1)         //如果正在关门，将门打开
  289.                                 {
  290.                                         flag_door = 0;
  291.                                 }
  292.                                 else                           //还没关门，清除停留时间计数
  293.                                 {
  294.                                         timer1_count_s = 0;
  295.                                 }
  296.                         }
  297.                         
  298.                         Stop = 0;
  299.     }
  300. //    else if(uart_buf[1] == 0x41)
  301. //    {
  302. //      flag_floor_u[4] = 4;
  303. //    }
  304. //    else if(uart_buf[1] == 0x42)
  305. //    {
  306. //      flag_floor_d[4] = 4;
  307. //    }
  308. //    else if(uart_buf[1] == 0x51)
  309. //    {
  310. //      flag_floor_u[5] = 5;
  311. //    }
  312. //    else if(uart_buf[1] == 0x52)
  313. //    {
  314. //      flag_floor_d[5] = 5;
  315. //    }
  316. //    else if(uart_buf[1] == 0x61)
  317. //    {
  318. //      flag_floor_u[6] = 6;
  319. //    }
  320. //    else if(uart_buf[1] == 0x62)
  321. //    {
  322. //      flag_floor_d[6] = 6;
  323. //    }
  324. //    else if(uart_buf[1] == 0x71)
  325. //    {
  326. //      flag_floor_u[7] = 7;
  327. //    }
  328. //    else if(uart_buf[1] == 0x72)
  329. //    {
  330. //      flag_floor_d[7] = 7;
  331. //    }
  332. //    else if(uart_buf[1] == 0x82)
  333. //    {
  334. //      flag_floor_u[8] = 8;
  335. //    }

  337.     Uart_Buf_Clear();         //清除接收缓存区
  338.   }
  339. }

  341. /****
  342. *******显示函数
  343. *****/
  344. void Display_function(void)
  345. {
  346.         Display_Tube_1(current_floor);  //数码管显示当前楼层
  347.   
  348.   if(flag_lift == 0)              //LED 显示方向电梯状态
  349.   {
  350.     LED_U = 1;
  351.     LED_D = 1;
  352.   }
  353.   else if(flag_lift == 1)
  354.   {
  355.     LED_U = 1;
  356.     LED_D = 0;
  357.   }
  358.   else if(flag_lift == 2)
  359.   {
  360.     LED_U = 0;
  361.     LED_D = 1;
  362.   }
  363.         
  364.   if(current_old != current_floor)      //如果楼层改变，发送当前楼层
  365.   {
  366. //    send_buf[1] = (current_floor/10*0x10 + current_floor%10);
  367.                
  368.          if(flag_lift == 1)          //如果电梯方向为下降，清除当前楼层下标志位
  369.          {
  370.                         if(current_floor == 1)
  371.                                 send_buf[1] = 0x01;
  372.                         else if(current_floor == 2)
  373.                                 send_buf[1] = 0x03;
  374.                         else if(current_floor == 3)
  375.                                 send_buf[1] = 0x04;
  376.                 }
  377.                 else if(flag_lift == 2)          //如果电梯方向为上升，清除当前楼层上标志位
  378.                 {
  379.                         if(current_floor == 1)
  380.                                 send_buf[1] = 0x01;
  381.                         else if(current_floor == 2)
  382.                                 send_buf[1] = 0x02;
  383.                         else if(current_floor == 3)
  384.                                 send_buf[1] = 0x04;
  385.                 }
  386.                                 
  387.     Uart_Sent_Str(send_buf);
  388.     current_old = current_floor;
  389.   }
  390. }

  392. /****
  393. *******处理函数
  394. *****/
  395. void Manage_function(void)
  396. {
  397.   if(flag_lift == 0)                            //如果当前电梯停止
  398.   {
  399. //                Uart_Sent_Str("123");
  400. //                Delay_function(1000);
  401.                
  402.     if(flag_stop == 1 && flag_door == 0)
  403.     {
  404.       if(flag_floor_d[1] == 1 || flag_floor_u[1] == 1)                 //一楼按下，目标楼层为一楼
  405.       {
  406.         target_floor = 1;
  407.       }
  408.       else if(flag_floor_d[2] == 2 || flag_floor_u[2] == 2)            //二楼按下，目标楼层为二楼
  409.       {
  410.         target_floor = 2;
  411.       }
  412.       else if(flag_floor_d[3] == 3 || flag_floor_u[3] == 3)            //三楼按下，目标楼层为三楼
  413.       {
  414.         target_floor = 3;
  415.       }

  417.     }
  418.   }
  419.         else if(flag_lift == 1)                            //如果电梯当前方向下降
  420.   {
  421.     if(flag_floor_d[3] == 3)                    //如果三楼下
  422.     {
  423.       if(current_floor > 3) //如果当前高于三楼，目标楼层等于三楼
  424.       {
  425.         target_floor = 3;
  426.       }
  427.     }

  429.     else if(flag_floor_d[2] == 2)           //如果二楼下
  430.     {
  431.       if(current_floor > 2) //如果当前高于二楼，目标楼层等于二楼
  432.       {
  433.         target_floor = 2;
  434.       }
  435.     }
  436.     else if(flag_floor_d[1] == 1)           //如果一楼
  437.     {
  438.       if(current_floor > 1) //如果当前高于一楼，目标楼层等于一楼
  439.         target_floor = 1;
  440.     }
  441.   }
  442.   else if(flag_lift == 2)                            //如果当前电梯上升
  443.   {
  444.     if(flag_floor_u[2] == 2)                //如果二楼上
  445.     {
  446.       if(current_floor < 2) //如果当前楼层低于二楼，目标楼层等于二楼
  447.       {
  448.         target_floor = 2;
  449.       }
  450.     }
  451.     else if(flag_floor_u[3] == 3)           //如果三楼上
  452.     {
  453.       if(current_floor < 3) //如果当前楼层低于三楼，目标楼层等于三楼
  454.       {
  455.         target_floor = 3;
  456.       }
  457.     }

  459.   }
  460.   
  461.   if(current_floor > target_floor)          //如果当前楼层比目标楼层高，电梯下降
  462.   {
  463.     flag_timer_begin = 0;
  464.     flag_stop = 0;
  465.     flag_lift = 1;
  466.     if(flag_bujin_2_o == 0 && flag_bujin_2_c == 0 && flag_door == 0)
  467.     {
  468.       flag_bujin_1_c = 1;
  469.       flag_bujin_1_o = 0;
  470.     }
  471.     flag_send = 0;
  472.   }
  473.   else if(current_floor < target_floor)     //如果当前楼层比目标楼层低，电梯上升
  474.   {
  475.     flag_timer_begin = 0;
  476.     flag_stop = 0;
  477.     flag_lift = 2;
  478.     if(flag_bujin_2_o == 0 && flag_bujin_2_c == 0 && flag_door == 0)
  479.     {
  480.       flag_bujin_1_c = 0;
  481.       flag_bujin_1_o = 1;
  482.     }
  483.     flag_send = 0;
  484.   }
  485.   else                                      //当前楼层等于目标楼层
  486.   {
  487.     if(flag_stop == 0)              //如果没有停留完成
  488.     {
  489.       if(flag_door == 0)            //如果门是关闭的，开门
  490.       {
  491.         flag_bujin_2_o = 1;
  492.         flag_bujin_2_c = 0;
  493.       }
  494.       else if(flag_door == 1)       //如果门已经打开了
  495.       {
  496.         flag_timer_begin_s = 1;     //开启停留定时
  497.       }
  498.                         
  499.       if(YL==0|| INFRARED == 0) //如果超重了或触发红外防夹，进行蜂鸣器提醒，清除停留时间计数
  500.       {
  501.         timer1_count_s = 0;
  502.                                 if(time_num % 15 == 0)
  503.                                 {
  504.                                         BEEP = ~BEEP;
  505.                                 }
  506.       }
  507.       else
  508.       {
  509.         BEEP = 1;
  510.       }
  511.                         
  512.       if(flag_time_s == 1)          //如果停留时间到达
  513.       {
  514.         flag_timer_begin_s = 0;
  515.         flag_time_s = 0;
  516.         flag_stop= 1;
  517.       }
  518.     }
  519.                
  520.     if(flag_stop == 1)              //如果停留完成
  521.     {
  522.       if(flag_door == 1)            //如果门是开启的，关门
  523.       {
  524.         flag_bujin_2_o = 0;
  525.         flag_bujin_2_c = 1;
  526.         if((INFRARED == 0 || YL == 0) && flag_bujin_2_c == 1)  //如果触发防夹，标记未停留完成
  527.         {
  528.           flag_door = 0;
  529.           flag_stop = 0;
  530.         }
  531.       }
  532.       else if(flag_door == 0)      //如果门已关闭清除当前按下楼层标志位
  533.       {
  534.         if(flag_lift == 1)          //如果电梯方向为下降，清除当前楼层下标志位
  535.         {
  536. //          if(flag_send == 0)
  537. //          {
  538. ////                                                        send_buf[1] = (current_floor/10*0x10 + current_floor%10);
  539. //                                                if(current_floor == 1)
  540. //                                                        send_buf[1] = 0x01;
  541. //                                                else if(current_floor == 2)
  542. //                                                        send_buf[1] = 0x03;
  543. //                                                else if(current_floor == 3)
  544. //                                                        send_buf[1] = 0x04;
  545. //                                                
  546. //            Uart_Sent_Str(send_buf);
  547. //            flag_send = 1;
  548. //          }
  549.           flag_floor_d[target_floor] = 0;
  550.         }
  551.         if(flag_lift == 2)          //如果电梯方向为上升，清除当前楼层上标志位
  552.         {
  553. //          if(flag_send == 0)
  554. //          {
  555. ////            send_buf[1] = (current_floor/10*0x10 + current_floor%10);
  556. //                                                if(current_floor == 1)
  557. //                                                        send_buf[1] = 0x01;
  558. //                                                else if(current_floor == 2)
  559. //                                                        send_buf[1] = 0x02;
  560. //                                                else if(current_floor == 3)
  561. //                                                        send_buf[1] = 0x04;
  562. //                                                
  563. //            Uart_Sent_Str(send_buf);
  564. //            flag_send = 1;
  565. //          }
  566.           flag_floor_u[target_floor] = 0;
  567.         }
  568.         if(flag_lift == 0)
  569.         {
  570. //                                        if(flag_send == 0)
  571. //          {
  572. ////            send_buf[1] = (current_floor/10*0x10 + current_floor%10);
  573. //                                                if(current_floor == 1)
  574. //                                                        send_buf[1] = 0x01;
  575. //                                                else if(current_floor == 2)
  576. //                                                        send_buf[1] = 0x02;
  577. //                                                else if(current_floor == 3)
  578. //                                                        send_buf[1] = 0x04;
  579. //                                                
  580. //            Uart_Sent_Str(send_buf);
  581. //            flag_send = 1;
  582. //          }

  584.           flag_floor_d[target_floor] = 0;
  585.           flag_floor_u[target_floor] = 0;
  586.         }
  587.         flag_timer_begin = 1;       //开启定时
  588.       }
  589.     }
  590.   }
  591.         
  592.   if(flag_time == 1)                //定时500ms到达，清除电梯运动标志位
  593.   {
  594.     flag_timer_begin = 0;
  595.     flag_lift = 0;
  596.     flag_time = 0;
  597.     flag_floor_d[current_floor] = 0;
  598.     flag_floor_u[current_floor] = 0;
  599.   }
  600.         
  601.         if(speed_alarm == 1)
  602.         {
  603.                 BEEP = 0;
  604.                 Delay_function(2000);
  605.                 BEEP = 1;
  606.                 speed_alarm = 0;
  607.         }
  608.         
  609.         if(YW == 0)
  610.         {
  611.                 if(time_num % 15 == 0)
  612.                 {
  613.                         BEEP = ~BEEP;
  614.                 }
  615.         }
  616.         else
  617.         {
  618.                 if(YL == 1 && INFRARED == 1)
  619.                         BEEP = 1;
  620.         }
  621. }

复制代码



外机:
  1. /**********************************
  2. 包含头文件
  3. **********************************/
  4. #include "main.h"
  5. #include "key.h"
  6. #include "uart.h"


  9. /**********************************
  10. 变量定义
  11. **********************************/
  12. uchar key_num = 0;                                                                                        //按键扫描标志位                        
  13. uint time_num = 0;                                                                                        //10ms计时变量

  15. extern uchar uart_buf[16];              //串口接收缓存区
  16. extern uchar uart_count;                //串口接收计数

  18. uchar send_buf[24]={0x01,0x00};                //发送数组


  21. /**********************************
  22. 函数声明
  23. **********************************/
  24. void Delay_function(uint x);                                                //延时函数(ms)
  25. void Key_function(void);                                                                //按键函数
  26. void Manage_function(void);                                                        //处理函数


  29. /****
  30. *******        主函数
  31. *****/
  32. void main(void)
  33. {
  34.   Uart_Init();                  //串口初始化
  35.   Delay_function(50);
  36.   LED1 = 0;
  37.   
  38.         while(1)
  39.         {
  40.                 Key_function();                                                                                        //按键函数
  41.                 Manage_function();                                                                        //处理函数

  43.                 Delay_function(10);                                                                        //延时10ms
  44.                 time_num++;                                                                                                        //计时变量+1
  45.                 if(time_num == 5000)
  46.                 {
  47.                         time_num = 0;
  48.                 }
  49.         }
  50. }

  52. /****
  53. *******        延时 x ms函数
  54. *****/
  55. void Delay_function(uint x)
  56. {
  57.         uint m,n;
  58.         for(m=x;m>0;m--)
  59.     for(n=110;n>0;n--);
  60. }

  62. /****
  63. *******按键函数
  64. *****/
  65. void Key_function(void)
  66. {
  67.         key_num = Chiclet_Keyboard_Scan(0);                  //按键扫描
  68.         if(key_num != 0)                                                                                        //有按键按下
  69.         {
  70.                 switch(key_num)
  71.                 {
  72.                         case 1:                                                                                                                //按键1，发送一楼上
  73.                                 send_buf[1] = 0x11;
  74.         Uart_Sent_Str(send_buf);
  75.                         break;

  77.                         case 2:                                                                                                                //按键2，发送二楼上
  78.                                 send_buf[1] = 0x21;
  79.         Uart_Sent_Str(send_buf);
  80.                         break;

  82.                         case 3:                                                                                                                //按键3，发送二楼下
  83.                                 send_buf[1] = 0x22;
  84.         Uart_Sent_Str(send_buf);
  85.                         break;
  86.       

  88.                         case 4:                                                                                                                //按键4，发送三楼下
  89.                                 send_buf[1] = 0x32;
  90.         Uart_Sent_Str(send_buf);
  91.                         break;      

  93.                         default:
  94.                         break;
  95.                 }
  96.         }
  97. }

  99. /****
  100. *******处理函数
  101. *****/
  102. void Manage_function(void)
  103. {
  104.         if(uart_count >= 2)         //如果接收到两个字节，解析数据，点亮对应楼层的LED
  105.   {
  106.     P1 = 0xff;
  107.     if(uart_buf[1] == 0x01)   
  108.     {
  109.       LED1 = 0;
  110.     }
  111.     else if(uart_buf[1] == 0x02)
  112.     {
  113.       LED2 = 0;
  114.     }
  115.     else if(uart_buf[1] == 0x03)
  116.     {
  117.       LED3 = 0;
  118.     }
  119.     else if(uart_buf[1] == 0x04)
  120.     {
  121.       LED4 = 0;
  122.     }
  123.    
  124.     Uart_Buf_Clear();         //清除接收缓存区
  125.   }
  126. }
复制代码


原理图: 无
仿真: 无
代码: 电梯-实物源程序-C语言源码.7z (32.72 KB, 下载次数: 0)
本主题由 admin 执行 审核通过

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表