2007-09-11 16:55:00 liuxp_008 阅读数 2830
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3410 人正在学习 去看看 朱有鹏

51单片机 Keil C 延时程序

应用单片机的时候,经常会遇到需要短时间延时的情况。需要的延时时间很短,一般都是几十到几百微妙(us)。有时候还需要很高的精度,比如用单片机驱动DS18B20的时候,误差容许的范围在十几us以内,不然很容易出错。这种情况下,用计时器往往有点小题大做。而在极端的情况下,计时器甚至已经全部派上了别的用途。这时就需要我们另想别的办法了。
    以前用汇编语言写单片机程序的时候,这个问题还是相对容易解决的。比如用的是12MHz晶振的51,打算延时20us,只要用下面的代码,就可以满足一般的需要:
        mov     r0, #09h
loop:   djnz    r0, loop
51单片机的指令周期是晶振频率的1/12,也就是1us一个周期。mov r0, #09h需要2个极其周期,djnz也需要2个极其周期。那么存在r0里的数就是(20-2)/2。用这种方法,可以非常方便的实现256us以下时间的延时。如果需要更长时间,可以使用两层嵌套。而且精度可以达到2us,一般来说,这已经足够了。
    现在,应用更广泛的毫无疑问是Keil的C编译器。相对汇编来说,C固然有很多优点,比如程序易维护,便于理解,适合大的项目。但缺点(我觉得这是C的唯一一个缺点了)就是实时性没有保证,无法预测代码执行的指令周期。因而在实时性要求高的场合,还需要汇编和C的联合应用。但是是不是这样一个延时程序,也需要用汇编来实现呢?为了找到这个答案,我做了一个实验。
    用C语言实现延时程序,首先想到的就是C常用的循环语句。下面这段代码是我经常在网上看到的:
void delay2(unsigned char i)
{
    for(; i != 0; i--);
}
到底这段代码能达到多高的精度呢?为了直接衡量这段代码的效果,我把 Keil C 根据这段代码产生的汇编代码找了出来:
             ; FUNCTION _delay2 (BEGIN)
                                           ; SOURCE LINE # 18
;---- Variable 'i' assigned to Register 'R7' ----
                                           ; SOURCE LINE # 19
                                           ; SOURCE LINE # 20
0000         ?C0007:
0000 EF                MOV     A,R7
0001 6003              JZ      ?C0010
0003 1F                DEC     R7
0004 80FA              SJMP    ?C0007
                                           ; SOURCE LINE # 21
0006         ?C0010:
0006 22                RET    
             ; FUNCTION _delay2 (END)
真是不看不知道~~~一看才知道这个延时程序是多么的不准点~~~光看主要的那四条语句,就需要6个机器周期。也就是说,它的精度顶多也就是6us而已,这还没算上一条 lcall 和一条 ret。如果我们把调用函数时赋的i值根延时长度列一个表的话,就是:
i    delay time/us
0    6
1    12
2    18
...
因为函数的调用需要2个时钟周期的lcall,所以delay time比从函数代码的执行时间多2。顺便提一下,有的朋友写的是这样的代码:
void delay2(unsigned char i)
{
    unsigned char a;
    for(a = i; a != 0; a--);
}
可能有人认为这会生成更长的汇编代码来,但是事实证明:
             ; FUNCTION _delay2 (BEGIN)
                                           ; SOURCE LINE # 18
;---- Variable 'i' assigned to Register 'R7' ----
                                           ; SOURCE LINE # 19
                                           ; SOURCE LINE # 21
;---- Variable 'a' assigned to Register 'R7' ----
0000         ?C0007:
0000 EF                MOV     A,R7
0001 6003              JZ      ?C0010
0003 1F                DEC     R7
0004 80FA              SJMP    ?C0007
                                           ; SOURCE LINE # 22
0006         ?C0010:
0006 22                RET    
             ; FUNCTION _delay2 (END)
其生成的代码是一样的。不过这的确不是什么好的习惯。因为这里实在没有必要再引入多余的变量。我们继续讨论正题。有的朋友为了得当更长的延时,甚至用了这样的代码:
void delay2(unsigned long i)
{
    for(; i != 0; i--);
}
这段代码产生的汇编代码是什么样子的?其实不用想也知道它是如何恐怖的$#^%&%$......让我们看一看:
             ; FUNCTION _delay2 (BEGIN)
                                           ; SOURCE LINE # 18
0000 8F00        R     MOV     i+03H,R7
0002 8E00        R     MOV     i+02H,R6
0004 8D00        R     MOV     i+01H,R5
0006 8C00        R     MOV     i,R4
                                           ; SOURCE LINE # 19
                                           ; SOURCE LINE # 20
0008         ?C0007:
0008 E4                CLR     A
0009 FF                MOV     R7,A
000A FE                MOV     R6,A
000B FD                MOV     R5,A
000C FC                MOV     R4,A
000D AB00        R     MOV     R3,i+03H
000F AA00        R     MOV     R2,i+02H
0011 A900        R     MOV     R1,i+01H
0013 A800        R     MOV     R0,i
0015 C3                CLR     C
0016 120000      E     LCALL   ?C?ULCMP
0019 601A              JZ      ?C0010
001B E500        R     MOV     A,i+03H
001D 24FF              ADD     A,#0FFH
001F F500        R     MOV     i+03H,A
0021 E500        R     MOV     A,i+02H
0023 34FF              ADDC    A,#0FFH
0025 F500        R     MOV     i+02H,A
0027 E500        R     MOV     A,i+01H
0029 34FF              ADDC    A,#0FFH
002B F500        R     MOV     i+01H,A
002D E500        R     MOV     A,i
002F 34FF              ADDC    A,#0FFH
0031 F500        R     MOV     i,A
0033 80D3              SJMP    ?C0007
                                           ; SOURCE LINE # 21
0035         ?C0010:
0035 22                RET    
             ; FUNCTION _delay2 (END)
呵呵,这倒是的确可以延迟很长时间~~~但是毫无精度可言了。
    那么,用C到底能不能实现精确的延时呢?我把代码稍微改了一下:
void delay1(unsigned char i)
{
    while(i--);
}
因为根据经验,越简洁的C代码往往也能得出越简洁的机器代码。那这样结果如何呢?把它生成的汇编代码拿出来看一看就知道了。满怀希望的我按下了“Build target”键,结果打击是巨大的:
             ; FUNCTION _delay1 (BEGIN)
                                           ; SOURCE LINE # 13
;---- Variable 'i' assigned to Register 'R7' ----
                                           ; SOURCE LINE # 14
0000         ?C0004:
                                           ; SOURCE LINE # 15
0000 AE07              MOV     R6,AR7
0002 1F                DEC     R7
0003 EE                MOV     A,R6
0004 70FA              JNZ     ?C0004
                                           ; SOURCE LINE # 16
0006         ?C0006:
0006 22                RET    
             ; FUNCTION _delay1 (END)
虽说生成的代码跟用for语句是不大一样,不过我可以毫无疑问的说,这两种方法的效率是一样的。似乎到此为止了,因为我实在想不出来源程序还有什么简化的余地。看来我就要得出来这个结论了:“如果需要us级的延时精度,需要时用汇编语言。”但是真的是这样吗?我还是不甘心。因为我不相信大名鼎鼎的 Keil C 编译器居然连 djnz 都不会用???因为实际上程序体里只需要一句 loop: djnz r7, loop。近乎绝望之际(往往人在这种情况下确可以爆发出来,哦呵呵呵~~~),我随手改了一下:
void delay1(unsigned char i)
{
    while(--i);
}
心不在焉的编译,看源码:
             ; FUNCTION _delay1 (BEGIN)
                                           ; SOURCE LINE # 13
;---- Variable 'i' assigned to Register 'R7' ----
                                           ; SOURCE LINE # 14
0000         ?C0004:
                                           ; SOURCE LINE # 15
0000 DFFE              DJNZ    R7,?C0004
                                           ; SOURCE LINE # 16
0002         ?C0006:
0002 22                RET    
             ; FUNCTION _delay1 (END)
天~~~奇迹出现了......我想这个程序应该已经可以满足一般情况下的需要了。如果列个表格的话:
i    delay time/us
1    5
2    7
3    9
...
计算延时时间时,已经算上了调用函数的lcall语句所花的2个时钟周期的时间。
    终于,结果已经明了了。只要合理的运用,C还是可以达到意想不到的效果。很多朋友抱怨C效率比汇编差了很多,其实如果对Keil C的编译原理有一个较深入的理解,是可以通过恰当的语法运用,让生成的C代码达到最优化。即使这看起来不大可能,但还是有一些简单的原则可循的:1.尽量使用unsigned型的数据结构。2.尽量使用char型,实在不够用再用int,然后才是long。3.如果有可能,不要用浮点型。4.使用简洁的代码,因为按照经验,简洁的C代码往往可以生成简洁的目标代码(虽说不是在所有的情况下都成立)。 
 
2010-11-15 01:35:00 HNSD983704669 阅读数 1343
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3410 人正在学习 去看看 朱有鹏

前几天上单片机课时,老师给我们讲了 单片机 延时子程序,我也发现延时  程序 在单片机中 是非常 常用的,很重要

做作业 写延时程序的时候,感觉根本就不会写,写出来了也是套出来 的,而且 根本就不精确   于是 我就想  我要想一个通用的算法出来,写一个 51单片机 汇编 延时程序 源码生成器,以后 广大的 同学们 或者 单片机 开发者 没 就不用 去套就可以 得到 精确到 一个机器周期的 延时程序了,这个东西也已经做出来了,好了废话少说,现在 开始 和大家分享 我想出来的 算法

 

看几个例子:

一重循环:

   MOV  R0, #3
   DJNZ  R0,$

  

二重循环:

延时时间:T1=2*R0+1

 DELAY:      MOV    R1,#2
LOOP_2:   MOV    R0,#197
                 DJNZ   R0,$
                 DJNZ   R1,LOOP_2

                

 延时: T2=(2*R0+1+2)*R1+1

 

三重循环:

                 MOV      R2,#8
LOOP_3:   MOV    R1,#244
LOOP_4:   MOV    R0,#254
                 DJNZ   R0,$
                 DJNZ   R1,LOOP_4
                 DJNZ   R2,LOOP_3

延时:T3=(  (  (2*R0+1+2)*R1+1)  )+2)*R2+1

 

四重循环:

                 MOV    R3,#18
LOOP_5:   MOV    R2,#255
LOOP_6:   MOV    R1,#255
LOOP_7:   MOV    R0,#255
                DJNZ   R0,$
                DJNZ   R1,LOOP_7
                DJNZ   R2,LOOP_6
                DJNZ   R3,LOOP_5

可以归纳出:

 T2=(T1+2)*R1+1

 T3=(T2+2)*R2+1

 T4=(T3+2)*R3+1

 

仔细看一个  自己也可以再写一个 相信你一定能和我一样 发现这个规律

 

下变进行数学变换一下

将T1 代入T2 表达式

T2=1+3*R2+2*R0*R1

T3=1+3*(R2*R3+R3)+2*R0*R1*R2

T4=1+3*(R2*R3*R4+R3*R4+R4)+2*R0*R1*R2*R3

 

再进行一次归纳,或者说是抽象成一个通式:

 

这个公式是我总结出来的,接下来对公式进行说明:

 

这个是一个K元K次方程     表达式的单位是 机器周期 的个数

 

变量K:循环的次数 R 代表寄存器,下标代表 哪一个寄存器,如 R1

 

假设k=3   则会有 三个未知数 R1  R2  R3

 

大家看到最后加了一个2,原因是 我考虑到 一个子程序 结束时 会有一个返回指令 RET 占用两个机器周期

 

这个东西有什么用呢,很有用 一个未知数 就代表  一个 寄存器的 值 ,表达示结果 就是  用这几个 寄存器 写来来的 K重循环 所延时的机

 

器 周期数,即如果你要 延时 某个 时长(机器周期的整数倍时)  你只要解这个方程就 OK了, 不幸的是 这一个 方程 K个未知数,从数

 

学角度来说就无法解出来,也可能这个方程 根本 就找不到 K 个0—255的数 满足方程的,怎么办呢,是不是放弃呢,大家可以想一想,我

 

们现在是要做什么:

 

我要的是: 输入 要延时的   时长,和晶振   输出: 延时 汇编 源代码

 

你或许会想,也应该明白,如果这个方程 有解,并且你能解出来 那么这个问题就解 决了,而且 就用一个 汇编 循环(不是指一重循环)

 

就能够 达到延时 指定时间的效果,可是我们解不出来,(就算是用穷举法,由于方程可能无满足条件(0—255)的解,所以穷举不一定

 

行,而且很费时间,我已试过 晶振:12MHz  延时:60s  很久 都 穷举不完,下面就说我的方法

 

整体思想:象叠方块样的,大的  上面 叠 小的, 最上面叠  最小的,  当然 不能叠  太多了 ,要不然  汇编 代码 太多了不好 ,占用存储

 

空间

 

具体方法很简单

1、要据上面推导的公式,确定用机重循环可以搞定  即确定K

 

2、个寄存器全部置为255  从最高R8  开始  用二分法  确定  是一个  当R8=R8+1 时 T(k)>要延时时间  

R8=R8-1     T(k)<要延时的时间  且保证  R8=R8时 T(k)<要延时的时间

 直到  R0确定完毕

 

一次近似完毕

3 、 算去 误差 T

 

重复  上面三步  只到 K=0 即 最后 小于一重循环最小值  的机器周期数  的用 NOP 来延迟(也可能不需要,这个由你输入的 晶振 和

延时决定的)

 

从问题的 抽象 到 确定 算法 整个思 路 讲完了,很好的一个东东,可以精确到  每一个机器都期,如:晶振12MHz  就可以精确到 1us

 

 

 

 

 

2019-03-22 16:19:26 qq_33738357 阅读数 343
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3410 人正在学习 去看看 朱有鹏

简介:延时与中断出错,是单片机新手在单片机开发应用过程中,经常会遇到的问题,本文汇总整理了包含了MCS-51系列单片机、MSP430单片机、C51单片机、8051F的单片机、avr单片机、STC89C52、PIC单片机…..在内的各种单片机常见的延时与中断问题及解决方法,希望对单片机新手们,有所帮助!


 

1、单片机延时程序的延时时间怎么算的?

 

答:如果用循环语句实现的循环,没法计算,但是可以通过软件仿真看到具体时间,但是一般精精确延时是没法用循环语句实现的。

 

如果想精确延时,一般需要用到定时器,延时时间与晶振有关系,单片机系统一般常选用11.059 2 MHz、12 MHz或6 MHz晶振。第一种更容易产生各种标准的波特率,后两种的一个机器周期分别为1 μs和2 μs,便于精确延时。本程序中假设使用频率为12 MHz的晶振。最长的延时时间可达216=65 536 μs。若定时器工作在方式2,则可实现极短时间的精确延时;如使用其他定时方式,则要考虑重装定时初值的时间(重装定时器初值占用2个机器周期)。

 

2、求个单片机89S51 12M晶振 用定时器延时10分钟,控制1个灯就可以

 

答:可以设50ms中断一次,定时初值,TH0=0x3c、TL0=0xb0。中断20次为1S,10分钟的话,需中断12000次。计12000次后,给一IO口一个低电平(如功率不够,可再加扩展),就可控制灯了。

 

而且还要看你用什么语言计算了,汇编延时准确,知道单片机工作周期和循环次数即可算出,但不具有可移植性,在不同种类单片机中,汇编不通用。用c的话,由于各种软件执行效率不一样,不会太准,通常用定时器做延时或做一个不准确的延时,延时短的话,在c中使用汇编的nop做延时

 

3、51单片机C语言for循环延时程序时间计算 ,设晶振12MHz,即一个机器周期是1us。

 

for(i=0,i<100;i++)

 

for(j=0,j<100;j++)

 

我觉得时间是100*100*1us=10ms,怎么会是100ms

 

答:

 

不可能的,是不是你的编译有错的啊

 

我改的晶振12M,在KEIL 4.0 里面编译的,为你得出的结果最大也就是40ms,这是软件的原因,

 

不可能出现100ms那么大的差距,是你的软件的原因。

 

不信你实际编写一个秒钟,利用原理计算编写一个烧进单片机和利用软件测试的秒程序烧进单片机,你会发现原理计算的程序是正确的

 

4 、51单片机c语言 _nop_()是一个空指令?短时间延时的?空几个机器周期?

 

答:这个_nop_()等效与汇编里面的,NOP指令,也就是空一个机器周期,如果是传统51单片机的话,等于空12个时钟周期【即一个机器周期】

 

5、51单片机 延时500ms 用机器周期叠加怎么算?

 

答:DELAY:

 

MOV R7,#4

 

D2:MOV R6,#250

 

D1:MOV R5,#250

 

DJNZ R5,$

 

DJNZ R6,D1

 

DJNZ R7,D2

 

RET

 

假设晶振为12MHz

 

刚延时时间为:

 

250*250*4*2=500MS

 

6、51单片机C语言程序中延时函数delay的原理是什么?

 

现在找到两个函数

 

第一:

 

void delay(void)

 

{ unsigned int i,j;

 

for(i=0;i<500;i++)

 

{ for(j=0;j<121;j++)

 

{;}

 

}

 

}

 

第二:

 

void delay(unsigned int k)

 

{ unsigned int i,j;

 

for(i=0;i

 

{ for(j=0;j<121;j++)

 

{;}

 

}

 

}

 

现有几个疑问:

 

(1):延时函数的原理?

 

(2):两个for循环的作用?

 

(3):i、j的取值有什么规律和依据?是不是和单片机接的晶振频率有关?所能延时的最小单位时间是怎么计算的?

 

延时时间怎么计算啊!假如用的是AT89C51RC+11.0592M的晶振呢?

 

答:

 

1:原理:仅仅执行一些,没有实质性影响的所谓“无意义指令”,比如做比大小啊,做某个int的自加运算啊之类的

 

2:两重for的作用:简单的说,就像高中数学中的“乘法原理”一样,这样可以很轻易的迅速增加上述“无意义指令”的数目

 

3:关于取值大小:这个如果是在C下变成,这个值不仅仅与晶振、单片机本身运算速度有关,而且还与C的编译器有关,所以说,这个值虽说是可以精确计算的,但大多数情况下,程序员用的都是“经验值”——当然,如果用汇编编程,情况就不一样了,因为每一条指令所使用的机器周期是一定的,你当然可以根据所有指令使用的总时间,精确的算出具体延时的总时间

 

综合你的的问题,我给你一点建议,就是刚学单片机的时候,还是一定要老老实实的从汇编编程学起——这样,在你以后接触到C之后,你才能明白,这中间实际上经历了一个什么样的过程,只有这样你才能真正理解单片机。当然,等最终你完全拿下一种单片机之后,尽量使用C编程,无疑是历史所肯定的。

 

7、51单片机,晶振为6M,求一个10ms的延时程序

 

答:延时有很多种方法,有一种是让单片机去做无聊的循环,还有一种是用定时器。

 

第一种的算法是:

 

晶振的周期T1=1/f; 这里f=6MHz 所以T1=1/6 us;(微秒)

 

单片机花12个T1去执行一个指令,

 

所以一个机器周期等于12个晶振周期,

 

T2=12*T1=2us

 

10ms=1000 0us

 

所以你要得到10ms的延时就要想办法让机器去做5000条“无聊的指令”

 

所以

 

DEL: MOV R5,#05H

 

F1: MOV R6,#05H

 

F2: MOV R7,#32H

 

F3: DJNZ R7,F3

 

DJNZ R6,F2

 

DJNZ R5,F1

 

RET

 

这种方法是用于对时间要求不高的地方,我说的是其思想,程序中可能有错的地方

 

用定时器的方法我不太会就不误人了 (补充一下就是这个是用汇编写的,你在主程序中用ACALL DEL调用就延时了。

 

8、今天我用单片机做“眨眼的LED”实验时,程序运行,每次只令灯亮或灭都没问题,但是一开延时不能出现期盼的灯亮灯灭的现象,这是怎么回事?

 

实验的硬件条件是:STC89C52,编译环境:keil 3。

 

下面是我写的程序,请教高手!!!

 

#include // 文件包含处理

 

#define uchar unsigned char //宏定义,方便以后程序的书写

 

#define uint unsigned int

 

sbit P1_0 = P1 ^ 0; //位变量定义

 

void Delay(uint t)

 

{

 

uchar i;

 

while(--t)

 

{

 

for(i = 0; i < 125; i++) //延时1MS,在这里我们用的晶振是是12M,根据机器周期的计算,我们

 

{;} //可算得本次循环延时约1MS

 

}

 

}

 

void main(void)

 

{

 

while(1)

 

{

 

P1_0 = 0; //点亮LED灯

 

Delay(1000); //应单片执行程序的时间很快,所以必须延时,要不看不到实验现象

 

P1_0 = 1; //熄灭LED灯

 

}

 

补充提问:我是让P1.0先低然后延时之后再高,即灯先亮再灭,然后开始循环的

 

答:应该这样写

 

while(1)

 

{

 

P1_0 = 0; //点亮LED灯

 

Delay(1000); //应单片执行程序的时间很快,所以必须延时,要不看不到实验现象

 

P1_0 = 1; //熄灭LED灯

 

Delay(1000);

 

补充问题回复:问题恰恰就错在这了,循环完一遍之后灯由灭到亮根本没有时间延时,即第一次循环中灯还没来的机灭呢,就进入到第二轮循环中的亮了,所以原因就在这,这错误太低级了,以后引以为鉴吧

 

9、单片机延时函数的问题

 

void delay(uchar i)

 

{

 

uchar j;

 

while(i--)

 

{

 

for(j=125;j>0;j--)

 

;

 

}

 

}

 

这个函数中的i,j的大小有**吗?

 

答:这个函数中j的大小和你定义的数据类型有关,因为你定义的为无符号字符型,为单字节数据,所以最大为255。.

 

如果你需要增大,可以改变j的数据类型定义,如unsigned int (2字节)可以到65535;无符号长整形unsigned long(4字节) 可以到4294967295。 而上面所所256是-1,而你定义的是无符号字符型。

 

10、请教一个AVR单片机延时的问题

 

外部晶振用的是8MHz,延时1微秒的程序如下:

 

void delay_us(unsigned int delay_counter)//延时1us

 

{

 

do

 

{

 

delay_counter--;

 

}

 

while(delay_counter>1);

 

}

 

请问,为什么能延时1微秒啊?

 

答:8MHZ表示单片机的运行周期为1/8us,也就是0.125us执行一步

 

你使用的是软件延时

 

那么包括程序的提取,执行等都要花费时间

 

比如,你提取这个函数可能花去一步,那现在就使用了0.125us啦

 

接着你执行这个函数,在单片机内部,运算是通过寄存器的移来移去实现的

 

这都需要时间,可能你看到的就一句counter--这个指令,可能会花费好几个时钟周期来实现

 

举个例子:

 

c=a+b,只有一句,但实际上花费的时间并不短

 

mov a,#data1;//数据data1放入a寄存器

 

mov b,#data2;//数据data2放入b寄存器

 

add a,b;//寄存器a的值与b相加,结果放入a

 

mov c,a;//将a的值放入c

 

这样才是单片机内部真正执行的指令,这需要花费至少4个时钟周期,而不是1个

 

至于晶体管级的我就不解释了,你得好好学习汇编才能理解单片机的运作。

 

至于这个函数为什么能延时1ms,这个是靠经验来判断的,最直接的方法就是用示波器看,以上均为推论。

 

11、PIC单片机的延时问题 晶振4Mhz:

 

void delay()

 

{

 

unsigned int d=1000;

 

while(--d){;}

 

}

 

此函数在4M晶体下产生10003us的延时,也就是10MS。

 

问题:我刚算了一下他应该执行了999条指令,1条单周期的指令也才1US,那就是999us,为什么会有10ms的延时?

 

1:for(x=100;--x;){;} : 2: for(x=0;x<100;x++){;} 2句话相同

 

第一句:X的值范围是不是 1~99?为什么?

 

第二句:X的范围是不是0~99?为什么?这么算的。我知道符号在前在后的区别。2句话应该是不一样的才对啊!

 

答:

 

问题1:“我刚算了一下他应该执行了999条指令”因为你算错了。延时时间是由产生的汇编代码所决定的,C语言语句只是个假象,千万不要以为C语言一行就是一条指令!此处由于涉及到双字节减法,因此会有额外的判断,编译结果每次循环耗费几十个周期毫不奇怪。

 

问题2:前一句x从100开始递减,递减至1时退出循环。后一句x从0开始递增,递增到100时退出循环。所谓“2句话”相同仅仅是指这两个循环体的循环次数相同。实际上两个循环的执行过程是完全不同的,所消耗时间也有可能不同。

 

12、stc单片机的延时问题 ,STC10F08XE单片机,晶振22.1184M

 

void delay(unsigned long uldata)

 

{

 

unsigned int j = 0;

 

unsigned int g = 0;

 

for (j=0;j<5;j++)

 

{

 

for (g=0;g

 

{

 

_nop_();

 

_nop_();

 

_nop_();

 

}

 

}

 

}

 

当uldata=1时延时多少秒?

 

请给出具体算法…………

 

答:用keil转换成汇编语句,然后对照指令表计算就行了

 

13、我想用单片机连接不断地向电脑发数,如下:

 

while (1)

 

{

 

send_char(\'9\');

 

delay(n);

 

}

 

如每发送一个数,应延时多少微妙好呢?即一般最短能延时多少微米呢?如延时太长的话,那发送很多数据不就用很长时间吗?

 

答:不做太多的串口处理分析,只顺着你的问题和你的方法说说:

 

先考虑下串口的速率 假设9600,那么发送一个字符要多久?

 

(9600bit/S) / 10bit(一个字符1+8+1) = 960字符/秒 约 1ms/byte

 

也就是说你如果在1ms内发送超过一个字符就没意义了,硬件速度达不到。

 

while(1)

 

{

 

send_char(\'9\');

 

delay(n);

 

}

 

这个循环是执行周期也就十几微秒+delay()的延迟,所以任何小于1040微秒的延迟对串口硬件来说没意义,上一个还没处理完,下一个就来了根本执行不了嘛。

 

如果你send_char()里面有while(!TI);TI = 0;这样的语句或有串口中断TI的处理的话,那么实际上你的delay()已经在发送函数里了,while(!TI);这部就是延迟等待吗?那根本不需要主函数去延迟了,直接发就行了。

 

14、一个单片机延时子程序的问题,在延时子程序那里,一直搞不明白,给r7和r6赋予0,然后下面的djnz r7,delayloop不就一直循环了,那还怎么接下去的程序?

 

org 0000h

 

ljmp start

 

org 0030h

 

start: mov a,#0feh

 

mov r5,#8

 

output: mov p1,a

 

rl a

 

call delay

 

djnz r5,output

 

ljmp start

 

delay: mov r6,#0

 

mov r7,#0

 

delayloop:djnz r7,delayloop

 

djnz r6,delayloop

 

ret

 

end

 

答: 你的延时程序不是因为值为0,而是跳转位置不对,改为如下:

 

delay: mov r6,#0

 

delayloop:mov r7,#0

 

:djnz r7,$

 

djnz r6,delayloop

 

ret

 

R7,R6初值为0,但是当DJNZ执行时,这条指令是先减1再判断,所以0-1=255,判断的话也不为0,仍然循环256次。

 

0-1=255的解释:

 

0000 0000

 

- 0000 0001

 

-------------------------

 

1111

 

15、我想提两个单片机延时与按键的问题

 

1:如果一个程序中延时和按键,如果延时子程序比较长(假如2秒),怎样确保按键能够得到及时响应(假如PC正在执行延时子程序,正在这时候有按键输入,不是响应不了)——,,,前提是不能用定时器定时扫描,和中断来做,因为定时器和中断我另有其他用途

 

2:单片机没有串口。怎样才能使得他与24C02进行通信(24C02是具有2K内存的EEPROM)

 

答:

 

首先明确一点你说单片机没有串口,应该是指没有I2C口吧。

 

1 在延时程序里面加入按键的检测

 

2 用IO口模拟I2C时序读写

 

16、51单片机延时小程序,求高手解释什么意思?

 

delay200ms:

 

mov r2,#82

 

l0:mov r1,#116

 

l1:mov r0,#9

 

djnz r0,$

 

djnz r1,l1

 

djnz r2,l0

 

ret

 

答:以下是每条指令的时间,T为一个机器周期

 

delay200ms:

 

mov r2,#82;1T

 

l0:mov r1,#116;1T

 

l1:mov r0,#9;1T

 

djnz r0,$;2T

 

djnz r1,l1;2T

 

djnz r2,l0;2T

 

ret;2T

 

以上共三层循环,忽略部分指令,最简单算法是:

 

2*9*116*82=171216

 

不忽略指令是:

 

1+(1+(1+2*9+2)*116+2)*82+2=200001

 

因此延时时间大约为200ms

 

17、于51单片机延迟时间的问题

 

uchar i;i--;

 

uint i;i--;

 

这两条语句在12M晶振下运行时间分别是多少??

 

答:一个时钟周期,2us,共4us

 

18、周期为6MHZ的单片机延时10秒的子程序的怎么编?

 

答:/********************************************************************

 

* 名称 : Delay()

 

* 功能 : 延时,延时时间为 10ms * del。这是通过软件延时,有一定误差。

 

* 输入 : del

 

* 输出 : 无

 

***********************************************************************/

 

void Delay(uint del)

 

{

 

uint i,j;

 

for(i=0; i

 

for(j=0; j<1827; j++) //这个是通过软件仿真得出的数

 

;

 

}

 

这个是晶振为12mhz的单片机延时10ms的程序,你只要在这个基础上减小一倍就行了,当然至于具体值还是要调试下的。

 

19、片机的有些程序需要调用延时程序,如何能合理的安排循环次数以及空操作的个数?

 

答:用汇编的话就根据你的当前晶振频率去推算你的指令周期,然后结合你需要延迟的时间,编写延迟程序,用C的话还是要看最后生成的汇编码是什么样的了。最简单的方法就是写好程序以后再编译器里软仿真看时间。赞同2| 评论(1)

 

20、单片机延时程序问题

 

延时程序 void delay(uint dt)

 

{

 

uchar bt;

 

for(;dt;dt--);

 

for(bt=0;bt<255;bt++);

 

}

 

编译时有警告C:DOCUMENTS AND SETTINGSADMINISTRATOR桌面字 310 点阵LED显示.C(46): warning C235: parameter 1: different types

 

为什么?求大侠指点

 

答:某个函数传参类型与声明类型不符。

 

另外你这个for(;dt;dt--);没有起到外层循环的作用……

2011-02-11 21:20:00 somethingma 阅读数 742
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3410 人正在学习 去看看 朱有鹏

以下为使用汇编代码产生的0.2s延时。

关于汇编与C语言的延时计算问题,推荐一篇好文章——彭老师的“51系列单片机延时程序运行时间的计算”。

 

2018-01-01 20:47:56 sczhangheng 阅读数 688
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3410 人正在学习 去看看 朱有鹏

1.例1,12MHz晶振调试

以下两个图片是无参数的delay函数,内部用的是for循环来delay。

LCALL 2个周期

MOV A到RX 1个周期

CLR  1个周期

INC  1个周期

CJNE 2个周期

RET  2个周期

LCALL+RET+CLR+MOV+110*(INC+CJNE)=2+2+1+1+110*(1+2)=336us  按110来算就是约等于110*3个周期,因为循环语句就两条共3个周期。




892.734-892.398ms=336us




例2:12MHz晶振调试,传参数,for循环只有1层,且是char类型。

MOV 1个周期

LCALL 2个周期

CLR 1个周期

SUBB 1个周期

JNC 2个周期

INC  1个周期

SMJP 2个周期

RET 2个周期

MOV+LCALL+CLR+MOV+123*(MOV+CLR+SUBB+JNC+INC+SJMP)-INC-SJMP+RET=1+2+1+1+124*(1+1+1+2+1+2)-1-2+2=996us



893.394ms-892.398ms=996us




结论,传参数类型的delay,占用更多指令,所以延迟更大。另外还和晶振大小有关,所以需要精确的延时时,需要单独测试for循环的延时,才能拿来使用。


void Delay(){unsigned char a,b,c;for(a=0;a

博文 来自: wangzhangshufa
没有更多推荐了,返回首页