延时子程序
单片机红绿灯程序完整版
通灯设计交通灯设计方案：1:实现东西路----南北路红绿灯的交通指示。
2:东西路灯变化----红绿黄一南北路灯变化----绿黄红＞ T3:红灯延时时间---25S绿灯延时时间---20S黄灯延时时间一3S4:数码管显示：红灯---前20S不显示，只在最后5S开始倒计时显示。
绿灯---前15S不显示，只在最后5S开始倒计时显示。
黄灯---3S倒计时显示（若东西路为黄灯，南北路为红灯，那么南北绿的数码管也显示3S）。
5:交通应急事件处理：利用中断分别实现东西路---南北路的交通应急事件处理。
6:延时程序的使用：用循环延时和定时器计时的方法。
注：P1.0---北路绿灯，P1.1--北路黄灯，P1.2---北路红灯cP1.3--东路绿灯，P1.4---东路黄灯，P1.5----东路红灯。
【交通灯流程图】开始延时20秒5秒倒计时结束其他灯不变南北路绿灯亮，红，黄灯灭东西路红灯亮，绿，黄灯灭南北路绿灯数码管开始倒计时5秒南北路绿灯灭，黄灯亮且数码管开始倒计时3秒东西路红灯——数码管开始倒计时3秒3秒倒计时结束延时25秒5秒倒计时结束东西路绿灯亮，黄灯，红灯灭南北路红灯亮，黄灯，绿灯灭东西路数码管开始倒计时5秒其他灯不变东西路绿灯灭，黄灯亮且数码管开始倒计时3秒南北路红灯一一数码管开始倒计时3秒3秒倒计时结束程序如下:ORG 0000HLJMP LOOPORG 000BHLJMP WZDOORG 0013HLJMP WZD1ORG 0030HLOOP:MOV R3,#5MOV R4,#5MOV R2,#20l=LIfc=ER；定时器0中断，实现交通应急事件；下载可编辑亮 oMOV SP,#70H MOV IE,#85HMOV TMOD,#01H ；置T0为工作方式1MOV TH0,#3CH;置T0定时初值50msMOV TL0,#0B0HCLRTF0SETBTR0;启动定时器T0SETB P1.1 ;东---红灯亮,北---绿灯亮SETB P1.2CLR P1.0SETB P1.3SETB P1.4CLR P1.5ACALL DEL30SACALL Y ELLOW1 ； 北---绿灯转黄灯，东---红灯亮 ACALL DEL3S ；延时后北---黄灯火SETB P1.0;东：红灯火，绿灯亮,北：黄灯火，红灯CLR P1.2SETB P1.4SETB P1.5ACALL DEL55S ; 北---红灯不变，东---绿灯转黄灯ACALL Y ELLOW2ACALL DEL3SSJMP LOOPYELLOW1: ; 北---绿灯转黄灯，东---红灯不变SETB P1.0SETB P1.2CLR P1.1SETB P1.3CLR P1.5SETB P1.4RETYELLOW2: ; 东---绿灯转黄灯，北---红灯不变SETB P1.0SETB P1.1CLR P1.2SETB P1.3CLR P1.4RETWZD0: ；实现南北路交通应急事件CLR P1.0 ；（南北路保持畅通，东西路停止通行）SETB P1.1SETB P1.2SETB P1.3SETB P1.4CLR P1.5JNB P3.2,WZD0RETIWZD1: ；实现东西路交通应急事件CLR P1.3 ；（东西路保持畅通，南北路停止通行）CLR P1.2SETB P1.1SETB P1.0SETB P1.4SETB P1.5JNB P3.3,WZD1RETIDEL30S: J红绿灯延时DEL25S:JNB TF0QEL25S ;查询50ms到否CLR TFOMOV TH0,#3CH ;恢复T0定时初值50msMOV TL0,#0B0HDJNZ R2,DEL25S ;判断1s到否？未到继续状态MOV R2,#20 ;置50ms计数初值DJNZ R4,DEL25S ;状态1维持25s取数延时DEL5S:5MOV R2,#6DEL5:MOV A,R2ACALLST ;取数MOV P0,A ;实现数码管显示ACALL DEL1S ;每隔1S减1DJNZ R2,DEL5RETDEL3S:MOV R2,#4HDEL3:MOV A,R2ACALL ST ;取数MOV P2,AMOV P0,A ;数码管显示ACALL DEL1SDJNZ R2,DEL3RETDEL55S:ACALL DEL20SMOV R2,#6 ;倒计时5S DEL55:ACALL DEL1SMOV A,R2ACALLSTMOV P2,A ;数码管显示DJNZ R2QEL55RETDEL1S: ;1S 延时子程序MOV R5,#0BHST1:MOV R6,#0DAH下载可编辑ST2:MOV R7,#0CFHDJNZ R7,$DJNZ R6,ST2DJNZ R5,ST1RETDEL20S: ;20S延时子程序MOV R5,#0BH;#0DCHST3:MOV R6,#0DAHST4:MOV R7,#0CFHDJNZ R7,$DJNZ R6,ST4DJNZ R5,ST3RETST: ;取数MOV DPTR,#TABMOVC A,@A+DPTRRETTAB:DB 0FFH,0FFH,0F9H,0A4H,0B0H,99H,92HEnd.专业.整理.。
单片机实验报告
单片机实验报告班级：09050541学号：0905054116姓名：王昆鹏实验1 P1口实验一、实验目的：1．学习P1口的使用方法。
2．学习延时子程序的编写和使用。
二、实验设备：CPU挂箱、8051CPU模块三、实验内容：1．P1口做输出口，接八只发光二极管，编写程序，使发光二极管循环点亮。
四、实验原理：P1口为准双向口，P1口的每一位都能独立地定义为输入位或输出位。
作为输入位时，必须向锁存器相应位写入“1”，该位才能作为输入。
软件延时，如果用c编程时，通过使用keil的软件模拟,调试观察子函数(delay)延时时间。
（具体延时可以自行设定）使用汇编语言的软件延时，可以计算其指令的周期数，大概估算其软件延时。
五、实验原理图：P1口输出、输入实验六、实验步骤：执行程序：P1.0～P1.7接发光二极管L1～L8。
七、程序框图：循环点亮发光二极管（具体延时可以自行设定）八、程序代码NAME T1_1ORG 0000HLJMP STARTORG 0030HSTART: MOV A,#0FEH //将1111 1110赋给A LOOP: RL A //A循环左移MOV P1,A //把A赋给端口P1LCALL DELAY //延时0.16sJMP LOOP //循环;延时函数DELAY: MOV R1,#200DEL1: MOV R2,#200DEL2: DJNZ R2,DEL2DJNZ R1,DEL1RETEND实验2 中断口实验一、实验目的：1．学习外部中断技术的基本使用方法。
2．学习中断处理程序的编程方法。
二、实验设备：CPU挂箱、8051CPU模块三、实验内容：通过设定两个中断使能和触发方式，并编写相应的中断服务子函数，改变led灯的变化情况。
当按下KEYBOARD的按键时8个led都灭，当把k1向上拉再复位后，4个led亮，4个灭。
四、实验原理：参考《单片机原理及接口技术》第三版，北京航空航天大学出版社。
单片机课程设计报告流水灯(WORD档)
XX工程学院单片机课程设计报告题目：流水灯学生姓名：学号：系部名称：职业技术学院班级：机电一体化Z11-1 指导教师：目录摘要 (3)一、课程设计题目 (4)二、设计任务及要求 (4)三、实验方案 (4)四、流程图 (4)五、硬件电路 (6)六、软件设计 (6)1 主体程序 (6)2 键扫描子程序 (6)3 闪烁控制程序 (6)4 延时子程序 (6)5 源程序设计 (7)七、功能调试 (12)八、设计总结 (12)九、参考文献 (13)【摘要】单片机课程设计主要是为了让我们增进对单片机芯片电路的感性认识，加深对理论方面的理解。
了解软硬件的有关知识，并掌握软件设计过程、方法及实现，为以后设计和实现应用系统打下良好基础。
另外，通过简单课题的设计练习，使我们了解必须提交的各项工程文件，达到巩固、充实和综合运用所学知识解决实际问题的目的。
一、课程设计题目：流水灯二、设计任务及要求：任务：完成对接在P1，P3口的发光二极管闪亮控制程序的设计1．用程序延时方法让P1的一个LED小灯每隔1S交替闪亮2．用程序延时方法让P1的8个LED小灯循环（每个亮50MS）闪亮3．用程序延时方法让P1的8个LED小灯追逐闪亮（50MS间隔变化）4．用程序延时方法让P1、P3的16个LED小灯循环（每个亮50MS）闪亮要求：1. 根据硬件电路原理，画出接线2. 设计出相应的软件程序三、实验方案：方案:单片机采用40脚的89C52标准双列直插系列，有4个标准输入/输出端口共32位控制端口。
本次设计采用并行口低电平(吸电流)直接驱动LED发光管发光形式，选择了P1和P3口的16个端口进行模拟LED小灯控制，如要多些小灯单元可再将P2口、P0口及其他空余端口用LED小灯驱动控制。
因系统功能要求能控制灯亮的方式，在P0.0—P0.3端口接了4个按键小开关，每个小开关可控制一种亮灯方式。
在端口较紧张的情况下，LED小灯驱动也可用串入/并出移位寄存器(如74HC595)，单片机用并行移位方式进行驱动。
温控代码
MOV P1.2,C
SETB P1.1
LCALL SDelay
CLR P1.1
LCALL SDelay
DJNZ R7,LP1
CLR P1.2
RET
MOV A,R2
SUBB A,R1
MOV R3,A
JC DJF1 ;跳到DJF1求补
CLR 22H ;差为正，符号置0
RET
;双字节带符号数加法程序
;被加数R1（高8位）R2（低8位），符号位23H
movx @dptr,a
mov r7,#20h
loop2: djnz r7,loop2
movx a,@dptr
MOV 4CH,A ;存储温度采样值
RET
;*********************************************************
MOV R6,#32H
WAIT: DJNZ R6,WAIT
ret
STFS: ；调发送一字节程序
CLR P1.0
LCALL LDelay
MOV R7,#08H
djnz r7, DelayLoop1
ret
SDelay: ；延时8us
MOV R6,#08H
LP5: DJNZ R6,LP5
ret
LDelay: ；延时50us
;PID控制算法
;单字节带符号数减法
;被减数R1，符号20H（正为0负为1）
;减数R2，符号21H
;差R3，符号22H
DJF:
JB 20H, DJF4 ;被减数为负，转DJF4
P1口输入、输出实验
实验一 P1口输入、输出实验一、实验要求1. P1口做输出口，接八只发光二极管，编写程序，使发光二极管循环点亮。
2. P1.0、P1.1作输入口接两个拨动开关，P1.2、P1.3作输出口，接两个发光二极管，编写程序读取开关状态，将此状态，在发光二极管上显示出来。
编程时应注意P1.0、P1.1作为输入口时应先置1，才能正确读入值。
二、实验目的1. 学习P1口的使用方法。
2. 学习延时子程序的编写和使用。
三、实验连线实验1: P1口循环点亮 实验2: P1口输入输出四、实验说明1. 8051延时子程序的计算延时程序的实现常用两种方法，一种用定时器中断来实现，另一种是用指令循环实现。
在系统时间允许的情况下可以采用后一种方法。
本实验系统晶振频率为6MHz ，执行一个机器周期时间为12/6MHZ=2µS，现在写一个延时0.1S 的程序如下：查指令表可知MOV 需要一个机器周期，DJNZ 指令需用两个机器周期，所以执行该段程序所需时间是：[ 1 ＋ ( 1 ＋ 2 × 200 ＋ 2 ) X ] × 2×10-6＝ 0.1S 指令（1） （2） （3） （4） 所需时间 所需时间 所需时间 所需时间求出X ＝124，将X ＝124代入上式可知实际延时约0.099946≈0.1S 。
2. P1口准双向口它作为输出口时与一般的双向口使用方法相同。
由准双向口结构可知当P1口用为Delay ：MOV R6，#X （1） DE1: MOV R7, #200 （2） DE2： DJNZ R7，DE2 （3）DJNZ R6，DE1 （4）输入口时，必须先对它置“1”。
若不先对它置“1”，读入的数据是不正确的。
六、硬件电路1、LED电平显示电路图1：LED电平显示电路2、逻辑电平开关电路实验仪上有8只开关K0―K7,并有与之相对应的K0―K7引线孔为逻辑电平输出端。
开关向上拨相应插孔输出高电平“1”,向下拨相应插孔输出低电平“0”。
51单片机闪烁灯制作
51单片机闪烁灯制作简介：51单片机闪烁灯制作：在单片机P1.0端口上接一个发光二极管L1，使L1在不停地一亮一灭形成闪烁灯状态，一亮一灭的时间间隔为0.2秒。
1.电路原理图图4.1.12.系统板上硬件连线把“单片机系统”区域中的P1.0端口用导线连接到“八路发光二极管指示模块”区域中的L1端口上。
3.程序设计内容(1). 延时程序的设计方法作为单片机的指令的执行的时间是很短，数量大微秒级，因此，我们要求的闪烁时间间隔为0.2秒，相对于微秒来说，相差太大，所以我们在执行某一指令时，插入延时程序，来达到我们的要求，但这样的延时程序是如何设计呢?下面具体介绍其原理：如图4.1.1所示的石英晶体为12MHz，因此，1个机器周期为1微MOV R6,#20 2个 2D1: MOV R7,#248 2个22+2×248=49820×DJNZ R7,$ 2个2×248 (498DJNZ R6,D1 2个2×20=4010002因此，上面的延时程序时间为10.002ms。
由以上可知，当R6=10、R7=248时，延时5ms，R6=20、R7=248时，延时10ms,以此为基本的计时单位。
如本实验要求0.2秒=200ms，10ms×R5=200ms，则R5=20，延时子程序如下：DELAY: MOV R5,#20D1: MOV R6,#20D2: MOV R7,#248DJNZ R7,$DJNZ R6,D2DJNZ R5,D1RET(2). 输出控制如图1所示，当P1.0端口输出高电平，即P1.0=1时，根据发光二极管的单向导电性可知，这时发光二极管L1熄灭;当P1.0端口输出低电平，即P1.0=0时，发光二极管L1亮;我们可以使用SETBP1.0指令使P1.0端口输出高电平，使用CLRP1.0指令使P1.0端口输出低电平。
4. 程序框图5. 汇编源程序ORG 0START: CLR P1.0LCALL DELAYSETB P1.0LCALL DELAYLJMP STARTDELAY: MOV R5,#20 ;延时子程序，延时0.2秒 D1: MOV R6,#20D2: MOV R7,#248DJNZ R7,$DJNZ R6,D2DJNZ R5,D1RETEND6. C语言源程序#includesbit L1=P1^0;void delay02s(void) //延时0.2秒子程序{unsigned char i,j,k;for(i=20;i0;i)for(j=20;j0;j)for(k=248;k0;k);}void main(void){while(1){L1=0;delay02s();L1=1;delay02s();}}完毕!您现在会不会制作自己的闪烁灯了呢?。
C51代码
1.#include < >2.#include < >3.4.sbit K1 =P1^4 ; //增加键5.sbit K2 =P1^5 ; //减少键6.sbit P00 =P0^1;7.sbit BEEP =P3^7 ; //蜂鸣器8.unsigned char PWM=0xe7; //赋初值9.10.void Beep();11.void delayms(unsigned char ms);12.void delay(unsigned char t);13.14./*********************************************************/15.void main()16.{17.18.P1=0xff;19. TMOD=0x21 ;20. TH0=0xff ; //50us延时常数21. TL0=0xce ; //频率调节22.23. TH1=PWM ; //脉宽调节24. TL1=0 ;25.26.EA=1;27.ET0=1;28.ET1=1;29.30.TR0=1 ;31.32.while(1)33.{34.do{35.if(PWM!=0xff)36.{PWM++ ;delayms(10);}37.else Beep() ;38.}39.while(K1==0);40.41.do{42.if(PWM!=0xce)43. {PWM-- ;delayms(10);}44.else Beep() ;45. }46.while(K2==0);47.}48.}49.50.void timer0() interrupt 151.{52. TR1=0 ;53. TH0=0xff ;54. TL0=0xce ;55. TH1=PWM ;56. TR1=1 ;57. P00=0 ; //启动输出58.}59.60.61.void timer1() interrupt 362.{63. TR1=0 ;64. P00=1 ; //结束输出65.}66.67./*********************************************************/68.//蜂鸣器子程序69./*********************************************************/70.71.void Beep()72.{73.unsigned char i ;74.for (i=0 ;i<100 ;i++)75.{76. delay(100) ;77. BEEP=!BEEP ; //Beep取反78.}79.BEEP=1 ; //关闭蜂鸣器80.delayms(100);81.}82.83./*********************************************************/84.// 延时子程序85./*********************************************************/86.void delay(unsigned char t)87.{88. while(t--) ;89.}90.91./*********************************************************/92.// 延时子程序93./*********************************************************/94.void delayms(unsigned char ms)95.96.{97. unsigned char i ;98. while(ms--)99.{100.for(i = 0 ; i < 120 ; i++) ;101.}102.}103.104./*********************************************************/ 105.#include < >106.#include < >107.108.sbit K1 =P1^4 ; //增加键109.sbit K2 =P1^5 ; //减少键110.sbit P00 =P0^1;111.sbit BEEP =P3^7 ; //蜂鸣器112.unsigned char PWM=0xe7; //赋初值113.114.void Beep();115.void delayms(unsigned char ms);116.void delay(unsigned char t);117.118./*********************************************************/119.void main()120.{121.122. P1=0xff;123. TMOD=0x21 ;124. TH0=0xff ; //50us延时常数125. TL0=0xce ; //频率调节126.127. TH1=PWM ; //脉宽调节128. TL1=0 ;129.130. EA=1;131. ET0=1;132. ET1=1;133.134. TR0=1 ;135.136. while(1)137. {138. do{139. if(PWM!=0xff)140. {PWM++ ;delayms(10);} 141. else Beep() ;142. }143. while(K1==0);144.145. do{146. if(PWM!=0xce)147. {PWM-- ;delayms(10);} 148. else Beep() ;149. }150. while(K2==0);151. }152.}153.154.void timer0() interrupt 1155.{156. TR1=0 ;157. TH0=0xff ;158. TL0=0xce ;159. TH1=PWM ;160. TR1=1 ;161. P00=0 ; //启动输出162.}163.164.165.void timer1() interrupt 3166.{167. TR1=0 ;168. P00=1 ; //结束输出169.}170.171./*********************************************************/172.//蜂鸣器子程序173./*********************************************************/174.175.void Beep()176. {177. unsigned char i ;178. for (i=0 ;i<100 ;i++)179. {180. delay(100) ;181. BEEP=!BEEP ; //Beep取反182. }183. BEEP=1 ; //关闭蜂鸣器184. delayms(100);185. }186.187./*********************************************************/188.// 延时子程序189./*********************************************************/190.void delay(unsigned char t)191.{192. while(t--) ;193.}194.195./*********************************************************/196.// 延时子程序197./*********************************************************/198.void delayms(unsigned char ms)199.200.{201. unsigned char i ;202. while(ms--)203. {204. for(i = 0 ; i < 120 ; i++) ;205. }206.}207.208./*********************************************************/ 209.#include < >210.#include < >211.212.sbit K1 =P1^4 ; //增加键213.sbit K2 =P1^5 ; //减少键214.sbit P00 =P0^1;215.sbit BEEP =P3^7 ; //蜂鸣器216.unsigned char PWM=0xe7; //赋初值217.218.void Beep();219.void delayms(unsigned char ms);220.void delay(unsigned char t);221.222./*********************************************************/ 223.void main()224.{225.226. P1=0xff;227. TMOD=0x21 ;228. TH0=0xff ; //50us延时常数229. TL0=0xce ; //频率调节230.231. TH1=PWM ; //脉宽调节232. TL1=0 ;233.234. EA=1;235. ET0=1;236. ET1=1;237.238. TR0=1 ;240. while(1)241. {242. do{243. if(PWM!=0xff)244. {PWM++ ;delayms(10);} 245. else Beep() ;246. }247. while(K1==0);248.249. do{250. if(PWM!=0xce)251. {PWM-- ;delayms(10);} 252. else Beep() ;253. }254. while(K2==0);255. }256.}257.258.void timer0() interrupt 1259.{260. TR1=0 ;261. TH0=0xff ;262. TL0=0xce ;263. TH1=PWM ;264. TR1=1 ;265. P00=0 ; //启动输出266.}267.268.269.void timer1() interrupt 3270.{271. TR1=0 ;272. P00=1 ; //结束输出274.275./*********************************************************/276.//蜂鸣器子程序277./*********************************************************/278.279.void Beep()280. {281. unsigned char i ;282. for (i=0 ;i<100 ;i++)283. {284. delay(100) ;285. BEEP=!BEEP ; //Beep取反286. }287. BEEP=1 ; //关闭蜂鸣器288. delayms(100);289. }290.291./*********************************************************/292.// 延时子程序293./*********************************************************/294.void delay(unsigned char t)295.{296. while(t--) ;297.}298.299./*********************************************************/300.// 延时子程序301./*********************************************************/302.void delayms(unsigned char ms)303.304.{305. unsigned char i ;306. while(ms--)307. {308. for(i = 0 ; i < 120 ; i++) ;309. }310.}311.312./*********************************************************/ 313.#include < >314.#include < >315.316.sbit K1 =P1^4 ; //增加键317.sbit K2 =P1^5 ; //减少键318.sbit P00 =P0^1;319.sbit BEEP =P3^7 ; //蜂鸣器320.unsigned char PWM=0xe7; //赋初值321.322.void Beep();323.void delayms(unsigned char ms);324.void delay(unsigned char t);325.326./*********************************************************/ 327.void main()328.{329.330. P1=0xff;331. TMOD=0x21 ;332. TH0=0xff ; //50us延时常数333. TL0=0xce ; //频率调节334.335. TH1=PWM ; //脉宽调节336. TL1=0 ;337.338. EA=1;339. ET0=1;340. ET1=1;341.342. TR0=1 ;343.344. while(1)345. {346. do{347. if(PWM!=0xff)348. {PWM++ ;delayms(10);} 349. else Beep() ;350. }351. while(K1==0);352.353. do{354. if(PWM!=0xce)355. {PWM-- ;delayms(10);} 356. else Beep() ;357. }358. while(K2==0);359. }360.}361.362.void timer0() interrupt 1363.{364. TR1=0 ;365. TH0=0xff ;366. TL0=0xce ;367. TH1=PWM ;368. TR1=1 ;369. P00=0 ; //启动输出370.}371.372.373.void timer1() interrupt 3374.{375. TR1=0 ;376. P00=1 ; //结束输出377.}378.379./*********************************************************/380.//蜂鸣器子程序381./*********************************************************/382.383.void Beep()384. {385. unsigned char i ;386. for (i=0 ;i<100 ;i++)387. {388. delay(100) ;389. BEEP=!BEEP ; //Beep取反390. }391. BEEP=1 ; //关闭蜂鸣器392. delayms(100);393. }394.395./*********************************************************/396.// 延时子程序397./*********************************************************/398.void delay(unsigned char t)399.{400. while(t--) ;401.}402.403./*********************************************************/404.// 延时子程序405./*********************************************************/406.void delayms(unsigned char ms)407.408.{409. unsigned char i ;410. while(ms--)411. {412. for(i = 0 ; i < 120 ; i++) ;413. }414.}415.416./*********************************************************/ 417.#include < >418.#include < >419.420.sbit K1 =P1^4 ; //增加键421.sbit K2 =P1^5 ; //减少键422.sbit P00 =P0^1;423.sbit BEEP =P3^7 ; //蜂鸣器424.unsigned char PWM=0xe7; //赋初值425.426.void Beep();427.void delayms(unsigned char ms);428.void delay(unsigned char t);429.430./*********************************************************/ 431.void main()432.{433.434. P1=0xff;435. TMOD=0x21 ;436. TH0=0xff ; //50us延时常数437. TL0=0xce ; //频率调节438.439. TH1=PWM ; //脉宽调节440. TL1=0 ;441.442. EA=1;443. ET0=1;444. ET1=1;445.446. TR0=1 ;447.448. while(1)449. {450. do{451. if(PWM!=0xff)452. {PWM++ ;delayms(10);} 453. else Beep() ;454. }455. while(K1==0);456.457. do{458. if(PWM!=0xce)459. {PWM-- ;delayms(10);} 460. else Beep() ;461. }462. while(K2==0);463. }464.}465.466.void timer0() interrupt 1467.{468. TR1=0 ;469. TH0=0xff ;470. TL0=0xce ;471. TH1=PWM ;472. TR1=1 ;473. P00=0 ; //启动输出474.}475.476.477.void timer1() interrupt 3478.{479. TR1=0 ;480. P00=1 ; //结束输出481.}482.483./*********************************************************/484.//蜂鸣器子程序485./*********************************************************/486.487.void Beep()488. {489. unsigned char i ;490. for (i=0 ;i<100 ;i++)491. {492. delay(100) ;493. BEEP=!BEEP ; //Beep取反494. }495. BEEP=1 ; //关闭蜂鸣器496. delayms(100);497. }498.499./*********************************************************/500.// 延时子程序501./*********************************************************/502.void delay(unsigned char t)503.{504. while(t--) ;505.}506.507./*********************************************************/508.// 延时子程序509./*********************************************************/510.void delayms(unsigned char ms)512.{513. unsigned char i ;514. while(ms--)515. {516. for(i = 0 ; i < 120 ; i++) ;517. }518.}519.520./*********************************************************/ 521.#include < >522.#include < >523.524.sbit K1 =P1^4 ; //增加键525.sbit K2 =P1^5 ; //减少键526.sbit P00 =P0^1;527.sbit BEEP =P3^7 ; //蜂鸣器528.unsigned char PWM=0xe7; //赋初值529.530.void Beep();531.void delayms(unsigned char ms);532.void delay(unsigned char t);533.534./*********************************************************/ 535.void main()536.{537.538. P1=0xff;539. TMOD=0x21 ;540. TH0=0xff ; //50us延时常数541. TL0=0xce ; //频率调节542.543. TH1=PWM ; //脉宽调节544. TL1=0 ;546. EA=1;547. ET0=1;548. ET1=1;549.550. TR0=1 ;551.552. while(1)553. {554. do{555. if(PWM!=0xff)556. {PWM++ ;delayms(10);} 557. else Beep() ;558. }559. while(K1==0);560.561. do{562. if(PWM!=0xce)563. {PWM-- ;delayms(10);} 564. else Beep() ;565. }566. while(K2==0);567. }568.}569.570.void timer0() interrupt 1571.{572. TR1=0 ;573. TH0=0xff ;574. TL0=0xce ;575. TH1=PWM ;576. TR1=1 ;577. P00=0 ; //启动输出578.}580.581.void timer1() interrupt 3582.{583. TR1=0 ;584. P00=1 ; //结束输出585.}586.587./*********************************************************/588.//蜂鸣器子程序589./*********************************************************/590.591.void Beep()592. {593. unsigned char i ;594. for (i=0 ;i<100 ;i++)595. {596. delay(100) ;597. BEEP=!BEEP ; //Beep取反598. }599. BEEP=1 ; //关闭蜂鸣器600. delayms(100);601. }602.603./*********************************************************/604.// 延时子程序605./*********************************************************/606.void delay(unsigned char t)607.{608. while(t--) ;609.}610.611./*********************************************************/612.// 延时子程序613./*********************************************************/ 614.void delayms(unsigned char ms)615.616.{617. unsigned char i ;618. while(ms--)619. {620. for(i = 0 ; i < 120 ; i++) ;621. }622.}623.624./*********************************************************/。
单片机延时程序怎么写(一)
单片机延时程序怎么写（一）引言概述：在单片机编程中，延时程序是非常常见且重要的一部分。
延时程序用于控制程序的执行时间，比如延时一定时间后进行下一步操作，实现定时或者延时功能。
本文将介绍如何编写单片机延时程序，帮助读者理解延时程序的基本原理和实现方法。
正文内容：1. 使用循环实现延时1.1 初始化相关寄存器和计数器1.2 进入延时循环1.3 设置循环次数或延时时间1.4 循环减计数器1.5 延时完成后退出循环2. 使用定时器实现延时2.1 初始化定时器相关设置2.2 设定定时器计数值2.3 开启定时器2.4 等待定时器中断或达到设定时间2.5 定时结束后关闭定时器3. 使用外部晶振实现延时3.1 初始化外部晶振相关设置3.2 计算延时对应的晶振周期3.3 使用循环控制延时时钟数3.4 延时完成后恢复晶振设置3.5 注意外部晶振频率与延时精度的关系4. 使用中断实现延时4.1 初始化中断相关设置4.2 设定中断触发时间或循环次数4.3 进入主循环等待中断触发4.4 中断处理程序执行延时操作4.5 中断结束后继续执行主循环5. 延时程序的注意事项5.1 延时精度和误差控制5.2 选择合适的延时方法和计算方式5.3 防止延时程序过长导致其他功能受阻5.4 注意延时程序对系统时钟和其他模块的影响5.5 调试和优化延时程序总结：编写单片机延时程序需要根据具体应用需求选择合适的方法，并考虑延时精度、系统资源占用等因素。
循环、定时器、外部晶振和中断等是常见的延时实现方式，开发者应根据具体情况进行选择和优化。
同时，在编写延时程序时要注意避免影响系统其他功能的正常运行，并进行必要的调试和优化工作，以确保延时程序的可靠性和稳定性。
51单片机延时函数
C程序中可使用不同类型的变量来进行延时设计。
经实验测试，使用unsigned char类型具有比unsigned int更优化的代码，在使用时应该使用unsigned char作为延时变量。
以某晶振为12MHz 的单片机为例，晶振为12MHz即一个机器周期为1us。
一. 500ms延时子程序程序:void delay500ms(void){unsigned char i,j,k;for(i=15;i>0;i--)for(j=202;j>0;j--)for(k=81;k>0;k--);}计算分析:程序共有三层循环一层循环n:R5*2 = 81*2 = 162us DJNZ 2us二层循环m:R6*(n+3) = 202*165 = 33330us DJNZ2us + R5赋值 1us = 3us三层循环: R7*(m+3) = 15*33333 = 499995us DJNZ 2us + R6赋值1us = 3us循环外: 5us子程序调用2us + 子程序返回 2us + R7赋值 1us = 5us延时总时间= 三层循环+ 循环外= 499995+5 = 500000us =500ms计算公式:延时时间=[(2*R5+3)*R6+3]*R7+5二. 200ms延时子程序程序:{unsigned char i,j,k;for(i=5;i>0;i--)for(j=132;j>0;j --)for(k=150;k>0;k --);}三. 10ms延时子程序程序:{unsigned char i,j,k;for(i=5;i>0;i--)for(j=4;j>0;j--)for(k=248;k>0;k --);}四. 1s延时子程序程序:void delay1s(void){unsigned char h,i,j,k;for(h=5;h>0;h--)for(i=4;i>0;i--)for(j=116;j>0;j --)for(k=214;k>0;k --);}关于单片机C语言的精确延时，网上很多都是大约给出延时值没有准确那值是多少,也就没有达到精确高的要求，而本函数克服了以上缺点，能够精确计数出要延时值且精确达到1us,本举例所用CPU为STC12C5412系列12倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。
单片机汇编延时程序的理解
单片机汇编延时程序的理解单片机汇编实现延迟的程序代码：DELAY： MOV R7，#250 ；D1： MOV R6，#250 ；D2： DJNZ R6，D2 ；DJNZ R7，D1 ；RET如果用高级语言编程，只需要简单地调用延时函数就可以实现，但是计算机具体是怎么实现的呢？要想知其所以然，还得从汇编开始学起。
冒号前面的“DELAY”、“D1”、“D2”为语句行的名字，是为了程序的条件语句跳转用的，分号后面为注释，计算机执行时将过滤掉这些信息，最大限度减少代码长度，提高效率。
DELAY： MOV R7，#250 ；名字为“DELAY”的语句：意思是将CPU内部内存RAM的R7位置填写为250（原来为0，为什么是0呢？因为任何程序开始执行前都要复位，就像我们打算盘要将算子复位一样，或者我们用沙盘写字，要将沙盘抹平类似）D1： MOV R6，#250 ；名字为“D1”的语句：将R6位置填写为250D2： DJNZ R6，D2 ；名字为“D2”的语句：将R6位置的250减1，如果为0就继续执行下一条，不为0就继续执行D2这一句，因为R6=250,所以这个语句要原地踏步执行250次！DJNZ R7，D1 ；这句没有名字，因为没有别的语句要跳到这里，所以就省略了。
R7同样等于250，但它不是原地踏步，而是跳回了D1，这么干，D!、D2和本句将被循环执行250遍，需要强调的是：D2语句自身每次都要执行250遍，也就是执行了250*250=62500遍！RET ；子程序结束（因为延时程序一般不作为独立程序存在，它只是一个子程序，也就是高级语言中的一个函数，看到这个字符，子程序将跳回到母程序，进行下一步）。
8255 控制led灯亮灭编程题
8255 控制led灯亮灭编程题第一种：基于8255芯片控制LED灯的亮灭编程，需要以下步骤：首先需要将8255芯片的PA口接LED灯，通过控制PA口的输出状态来控制LED灯的亮灭。
2.设置8255芯片的控制字，以确定芯片的工作方式和工作模式。
3.使用汇编语言编写程序，控制8255芯片的PA口输出状态，从而实现LED 灯的亮灭控制。
以下是一份基于8255芯片控制LED灯亮灭的汇编程序示例：ORG 0HDB 0B0H, 0B1H, 0B2H, 0B3H ; 控制字，确定8255芯片的工作方式和模式LED DB 0FFH ; 定义LED灯的状态，初始值为全灭LOOP:MOV AL, LED ; 将LED灯的状态存入AL寄存器OUT 0A0H, AL ; 将AL寄存器的值输出到8255芯片的PA口，控制LED灯的状态MOV AL, LED ; 将LED灯的状态存入AL寄存器ADD AL, 001 ; 将LED灯的状态翻转，实现亮灭变化SHL AL, 1 ; 将AL寄存器的值左移一位，更新LED灯的状态MOV LED, AL ; 将更新后的LED灯状态存入变量中JMP LOOP ; 重复以上操作，实现LED灯的持续亮灭控制在上述程序中，控制字被定义为0B0H、0B1H、0B2H和0B3H，分别对应8255芯片的四种工作方式和模式。
LED变量存储LED灯的状态，初始值为全灭。
在循环中，先将LED灯的状态输出到8255芯片的PA口，然后更新LED灯的状态并再次输出，实现LED灯的亮灭控制。
程序中的SHL指令是将AL寄存器的值左移一位，相当于将LED灯的状态翻转。
最后，程序通过JMP指令实现循环操作，让LED灯持续亮灭控制。
第二种：以下是使用8255芯片控制LED灯亮灭的编程题示例：假设LED灯连接在8255芯片的PA口，端口A的低4位控制LED的亮灭。
现在需要编写一个程序，让LED灯在PA口的低4位上以二进制方式从0000到1111逐位亮灭，每次亮灭的时间为1秒。
单片机程序设计题库及答案
单片机程序设计题库及答案2.查表法求 Y=某 2。
设某(0≤某≤15)在片内 RAM 的 20H 单元中，要求查表求 Y，存入片内 RAM21H 单元。
1)ORG1000H3.分析下面程序MOVR0,#0C8H；(R0) =200CLRP1.7；P1.7 为低电平LOOP:CPLP1.7；P1.7 变反(1μ) NOP；(1μ) NOP；(1μ)DJNZR0，LOOP；(R0)≠0 则转(2μ)4.设计一个延时 10m 的延时子程序，已知单片机使用的晶振为 6MHZ。
机器周期数 ORG0020H1MOVR0,#0AH；外循环 10 次 1DL2:MOVR1,#MT；内循环 MT 次 1DL1:NOP 1NOP；空操作指令2DJNZR1,DL12DJNZR0,DL2RET内循环 DL1 到指令 DJNZR1,DL1 的计算：(1＋1＋2)ⅹ2μⅹMT=1000μMT=125=7DH 总的延时时间： {1＋[1+(1+1+2)ⅹ125+2]ⅹ10}ⅹ2μ=10.062m5.试计算延时程序的执行时间DELAY：MOVR6，#64H (=100) 1I1：MOVR7，#0FFH (=255) 1I2：DJNZR7，I22DJNZR6，I12RET2 延时时间计算：(设时钟 fOSC=12MHz)T=1u计算延时程序的执行时间(设时钟 fOSC=6MHz,T=2u) 7.十六进制数转换为 ASCII 码：HASC：CJNEA，#0AH，NN：JNCN1 (C=0 跳 N1) ADDA，#30HSJMPSEN1：ADDA，#37HSE：RET8.设从片内 RAM30H 单元和40H 单元有两个 16 字节数，把它们相加，结果放于 30H 单元开始的位置处(设结果不溢出)。
ORG1000HMOVR0，#30HMOVR1，#40HMOVR2，#16CLRC9.按下面公式编写程序，某为无符号数，存在 20h 单元 y 存放在 21h 单元MOVB,#2MULABAJMPNE 某 T2NE 某 T1:CPLANE 某 T2:MOV21H,AEND从内部 RAM22h 单元开始存有一个无符号数数据块，长度 n 存于 21h 中。
用单片机C语言精确延时（定时）的方法
用单片机C语言精确延时（定时）的方法用单片机C语言精确延时(定时)的方法C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
那么用单片机C语言精确延时(定时)的方法都是怎样的呢？以下仅供参考！由于单片机C语言下利用软件延时不容易做到精确的定时，所以很多人在编写延时子程序的时候不能好好的把握延时的具体时间。
C 语言下，延时程序主要有以下几种：一：void delay(unsigned char k){unsigned char i,k; //定义变量for(i=0;i<k;i++); //for循环语句}该程序在Keil环境下，会先将C语言转化成汇编语言，那么我们就可以根据汇编语言来计算出精确的`时间，转化具体步骤如下：CLR A ；指令1MOV R7,A ；指令2LOOP:INC R7 ；指令3CJNE R7,k,LOOP ；指令4这里，指令1，指令2和指令3各消耗1个机器周期，指令4消耗两个机器周期（可查文末附录表），而在12M的晶振下一个机器周期是1us，在这个过程中，指令1和指令2分别执行1次，即消耗1+1us，而指令3和指令4分别执行了k次，那么这样加起来，这个延时子程序所消耗的具体时间就是t=1+1+(1+2)*k=3k+2us。
呵呵，这样说来，如果我们定义的k为100的话，这个延时子程序的精确时间就是302us。
二：void delay(unsigned char i){while(--i){;}}同样的道理，将其反汇编，可以看到，只有一条语句：DJNZ i,$;该语句消耗2us，一共执行i次，所以总共消耗时间t=i*2us。
三：下面的将形参换为整形int，这样的话，反汇编所执行的语句完全不同，用个具体的数字做例子：void delay(){unsigned int i=10000;while(--i);}反汇编后：4: unsigned int i=10000;C:0x0003 7F10 MOV R7,#0x10C:0x0005 7E27 MOV R6,#0x275: while(--i)6: ;C:0x0007 EF MOV A,R7C:0x0008 1F DEC R7C:0x0009 7001 JNZ C:000CC:0x000B 1E DEC R6C:0x000C 14 DEC AC:0x000D 4E ORL A,R6C:0x000E 70F7 JNZ C:0007具体计算如下1.R7经过10H（16）次循环减为0：t1=10H*（1+1+2+1+1+2）2.R6经过27H*256次循环减为0：t2=27H*256*（1+1+2+1+1+2）+27H*13.最后R7的是变为255，因此还要多出255次的循环：t3=255*（1+1+2+1+1+2）4.加上之前消耗的2us，总消耗时间：T=2+10H*（1+1+2+1+1+2）+27H*256*（1+1+2+1+1+2）+27H*1+255*（1+1+2+1+1+2）=2+16*7+39*256*7+39*1+255*7=71826us大约为72ms吧如果定义一个unsigned int i,那么延时计算公式为T=2+(i%256)*7+(i/256)*256*7+i/256+255*7关于其他类型的延时程序都可以按照这个方法对时间进行较为精确的计算。
计算机硬件技术基础实验教程答案(重庆大学)
计算机硬件技术基础实验教程答案 实验一：简单程序设计实验（1）编写一个 32 位无符号数除法的程序，要求将存放在 NUM1 中的 32 位无符号数与存放 在 NUM2 中的 16 位无符号数相除，结果存放在 NUM3 和 NUM4 中。
程序流程图略。
参考源程序：DATASEGMENTNUM1 DD 2A8B7654H NUM2 DW 5ABCH NUM3 DW ? NUM4 DW ?DATAENDSCODESEGMENTASSUME DS:DATA, CS:CODESTART: MOV AX,DATA;数据段寄存器初始化MOV DS,AXMOV AX, WORD PTR NUM1 MOV DX, WORD PTR NUM1+2 DIV NUM2 MOV NUM3,AX MOV NUM4,DX MOV AH,4CH ;正常返回DOS 系统INT 21HCODEENDS END START（2）编写一个拆字程序。
要求将存放在 ARY 单元的 2 位十六进制数 X 1X 2 拆为 X 1 和 X 2 两 部分，并以 0X 1 和 0X 2 的形式分别存入 ARY+1 和 ARY+2 单元中。
程序流程图略。
参考源程序：DATA SEGMENTARY DB 2AH,?,?DATA ENDSCODESEGMENTASSUME DS:DATA, CS:CODESTART: MOV AX,DATAMOV DS,AXMOV SI,OFFSET ARY ;取ARY 的偏移地址 MOV AL,[SI];取16进制数至ALMOV BL,ALAND AL,0F0H ;取16进制数的高四位，即X1SHR AL,4MOV [SI+1],AL ;存0X1MOV AL,BLAND AL,0FH ;取16进制数的低四位，即X2MOV [SI+2],AL ;存0X2MOV AH,4CHINT 21HCODE ENDSEND START实验二：分支程序设计实验（1）编写一个字符比较程序，比较3 个无符号字节数A，B，C 的大小，并根据比较结果对变量K 赋值：如果3 个数不相等，则K=0；如果3 个数中有两个相等，则K=1；如果3 个数都相等，则K=2。
51单片机汇编延时程序的设计方法
MOV 为1个机器周期，DNJZ 为2个机器周期，RET 为2个机器周期。
例1：
MAIN: AJMP DELAY1MS
DELAY1MS: ;误差 0us，包含调用时间
MOV R6,#0C7H 1个机器周期 0C7H=199
DL0:
MOV R5,#01H 1个机器周期
例3：
DELAY1MS: ;误差 0us，不包含调用时间
MOV R7,#01H
DL1:
MOV R6,#8EH
DL0:
MOV R5,#02H
DJNZ R5,$
DJNZ R6,DL0
DJNZ R7,DL1
RET
ห้องสมุดไป่ตู้
例4：
以此为基本的计时单位。如本实验要求0.2秒＝200ms，10ms×R5＝200ms，则R5＝20，延时子程序如下：
DELAY200MS: MOV R5,#20
D1: MOV R6,#20
D2: MOV R7,#248
DJNZ R7,$
DJNZ R6,D2
DJNZ R5,D1
RET
作为单片机的指令的执行的时间是很短，数量大微秒级，因此，我们要求的闪烁时间间隔为0.2秒，相对于微秒来说，相差太大，所以我们在执行某一指令时，插入延时程序，来达到我们的要求，但这样的延时程序是如何设计呢？下面具体介绍其原理：
石英晶体为12MHz，因此，1个机器周期为1微秒，如果石英晶体为24MHz，1个机器周期为0.5微妙。
MOV R7,#05H
DL1:
MOV R6,#04H
DL0:
MOV R5,#0F8H
DJNZ R5,$
单片机实验指导书
目录实验一P1口输入、输出实验 (2)实验二继电器控制实验 (8)实验三音频控制实验 (11)实验四程序调试 (14)实验五5LED静态串行显示实验 (16)实验六6LED动态扫描显示实验 (21)实验七查询式键盘实验 (28)实验八阵列式键盘实验 (36)实验九计数器实验 (47)实验十定时器实验 (49)实验十一外部中断实验 (54)实验一P1口输入、输出实验一、实验目的1、学习P1口的使用方法2、学习延时子程序的编写和使用二、实验说明P1口是准双向口,它作为输出口时与一般的双向口使用方法相同。
由准双向口结构可知当P1口用作输入口时，必须先对口的锁存器写“1”，若不先对它写“1”，读入的数据是不正确的。
三、实验内容及步骤实验(一)：用P1口做输出口，接八位逻辑电平显示，程序功能使发光二极管从右到左轮流循环点亮。
1、使用单片机最小应用系统1模块。
关闭该模块电源，用扁平数据线连接单片机P1口与八位逻辑电平显示模块。
2、用串行数据通信线连接计算机与仿真器，把仿真器插到模块的锁紧插座中，请注意仿真器的方向：缺口朝上。
3、打开Keil uVision2仿真软件，首先建立本实验的项目文件，接着添加P1_A.ASM源程序，进行编译，直到编译无误。
4、进行软件设置，选择硬件仿真，选择串行口，设置波特率为38400。
5、打开模块电源和总电源，点击开始调试按钮，点击RUN按钮运行程序，观察发光二极管显示情况。
发光二极管单只从右到左轮流循环点亮。
实验(二)：用P1.0、P1.1作输入接两个拨断开关，P1.2、P1.3作输出接两个发光二极管。
程序读取开关状态，并在发光二极管上显示出来。
1、用导线分别连接P1.0、P1.1到两个拨断开关，P1.2、P1.3到两个发光二极管。
2、添加 P1_B.ASM源程序，编译无误后，运行程序，拨动拨断开关，观察发光二极管的亮灭情况。
向上拨为熄灭，向下拨为点亮。
四、流程图及源程序1．流程图2．源程序：（一）实验一ORG 0000HLJMP STARTORG 0030HSTART: MOV A, #0FEHMOV R2,#8OUTPUT: MOV P1,ARL AACALL DELAYDJNZ R2,OUTPUTLJMP STARTDELAY: MOV R6,#0MOV R7,#0DELAYLOOP:；延时程序DJNZ R6,DELAYLOOPDJNZ R7,DELAYLOOPRETEND（二）实验二KEYLEFT BIT P1.0 ；定义KEYRIGHT BIT P1.1LEDLEFT BIT P1.2LEDRIGHT BIT P1.3ORG 0000HLJMP STARTORG 0030HSTART: SETB KEYLEFT ；欲读先置一SETB KEYRIGHTLOOP: MOV C,KEYLEFTMOV LEDLEFT,CMOV C,KEYRIGHTMOV LEDRIGHT,CLJMP LOOPEND五、思考题（1）对于本实验延时子程序Delay： MOV R6，0MOV R7, 0DelayLoop：DJNZ R6，DelayLoopDJNZ R7，DelayLoopRET如使用12MHz晶振，粗略计算此程序的执行时间为多少？六、电路图实验二继电器控制实验一、实验目的1、学习I/O端口的使用方法2、掌握继电器的控制的基本方法3、了解用弱电控制强电的方法二、实验说明现代自动控制设备中，都存在一个电子电路的互相连接问题，一方面要使电子电路的控制信号能控制电气电路的执行元件（电动机，电磁铁，电灯等），另一方面又要为电子线路和电气电路提供良好的电气隔离，以保护电子电路和人身的安全。
51单片机延时程序算法详解
51单片机汇编延时程序算法详解将以12MHZ晶振为例，详细讲解MCS-51单片机中汇编程序延时的精确算法。
指令周期、机器周期与时钟周期指令周期：CPU执行一条指令所需要的时间称为指令周期，它是以机器周期为单位的，指令不同，所需的机器周期也不同。
时钟周期：也称为振荡周期，一个时钟周期＝晶振的倒数。
MCS-51单片机的一个机器周期=6个状态周期=12个时钟周期。
MCS-51单片机的指令有单字节、双字节和三字节的，它们的指令周期不尽相同，一个单周期指令包含一个机器周期，即12个时钟周期，所以一条单周期指令被执行所占时间为12*（1/12000000）=1μs。
程序分析例1 50ms 延时子程序：DEL：MOV R7，#200 ①DEL1：MOV R6，#125 ②DEL2：DJNZ R6，DEL2 ③DJNZ R7，DEL1 ④RET ⑤精确延时时间为：1+（1*200）+（2*125*200）+（2*200）+2=（2*125+3）*200+3 ⑥=50603μs≈50ms由⑥整理出公式（只限上述写法）延时时间=（2*内循环+3）*外循环+3 ⑦详解：DEL这个子程序共有五条指令，现在分别就每一条指令被执行的次数和所耗时间进行分析。
第一句：MOV R7，#200 在整个子程序中只被执行一次，且为单周期指令，所以耗时1μs 第二句：MOV R6，#125 从②看到④只要R7-1不为0，就会返回到这句，共执行了R7次，共耗时200μs第三句：DJNZ R6，DEL2 只要R6-1不为0,就反复执行此句（内循环R6次），又受外循环R7控制，所以共执行R6*R7次，因是双周期指令，所以耗时2*R6*R7μs。
例2 1秒延时子程序：DEL：MOV R7,#10 ①DEL1：MOV R6，#200 ②DEL2：MOV R5，#248 ③DJNZ R5，$ ④DJNZ R6，DEL2 ⑤DJNZ R7，DEL1 ⑥RET ⑦对每条指令进行计算得出精确延时时间为：1+（1*10）+（1*200*10）+（2*248*200*10）+（2*200*10）+（2*10）+2 =[（2*248+3）*200+3]*10+3 ⑧=998033μs≈1s由⑧整理得：延时时间=[（2*第一层循环+3）*第二层循环+3]*第三层循环+3 ⑨此式适用三层循环以内的程序，也验证了例1中式⑦（第三层循环相当于1）的成立。
汇编延时1s的延时子程序
汇编延时1s的延时子程序一、延时子程序的概念延时子程序是指在程序中设置一个时间延迟，使得程序在执行到该子程序时暂停一段时间后再继续执行下一条指令。
在汇编语言中，常用的延时子程序有软件延时和硬件延时两种。
二、软件延时的实现方法1. 循环计数法循环计数法是一种简单而常用的软件延时方法。
其原理是利用CPU进行循环计数，当计数器达到设定值后，即完成了指定的时间延迟。
2. 空循环法空循环法是在循环体内不执行任何有意义的操作，只进行空转等待的方法。
其原理是利用CPU进行忙等待，当指定的时间到达后再继续执行下一条指令。
三、硬件延时的实现方法硬件延时是通过外部电路或芯片来实现的。
常用的硬件延时器有555定时器和8254可编程定时器等。
四、汇编语言实现1s延时子程序以下以循环计数法为例，介绍如何使用汇编语言实现1s延时子程序。
1. 程序思路：（1）将需要等待的时间转换为机器周期；（2）循环计数，当计数器达到指定值时，跳出循环。
2. 程序代码：delay:mov cx, 0FFFFh ;将计数器初始化为最大值mov dx, 0FFFFhdelay1:loop delay1 ;循环计数dec dx ;减少dx的值jnz delay1 ;如果dx不为0，则继续循环dec cx ;减少cx的值jnz delay1 ;如果cx不为0，则继续循环ret ;延时结束，返回3. 程序说明：（1）mov cx, 0FFFFh：将CX寄存器初始化为最大值，即65535；（2）mov dx, 0FFFFh：将DX寄存器初始化为最大值，即65535；（3）loop delay1：循环计数，每次减少CX的值，当CX的值为0时跳出循环；（4）dec dx：每次减少DX的值；（5）jnz delay1：如果DX的值不为0，则跳转到delay1标号处继续执行循环；（6）dec cx：每次减少CX的值；（7）jnz delay1：如果CX的值不为0，则跳转到delay1标号处继续执行循环；（8）ret：延时结束，返回。
蜂鸣器程序
要求：让蜂鸣器响，频率为1KHZ1、延时子程序实现汇编： ORG 0000HSJMP STARTORG 0030HSTART: MOV P2,#11110111B //P2^3控制蜂鸣器LCALL DELAYMOV P2,#11111111BLCALL DELAYAJMP STARTDELAY:MOV R5,#125L1:NOP //()ms us us us 5.0125211=⨯++NOPDJNZ R5,L1RET //返回主程序ENDC 语言：#include <reg52.h>#define uint unsigned int //宏定义void delay(uint z ) //延时0.5ms{uint i,j;for(i=z;i>0;i--)for(j=55;j>0;j--);}sbit beep=P2^3; //位定义void main(){while(1) //大循环{delay(1); //延时0.5msbeep=~beep; //取反}}2、用定时器1、方式2实现延时方式2最大定时：256⨯1us=0.256ms所以选择定时0.25ms ，那么循环2次实现0.5ms 延时计数值0.25ms/1us=250则256-250=06H汇编： ORG 0000HSJMP STARTORG 0030HSTART:MOV P2,#11110111BLCALL DELAYMOV P2,#11111111BLCALL DELAYAJMP STARTDELAY:MOV R5,#02H //置计数循环初值2 MOV TMOD,#20H //置定时器1方式2MOV TH1,#06H //置定时器初值MOV TL1,#06HSETB TR1 //启动定时器1LP1:JBC TF1,LP2 //查询计数溢出SJMP LP1 //未溢出继续计数LP2:DJNZ R5,LP1 //未到0.5ms继续循环 RET //返回主程序ENDC语言：#include <reg52.h>#define uchar unsigned char#define uint unsigned intsbit D0=P2^3;char num=0; //定义变量void main(){TMOD=0x20; //定时器1方式2TH1=6; //装入初值TL1=6;EA=1; //开总中断ET1=1; //开定时器1中断TR1=1; //启动定时器1D0=0; //蜂鸣器响while (1);{if(num==2) //循环两次实现0.5ms延时{num=0; //把num清零重新再计数D0=~D0; //让蜂鸣器状态取反}}}void T1_time()interrupt 3{num++;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
汇编延时程序大集合2009-05-31 19:24各种汇编延时程序大集合;513微秒延时程序DELAY: MOV R2,#0FEHDELAY1: DJNZ R2,DELAY1RET;10毫秒延时程序DL10MS: MOV R3,#14HDL10MS1:LCALL DELAYDJNZ R3,DL10MS1RET;0.1s延时程序12mhzDELAY: MOV R6,#250DL1: MOV R7,#200DL2: DJNZ R6,DL2DJNZ R7,DL1RET;延时1046549微秒(12mhz);具体的计算公式是:;((((r7*2+1)+2)*r6+1)+2)*r5+1+4 = ((r7*2+3)*r6+3)*r5+5DEL : MOV R5,#08HDEL1: MOV R6,#0FFHDEL2: MOV R7,#0FFHDJNZ R7,$DJNZ R6,DEL2DJNZ R5,DEL1RET;1秒延时子程序是以12MHz晶振Delay1S:mov r1,#50del0: mov r2,#91del1: mov r3,#100djnz r3,$djnz r2,del1djnz r1,del0Ret;1秒延时子程序是以12MHz晶振为例算指令周期耗时KK: MOV R5,#10 ;1指令周期1K1: MOV R6,#0FFH ;1指令周期10K2: MOV R7,#80H ;1指令周期256*10=2560K3: NOP ;1指令周期128*256*10=327680DJNZ R7,K3 ;2指令周期2*128*256*10=655360DJNZ R6,K2 ;2指令周期2*256*10=5120DJNZ R5,K1 ;2指令周期2*10=20RET;2指令周期21+10+2560+327680+655360+5120+20+2=990753 ;约等于1秒1秒=1000000微秒;这个算下来也只有0.998抄T_0: MOV R7,#10;D1: MOV R6,#200;D2: MOV R5,#248;DJNZ R5,$DJNZ R6,D2;DJNZ R7,D1;RET;这样算下来应该是1.000011秒T_0: MOV R7,#10;D1: MOV R6,#200;D2: NOPMOV R5,#248;DJNZ R5,$DJNZ R6,D2;DJNZ R7,D1;RETDELAY_2S: ;10MS(11.0592mhz)MOV R3,#200JMP DELAY10MSDELAY_100MS: ;100MS(11.0592mhz)MOV R3,#10JMP DELAY10MSDELAY_10MS:MOV R3,#1DELAY10MS: ;去抖动10MS(11.0592mhz)MOV R4,#20DELAY10MSA:MOV R5,#247DJNZ R5,$DJNZ R4,DELAY10MSADJNZ R3,DELAY10MSRETDELAY_500MS: ;500500MS MOV R2,#208JMP DELAY_MSDELAY_175MS: ;175MSMOV R2,#73JMP DELAY_MSdelaY_120MS: ;120MSMOV R2,#50JMP DELAY_MSdelay_60ms: ;60msMOV R2,#25JMP DELAY_MSdelay_30ms: ;30msMOV R2,#12JMP DELAY_MSDELAY_5MS: ;5MSMOV R2,#2;=================================== DELAY_MS:CALL DELAY2400DJNZ R2,DELAY_MSRET;=================================== DELAY2400: ;10x244+4=2447/1.024=2390MOV R0,#244 ;1DELAY24001:MUL AB ;4MUL AB ;4DJNZ R0,DELAY24001 ;2RETDELAY: ;延时子程序(1秒)MOV R0,#0AHDELAY1: MOV R1,#00HDELAY2: MOV R2,#0B2HDJNZ R2,$DJNZ R1,DELAY2DJNZ R0,DELAY1RETMOV R2,#10 ;延时1秒LCALL DELAYMOV R2,#50 ;延时5秒LCALL DELAYDELAY: ;延时子程序PUSH R2PUSH R1PUSH R0DELAY1: MOV R1,#00HDELAY2: MOV R0,#0B2HDJNZ R0,$DJNZ R1,DELAY2 ;延时 100 mSDJNZ R2,DELAY1POP R0POP R1POP R2RET1:DEL: MOV R7, #200DEL1: MOV R6, #123NOPDEL2: DJNZ R6, DEL2DJNZ R7, DEL1RET是50.001ms 算法是:0.001ms+200*0.001ms+200*0.001ms+200*123*0.002ms+200*0.002ms ;(123*2+4)*200+12: DEL: MOV R7, #200DEL1: MOV R6, #123DEL2:NOPDJNZ R6,DEL2DJNZ R7,DEL1RETD500MS:PUSH PSWSETB RS0MOV R7,#200D51: MOV R6,#250D52: NOPNOPNOPNOPDJNZ R6,D52DJNZ R7,D51POP PSWRETDELAY: ;延时1毫秒PUSH PSWSETB RS0MOV R7,#50D1: MOV R6,#10D2: DJNZ R6,$DJNZ R7,D1POP PSWRETORG 0LJMP MAINORG 000BH LJMP CTC0MAIN: MOV SP, #50H CLR EAMOV TMOD, #01H MOV TH0,#3CH MOV TL0,#0B0H MOV R4, #10 SETB ET0SETB EASETB TR0SJMP $ ; CTC0: MOV TH0, #3CH MOV TL0, #0B0H DJNZ R4, LPCPL P1.0MOV R4, #10 LP: RETIEND..................................................................... ..........................................延时5秒左右DELAY5S:PUSH 04HPUSH 05HPUSH 06HMOV R4,#50DELAY5S_0:MOV R5,#200DELAY5S_1:MOV R6,#245DJNZ R6,$DJNZ R5,DELAY5S_1DJNZ R4,DELAY5S_0POP 06HPOP 05HPOP 04HRET指令周期、机器周期与时钟周期指令周期：CPU执行一条指令所需要的时间称为指令周期，它是以机器周期为单位的，指令不同，所需的机器周期也不同。
时钟周期：也称为振荡周期，一个时钟周期＝晶振的倒数。
MCS-51单片机的一个机器周期=6个状态周期=12个时钟周期。
MCS-51单片机的指令有单字节、双字节和三字节的，它们的指令周期不尽相同，一个单周期指令包含一个机器周期，即12个时钟周期，所以一条单周期指令被执行所占时间为12*（1/12000000）=1µs。
程序分析例1 50ms 延时子程序：DEL：MOV R7，#200 ①DEL1：MOV R6，#125 ②DEL2：DJNZ R6，DEL2 ③DJNZ R7，DEL1 ④RET ⑤精确延时时间为：1+（1*200）+（2*125*200）+（2*200）+2 =（2*125+3）*200+3 ⑥=50603µs≈50ms由⑥整理出公式（只限上述写法）延时时间=（2*内循环+3）*外循环+3 ⑦详解：DEL这个子程序共有五条指令，现在分别就每一条指令被执行的次数和所耗时间进行分析。
第一句：MOV R7，#200 在整个子程序中只被执行一次，且为单周期指令，所以耗时1µs第二句：MOV R6，#125 从②看到④只要R7-1不为0，就会返回到这句，共执行了R7次，共耗时200µs第三句：DJNZ R6，DEL2 只要R6-1不为0,就反复执行此句（内循环R6次），又受外循环R7控制，所以共执行R6*R7次，因是双周期指令，所以耗时2*R6*R7µs。
例2 1秒延时子程序：DEL：MOV R7,#10 ①DEL1：MOV R6，#200 ②DEL2：MOV R5，#248 ③DJNZ R5，$ ④DJNZ R6，DEL2 ⑤DJNZ R7，DEL1 ⑥RET ⑦对每条指令进行计算得出精确延时时间为：1+（1*10）+（1*200*10）+（2*248*200*10）+（2*200*10）+（2*10）+2=[（2*248+3）*200+3]*10+3 ⑧=998033µs≈1s由⑧整理得：延时时间=[（2*第一层循环+3）*第二层循环+3]*第三层循环+3 ⑨此式适用三层循环以内的程序，也验证了例1中式⑦（第三层循环相当于1）的成立。
注意，要实现较长时间的延时，一般采用多重循环，有时会在程式序里加入NOP指令，这时公式⑨不再适用，下面举例分析。
例3仍以1秒延时为例DEL：MOV R7,#10 1指令周期1DEL1：MOV R6，#0FFH 1指令周期10DEL2：MOV R5，#80H 1指令周期255*10=2550KONG：NOP 1指令周期128*255*10=326400DJNZ R5，$ 2指令周期2*128*255*10=652800DJNZ R6，DEL2 2指令周期2*255*10=5110DJNZ R7，DEL1 2指令周期2*10=20RET 2延时时间=1+10+2550+326400+652800+5110+20+2=986893µs约为1s整理得：延时时间=[（3*第一层循环+3）*第二层循环+3]*第三层循环+3 ⑩结论：论文针对初学者的困惑，对汇编程序的延时算法进行了分步讲解，并就几种不同写法分别总结出相应的计算公式，只要仔细阅读例1中的详解，并用例2、例3来加深理解，一定会掌握各种类型程序的算法并加以运用。