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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 16层楼梯单片机源程序+Proteus仿真
返回列表 发新帖
查看: 1188|回复: 0
打印 上一主题 下一主题
收起左侧

16层楼梯单片机源程序+Proteus仿真

[复制链接]
跳转到指定楼层
楼主
ID:674815 发表于 2020-12-2 20:09 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. /*************************电梯主程序*****************************/

  3. #include "reg51.h"
  4. #include "intrins.h"

  6. /*********************程序选择****************************/
  7. #define USE_MODE 0   //0-定时模拟  1-传感器
  8. /****************************************************************/
  9. /*********************平台移植部分代码****************************/
  10. //定时器模拟版接口：
  11. #if (USE_MODE==0)
  12. sbit DOOR=P3^5;        //电梯门开关控制信号
  13. sbit ElevMotor_P=P3^6; //电梯电机正极控制信号
  14. sbit ElevMotor_N=P3^7; //电梯电机负极控制信号
  15. sbit SHCP=P0^5;        //74HC595  LED、数码管显示驱动
  16. sbit DS=P0^6;          //74HC595  LED、数码管显示驱动
  17. sbit STCP=P0^7;        //74HC595  LED、数码管显示驱动
  18. #define KeyPort_X  P1  //矩阵按键接口
  19. #define KeyPort_Y  P2  //矩阵按键接口
  20. #endif
  21. //除以上定义的IO外，还需用到P33作为矩阵键盘的中断触发引脚
  22. //8路与门：用8路与非门CD4068或74LS30+输出端接一个三极管反向电平。


  25. //传感器版接口：
  26. #if (USE_MODE==1)
  27. sbit DOOR_CLOSE_SENSOR=P3^4;//电梯门关闭检测传感器输入
  28. sbit DOOR=P3^5;        //电梯门开关控制信号
  29. sbit ElevMotor_P=P3^6; //电梯电机正极控制信号
  30. sbit ElevMotor_N=P3^7; //电梯电机负极控制信号
  31. sbit SHCP=P0^5;        //74HC595  LED、数码管显示驱动
  32. sbit DS=P0^6;          //74HC595  LED、数码管显示驱动
  33. sbit STCP=P0^7;        //74HC595  LED、数码管显示驱动
  34. #define KeyPort_X  P1  //矩阵按键接口
  35. #define KeyPort_Y  P2  //矩阵按键接口
  36. #endif
  37. //除以上定义的IO外，还需用到P33作为矩阵键盘的中断触发引脚
  38. //需用到P32作为楼层限位开关触发中断引脚
  39. //每个楼层一个限位开关，接在N路输入的与门芯片上
  40. //如果大于8层，可用两个8路输入的与门芯片+一个2路的与门芯片组合
  41. /****************************************************************/
  42. /***********************楼梯参数设置*****************************/
  43. #define MaxFloor      16  //电梯总楼层(最大16)

  45. #define FloorStayTime 40 //单位：50ms, 楼层停留时间：40*50ms=2S
  46. #define DoorStayTime  2  //单位：S   , 电梯门停留时间
  47. #define SEG_Num       2  //数码管数量(为1时请删除第一个数码管的595)
  48. /****************************************************************/
  49. #define u8  unsigned char
  50. #define u16 unsigned int
  51.    
  52. #define TRUE  1    //真
  53. #define FALSE 0    //假

  55. //电梯运行状态
  56. #define Null  0     //空闲
  57. #define STOP  1     //停止
  58. #define UP    2     //向上
  59. #define DOWN  3     //向下

  61. #define UP_IN     0x01     //内部向上标记(在呼叫列表中的标记  用bit0标记)
  62. #define UP_OUT    0x02     //外部向上标记(在呼叫列表中的标记  用bit1标记)
  63. #define DOWN_IN   0x04     //内部向下标记(在呼叫列表中的标记  用bit2标记)
  64. #define DOWN_OUT  0x08     //外部向下标记(在呼叫列表中的标记  用bit3标记)

  66. #define Elev_UP    ElevMotor_P=0;ElevMotor_N=1  //低电平有效
  67. #define Elev_DOWN  ElevMotor_P=1;ElevMotor_N=0  //低电平有效  电机正转
  68. #define Elev_STOP  ElevMotor_P=1;ElevMotor_N=1  //低电平有效  电机反转

  70. #define OPEN  1  
  71. #define CLOSE 0
  72. #define DOOR_Open  DOOR=OPEN     //开门
  73. #define DOOR_Close DOOR=CLOSE    //关门

  75. #define SHCP_H SHCP=1
  76. #define SHCP_L SHCP=0
  77. #define DS_H   DS=1
  78. #define DS_L   DS=0
  79. #define STCP_H STCP=1
  80. #define STCP_L STCP=0

  82. #if MaxFloor>8  
  83. #define MHC595_NUM 8
  84. #else
  85. #define MHC595_NUM 5
  86. #endif

  88. #define SEGPort 0x01
  89. #define LED_IN_Port 0x02
  90. #define LED_OUT_UP_Port 0x03
  91. #define LED_OUT_DOWN_Port 0x04

  93. //FloorCallTable[]呼叫列表说明:该列表由数组构成，下标和每个楼层一一对应，如FloorCallTable[1]表示1楼的呼叫状态
  94. // bit3-DOWN_OUT  bit2-DOWN_IN  bit1-UP_OUT  bit0-UP_IN   bit=0为没有呼叫，=1为有呼叫
  95. typedef struct
  96. {
  97.     u8 ElevRunning;      //电梯运行状态标志
  98.   u8 CurrentFloor;     //当前电梯所处楼层
  99.     u8 Direction;        //电梯运行方向
  100.     u8 FloorCallTable[MaxFloor+1];//数组[0]不用，从[1]开始使用 ，呼叫列表(所有楼层呼叫的信息均保存于此)
  101.     u8 FloorTimerCount;     //计时
  102.     u8 ArriveFlag;       //到达楼层信号(用于停止或在前一楼层提前加减速)(定时器模拟的用不到)
  103.     u8 FreeFlag;           //电梯空闲状态标志
  104. }TYPEDEF_ELEVSTATE;
  105. TYPEDEF_ELEVSTATE ElevState; //电梯状态结构体

  107. //u8 code SEG_NUM[]={0x3f,0x06,0x5b,0x4f,0x66,0x6D,0x7D,0x07,0x7f,0x6f};   //共阴SEG数码管段码  0~9
  108. u8 code SEG_NUM[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e}; //共阳SEG数码管段码  0~F
  109. u16 code LED_NUM[]={0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};   //SEG数码管段码  0~9

  111. u8 HC595_BUFF[MHC595_NUM]={0};
  112. u8 Timer_Second;
  113. u16 TimerCount;

  115. u8 ExternKey[2]={0}; //外部按键按下信息
  116. u8 FloorCallTableBUFF[MaxFloor+10]={0};
  117. u8 KeyPressFlag=0;

  119. #define USART_RX_LEN 20  //接收缓存长度(请勿超过芯片rom剩余大小)
  120. typedef struct
  121. {
  122.   u8 RX_BUFF[USART_RX_LEN]; //接收缓存
  123.     u8 TX_BUFF[USART_RX_LEN]; //发送缓存
  124.     u16 RX_COUNT;
  125. }USART;
  126. USART Usart;

  128. void delay_ms(u16 xms); //ms延时
  129. void delay_s(u8 xs);    //s延时
  130. void EXTI0_Init(void);
  131. void EXTI1_Init(void);
  132. void TIMER0_Init(void);
  133. void USART_Config(u16 BaudRate);
  134. void HC595_Send(u8 *p);
  135. u8 KeyScan(void);
  136. void KeyDatHandle(u8 key);
  137. void WaitDoorOpen(u8 ts);
  138. void WaitDoorClose(u8 ts);
  139. void SEG_Display(u8 segnum);
  140. void LED_ON(u8 addr,u8 lednum);
  141. void LED_OFF(u8 addr,u8 lednum);
  142. void ElevWorkState(u8 state);
  143. void Elevator(void);
  144. u8 FloorCall_UP(u8 floorside);
  145. u8 FloorCall_DOWN(u8 floorside);
  146. u8 DelNullCheck(void);
  147. void FloorCallCheck(void);
  148. void USART_SendByte(u8 dat);
  149. void USART_Send(u8* arr,u16 len);
  150. void USART_SendStr(u8* str);
  151. void SYSYEM_INIT(void);

  153. void delay_ms(u16 xms)
  154. {
  155.     u8 i;
  156.     u16 t;
  157.   for(t=xms;t>0;t--)
  158.       for(i=112;i>0;i--);
  159. }

  161. void delay_s(u8 xs)
  162. {
  163.    TimerCount=0;
  164.      Timer_Second=0;
  165.    while(Timer_Second<xs);   
  166. }

  168. void EXTI0_Init(void)
  169. {
  170.   EA = 1;  
  171.     IT0= 1; //下降沿触发
  172.     EX0= 1;
  173. }

  175. void EXTI1_Init(void)
  176. {
  177.   EA = 1;  
  178.     IT1= 1; //下降沿触发
  179.     EX1= 1;
  180. }

  182. void Timer0_Init(void)
  183. {
  184.     TMOD |= 0x01;  
  185.   TH0=(65536-50000)/256;
  186.     TL0=(65536-50000)%256;
  187.     EA = 1;
  188.     ET0 = 1;
  189.     TR0 = 1;
  190. }


  193. void USART_Config(u16 BaudRate)
  194. {
  195.     u8 TH1_Dat;
  196.    
  197.   switch(BaudRate)
  198.     {
  199.       case 1200:  TH1_Dat=0xE8; break;
  200.         case 2400:  TH1_Dat=0xF4; break;
  201.         case 4800:  TH1_Dat=0xFA; break;
  202.         case 9600:  TH1_Dat=0xFD; break;
  203.         case 14400: TH1_Dat=0xFE; break;
  204.     }
  205.     TMOD |= 0x20;
  206.     SCON |= 0x50;
  207.     TH1 = TH1_Dat;
  208.     TL1 = TH1;
  209.     PCON |= 0x00;
  210.     EA = 1;
  211.     ES = 1;
  212.     TR1 = 1;  
  213. }

  215. void HC595_Send(u8 *p)
  216. {
  217.   u8 i,j;
  218.     u8 temp;
  219.     for(i=MHC595_NUM;i>2-SEG_Num;i--)
  220.     {
  221.         temp=p[i-1];
  222.         for(j=0;j<8;j++)
  223.         {
  224.           DS=temp&0x80;   
  225.       temp<<=1;   
  226.       SHCP_L;
  227.       SHCP_H;            
  228.         }
  229.     }
  230.     STCP_L;
  231.   STCP_H;   
  232. }
  233. /*键盘剪裁说明：
  234. 按键扫描函数 8*8  如要改为4*4或其他  
  235. 请把KeyPort_Y 和 KeyPort_X 对应的IO口数量减少,如4*4，则用KeyPort_Y低4位和KeyPort_X高4位
  236. 键盘分布如下:(序号和IO口高低位对应)

  238.        P20      ->         P27

  240.              Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7
  241. P10     X0 *  *  *  *  *  *  *  *                57 58 59 60 61 62 63 64  
  242.          X1 *  *  *  *  *  *  *  *                49 50 51 52 53 54 55 56
  243.          X2 *  *  *  *  *  *  *  *                41 42 43 44 45 46 47 48
  244. |     X3 *  *  *  *  *  *  *  *  对应按键扫描  33 34 35 36 37 38 39 40  仿真文件
  245. |     X4 *  *  *  *  *  *  *  *   函数返回值-> 25 26 27 28 29 30 31 32    布局->  25 26 27 28 29 30 31 32  57 58 59 60 61 62 63 64
  246.          X5 *  *  *  *  *  *  *  *                17 18 19 20 21 22 23 24            17 18 19 20 21 22 23 24  49 50 51 52 53 54 55 56
  247.          X6 *  *  *  *  *  *  *  *                9  10 11 12 13 14 15 16            9  10 11 12 13 14 15 16  41 42 43 44 45 46 47 48
  248. P17     X7 *  *  *  *  *  *  *  *                1  2  3  4  5  6  7  8             1  2  3  4  5  6  7  8   33 34 35 36 37 38 39 40

  250. */
  251. //KeyScan()扫描函数兼容8*8以下所有键盘，键盘改小时无需修改
  252. u8 KeyScan(void)
  253. {
  254.     u8 keynum;
  255.   
  256.     KeyPort_Y=0x00;
  257.     KeyPort_X=0xFF;
  258.     _nop_(); _nop_(); _nop_(); _nop_();
  259.     if(KeyPort_X!=0xFF)
  260.     {
  261.      delay_ms(10);
  262.      if(KeyPort_X!=0xFF)
  263.      {
  264.          switch(KeyPort_X)
  265.          {
  266.              case 0x7F: keynum=1;   break;
  267.              case 0xBF: keynum=9;   break;
  268.              case 0xDF: keynum=17;  break;
  269.              case 0xEF: keynum=25;  break;
  270.              case 0xF7: keynum=33;  break;
  271.              case 0xFB: keynum=41;  break;
  272.              case 0xFD: keynum=49;  break;
  273.              case 0xFE: keynum=57;  break;
  274.          }
  275.          KeyPort_Y=0xFF;
  276.          KeyPort_X=0x00;
  277.          _nop_(); _nop_(); _nop_(); _nop_();
  278.          if(KeyPort_Y!=0xFF)
  279.          {
  280.              switch(KeyPort_Y)
  281.              {
  282.                  case 0xFE: keynum=keynum+0;  break;
  283.                  case 0xFD: keynum=keynum+1;  break;
  284.                  case 0xFB: keynum=keynum+2;  break;
  285.                  case 0xF7: keynum=keynum+3;  break;
  286.                  case 0xEF: keynum=keynum+4;  break;
  287.                  case 0xDF: keynum=keynum+5;  break;
  288.                  case 0xBF: keynum=keynum+6;  break;
  289.                  case 0x7F: keynum=keynum+7;  break;
  290.              }
  291.          }
  292.          KeyPort_Y=0x00;
  293.    }
  294.     }
  295.     else keynum=0;
  296.     return keynum;
  297. }
  298. //键值处理函数：当键盘键值需要改动时，请根据上面的键值改动
  299. void KeyDatHandle(u8 key)
  300. {
  301.     u8 tempkey;
  302.     if(key==0)
  303.     {
  304.    
  305.     }
  306.     else
  307.     if(((key>0)&&(key<=8))||((key>32)&&(key<=40))) //楼梯内的楼层选择按键（使用1-8 和 33-40作为按键）
  308.     {
  309.         if(key>32) tempkey=key-32+8;
  310.         else       tempkey=key;
  311.         if(tempkey<=MaxFloor)
  312.         {
  313.             LED_ON(LED_IN_Port,tempkey);
  314.             if(((tempkey>ElevState.CurrentFloor)&&(tempkey<MaxFloor))||(tempkey==1)) ElevState.FloorCallTable[tempkey]|=UP_IN;//内部按1只能往上
  315.             else
  316.             if((tempkey<ElevState.CurrentFloor)||(tempkey==MaxFloor)) ElevState.FloorCallTable[tempkey]|=DOWN_IN;   
  317.         }
  318.     }
  319.     else
  320.     if(((key>9)&&(key<=16))||((key>40)&&(key<=48)))  //每个楼层门口外的向下按键(底楼按向下无效)（使用10-16 和 41-48作为按键）
  321.     {
  322.          if(key>40) tempkey=key-40+8;
  323.          else       tempkey=key-8;
  324.          if((tempkey>1)&&(tempkey<=MaxFloor))
  325.          {
  326.              LED_ON(LED_OUT_DOWN_Port,tempkey);
  327.            ElevState.FloorCallTable[tempkey]|=DOWN_OUT;
  328.          }
  329.     }
  330.     else
  331.     if(((key>16)&&(key<=24))||((key>48)&&(key<56))) //每个楼层门口外的向上按键(顶楼按向上无效)（使用17-24 和 49-55作为按键）
  332.     {
  333.          if(key>48) tempkey=key-48+8;
  334.          else       tempkey=key-16;
  335.          if(tempkey<MaxFloor)
  336.          {
  337.              LED_ON(LED_OUT_UP_Port,tempkey);
  338.              ElevState.FloorCallTable[tempkey]|=UP_OUT;
  339.          }
  340.     }
  341.     else
  342.     if(key==25)  //开门   （使用25 作为按键）
  343.     {
  344.         if(ElevState.ElevRunning==FALSE)
  345.         {
  346.           if(DOOR==CLOSE) DOOR_Open;
  347.         }
  348.     }
  349.     else
  350.     if(key==26) //关门    （使用26 作为按键）
  351.     {
  352.         if(DOOR==OPEN)
  353.         {
  354.             DOOR_Close;
  355.             ElevState.FloorTimerCount=0;     //计时器清0
  356.         }
  357.     }
  358. }
  359. //第待开门
  360. void WaitDoorOpen(u8 ts)
  361. {
  362.     DOOR_Open;
  363.     delay_s(ts);
  364. }
  365. //第待关门
  366. void WaitDoorClose(u8 ts)
  367. {
  368.     DOOR_Close;
  369.     #if (USE_MODE==0)
  370.     delay_s(ts);
  371.     #endif
  372.     #if (USE_MODE==1)
  373.     ts=ts; //防止警告
  374.     while(DOOR_CLOSE_SENSOR==OPEN);
  375.     #endif
  376.    
  377. }
  378. //数码管显示驱动
  379. void SEG_Display(u8 segnum)
  380. {
  381.     HC595_BUFF[0]=SEG_NUM[segnum/10];
  382.     HC595_BUFF[1]=SEG_NUM[segnum%10];
  383.     HC595_Send(HC595_BUFF);   
  384. }
  385. //LED显示驱动
  386. void LED_ON(u8 addr,u8 lednum)
  387. {
  388.     switch(addr)
  389.     {
  390.         case LED_IN_Port:        if(lednum<9)   HC595_BUFF[2]|=LED_NUM[lednum];
  391.                                else           HC595_BUFF[5]|=LED_NUM[lednum-8]; break;
  392.         case LED_OUT_DOWN_Port:  if(lednum<9)   HC595_BUFF[3]|=LED_NUM[lednum];
  393.                                                  else           HC595_BUFF[6]|=LED_NUM[lednum-8]; break;
  394.         case LED_OUT_UP_Port:    if(lednum<9)   HC595_BUFF[4]|=LED_NUM[lednum];
  395.                                                  else           HC595_BUFF[7]|=LED_NUM[lednum-8]; break;
  396.     }
  397.     HC595_Send(HC595_BUFF);   
  398. }
  399. //LED显示驱动
  400. void LED_OFF(u8 addr,u8 lednum)
  401. {
  402.     switch(addr)
  403.     {
  404.         case LED_IN_Port:        if(lednum<9)  HC595_BUFF[2]&=~LED_NUM[lednum];
  405.                                else          HC595_BUFF[5]&=~LED_NUM[lednum-8]; break;
  406.         case LED_OUT_DOWN_Port:  if(lednum<9)  HC595_BUFF[3]&=~LED_NUM[lednum];
  407.                                                  else          HC595_BUFF[6]&=~LED_NUM[lednum-8]; break;
  408.         case LED_OUT_UP_Port:    if(lednum<9)  HC595_BUFF[4]&=~LED_NUM[lednum];
  409.                                                  else          HC595_BUFF[7]&=~LED_NUM[lednum-8]; break;
  410.     }
  411.     HC595_Send(HC595_BUFF);   
  412. }
  413. //电梯运行状态设置
  414. void ElevWorkState(u8 state)
  415. {
  416.   if(state==UP)
  417.     {
  418.         Elev_UP;
  419.         ElevState.ElevRunning=TRUE;
  420.     }
  421.     else
  422.     if(state==DOWN)
  423.     {
  424.         Elev_DOWN;
  425.         ElevState.ElevRunning=TRUE;
  426.     }
  427.     else
  428.     if(state==STOP)
  429.     {
  430.         Elev_STOP;
  431.         ElevState.ElevRunning=FALSE;
  432.     }
  433.     SEG_Display(ElevState.CurrentFloor);        //数码管显示
  434. }
  435. //调头检测函数
  436. void TurnHead_Check(void)
  437. {
  438.     if(ElevState.CurrentFloor==1)  
  439.     {
  440.         ElevState.Direction=UP;  //1楼调头
  441.     }
  442.     else if(ElevState.CurrentFloor==MaxFloor)
  443.     {
  444.         ElevState.Direction=DOWN; //顶楼调头
  445.     }
  446. }
  447. //电梯运行函数
  448. void Elevator(void)
  449. {
  450.     if((DOOR==OPEN)||(ElevState.FreeFlag==TRUE)) ElevWorkState(STOP);   
  451.   else   ElevWorkState(ElevState.Direction);   
  452.     TurnHead_Check();  //调头检测
  453.     if(ElevState.Direction==UP)  //电梯正在向上运行的情况
  454.     {
  455.         if(ElevState.CurrentFloor<=MaxFloor)  //扫描呼叫列表中的向上方向的呼叫楼层
  456.         {
  457.              if(((ElevState.FloorCallTable[ElevState.CurrentFloor]&UP_IN)==UP_IN)||((ElevState.FloorCallTable[ElevState.CurrentFloor]&UP_OUT)==UP_OUT)) //到达目标楼层，停下开门5秒
  458.              {
  459.                  LED_OFF(LED_IN_Port,ElevState.CurrentFloor);
  460.                  LED_OFF(LED_OUT_UP_Port,ElevState.CurrentFloor);
  461.                  ElevState.FloorCallTable[ElevState.CurrentFloor]&=~UP_IN; //到达相应的楼层从向上列表中清除   
  462.          ElevState.FloorCallTable[ElevState.CurrentFloor]&=~UP_OUT; //到达相应的楼层从向上列表中清除                     
  463.                  ElevState.FreeFlag=TRUE; //到达楼层，暂时进入空闲状态                 
  464.                  ElevWorkState(STOP);     //修改电梯状态为停止态
  465.                WaitDoorOpen(DoorStayTime);    //延时等待电梯门打开
  466.                  delay_s(2*DoorStayTime);       //适当延时
  467.                  WaitDoorClose(DoorStayTime);   //等待门关好
  468.                  ElevWorkState(ElevState.Direction);
  469.                  ElevState.FreeFlag=FALSE; //离开楼层，退出空闲状态
  470.                  ElevState.FloorTimerCount=0;     //计时器清0
  471.              }         
  472.         }        
  473.     }
  474.     else
  475.     if(ElevState.Direction==DOWN)  //电梯正在向下运行的情况
  476.     {
  477.         if(ElevState.CurrentFloor>=1)  //扫描呼叫列表中的向下方向的呼叫楼层
  478.         {
  479.              if(((ElevState.FloorCallTable[ElevState.CurrentFloor]&DOWN_IN)==DOWN_IN)||((ElevState.FloorCallTable[ElevState.CurrentFloor]&DOWN_OUT)==DOWN_OUT)) //到达楼层，停下开门5秒
  480.              {   
  481.                  LED_OFF(LED_IN_Port,ElevState.CurrentFloor);
  482.                  LED_OFF(LED_OUT_DOWN_Port,ElevState.CurrentFloor);
  483.          ElevState.FloorCallTable[ElevState.CurrentFloor]&=~DOWN_IN; //到达相应的楼层从向下列表中清除   
  484.                  ElevState.FloorCallTable[ElevState.CurrentFloor]&=~DOWN_OUT; //到达相应的楼层从向下列表中清除   
  485.                  ElevState.FreeFlag=TRUE; //到达楼层，暂时进入空闲状态         
  486.                  ElevWorkState(STOP);     //修改电梯状态为停止态
  487.                WaitDoorOpen(DoorStayTime);    //延时等待电梯门打开
  488.                  delay_s(2*DoorStayTime);       //保持门开2秒让人进出
  489.                  WaitDoorClose(DoorStayTime);   //适当延时
  490.                  ElevWorkState(ElevState.Direction);   //等待门关好
  491.                  ElevState.FreeFlag=FALSE; //离开楼层，退出空闲状态
  492.                  ElevState.FloorTimerCount=0;     //计时器清0
  493.              }            
  494.         }        
  495.     }

  497. }  

  499. //扫描呼叫列表查看楼上或楼下是否有要向上的呼叫，有则返回TRUE,没有返回FALSE
  500. u8 FloorCall_UP(u8 floorside) // floorside  =  DOWN楼下  UP楼上
  501. {
  502.      u8 i;

  504.      if(floorside==UP)
  505.      {
  506.          for(i=ElevState.CurrentFloor+1;i<=MaxFloor;i++) //扫描呼叫列表楼上是否有要向上的呼叫
  507.          {
  508.              if(((ElevState.FloorCallTable[i]&UP_IN)==UP_IN)||((ElevState.FloorCallTable[i]&UP_OUT)==UP_OUT)) //如果扫描到上方楼层有向上的呼叫
  509.              {
  510.                  return TRUE;
  511.              }
  512.          }
  513.          return FALSE;
  514.      }
  515.      else
  516.      if(floorside==DOWN)
  517.      {
  518.          for(i=ElevState.CurrentFloor-1;i>=1;i--) //扫描呼叫列表楼下是否有要向上的呼叫
  519.          {
  520.              if(((ElevState.FloorCallTable[i]&UP_IN)==UP_IN)||((ElevState.FloorCallTable[i]&UP_OUT)==UP_OUT)) //如果扫描到上方楼层有向上的呼叫
  521.              {
  522.                  return TRUE;
  523.              }
  524.          }
  525.          return FALSE;
  526.      }
  527.      else return FALSE;
  528. }
  529. //扫描呼叫列表查看楼上或楼下是否有要向下的呼叫，有则返回TRUE,没有返回FALSE
  530. u8 FloorCall_DOWN(u8 floorside) // floorside  =  DOWN楼下  UP楼上
  531. {
  532.      u8 i;

  534.      if(floorside==UP)
  535.      {
  536.          for(i=ElevState.CurrentFloor+1;i<=MaxFloor;i++) //扫描呼叫列表楼上是否有要向下的呼叫
  537.          {
  538.              if(((ElevState.FloorCallTable[i]&DOWN_IN)==DOWN_IN)||((ElevState.FloorCallTable[i]&DOWN_OUT)==DOWN_OUT)) //如果扫描到上方楼层有向下的呼叫
  539.              {
  540.                  return TRUE;
  541.              }
  542.          }
  543.          return FALSE;
  544.      }
  545.      else
  546.      if(floorside==DOWN)
  547.      {
  548.          for(i=ElevState.CurrentFloor-1;i>=1;i--) //扫描呼叫列表楼下是否有要向下的呼叫
  549.          {
  550.              if(((ElevState.FloorCallTable[i]&DOWN_IN)==DOWN_IN)||((ElevState.FloorCallTable[i]&DOWN_OUT)==DOWN_OUT)) //如果扫描到上方楼层有向下的呼叫
  551.              {
  552.                  return TRUE;
  553.              }
  554.          }
  555.          return FALSE;
  556.      }
  557.      else return FALSE;
  558. }

  560. ////扫描呼叫列表是否为空(没有呼叫)，空-返回TRUE  有呼叫-返回FALSE
  561. u8 DelNullCheck(void) //扫描呼叫列表是否空闲
  562. {
  563.   u8 i;
  564.     u8 result;
  565.         
  566.     for(i=1;i<=MaxFloor;i++)
  567.     {
  568.       if(ElevState.FloorCallTable[i]!=Null)
  569.         {
  570.              result=FALSE; //非空闲
  571.        break;
  572.         }
  573.         else if(i==MaxFloor) result=TRUE;  //空闲
  574.     }
  575.     return result;
  576. }
  577. //楼层呼叫处理函数(无需修改)
  578. void FloorCallCheck(void)
  579. {
  580.     if(DelNullCheck()==FALSE) //非空闲
  581.     {
  582.          ElevState.FreeFlag=FALSE; //退出空闲状态
  583.          ElevState.ElevRunning=TRUE;//正在运行标志打开
  584.     }
  585.     else  ElevState.FreeFlag=TRUE; //进入空闲状态
  586.     TurnHead_Check();
  587.   if((ElevState.FreeFlag==FALSE)&&(DOOR==CLOSE)) //非空闲下
  588.     {               
  589.      if(ElevState.Direction==UP)//方向向上
  590.          {
  591.             if((FloorCall_UP(UP)==TRUE)||(FloorCall_DOWN(UP)==TRUE)) //如果当前楼层上方有呼叫向上的 或 如果当前楼层上方有呼叫向下的
  592.                 {
  593.                     #if (USE_MODE==0)
  594.                   if(ElevState.FloorTimerCount>FloorStayTime) //检测是否到达楼层  如果接收到 到达楼层的限位开关信号，则当前楼层值+1（这里用定时器来模拟）
  595.                   {                                
  596.                       ElevState.FloorTimerCount=0;     //计时器清0
  597.                       ElevState.CurrentFloor++;//电梯继续往上走
  598.                   }
  599.                     #endif
  600.                     #if (USE_MODE==1)
  601.                   if(ElevState.ArriveFlag==TRUE) //检测是否到达楼层  如果接收到 到达楼层的限位开关信号，则当前楼层值+1
  602.                   {        
  603.             ElevState.ArriveFlag=FALSE; //清除标志                        
  604.                       ElevState.FloorTimerCount=0;     //计时器清0
  605.                       ElevState.CurrentFloor++;//电梯继续往上走
  606.                   }   
  607.           #endif                    
  608.                 }
  609.                 else ElevState.Direction=DOWN; //调头               
  610.          }
  611.          else
  612.          if(ElevState.Direction==DOWN)//方向向下
  613.          {
  614.             if((FloorCall_DOWN(DOWN)==TRUE)||(FloorCall_UP(DOWN)==TRUE)) //如果当前楼层下方有呼叫向下的 或 如果当前楼层下方有呼叫向上的
  615.                 {
  616.                     #if (USE_MODE==0)
  617.                   if(ElevState.FloorTimerCount>FloorStayTime) //检测是否到达楼层  如果接收到 到达楼层的限位开关信号，则当前楼层值+1（这里用定时器来模拟）
  618.                   {                                
  619.                       ElevState.FloorTimerCount=0;   
  620.                       ElevState.CurrentFloor--;//电梯继续往下走
  621.                   }
  622.                     #endif
  623.                     #if (USE_MODE==1)
  624.                   if(ElevState.ArriveFlag==TRUE) //检测是否到达楼层  如果接收到 到达楼层的限位开关信号，则当前楼层值+1
  625.                   {   
  626.             ElevState.ArriveFlag=FALSE; //清除标志                                
  627.                       ElevState.FloorTimerCount=0;   
  628.                       ElevState.CurrentFloor--;//电梯继续往下走
  629.                   }
  630.                     #endif
  631.                 }
  632.                 else ElevState.Direction=UP; //调头            
  633.          }
  634.     }
  635.     else
  636.     {        
  637.        ElevWorkState(STOP); //停止运行
  638.          ElevState.ElevRunning=FALSE;//正在运行标志关闭
  639.     }
  640. }

  642. void USART_SendByte(u8 dat)
  643. {
  644.     SBUF=dat;
  645.     while(!TI);  //等待发送数据完成
  646.     TI=0;                //清除发送完成标志位
  647. }
  648. void USART_Send(u8* arr,u16 len)
  649. {
  650.   u16 i;
  651.     for(i=0;i<len;i++)
  652.     {
  653.         SBUF=arr[i];
  654.       while(!TI);  //等待发送数据完成
  655.       TI=0;                //清除发送完成标志位  
  656.     }
  657. }
  658. void USART_SendStr(u8* str)
  659. {
  660.   while(1)
  661.     {
  662.       if(*str=='\0') break;
  663.         SBUF=*str++;
  664.         while(!TI);  //等待发送数据完成
  665.       TI=0;                //清除发送完成标志位
  666.     }
  667. }
  668. //系统初使化
  669. void SYSYEM_INIT(void)
  670. {
  671.      u8 i;
  672.      ElevState.CurrentFloor=1;
  673.      ElevState.Direction=UP;              //初使化方向为向上
  674.      ElevState.FloorTimerCount=0;            //定时器版计时清0
  675.      ElevState.FreeFlag=TRUE;             //初使化为空闲状态
  676.      ElevState.ElevRunning=FALSE;         //运行标志置FALSE  表示暂停运行
  677.      Usart.RX_COUNT=0;                    //串口接收计数清0
  678.      for(i=0;i<=MaxFloor;i++)
  679.      {
  680.          ElevState.FloorCallTable[i]=Null;  //初使化呼叫列表为Null
  681.      }
  682.      DOOR_Close;                          //关门
  683. }
  684. void main(void)
  685. {
  686.     SYSYEM_INIT();
  687.     EXTI0_Init();
  688.     EXTI1_Init();
  689.     TIMER0_Init();
  690.     USART_Config(9600);
  691.     USART_SendStr("Welcome to use Hailin's elevator program \r\n");
  692.   while(1)
  693.     {     
  694.          KeyPort_Y=0x00;   //不可删除
  695.          FloorCallCheck();
  696.        Elevator();   
  697.     }
  698. }
  699. void EXTI0_IRQHandler(void) interrupt 0   //楼层传感器中断
  700. {     
  701.     #if (USE_MODE==1)
  702.     ElevState.ArriveFlag=TRUE;//触发中断后表示到达楼层，让到达楼层标志置TRUE
  703.     #endif
  704. }
  705. void EXTI1_IRQHandler(void) interrupt 2    //矩阵按键中断
  706. {
  707.    KeyDatHandle(KeyScan()); //把KeyScan()按键扫描函数返回的按键值带入到KeyDatHandle()处理按键
  708. }
  709. void TIM0_IRQHandler(void)  interrupt 1    //定时模拟电梯上升和下降
  710. {
  711.    TH0=(65536-50000)/256;//定时50ms
  712.      TL0=(65536-50000)%256;//定时50ms
  713.    
  714.      TimerCount++;
  715.      if(TimerCount==20)  //1秒
  716.      {
  717.          TimerCount=0;
  718.          Timer_Second++;
  719.      }   
  720.      if(DelNullCheck()==FALSE) ElevState.FloorTimerCount++; //非空闲状态计时累加
  721.      else ElevState.FloorTimerCount=0;  //空闲状态计时清0
  722. }

  724. void USART_IRQHandler(void) interrupt 4  //用于电梯之间的通信
  725. {         
  726.   if(RI==1)    //判断是否为接收中断(串口中断分为发送中断和接收中断，均用同一个中断服务函数入口)
  727.     {
  728.         RI = 0;    //清除RI接收中断标志
  729.         Usart.RX_BUFF[Usart.RX_COUNT++]=SBUF;
  730.         if(Usart.RX_COUNT==USART_RX_LEN) Usart.RX_COUNT=0;
  731.     }   
  732. }
  733. /*Uart串口发送函数示例：
  734. 1.USART_SendByte(u8 dat) //发送单字节数据
  735.   例：USART_SendByte(0x04);

  737. 2.USART_Send(u8* arr,u16 len) //发送多字节数据
  738.   例：
  739.   Usart.TX_BUFF[0]=0xA1;
  740.   Usart.TX_BUFF[1]=0x08;
  741.   Usart.TX_BUFF[2]=0x04;
  742.   Usart.TX_BUFF[3]=0xF9;
  743.   USART_SendByte(Usart.TX_BUFF,4);
  744.   或
  745.   u8 Arr[16]={0xA1,0x08,0x04,0xF9};
  746.   USART_SendByte(Arr,4);

  748. 3.USART_SendStr(u8* str) //发送字符串数据
  749.   USART_SendStr("大吉在利，晚上吃鸡！\r\n");

  751. 4.有关电梯通信代码参考：
  752. <1>发送电梯当前楼层给其他设备：     USART_SendByte(ElevState.CurrentFloor);
  753. <2>发送电梯当前运行方向给其他设备： USART_SendByte(ElevState.Direction);
  754. <3>发送电梯当前所有数据给其他设备： USART_Send((u8*)(&ElevState),sizeof(ElevState));

  756. */

  758. /*Uart串口接收函数示例：
  759. 1.单字符指令接收：
  760. #include "reg51.h"
  761. void main(void)
  762. {
  763.    USART_Configure(9600);//配置9600波特率(默认无奇偶校验，1位停止位，8位数据位)
  764.    while(1)
  765.      {
  766.        if(Usart.RX_COUNT>0) //判断串口是否有接收
  767.          {
  768.            Usart.RX_COUNT=0;
  769.              if(Usart.RX_BUFF[0]=='A') //如果控制对象比较多请换成switch()
  770.              {
  771.                P1=0x0F;
  772.              }
  773.              if(Usart.RX_BUFF[0]=='B')
  774.              {
  775.                P1=0xF0;
  776.              }
  777.          }
  778.      }
  779. }
  780. 2.多字符指令接收：(为了方便,我们用C标准库自带的string.h)
  781. #include "reg51.h"
  782. #include <string.h>
  783. void main(void)
  784. {
  785.    char xbuff[20];
  786.    USART_Configure(9600);//配置9600波特率(默认无奇偶校验，1位停止位，8位数据位)
  787.    while(1)
  788.      {
  789.        if(Usart.RX_COUNT>4) //判断串口是否接收到指令(设指令格式为：开灯/  关灯/  用/来表示指令结束符)
  790.          {
  791.            if(Usart.RX_BUFF[4]=='/') //断判结束符
  792.              {
  793.                  Usart.RX_COUNT=0;
  794.                  strncpy(xbuff, Usart.RX_BUFF+0 , 4);//+0表示从接收缓存的第0个字符开始截取4个字符到xbuff判断指令
  795.                  if(strncmp(xbuff,"开灯",4) == 0)
  796. ……………………

  798. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
16层电梯.zip (102.19 KB, 下载次数: 21)



评分

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

查看全部评分

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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