基于单片机的电梯仿真程序课程设计

目录
（一）前言 (1)
（二）现代电梯概述
(3)
（三）硬件部分设计
(6)
（四）软件部分设计
(12)
（五）电梯运行界面 (52)
（六）设计总结与感悟
(56)
（七）参考文献 (57)
电梯仿真程序
一、前言：
本电梯仿真程序采用的是一个基于单片机及其相关外设，编程语言采用汇编与C语言结合的方式，通过矩阵键盘线反选法输入楼层，上、下行等控制信号，经I\O口读入，进行相关实时控制，软硬件结合的仿真系统，输出设备包括由CD4511驱动显示楼层的7段数码管，显示实时信息的显示屏LCD12864,由PWM控制显示电梯门开关的舵机，以及由I\O口间接控制的驱动电机正反转双桥驱动电路等几个部分组成。

可以实现真实电梯中，任意层呼叫，目的层到达按要求顺序到达，开关门，无输入自动回1层等一系列功能，并实时显示当前电梯运行状态，关于真实电梯门控光幕装置，电机自动抱闸平层等部分，由于知识不足，没有足一实现，但会在接下来的专业知识学习过程中不断完善，同时也希望得到程老师的指导。

二、现代电梯概述：
电梯是一种以电动机为动力的垂直升降机，装有箱状吊舱，用于多层建筑乘人或载运货物。

也有台阶式，踏步板装在履带上连续运行，俗称自动电梯。

服务于规定楼层的固定式升降设备。

它具有一个轿厢，运行在至少两列垂直的或倾斜角小于15°的刚性导轨之间。

轿厢尺寸与结构形式便于乘客出入或装卸货物，本次微机课程设计电梯仿真选用的是垂直升降梯。

2.1、电梯功能
现代电梯主要由曳引机（绞车）、导轨、对重装置、安全装置(如限速器、安全钳和缓冲器等)、信号操纵系统、轿厢与厅门等组成。

这些部分分别安装在建筑物的井道和机房中。

通常采用钢丝绳摩擦传动，钢丝绳绕过曳引轮，两端分别连接轿厢和平衡重，电动机驱动曳引轮使轿厢升降。

电梯要求安全可靠、输送效率高、平层准确和乘坐舒适等。

电梯的基本参数主要有额定载重量、可乘人数、额定速度、轿厢外廓尺寸和井道型式等。

简单使用方法（紧急情况下面有解决方法）载人电梯都是微机控制的智能化、自动化设备，不需要专门的人员来操作电梯电梯结构图电梯内部结构图驾驶，普通乘客只要按下列程序乘坐和操作电梯即可。

2.2、运行过程：
1、在乘梯楼层电梯入口处，根据自己上行或下行的需要，按上方向或下方向箭头按钮，只要按钮上的灯亮，就说明你的呼叫已被记录，只要等待电梯到来即可。

2、电梯到达开门后，先让轿厢内人员走出电梯，然后呼梯者再进入电梯轿厢。

进入轿厢后，根据你需要到达的楼层，按下轿厢内操纵盘上相应的数字按钮。

同样，只要该按钮灯亮，则说明你的选层已被记录；此时不用进行其他任何操作，只要等电梯到达你的目的层停靠即可。

3、电梯行驶到你的目的层后会自动开门，此时按顺序走出电梯即结束了一个乘梯过程。

三、硬件部分设计
3.1、总电路图：
3.2、单片机最小系统：
单片机最小系统,或者称为最小应用系统,是指用最少的元件组成的单片机可以工作的系统.对51系列单片机来说,最小系统一般应该包括:单片机、晶振电路、复位电路.下面给出一个51单片机的最小系统电路图.
3.3、矩阵键盘：
在键盘中按键数量较多时，为了减少I/O口的占用，通常将按键排列成矩阵形式。

在矩阵式键盘中，每条水平线和垂直线在交叉处不直接连通，而是通过一个按键加以连接。

这样，一个端口（如P1口）就可以构成4*4=16个按键，
1．键盘的工作原理：按键设置在行、列线交点上，行、列线分别连接到按键开关的两端。

行线通过上拉电阻接到+5V 电源上。

无按键按下时，行线处于高电平的状态，而当有按键按下时，行线电平与此行线相连的列线电平决定。

2．行列扫描法原理：
第一步，使行线为编程的输入线，列线是输出线，拉低所有的列线，判断行线的变化，如果有按键按下，按键按下的对应行线被拉低，否则所有的行线都为高电平。

第二步，在第一步判断有键按下后，延时10ms 消除机械抖动，再次读取行值，如果此行线还处于低电平状态则进入下一步，否则返回第一步重新判断。

第三步，开始扫描按键位置，采用逐行扫描，每间隔1ms 的时间，分别拉低第一列，第二列，第三列，第四列，无论拉低哪一列其他三列都为高电平，读取行值找到按键的位置，分别把行值和列值储存在寄存器里。

3.4、CD4511当前楼层显示
CD4511 是一片CMOS BCD-锁存/7 段译码/驱动器，用于驱动共阴极LED （数码管）显示器的BCD 码-七段码译码器。

它具有BCD转换、消隐和锁存控制、七段译码及驱动功能的CMOS电路能提供较大的拉电流。

可直接驱动共阴LED数码管。

以下是CD4511数码管驱动原理电路图。

是CD4511实现LED与单片机的并行接口方法。

3.5、LCD12864
不带中文字库的128X64 是一种具有4 位/8 位并行、2 线或3 线串行多种接口方式，内部含有国标一级、二级简体中文字库的点阵图形液晶显示模块；其显示分辨率为128×64, 内置8192 个16*16 点汉字，和128 个16*8 点ASCII 字符集.利用该模块灵活的接口方式和简单、方便的操作指令，可构成全中文人机交互图形界面。

可以显示8×4 行16×16 点阵的汉字. 也可完成图形显示.低电压低功耗是其又一显著特点。

由该模块构成的液晶显示方案与同类型的图形点阵液晶显示模块相比，不论硬件电路结构或显示程序都要简洁得多，且该模块的价格也略低于相同点阵的图形液晶模块。

3.6、电机双桥驱动系统
一、H桥驱动电路
图4.12中所示为一个典型的直流电机控制电路。

电路得名于“H桥驱动电路”是因为它的形状酷似字母H。

4个三极管组成H的4条垂直腿，而电机就是H中的横杠（注意：图4.12及随后的两个图都只是示意图，而不是完整的电路图，其中三极管的驱动电路没有画出来）。

如图所示，H桥式电机驱动电路包括4个三极管和一个电机。

要使电机运转，必须导通对角线上的一对三极管。

根据不同三极管对的导通情况，电流可能会从左至右或从右至左流过电机，从而控制电机的转向。

图4.12 H桥驱动电路
要使电机运转，必须使对角线上的一对三极管导通。

例如，如图4.13所示，当Q1管和Q4管导通时，电流就从电源正极经Q1从左至右穿过电机，然后再经Q4回到电源负极。

按图中电流箭头所示，该流向的电流将驱动电机顺时针转动。

当三极管Q1和Q4导通时，电流将从左至右流过电机，从而驱动电机按特定方向转动（电机周围的箭头指示为顺时针方向）。

图4.13 H桥电路驱动电机顺时针转动
图4.14所示为另一对三极管Q2和Q3导通的情况，电流将从右至左流过电机。

当三极管Q2和Q3导通时，电流将从右至左流过电机，从而驱动电机沿另一方向转动（电机周围的箭头表示为逆时针方向）。

图4.14 H桥驱动电机逆时针转动
二、使能控制和方向逻辑
驱动电机时，保证H桥上两个同侧的三极管不会同时导通非常重要。

如果三极管Q1和Q2同时导通，那么电流就会从正极穿过两个三极管直接回到负极。

此时，电路中除了三极管外没有其他任何负载，因此电路上的电流就可能达到最大值（该电流仅受电源性能限制），甚至烧坏三极管。

基于上述原因，在实际驱动电路中通常要用硬件电路方便地控制三极管的开关。

图4.155 所示就是基于这种考虑的改进电路，它在基本H桥电路的基础上增加了4个与门和2个非门。

4个与门同一个“使能”导通信号相接，这样，用这一个信号就能控制整个电路的开关。

而2个非门通过提供一种方向输人，可以保证任何时候在H桥的同侧腿上都只有一个三极管能导通。

（与本节前面的示意图一样，图4.15所示也不是一个完整的电路图，特别是图中与门和三极管直接连接是不能正常工作的。

）
图4.15 具有使能控制和方向逻辑的H桥电路
采用以上方法，电机的运转就只需要用三个信号控制：两个方向信号和一个使能信号。

如果DIR－L信号为0，DIR－R信号为1，并且使能信号是1，那么三极管Q1和Q4导通，电流从左至右流经电机（如图4.16所示）；如果DIR－L信号变为1，而DIR－R信号变为0，那么Q2和Q3将导通，电流则反向流过电机。

四、软件部分设计：
4.1、程序框图
否
是
否
否
是
是
硬件上电待命 显示提示，开发者、版本信息
键盘输入目的楼层
结束键是否按下 记录并该楼层标志位 程序开始运行While(1){...} 电机运行，到达下一层 当前楼层标志位加一并与存储楼层对比 若相等 电机停转，电梯门开，延时lcd 显示,7段数码管显示 电梯门，电机运行，延时lcd 显示,7段数码管显示 运行至最后目 的楼层 键盘扫描 继续否 结束待命
4.2、C51单片机汇编、C语言混编程序：
; 电梯。

SRC generated from: 电梯.c
; COMPILER INVOKED BY:
; C:\Keil\C51\BIN\C51.EXE 电梯.c BROWSE DEBUG OBJECTEXTEND $NOMOD51
NAME 电梯
P0 DATA 080H
P1 DATA 090H
P2 DATA 0A0H
P3 DATA 0B0H
T0 BIT 0B0H.4
AC BIT 0D0H.6
T1 BIT 0B0H.5
T2 BIT 090H.0
EA BIT 0A8H.7
IE DATA 0A8H
clock BIT 0B0H.0
EXF2 BIT 0C8H.6
RD BIT 0B0H.7
ES BIT 0A8H.4
IP DATA 0B8H
RI BIT 098H.0
INT0 BIT 0B0H.2
CY BIT 0D0H.7
TI BIT 098H.1
INT1 BIT 0B0H.3 RCAP2H DATA 0CBH PS BIT 0B8H.4
SP DATA 081H
T2EX BIT 090H.1
OV BIT 0D0H.2
RCAP2L D ATA 0CAH
C_T2 BIT 0C8H.1
WR BIT 0B0H.6
RCLK BIT 0C8H.5
TCLK BIT 0C8H.4 SBUF DATA 099H PCON DATA 087H SCON DATA 098H TMOD DATA 089H TCON DATA 088H
IE0 BIT 088H.1
IE1 BIT 088H.3
B DATA 0F0H
CP_RL2 BIT 0C8H.0
ACC DATA 0E0H servo_door BIT 0B0H.7 ET0 BIT 0A8H.1
ET1 BIT 0A8H.3
TF0 BIT 088H.5
ET2 BIT 0A8H.5
TF1 BIT 088H.7
TF2 BIT 0C8H.7
RB8 B IT 098H.2
TH0 D ATA 08CH
EX0 B IT 0A8H.0
IT0 BIT 088H.0
TH1 D ATA 08DH
TB8 BIT 098H.3
EX1 B IT 0A8H.2
IT1 BIT 088H.2
TH2 D ATA 0CDH
P BIT 0D0H.0
SM0 BIT 098H.7 TL0 DATA 08AH SM1 BIT 098H.6 TL1 DATA 08BH SM2 BIT 098H.5 TL2 DATA 0CCH
PT0 BIT 0B8H.1
PT1 BIT 0B8H.3
RS0 BIT 0D0H.3
PT2 BIT 0B8H.5
TR0 BIT 088H.4
RS1 BIT 0D0H.4
TR1 BIT 088H.6
TR2 BIT 0C8H.2
PX0 BIT 0B8H.0
PX1 BIT 0B8H.2
DPH DATA 083H DPL D ATA 082H EXEN2 BIT 0C8H.3 REN BIT 098H.4
T2CON DATA 0C8H RXD BIT 0B0H.0
TXD BIT 0B0H.1
F0 BIT 0D0H.5
PSW DATA 0D0H
?PR?_delay?SMARTCAR SEGMENT CODE
?PR?_ABS?SMARTCAR SEGMENT CODE
?PR?keysort?SMARTCAR SEGMENT CODE
?PR?keycheck?SMARTCAR SEGMENT CODE
?PR?sys_init?SMARTCAR SEGMENT CODE
?PR?_BCD?SMARTCAR SEGMENT CODE
?PR?main?SMARTCAR SEGMENT CODE
?PR?TIME_BASE?SMARTCAR SEGMENT CODE ?C_INITSEG SEGMENT CODE
?BI?SMARTCAR SEGMENT BIT
?DT?SMARTCAR SEGMENT DA TA
EXTRN CODE (?C_STARTUP)
PUBLIC floor_up_2
PUBLIC floor_up_1
PUBLIC rankkey
PUBLIC opendoor
PUBLIC i
PUBLIC up_flag
PUBLIC row
PUBLIC floor_down_5
PUBLIC floor_down_4
PUBLIC floor_down_3
PUBLIC floor_down_2
PUBLIC pressflag
PUBLIC key
PUBLIC key_flag
PUBLIC stop_flag
PUBLIC temp
PUBLIC down_flag PUBLIC floor_flag_5 PUBLIC floor_flag_4 PUBLIC floor_flag_3 PUBLIC floor_flag_2 PUBLIC floor_flag_1 PUBLIC start
PUBLIC close_door PUBLIC rank
PUBLIC count
PUBLIC rowkey PUBLIC floor_up_4 PUBLIC floor_up_3 PUBLIC TIME_BASE PUBLIC main
PUBLIC _BCD
PUBLIC sys_init PUBLIC keycheck PUBLIC keysort PUBLIC _ABS
PUBLIC _delay
RSEG ?BI?SMARTCAR floor_up_3: DBIT 1 floor_up_4: DBIT 1 close_door: DBIT 1
start: DBIT 1 floor_flag_1: DBIT 1 floor_flag_2: DBIT 1
floor_flag_3: DBIT 1 floor_flag_4: DBIT 1 floor_flag_5: DBIT 1 down_flag: DBIT 1
stop_flag: DBIT 1
pressflag: DBIT 1 floor_down_2: DBIT 1 floor_down_3: DBIT 1 floor_down_4: DBIT 1 floor_down_5: DBIT 1 up_flag: DBIT 1
opendoor: DBIT 1 floor_up_1: DBIT 1 floor_up_2: DBIT 1
RSEG ?DT?SMARTCAR
rowkey: DS 1
count: DS 2
rank: DS 1
temp: DS 1 key_flag: DS 16
key: DS 1
row: DS 1
i: DS 1
rankkey: DS 1
RSEG ?C_INITSEG
DB 002H
DB count
DW 00000H
DB 010H
DB key_flag
DB 000H
DB 000H,000H,000H,000H,000H,000H,000H,000H,000H,000H DB 000H,000H,000H,000H,000H
DB 001H
DB key
DB 000H
DB 001H
DB i
DB 000H
DB 0C1H, pressflag + 000H ; bit-init
DB 0C1H, up_flag + 000H ; bit-init
DB 0C1H, down_flag + 000H ; bit-init
DB 0C1H, stop_flag + 000H ; bit-init
DB 001H
DB rowkey
DB 000H
DB 001H
DB rankkey
DB 000H
DB 001H
DB temp
DB 000H
DB 001H
DB row
DB 000H
DB 001H
DB rank
DB 000H
DB 0C1H, floor_flag_1 + 000H ; bit-init
DB 0C1H, floor_flag_2 + 000H ; bit-init
DB 0C1H, floor_flag_3 + 000H ; bit-init
DB 0C1H, floor_flag_4 + 000H ; bit-init
DB 0C1H, floor_flag_5 + 000H ; bit-init
DB 0C1H, floor_down_5 + 000H ; bit-init DB 0C1H, floor_up_4 + 000H ; bit-init
DB 0C1H, floor_down_4 + 000H ; bit-init DB 0C1H, floor_up_3 + 000H ; bit-init
DB 0C1H, floor_down_3 + 000H ; bit-init DB 0C1H, floor_up_2 + 000H ; bit-init
DB 0C1H, floor_down_2 + 000H ; bit-init DB 0C1H, floor_up_1 + 000H ; bit-init
DB 0C1H, opendoor + 000H ; bit-init
DB 0C1H, close_door + 000H ; bit-init
DB 0C1H, start + 000H ; bit-init
; //晶振12MHz 6T模式，总线频率2MHz 指令0.5us
; #pragma src
; #include <REG52.H> //89C52的头文件
;
; #define T0_HIGH 0xff //T0计时器寄存器初值
; #define T0_LOW 0x9b //溢出计数80个，定时周期80*0.25us=20us
; //为了保证主程序正常运行，定时器计数最好不要小于80个
;
; #define keynumber 16 16个按键标志
; #define KEYIO P2 4*4键盘输入
; #define output P1 lcd12864数据D0~D7
; #define nobcd P0 BCD端口输出
;
; sbit clock=P3^0; lcd12864时钟输出端
; sbit servo_door=P3^7; 舵机控制门输出端口
; int count=0;
;
; char key_flag[keynumber]={0}; 按键标志位
;
; char key=0;
; char i=0;
;
; bit pressflag=0;
; bit up_flag=0;
; bit down_flag=0; 控制信号标志位
; bit stop_flag=0;
;
;
;
;
;
; char rowkey=0; 键盘反选变量设置; char rankkey=0;
; char temp=0;
; char row=0;
; char rank=0;
;
; bit floor_flag_1=0;、、各楼层标志位; bit floor_flag_2=0;
; bit floor_flag_3=0;
; bit floor_flag_4=0;
; bit floor_flag_5=0;
; bit floor_down_5=0;
; bit floor_up_4=0;
; bit floor_down_4=0;
; bit floor_up_3=0;
; bit floor_down_3=0;
; bit floor_up_2=0;
; bit floor_down_2=0;
; bit floor_up_1=0;
; bit opendoor=0;
; bit close_door=0;
; bit start=0;
;
; //----------------------------------------------------------------------- ; void delay(unsigned int i)//延时函数
_delay:
USING 0
; SOURCE LINE # 56
;---- Variable 'i?040' assigned to Register 'R6/R7' ----
; {
; SOURCE LINE # 57
; unsigned char j;
; for(;i>0;i--)
; SOURCE LINE # 59
?C0001:
SETB C
MOV A,R7
SUBB A,#00H
MOV A,R6
SUBB A,#00H
JC ?C0007
; for(j=0;j<250;j++);
; SOURCE LINE # 60
;---- Variable 'j?041' assigned to Register 'R5' ----
CLR A
MOV R5,A
?C0004:
INC R5
CJNE R5,#0FAH,?C0004
?C0003:
MOV A,R7
DEC R7
JNZ ?C0001
DEC R6
?C0113:
SJMP ?C0001
; }
; SOURCE LINE # 61
?C0007:
RET
; END OF _delay
; //-----------------------------------------------------------------------
; int ABS(int i) //绝对值函数
RSEG ?PR?_ABS?SMARTCAR
_ABS:
USING 0
; SOURCE LINE # 63
;---- Variable 'i?142' assigned to Register 'R6/R7' ---- 键盘线反选函数; {
; SOURCE LINE # 64
; if (i>=0) return i;
; SOURCE LINE # 65
CLR C
MOV A,R6
XRL A,#080H
SUBB A,#080H
JC ?C0008
RET
?C0008:
; else return -i;
; SOURCE LINE # 66
CLR C
CLR A
SUBB A,R7
MOV R7,A
CLR A
SUBB A,R6
MOV R6,A
; }
; SOURCE LINE # 67
?C0009:
RET
; END OF _ABS
; //----------------------------------------------------------------------- ; void keysort(void)
RSEG ?PR?keysort?SMARTCAR
keysort:
USING 0
; SOURCE LINE # 69
; {
; SOURCE LINE # 70
; for(i=0;i<16;i++)
; SOURCE LINE # 71
CLR A
MOV i,A
?C0011:
; {
; SOURCE LINE # 72
; if(key==i) key_flag[i]=1;
; SOURCE LINE # 73
MOV A,key
CJNE A,i,?C0013
MOV A,#LOW (key_flag) 读并且记录标志位函数ADD A,i
MOV R0,A
MOV @R0,#01H
; }
; SOURCE LINE # 74
?C0013:
INC i
MOV A,i
CJNE A,#010H,?C0011
?C0012:
;
; for(i=0;i<16;i++)
; SOURCE LINE # 76
CLR A
MOV i,A
?C0015:
; {
; SOURCE LINE # 77
; if(key_flag[i]!=0)
; SOURCE LINE # 78
MOV A,#LOW (key_flag)
ADD A,i
MOV R0,A
MOV A,@R0
JNZ $ + 5H
LJMP ?C0017
; {
; SOURCE LINE # 79
; if(i==0) floor_flag_1=1; else floor_flag_1=0;
; SOURCE LINE # 80
MOV A,i
JNZ ?C0019
SETB floor_flag_1
SJMP ?C0020
?C0019:
CLR floor_flag_1
?C0020:
; if(i==1) floor_flag_2=1; else floor_flag_2=0;
; SOURCE LINE # 81
MOV A,i
CJNE A,#01H,?C0021
SETB floor_flag_2
SJMP ?C0022
?C0021:
CLR floor_flag_2
?C0022:
; if(i==2) floor_flag_3=1; else floor_flag_3=0;
; SOURCE LINE # 82
MOV A,i
CJNE A,#02H,?C0023
SETB floor_flag_3
SJMP ?C0024
?C0023:
CLR floor_flag_3
?C0024:
; if(i==3) floor_flag_4=1; else floor_flag_4=0;
; SOURCE LINE # 83
MOV A,i
CJNE A,#03H,?C0025
SETB floor_flag_4
SJMP ?C0026
?C0025:
CLR floor_flag_4
?C0026:
; if(i==4) floor_flag_5=1; else floor_flag_5=0;
; SOURCE LINE # 84
MOV A,i
CJNE A,#04H,?C0027
SETB floor_flag_5
SJMP ?C0028
?C0027:
CLR floor_flag_5
?C0028:
; if(i==5) floor_down_5=1; else floor_down_5=0;
; SOURCE LINE # 85
MOV A,i
CJNE A,#05H,?C0029
SETB floor_down_5
SJMP ?C0030
?C0029:
CLR floor_down_5
?C0030:
; if(i==6) floor_up_4=1; else floor_up_4=0;
; SOURCE LINE # 86
MOV A,i
CJNE A,#06H,?C0031
SETB floor_up_4
SJMP ?C0032
?C0031:
CLR floor_up_4
?C0032:
; if(i==7) floor_down_4=1; else floor_down_4=0;
; SOURCE LINE # 87
MOV A,i
CJNE A,#07H,?C0033
SETB floor_down_4
SJMP ?C0034
?C0033:
CLR floor_down_4
?C0034:
; if(i==8) floor_up_3=1; else floor_up_3=0;
; SOURCE LINE # 88
MOV A,i
CJNE A,#08H,?C0035
SETB floor_up_3
SJMP ?C0036 电梯运行函数?C0035:
CLR floor_up_3
?C0036:
; if(i==9) floor_down_3=1; else floor_down_3=0;
; SOURCE LINE # 89
MOV A,i
CJNE A,#09H,?C0037
SETB floor_down_3
SJMP ?C0038
?C0037:
CLR floor_down_3
?C0038:
; if(i==10) floor_up_2=1; else floor_up_2=0;
; SOURCE LINE # 90
MOV A,i
CJNE A,#0AH,?C0039
SETB floor_up_2
SJMP ?C0040
?C0039:
CLR floor_up_2
?C0040:
; if(i==11) floor_down_2=1; else floor_down_2=0;
; SOURCE LINE # 91
MOV A,i
CJNE A,#0BH,?C0041
SETB floor_down_2
SJMP ?C0042
?C0041:
CLR floor_down_2
?C0042:
; if(i==12) floor_up_1=1; else floor_up_1=0;
; SOURCE LINE # 92
MOV A,i
CJNE A,#0CH,?C0043
SETB floor_up_1
SJMP ?C0044
?C0043:
CLR floor_up_1
?C0044:
; if(i==13) opendoor=1; else opendoor=0;
; SOURCE LINE # 93
MOV A,i
CJNE A,#0DH,?C0045
SETB opendoor
SJMP ?C0046
?C0045:
CLR opendoor
?C0046:
; if(i==14) close_door=1; else close_door=0;
; SOURCE LINE # 94
MOV A,i
CJNE A,#0EH,?C0047
SETB close_door
SJMP ?C0048
?C0047:
CLR close_door
?C0048:
; if(i==15) start=1; else start=0;
; SOURCE LINE # 95
MOV A,i
CJNE A,#0FH,?C0049
SETB start
SJMP ?C0017
?C0049:
CLR start
; }
; SOURCE LINE # 96
; }
; SOURCE LINE # 97
?C0017:
INC i
MOV A,i
XRL A,#010H
JZ $ + 5H
LJMP ?C0015
;
;
;
;
;
;
;
; }
; SOURCE LINE # 105
?C0051:
RET
; END OF keysort
;
;
;
; unsigned char keycheck() 4*4 键盘
RSEG ?PR?keycheck?SMARTCAR
keycheck:
USING 0
; SOURCE LINE # 109
; {
; SOURCE LINE # 110
; char i=0;
; SOURCE LINE # 111
;---- Variable 'i?343' assigned to Register 'R4' ---- CLR A
MOV R4,A
; temp=0;
; SOURCE LINE # 112
MOV temp,A
; KEYIO=0xf0;
; SOURCE LINE # 113
MOV P2,#0F0H
; delay(5);
; SOURCE LINE # 114
MOV R7,#05H
MOV R6,A
LCALL _delay
; rowkey=P2;
; SOURCE LINE # 115
MOV rowkey,P2
; if(rowkey!=0xf0)
; SOURCE LINE # 116
MOV R7,rowkey
MOV A,R7
RLC A
SUBB A,ACC
MOV R6,A
MOV A,R7
XRL A,#0F0H
ORL A,R6
JZ ?C0052
; {
; SOURCE LINE # 117
; //delay(10);
; if(rowkey!=0xf0)
; SOURCE LINE # 119
MOV A,R7
XRL A,#0F0H
ORL A,R6
JZ ?C0053
; {pressflag=1;rowkey=(rowkey&0x0f);}
; SOURCE LINE # 120
SETB pressflag
ANL rowkey,#0FH
SJMP ?C0055
?C0053:
; else pressflag=0;
; SOURCE LINE # 121
CLR pressflag
; }
; SOURCE LINE # 122
SJMP ?C0055
?C0052:
; else pressflag=0;
; SOURCE LINE # 123
CLR pressflag
?C0055:
;
;
; if(pressflag==1)
; SOURCE LINE # 126
JB pressflag,$ + 6H
LJMP ?C0085
; {
; SOURCE LINE # 127 ; KEYIO=0x0f;
; SOURCE LINE # 128 MOV P2,#0FH
; //delay(10);
; rankkey=P2;
; SOURCE LINE # 130 MOV rankkey,P2
; rankkey=(rankkey&0xf0);
; SOURCE LINE # 131 ANL rankkey,#0F0H
; rankkey=(rankkey>>4);
; SOURCE LINE # 132 MOV A,rankkey
MOV R0,#04H
?C0114:
MOV C,ACC.7
RRC A
DJNZ R0,?C0114
MOV rankkey,A
;
; {
; SOURCE LINE # 134 ; for(i=0;i<=3;i++)
; SOURCE LINE # 135 CLR A
MOV R4,A
?C0057:
; {
; SOURCE LINE # 136
; temp=0x01;
; SOURCE LINE # 137
MOV temp,#01H
; temp=(temp<<i);
; SOURCE LINE # 138
MOV A,temp
MOV R0,AR4
INC R0
SJMP ?C0116
?C0115:
CLR C
RLC A
?C0116:
DJNZ R0,?C0115
MOV temp,A
; if((rowkey&temp)!=0) {row=i+1;i=4;}
; SOURCE LINE # 139
ANL A,rowkey
JZ ?C0059
MOV A,R4
INC A
MOV row,A
MOV R4,#04H
; }
; SOURCE LINE # 140
?C0059:
INC R4
SETB C
MOV A,R4
XRL A,#080H
SUBB A,#083H
JC ?C0057
?C0058:
;
;
; for(i=0;i<=3;i++)
; SOURCE LINE # 143 CLR A
MOV R4,A
?C0061:
; {
; SOURCE LINE # 144 ; temp=0x01;
; SOURCE LINE # 145 MOV temp,#01H
; temp=(temp<<i);
; SOURCE LINE # 146 MOV A,temp
MOV R0,AR4
INC R0
SJMP ?C0118
?C0117:
CLR C
RLC A
?C0118:
DJNZ R0,?C0117
MOV temp,A
; if((rankkey&temp)!=0) {rank=i+1;i=4;}
; SOURCE LINE # 147
ANL A,rankkey
JZ ?C0063
MOV A,R4
INC A
MOV rank,A
MOV R4,#04H
; }
; SOURCE LINE # 148
?C0063:
INC R4
SETB C
MOV A,R4
XRL A,#080H
SUBB A,#083H
JC ?C0061
?C0062:
;
; if(row==1)
; SOURCE LINE # 150
MOV A,row
CJNE A,#01H,?C0065
; {
; SOURCE LINE # 151
; if(rank==1) key=0;
; SOURCE LINE # 152
MOV A,rank
CJNE A,#01H,?C0066
CLR A
?C0066:
; if(rank==2) key=1;
; SOURCE LINE # 153 MOV A,rank
CJNE A,#02H,?C0067
MOV key,#01H
?C0067:
; if(rank==3) key=2;
; SOURCE LINE # 154 MOV A,rank
CJNE A,#03H,?C0068
MOV key,#02H
?C0068:
; if(rank==4) key=3;
; SOURCE LINE # 155 MOV A,rank
CJNE A,#04H,?C0065
MOV key,#03H
; }
; SOURCE LINE # 156 ?C0065:
; if(row==2)
; SOURCE LINE # 157 MOV A,row
CJNE A,#02H,?C0070
; {
; SOURCE LINE # 158 ; if(rank==1) key=4;
; SOURCE LINE # 159
CJNE A,#01H,?C0071
MOV key,#04H
?C0071:
; if(rank==2) key=5;
; SOURCE LINE # 160 MOV A,rank
CJNE A,#02H,?C0072
MOV key,#05H
?C0072:
; if(rank==3) key=6;
; SOURCE LINE # 161 MOV A,rank
CJNE A,#03H,?C0073
MOV key,#06H
?C0073:
; if(rank==4) key=7;
; SOURCE LINE # 162 MOV A,rank
CJNE A,#04H,?C0070
MOV key,#07H
; }
; SOURCE LINE # 163 ?C0070:
; if(row==3)
; SOURCE LINE # 164 MOV A,row
CJNE A,#03H,?C0075
; {
; SOURCE LINE # 165
; if(rank==1) key=8;
; SOURCE LINE # 166 MOV A,rank
CJNE A,#01H,?C0076
MOV key,#08H
?C0076:
; if(rank==2) key=9;
; SOURCE LINE # 167 MOV A,rank
CJNE A,#02H,?C0077
MOV key,#09H
?C0077:
; if(rank==3) key=10;
; SOURCE LINE # 168 MOV A,rank
CJNE A,#03H,?C0078
MOV key,#0AH
?C0078:
; if(rank==4) key=11;
; SOURCE LINE # 169 MOV A,rank
CJNE A,#04H,?C0075
MOV key,#0BH
; }
; SOURCE LINE # 170 ?C0075:
; if(row==4)
; SOURCE LINE # 171 MOV A,row
CJNE A,#04H,?C0080
; {
; SOURCE LINE # 172 ; if(rank==1) key=12;
; SOURCE LINE # 173 MOV A,rank
CJNE A,#01H,?C0081
MOV key,#0CH
?C0081:
; if(rank==2) key=13;
; SOURCE LINE # 174 MOV A,rank
CJNE A,#02H,?C0082
MOV key,#0DH
?C0082:
; if(rank==3) key=14;
; SOURCE LINE # 175 MOV A,rank
CJNE A,#03H,?C0083
MOV key,#0EH
?C0083:
; if(rank==4) key=15;
; SOURCE LINE # 176 MOV A,rank
CJNE A,#04H,?C0080
MOV key,#0FH
; }
; SOURCE LINE # 177 ?C0080:
; rank=0;
; SOURCE LINE # 178
CLR A
MOV rank,A
; row=0;
; SOURCE LINE # 179 MOV row,A
; rowkey=0;
; SOURCE LINE # 180 MOV rowkey,A
; rankkey=0;
; SOURCE LINE # 181 MOV rankkey,A
; }
; SOURCE LINE # 182 ; }
; SOURCE LINE # 183 ?C0085:
; while(P2!=0x0f)
; SOURCE LINE # 184 MOV A,P2
CJNE A,#0FH,?C0085
; {
; SOURCE LINE # 185 ; //delay(5);
; }
; SOURCE LINE # 187 ?C0086:
; return key;
; SOURCE LINE # 188 MOV R7,key
;
; }
; SOURCE LINE # 190
?C0087:
RET
; END OF keycheck
; void sys_init(void) 单片机IO口初始化
RSEG ?PR?sys_init?SMARTCAR
sys_init:
; SOURCE LINE # 191
; {
; SOURCE LINE # 192
; //------IO口设置------------
;
;
;
;
; //------定时器设置------------
;
; TMOD=0x11; //定时器0方式1
; SOURCE LINE # 200
MOV TMOD,#011H
; TH0=T0_HIGH; //定时器赋初值
; SOURCE LINE # 201
MOV TH0,#0FFH
; TL0=T0_LOW ;
; SOURCE LINE # 202
MOV TL0,#09BH
;
; TR0=1; //定时器运行
; SOURCE LINE # 204
SETB TR0
; ET0=1; //开定时器中断
; SOURCE LINE # 205
SETB ET0
; EA=1; //开总中断
; SOURCE LINE # 206
SETB EA
; }
; SOURCE LINE # 207
RET
; END OF sys_init
;
; unsigned char BCD(char keyp)
RSEG ?PR?_BCD?SMARTCAR
_BCD:
USING 0
; SOURCE LINE # 209
;---- Variable 'keyp?544' assigned to Register 'R7' ---- ; {
; SOURCE LINE # 210
; if(keyp==0x00) keyp=0x00;
; SOURCE LINE # 211
MOV A,R7
JNZ ?C0089
MOV R7,A
?C0089:
; SOURCE LINE # 212 CJNE R7,#01H,?C0090
MOV R7,#01H
?C0090:
; if(keyp==0x02) keyp=0x02;
; SOURCE LINE # 213 CJNE R7,#02H,?C0091
MOV R7,#02H
?C0091:
; if(keyp==0x03) keyp=0x03;
; SOURCE LINE # 214 CJNE R7,#03H,?C0092
MOV R7,#03H
?C0092:
; if(keyp==0x04) keyp=0x04;
; SOURCE LINE # 215 CJNE R7,#04H,?C0093
MOV R7,#04H
?C0093:
; if(keyp==0x05) keyp=0x05;
; SOURCE LINE # 216 CJNE R7,#05H,?C0094
MOV R7,#05H
?C0094:
; if(keyp==0x06) keyp=0x06;
; SOURCE LINE # 217 CJNE R7,#06H,?C0095
MOV R7,#06H
?C0095:
; SOURCE LINE # 218 CJNE R7,#07H,?C0096
MOV R7,#07H
?C0096:
; if(keyp==0x08) keyp=0x08;
; SOURCE LINE # 219 CJNE R7,#08H,?C0097
MOV R7,#08H
?C0097:
; if(keyp==0x09) keyp=0x09;
; SOURCE LINE # 220 CJNE R7,#09H,?C0098
MOV R7,#09H
?C0098:
;
; if(keyp==0x0a) keyp=0x10;
; SOURCE LINE # 222 CJNE R7,#0AH,?C0099
MOV R7,#010H
?C0099:
;
; if(keyp==0x0b) keyp=0x11;
; SOURCE LINE # 224 CJNE R7,#0BH,?C0100
MOV R7,#011H
?C0100:
; if(keyp==0x0c) keyp=0x12;
; SOURCE LINE # 225 CJNE R7,#0CH,?C0101
MOV R7,#012H
?C0101:
; if(keyp==0x0d) keyp=0x13;
; SOURCE LINE # 226
CJNE R7,#0DH,?C0102
MOV R7,#013H
?C0102:
; if(keyp==0x0e) keyp=0x14;
; SOURCE LINE # 227
CJNE R7,#0EH,?C0103
MOV R7,#014H
?C0103:
; if(keyp==0x0f) keyp=0x15;
; SOURCE LINE # 228
CJNE R7,#0FH,?C0104
MOV R7,#015H
?C0104:
;
; return keyp;
; SOURCE LINE # 230
; }
; SOURCE LINE # 231
?C0105:
RET
; END OF _BCD
;
; //-----------------------------------------------------------------------
; void main(void) 主函数
main:
USING 0
; SOURCE LINE # 234
; {
; SOURCE LINE # 235
; sys_init(); //初始化
; SOURCE LINE # 236 LCALL sys_init
?C0106:
; while(1)
; SOURCE LINE # 237
; {
; SOURCE LINE # 238
; keycheck();
; SOURCE LINE # 239 LCALL keycheck
; nobcd=key;
; SOURCE LINE # 240 MOV P0,key
; output=BCD(key);
; SOURCE LINE # 241 MOV R7,key
LCALL _BCD
MOV P1,R7
;
; }
; SOURCE LINE # 243 SJMP ?C0106
; END OF main
CSEG AT 0000BH
LJMP TIME_BASE
; }
; //-----------------------------------------------------------------------
; void TIME_BASE(void) interrupt 1 using 1 //定时器生成控制PWM
RSEG ?PR?TIME_BASE?SMARTCAR
USING 1
TIME_BASE:
PUSH ACC
PUSH PSW
; SOURCE LINE # 246
; {
; TH0=T0_HIGH; //赋初值
; SOURCE LINE # 248
MOV TH0,#0FFH
; TL0=T0_LOW ;
; SOURCE LINE # 249
MOV TL0,#09BH
; count++;
; SOURCE LINE # 250
INC count+01H
MOV A,count+01H
JNZ ?C0119
INC count
?C0119:
; if(count<=0) servo_door=1;
; SOURCE LINE # 251
SETB C
SUBB A,#00H
MOV A,count
XRL A,#080H
SUBB A,#080H
JNC ?C0109
SETB servo_door
SJMP ?C0110
?C0109:
; else servo_door=0;
; SOURCE LINE # 252 CLR servo_door
?C0110:
;
; if(count>400) //PWM比较、生成
; SOURCE LINE # 254 SETB C
MOV A,count+01H
SUBB A,#090H
MOV A,count
XRL A,#080H
SUBB A,#081H
JC ?C0112
; {
; SOURCE LINE # 255
; count=1;
; SOURCE LINE # 256 MOV count,#00H
MOV count+01H,#01H
; }
; SOURCE LINE # 257。