找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1913|回复: 1
打印 上一主题 下一主题
收起左侧

单片机操作系统源码,可以完成基本的电梯功能

[复制链接]
跳转到指定楼层
楼主
此电梯完成了基本的逻辑功能

单片机源程序如下:
  1. #include "task.h"

  2. typedef enum
  3. {
  4.         judge          = 0,
  5.            up_open_door   = 1,
  6.         uping          = 2,
  7.         up_lift        = 3,
  8.         down_open_door = 4,
  9.         downing        = 5,
  10.         down_lift      = 6,
  11.         finish         = 7
  12. }_up_Typedef_t;

  13. static _up_Typedef_t up_status = judge;

  14. _task_Typedef_t task_buff[4] = {0,0,0,{0}};      //建立任务列表

  15. static u8 taskID         = 0;
  16. static u8 process_status = 0;
  17. u8 now_lift              = 1;    //当前电梯所在楼层

  18. sbit BEEP = P0^7;

  19. static void Task_Clear(u8 taskid)          //清除任务表中的指定任务
  20. {
  21.         task_buff[taskid].now_dir        = 0;
  22.         task_buff[taskid].max_lift       = 1;
  23.         task_buff[taskid].min_lift       = 4;
  24.         task_buff[taskid].lift_buff[0]   = 0;
  25.         task_buff[taskid].lift_buff[1]   = 0;
  26.         task_buff[taskid].lift_buff[2]   = 0;
  27.         task_buff[taskid].lift_buff[3]   = 0;       
  28. }

  29. void Task_Table_Clear(void)             //清除任务表
  30. {
  31.         Task_Clear(0);
  32.         Task_Clear(1);
  33.         Task_Clear(2);
  34.         Task_Clear(3);
  35. }

  36. void Check_Task_Table(void)              //查询任务表
  37. {
  38.         LED_display(now_lift);
  39.         while(task_buff[taskID].now_dir == 0);     //等待任务发生
  40. }

  41. void Task_Init(void)
  42. {
  43.         process_status = 1;
  44.         up_status      = judge;       
  45. }


  46. void Task_Creat(u8 dir,u8 lift_id,u8 in_out)    //in_out:0,里面按键,1外面按键
  47. {
  48.         if(in_out == 1)       //外面按键
  49.         {
  50.                 if(task_buff[taskID].now_dir == 0)     //如果当前电梯空闲
  51.                 {
  52.                         if(lift_id >= now_lift)
  53.                         {
  54.                                 task_buff[taskID].now_dir = 1;                               //创建新任务
  55.                                 task_buff[taskID].lift_buff[lift_id - 1] = 1;
  56.                                 task_buff[taskID].max_lift = lift_id;       
  57.                         }
  58.                         else
  59.                         {
  60.                                 task_buff[taskID].now_dir = 2;                               //创建新任务
  61.                                 task_buff[taskID].lift_buff[lift_id - 1] = 1;
  62.                                 task_buff[taskID].min_lift = lift_id;
  63.                         }
  64.                 }
  65.                 else if(dir == task_buff[taskID].now_dir)  //如果顺路
  66.                 {
  67.                         if(task_buff[taskID].now_dir == 1)    //如果向上运行
  68.                         {
  69.                                 if(lift_id >= now_lift)          //如果人在电梯之上
  70.                                 {
  71.                                         task_buff[taskID].lift_buff[lift_id - 1] = 1;     //在当前任务中添加
  72.                                         if(lift_id > task_buff[taskID].max_lift)
  73.                                         {
  74.                                                 task_buff[taskID].max_lift = lift_id;
  75.                                         }
  76.                                 }
  77.                                 else
  78.                                 {
  79.                                         task_buff[(taskID + 1) % 4].now_dir = 2;                               //创建新任务
  80.                                         task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;       
  81.                                 }
  82.                         }
  83.                         else if(task_buff[taskID].now_dir == 2)     //如果向下运行
  84.                         {
  85.                                 if(lift_id <= now_lift)             //如果人在电梯之下
  86.                                 {
  87.                                         task_buff[taskID].lift_buff[lift_id - 1] = 1;     //在当前任务中添加
  88.                                         if(lift_id < task_buff[taskID].min_lift)
  89.                                         {
  90.                                                 task_buff[taskID].min_lift = lift_id;
  91.                                         }       
  92.                                 }
  93.                                 else
  94.                                 {
  95.                                         task_buff[(taskID + 1) % 4].now_dir = 1;                               //创建新任务
  96.                                         task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;       
  97.                                 }
  98.                         }
  99.                 }
  100.                 else
  101.                 {
  102.                         if(dir == 1)     //如果人想向上
  103.                         {
  104.                                 if(task_buff[taskID].min_lift > lift_id)
  105.                                 {
  106.                                         task_buff[(taskID + 1) % 4].now_dir = 2;                               //创建新任务
  107.                                         task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;
  108.                                 }                               
  109.                                 else
  110.                                 {
  111.                                         task_buff[(taskID + 1) % 4].now_dir = 1;                               //创建新任务
  112.                                         task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;
  113.                                 }
  114.                         }
  115.                         else if(dir == 2)     //如果人想向下
  116.                         {
  117.                                 if(task_buff[taskID].max_lift > lift_id)
  118.                                 {
  119.                                         task_buff[(taskID + 1) % 4].now_dir = 2;                               //创建新任务
  120.                                         task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;       
  121.                                 }
  122.                                 else
  123.                                 {
  124.                                         task_buff[(taskID + 1) % 4].now_dir = 1;                               //创建新任务
  125.                                         task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;
  126.                                 }
  127.                         }
  128.                 }
  129.         }
  130.         else if(in_out == 0)      //如果人在里面按按键
  131.         {
  132.                 if(task_buff[taskID].now_dir == 0)     //如果当前电梯空闲
  133.                 {
  134.                         if(lift_id >= now_lift)
  135.                         {
  136.                                 task_buff[taskID].now_dir = 1;                               //创建新任务
  137.                                 task_buff[taskID].lift_buff[lift_id - 1] = 1;
  138.                                 task_buff[taskID].max_lift = lift_id;       
  139.                         }
  140.                         else
  141.                         {
  142.                                 task_buff[taskID].now_dir = 2;                               //创建新任务
  143.                                 task_buff[taskID].lift_buff[lift_id - 1] = 1;
  144.                                 task_buff[taskID].min_lift = lift_id;
  145.                         }
  146.                 }
  147.                 else if(task_buff[taskID].now_dir == 1)      //如果当前运行方向向上
  148.                 {
  149.                         if(lift_id > now_lift)    //如果要去的楼层在当前楼层之上
  150.                         {
  151.                                 task_buff[taskID].lift_buff[lift_id - 1] = 1;     //在当前任务中添加
  152.                                 if(lift_id > task_buff[taskID].max_lift)
  153.                                 {
  154.                                         task_buff[taskID].max_lift = lift_id;
  155.                                 }
  156.                         }
  157.                         else
  158.                         {
  159.                                 task_buff[(taskID + 1) % 4].now_dir = 2;                               //创建新任务
  160.                                 task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;
  161.                         }
  162.                 }
  163.                 else if(task_buff[taskID].now_dir == 2)    //如果当前运行方向向下
  164.                 {
  165.                         if(lift_id < now_lift)     //如果要去的楼层在当前楼层之下
  166.                         {
  167.                                 task_buff[taskID].lift_buff[lift_id - 1] = 1;     //在当前任务中添加
  168.                                 if(lift_id < task_buff[taskID].min_lift)
  169.                                 {
  170.                                         task_buff[taskID].min_lift = lift_id;
  171.                                 }       
  172.                         }
  173.                         else
  174.                         {
  175.                                 task_buff[(taskID + 1) % 4].now_dir = 1;                               //创建新任务
  176.                                 task_buff[(taskID + 1) % 4].lift_buff[lift_id - 1] = 1;
  177.                         }
  178.                 }
  179.         }
  180. }

  181. void Update_Task_Table(void)    //更新任务列表
  182. {
  183.         switch(gKey_Value)
  184.         {
  185.                 case IN_FLOOR_1:                        //如果在一楼
  186.                 {
  187.                            gKey_Value = 0;
  188.                         Task_Creat(0,1,0);
  189.                 }
  190.                 break;

  191.                 case IN_FLOOR_2:
  192.                 {
  193.                         gKey_Value = 0;
  194.                         Task_Creat(0,2,0);
  195.                 }
  196.                 break;

  197.                 case IN_FLOOR_3:
  198.                 {
  199.                         gKey_Value = 0;
  200.                         Task_Creat(0,3,0);
  201.                 }
  202.                 break;

  203.                 case IN_FLOOR_4:
  204.                 {
  205.                         gKey_Value = 0;
  206.                         Task_Creat(0,4,0);
  207.                 }
  208.                 break;

  209.                 case OPEN_DOOR:
  210.                 {
  211.                         gKey_Value = 0;
  212.                        
  213.                 }
  214.                 break;

  215.                 case CLOSE_DOOR:
  216.                 {
  217.                         gKey_Value = 0;
  218.                 }
  219.                 break;

  220.                 case OUT_FLOOR_DOWN_2:
  221.                 {
  222.                         gKey_Value = 0;
  223.                         Task_Creat(2,2,1);
  224.                 }
  225.                 break;

  226.                 case OUT_FLOOR_UP_2:
  227.                 {
  228.                         gKey_Value = 0;
  229.                         Task_Creat(1,2,1);
  230.                 }
  231.                 break;

  232.                 case OUT_FLOOR_1:
  233.                 {
  234.                         gKey_Value = 0;
  235.                         Task_Creat(1,1,1);
  236.                 }
  237.                 break;

  238.                 case OUT_FLOOR_4:
  239.                 {
  240.                         gKey_Value = 0;
  241.                         Task_Creat(2,4,1);
  242.                 }
  243.                 break;

  244.                 case OUT_FLOOR_DOWN_3:
  245.                 {
  246.                         gKey_Value = 0;
  247.                         Task_Creat(2,3,1);
  248.                 }
  249.                 break;

  250.                 case OUT_FLOOR_UP_3:
  251.                 {
  252.                         gKey_Value = 0;
  253.                         Task_Creat(1,3,1);
  254.                 }
  255.                 break;

  256.                 case WRINGING:
  257.                 {
  258.                         gKey_Value = 0;
  259.                         BEEP = 0;
  260.                 }
  261.                 break;
  262.         }
  263. }

  264. void Task_Process(void)
  265. {
  266.         while(process_status)
  267.         {
  268.                 switch(up_status)
  269.                 {
  270.                         case judge:
  271.                         {
  272.                                 if(task_buff[taskID].now_dir == 1)     //当前任务需向上
  273.                                 {
  274.                                         if(task_buff[taskID].lift_buff[now_lift - 1] == 1)    //本层需上人
  275.                                         {
  276.                                                 up_status = up_open_door;
  277.                                                 time_count = 0;       
  278.                                         }
  279.                                         else        //本层不需上人  
  280.                                         {
  281.                                                 up_status = uping;
  282.                                                 time_count = 0;       
  283.                                         }
  284.                                 }
  285.                                 else if(task_buff[taskID].now_dir == 2)   //当前任务需向下
  286.                                 {
  287.                                         if(task_buff[taskID].lift_buff[now_lift - 1] == 1)    //本层需上人
  288.                                         {
  289.                                                 up_status = down_open_door;
  290.                                                 time_count = 0;       
  291.                                         }
  292.                                         else        //本层不需上人  
  293.                                         {
  294.                                                 up_status = downing;
  295.                                                 time_count = 0;       
  296.                                         }       
  297.                                 }

  298.                                 LED_display(now_lift);
  299.                         }
  300.                         break;

  301.                         case up_open_door:
  302.                         {
  303.                                 if(time_count < 3000)
  304.                                 {
  305.                                         Motor_Status(0);          //电梯不动
  306.                                         LED_UP_OFF;
  307.                                 }
  308.                                 else      //5s时间到
  309.                                 {
  310.                                         if(now_lift >= task_buff[taskID].max_lift)    //如果已经到达当前任务的最高层
  311.                                         {
  312.                                                 up_status = finish;
  313.                                         }
  314.                                         else
  315.                                         {
  316.                                                 up_status = uping;
  317.                                                 time_count = 0;
  318.                                         }       
  319.                                 }
  320.                         }
  321.                         break;

  322.                         case uping:
  323.                         {
  324.                                 if(time_count < 2000)
  325.                                 {
  326.                                         Motor_Status(1);     //向上
  327.                                         LED_UP_ON;
  328.                                 }
  329.                                 else
  330.                                 {
  331.                                         up_status = up_lift;
  332.                                 }
  333.                         }
  334.                         break;

  335.                         case up_lift:
  336.                         {
  337.                                 if(now_lift < 4)
  338.                                 {
  339.                                         now_lift++;
  340.                                         LED_display(now_lift);
  341.                                         if(task_buff[taskID].lift_buff[now_lift - 1] == 0)     //如果不需上人
  342.                                         {
  343.                                                 up_status = uping;
  344.                                                 time_count = 0;
  345.                                         }
  346.                                         else
  347.                                         {
  348.                                                 up_status = up_open_door;
  349.                                                 time_count = 0;
  350.                                         }
  351.                                 }
  352.                         }
  353.                         break;

  354.                         case down_open_door:
  355.                         {
  356.                                  if(time_count < 3000)
  357.                                 {
  358.                                         Motor_Status(0);          //电梯不动
  359.                                         LED_UP_OFF;
  360.                                 }
  361.                                 else
  362.                                 {
  363.                                         if(now_lift <= task_buff[taskID].min_lift)  //如果已经到达当前任务的最低层
  364.                                         {
  365.                                                 up_status = finish;
  366.                                         }
  367.                                         else
  368.                                         {
  369.                                                 up_status = downing;
  370.                                                 time_count = 0;
  371.                                         }
  372.                                 }
  373.                         }
  374.                         break;

  375.                         case downing:
  376.                         {
  377.                                 if(time_count < 2000)
  378.                                 {
  379.                                         Motor_Status(2);     //向下
  380.                                         LED_DOWN_ON;
  381.                                 }
  382.                                 else
  383.                                 {
  384.                                         up_status = down_lift;
  385.                                 }
  386.                         }
  387.                         break;

  388.                         case down_lift:
  389.                         {
  390.                                 if(now_lift > 1)
  391.                                 {
  392.                                         now_lift--;
  393.                                         LED_display(now_lift);
  394.                                         if(task_buff[taskID].lift_buff[now_lift - 1] == 0)     //如果不需上人
  395.                                         {
  396.                                                 up_status = downing;
  397.                                                 time_count = 0;
  398.                                         }
  399.                                         else
  400.                                         {
  401.                                                 up_status = down_open_door;
  402.                                                 time_count = 0;
  403.                                         }       
  404.                                 }
  405.                         }
  406.                         break;

  407.                         case finish:
  408.                         {
  409.                                  process_status = 0;
  410.                                  Task_Clear(taskID);          //清除刚才完成的任务
  411.                                  taskID = (taskID + 1) % 4;          //指向下一个任务
  412.                         }
  413.                         break;
  414.                 }
  415.         }
  416. }


复制代码


  1. #include <reg52.h>
  2. #include "main.h"
  3. #include "display.h"
  4. #include "delay.h"
  5. #include "key.h"
  6. #include "motor.h"
  7. #include "task.h"

  8. u16 time_count = 0;

  9. int main(void)
  10. {
  11.         delay_init();
  12.         Task_Table_Clear();    //清除任务表
  13.        
  14.         while(1)
  15.         {
  16.                 Check_Task_Table();              //查询任务表
  17.                 Task_Init();                          //任务初始化
  18.                 Task_Process();                      //执行任务
  19.         }
  20. }
复制代码

所有资料51hei提供下载:
电梯.zip (79.41 KB, 下载次数: 12)



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

使用道具 举报

沙发
ID:1 发表于 2019-3-11 00:09 | 只看该作者
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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