找回密码
 立即注册

QQ登录

只需一步,快速开始

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

基于单片机电梯控制系统设计资料

[复制链接]
跳转到指定楼层
楼主
ID:888341 发表于 2021-4-3 15:50 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
设计原理及单元模块
3.1设计原理及方法
根据层次化设计理论,该设计问题自顶向下可分为单片机最小系统模块、显示模块、开关控制模块、电机驱动模块、报警模块,其系统框图如图所示。


图3.1 电梯控制系统框图
本次设计是采用开关控制实现上下到指定楼层,通过电机转动带动电梯箱上下运动,到达指定楼层。显示模块是显示此时的楼层,报警模块具有错误操作报警以及楼层到达的提示功能。
3.2单元模块设计
3.2.1
单片机最小系统模块
图3.2.1单片机最小系统
单片机最小系统包括主芯片,复位电路和晶振脉冲产生电路。X1为12MHz晶振,与30Pf电容并联,产生1us的脉冲信号作为单片机的“心脏”部分。复位电路是开关与10uf电容并联组成的上电自动复位电路,在RST端为高电平时单片机清零,也即开关按下会产生清零信号。RP1为排阻,作为P0端的上拉电阻,接此原因是P0端口是由OC门组成。U1为数据输入端口,通过电脑编程能将程序通过此接口烧录入单片机中。



3.2.2 开关控制模块
图3.2.2 开关控制模块
开关控制模块采用4*4矩阵形式电路可以减少单片机接口的使用。写键盘代码时运用的是逐行扫描判断键值按下与否。编程如下:
uchar key_scan(void)
{              uchar scode,recode;
              P1=0xf0;
              if((P1&0xf0)!=0xf0)
              {              delay1(2);
                            if((P1&0xf0)!=0xf0)//有键按下
                            {              scode=0xfe;//辅助变量,设定行
                                          while((scode&0x10)!=0)
                                          {              P1=scode;//将某一行设为0,从而判断是否为该行
                                                        if((P1&0xf0)!=0xf0)
                                                        {              recode=P1&0xf0;//列码
                                                                      scode=scode&0xf0;//行码
                                                                      return(scode+recode);//按键坐标}
                                                        else    scode=(scode<<1)|0x01;//下一行判断
}}}
              return 0;}
3.2.3电机驱动模块
图3.2.3电机驱动模块
电机驱动采用L297环形计数分配器和L298大功率步进电机驱动器完成。本次设计采用步进电机,目的是方便智能控制,可实现调速功能。电机使用的是二相步进电机,由于仅用来实验,所以电机采用5V电源供电即可,实际中必须使用大电压来供电方能带动重物(人等)。
环形分配器L297引脚图如图3.2.3-1:
图3.2.3-1 L97引脚图
L297功能介绍:
SYNC为斩波器输出端,多个L297一起用时用此端口连接在一起共用一组时钟振荡;
HPME端为集电极开路输出端;
A~D为四相输入端;
INIH1,INIH2为控制A~D相驱动,此引脚为低电平时A~D相禁止输入;
ENABLE端为使能输入端,低电平阻止电机驱动;
RESET为复位端;
HALF/FULL为半角全角控制端,高电平时选择半步输入;
CLOCK为时钟输入端,控制电机速度;
CW/CCW为方向控制端;
OSC为斩波器频率输入端;
SEN1和SEN2为电流检测端。
大功率步进电机驱动器L298引脚图如图3.2.3-2:
图3.2.3-2 L298引脚图
L298功能介绍:   
SENA和SENB为电流检测端;
IN1~IN4为A~D相输入控制端;
ENA和ENB为使能输入端,低电平禁止输入;
OUT1~OUT4为输出端。
3.2.4显示模块
图3.2.4显示模块
由于点阵和双位数码管耗电流较大,不能直接连接单片机IO口驱动其正常工作,所以加上锁存器74HC573和显示译码器CD4511驱动。其中利用CD4511模块的另一作用是节省接口,因为本次设计外围电路较多,单片机接口不够,使用此驱动是必要的。
锁存器74HC573引脚图如图3.2.4-1:
图3.2.4-1 74HC573引脚图
74HC573功能介绍:
D0~D7为输入端;
Q0~Q7为输出端;
OEN为输出使能端,当其输入为高电平时输出关断,输入为低电平时输出正常;
DEN为输出输入使能端,当此端口为高电平时,输出跟随D0~D7,当此端口为低电平时,输出保持上一时刻的状态;
显示译码器CD4511引脚图如图3.2.4-2:
图3.2.4-2 CD4511引脚图
CD4511功能介绍:
A~D为输入端;
QA~QG为输出端;
LT为试灯输入端,当此端口为低电平时,无论其他的状态如何,始终输出数字8,作为判断数码管的好坏端口使用;
LE/STB为灭灯输入端,当此端口输入低电平时数码管灭,输入高电平时数码管正常显示;
BI为动态消零信号输入端,当此端口输入低电平时且LT为高电平时,当输入0000时,输出0熄;
点阵的使用介绍:
点阵是8*8位的,相当于由64个LED组成,8个阳极控制端口,8个阴极控制端口;
数码管的使用介绍:
数码管是采用两位共阴极数码管,通过对a~g的编码来显示数字。
3.2.5报警模块
图3.2.5报警模块
本设计采用8550三极管驱动蜂鸣器。当PO口送高电平时,三极管处于截止状态,三极管Vce电压约为VCC,蜂鸣器只有很少电流流过,没法驱动其发声。当PO口送低电平时,三极管处于饱和导通状态,三极管Vce约为0.3V,蜂鸣器有较大电流流过,能驱动其报警发声。
3.2.6电路总图
图3.2.6 电路总图
由于protel99se内部元件不齐全,本次设计全部采用手工绘制元件库以达到训练的最佳效果。


4软件模块

图4 程序流程图
注:详细程序见附录二
5 PCB印刷版图模块
5.1 protel99se功能介绍
Protel99SE是应用于Windows9X/2000/NT操作系统下的EDA设计软件,采用设计库管理模式,可以进行联网设计,具有很强的数据交换能力和开放性及3D模拟功能,是一个32位的设计软件,可以完成电路原理图设计,印制电路板设计和可编程逻辑器件设计等工作,可以设计32个信号层,16个电源--地层和16个机加工层。
5.2 PCB版图
图5.2.1非镀铜版图
在生成PCB之前,要进行元件的封装。由于protel99se内部封装不齐全,本次设计全部采用手工绘制封装库以达到最佳训练效果。PCB布线规则是尽量使正面走线和反面走线成90度角,以达到最小干扰。
图5.2.2镀铜顶层图样
图5.2.3 镀铜底层图样
图5.3.4 3D版图正面
图5.3.5 3D版图背面

附录一
元件清单
单片机源程序如下:
  1. #include"reg52.h"
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. uchar DZ1[]={0x08,0x14,0x2a,0x08,0x08,0x08};
  5. uchar DZ2[]={0xbf,0xdf,0xef,0xf7,0xfd,0xfb};
  6. uchar DZ3[]={0x08,0x08,0x08,0x2a,0x14,0x08};
  7. uchar shuma[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09};
  8. uchar LC[]={0xee,0xde,0xbe,0x7e,0xed,0xdd,0xbd,0x7d,0xeb,0xedb,0xbb,0x7b,0xe7,0xd7,0xb7,0x77};//楼层编码
  9. uchar key,dir,floor,zancun,s,x,p2;
  10. sbit DA=P0^0;
  11. sbit DB=P0^1;
  12. sbit DC=P0^2;
  13. sbit DD=P0^3;
  14. sbit w1=P0^4;//数码管位选1
  15. sbit w2=P0^5;//数码管位选2
  16. sbit wa=P0^6;//点阵阳极使能
  17. sbit wb=P0^7;//点阵阴极使能
  18. sbit EN=P3^0;//电机使能
  19. sbit CW=P3^1;//方向控制
  20. sbit CLOCK=P3^2;//速度控制
  21. sbit red=P3^3;//上键显示
  22. sbit green=P3^4;//下键显示
  23. sbit beep=P3^5;//报警
  24. void delay1(uchar z)
  25. {
  26.               uchar i,j;
  27.               for(i=z;i>0;i--)
  28.               for(j=110;j>0;j--);
  29. }
  30. void delay2(uchar z)
  31. {
  32.               uchar i,j;
  33.               for(i=z;i>0;i--)
  34.               {
  35.                             if(key==0)//减短代码运行时间,使用更多时间扫描键盘
  36.                             break;
  37.                             else
  38.                             for(j=110;j>0;j--);
  39.               }
  40.             
  41. }
  42. uchar key_scan(void)
  43. {
  44.               uchar scode,recode;
  45.               P1=0xf0;
  46.               if((P1&0xf0)!=0xf0)
  47.               {
  48.                             delay1(2);
  49.                             if((P1&0xf0)!=0xf0)//有键按下
  50.                             {
  51.                                           scode=0xfe;//辅助变量,设定行
  52.                                           while((scode&0x10)!=0)
  53.                                           {
  54.                                                         P1=scode;//将某一行设为0,从而判断是否为该行
  55.                                                         if((P1&0xf0)!=0xf0)
  56.                                                         {
  57.                                                                       recode=P1&0xf0;//列码
  58.                                                                       scode=scode&0x0f;//行码
  59.                                                                       return(scode+recode);//按键坐标
  60.                                                         }
  61.                                                         else
  62.                                                         scode=(scode<<1)|0x01;//下一行判断
  63.                                           }
  64.                             }
  65.               }
  66.               return 0;
  67. }
  68. void display1(void)//上箭头显示
  69. {
  70.               uchar i,j;
  71.               for(i=0;i<1;i++)
  72.               {
  73.                             wa=1;
  74.                             P2=DZ1[i];
  75.                             for(j=500;j>0;j--);
  76.                             wa=0;
  77.                             wb=1;
  78.                             P2=DZ2[i];
  79.                             for(j=500;j>0;j--);
  80.                             wb=0;
  81.               }
  82. }
  83. void display2(void)//下箭头显示
  84. {
  85.               uchar i,j;
  86.               for(i=0;i<1;i++)
  87.               {
  88.                             wa=1;
  89.                             P2=DZ3[i];
  90.                             for(j=500;j>0;j--);
  91.                             wa=0;
  92.                             wb=1;
  93.                             P2=DZ2[i];
  94.                             for(j=500;j>0;j--);
  95.                             wb=0;
  96.               }
  97. }
  98. void shuxian(uchar z)//数码管显示
  99. {
  100.               uchar temp;
  101.               w1=0;
  102.               p0=shuma[z/10];
  103.               temp=P0;
  104.               P0=p0|temp;
  105.               w1=1;
  106.               w2=0;
  107.               p0=shuma[z%10];
  108.               temp=P0;
  109.               P0=p0|temp;
  110.               w2=1;
  111. }
  112. void init(void)//初始化
  113. {
  114.               dir=0;
  115.               w1=1;
  116.               w2=1;
  117.               wa=0;
  118.               wb=0;
  119.               floor=0;
  120.               zancun=1;
  121.               beep=1;
  122.               EN=0;
  123.               EA=1;
  124.               ET1=1;//T1中断允许
  125.               TMOD=0x10;//T1的8位计数
  126.               TH1=(65536-50000)/256;
  127.               TL1=(65536-50000)%256;
  128. }
  129. void main(void)
  130. {
  131.               init();
  132.               while(1)
  133.               {
  134.                             key=key_scan();
  135.                             if(key!=0)
  136.                             {
  137.                                           delay2(10);
  138.                                           if(key!=0)
  139.                                           {
  140.                                                         TR1=1;
  141.                                                         switch(key)
  142.                                                         {
  143.                                                                       case LC[14]:
  144.                                                                       dir=1;//按键储存上键值
  145.                                                                       break;
  146.                                                                       case LC[15]:
  147.                                                                       dir=2;//按键储存下键值
  148.                                                                       break;
  149.                                                                       default break;
  150.                                                         }
  151.                                                         if(dir==1)
  152.                                                         {
  153.                                                                       shuxian(s);
  154.                                                                       display1();
  155.                                                                       if((zancun-floor)>=0)
  156.                                                                       {
  157.                                                                                     switch(key)
  158.                                                                                     {
  159.                                                                                                   case LC[0]:
  160.                                                                                                   floor=1;
  161.                                                                                                   break;
  162.                                                                                                   case LC[1]:
  163.                                                                                                   floor=2;
  164.                                                                                                   break;
  165.                                                                                                   case LC[2]:
  166.                                                                                                   floor=3;
  167.                                                                                                   break;
  168.                                                                                                   case LC[3]:
  169.                                                                                                   floor=4;
  170.                                                                                                   break;
  171.                                                                                                   case LC[4]:
  172.                                                                                                   floor=5;
  173.                                                                                                   break;
  174.                                                                                                   case LC[5]:
  175.                                                                                                   floor=6;
  176.                                                                                                   break;
  177.                                                                                                   case LC[6]:
  178.                                                                                                   floor=7;
  179.                                                                                                   break;
  180.                                                                                                   case LC[7]:
  181.                                                                                                   floor=8;
  182.                                                                                                   break;
  183.                                                                                                   case LC[8]:
  184.                                                                                                   floor=9;
  185.                                                                                                   break;
  186.                                                                                                   case LC[9]:
  187.                                                                                                   floor=10;
  188.                                                                                                   break;
  189.                                                                                                   case LC[10]:
  190.                                                                                                   floor=11;
  191.                                                                                                   break;
  192.                                                                                                   case LC[11]:
  193.                                                                                                   floor=12;
  194.                                                                                                   break;
  195.                                                                                                   case LC[12]:
  196.                                                                                                   floor=13;
  197.                                                                                                   break;
  198.                                                                                                   case LC[13]:
  199.                                                                                                   floor=14;
  200.                                                                                                   break;                                                                                                                                                                       
  201.                                                                                     }
  202.                                                                       }
  203.                                                                       else   //不符逻辑报警停止电机转动
  204.                                                                       beep=0;
  205.                                                                       EN=0;
  206.                                                                       TR1=0;            
  207.                                                         }
  208.                                                         if(dir==0)
  209.                                                         {
  210.                                                                       shuxian(x);
  211.                                                                       display2();
  212.                                                                       if((zancun-floor)<=0)
  213.                                                                       {
  214.                                                                                     switch(key)
  215.                                                                                     {
  216.                                                                                                   case LC[0]:
  217.                                                                                                   floor=1;
  218.                                                                                                   break;
  219.                                                                                                   case LC[1]:
  220.                                                                                                   floor=2;
  221.                                                                                                   break;
  222.                                                                                                   case LC[2]:
  223.                                                                                                   floor=3;
  224.                                                                                                   break;
  225.                                                                                                   case LC[3]:
  226.                                                                                                   floor=4;
  227.                                                                                                   break;
  228.                                                                                                   case LC[4]:
  229.                                                                                                   floor=5;
  230.                                                                                                   break;
  231.                                                                                                   case LC[5]:
  232.                                                                                                   floor=6;
  233.                                                                                                   break;
  234.                                                                                                   case LC[6]:
  235.                                                                                                   floor=7;
  236.                                                                                                   break;
  237.                                                                                                   case LC[7]:
  238.                                                                                                   floor=8;
  239.                                                                                                   break;
  240.                                                                                                   case LC[8]:
  241.                                                                                                   floor=9;
  242.                                                                                                   break;
  243.                                                                                                   case LC[9]:
  244.                                                                                                   floor=10;
  245.                                                                                                   break;
  246.                                                                                                   case LC[10]:
  247.                                                                                                   floor=11;
  248.                                                                                                   break;
  249.                                                                                                   case LC[11]:
  250.                                                                                                   floor=12;
  251.                                                                                                   break;
  252.                                                                                                   case LC[12]:
  253.                                                                                                   floor=13;
  254.                                                                                                   break;
  255.                                                                                                   case LC[13]:
  256.                                                                                                   floor=14;
  257.                                                                                                   break;                                                                                                                                                                       
  258.                                                                                     }                                                                                   
  259.                                                                       }
  260.                                                                       else //不符逻辑报警停止电机转动
  261. ……………………

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

以上的Word格式文档51黑下载地址:
基于单片机电梯控制系统设计.doc (1.38 MB, 下载次数: 55)

评分

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

查看全部评分

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

使用道具 举报

沙发
ID:513213 发表于 2021-7-16 08:24 | 只看该作者
比较完整的一个设计项目&资料
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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