delay_delayqueue - CSDN
精华内容
参与话题
  • delay函数的用法及声明

    万次阅读 2017-01-16 14:02:30
    在VC中使用带上头文件 #include 注意: 在VC中Sleep中的第一个英文字符为大写的"S" 在标准C中是sleep, 不要大写.. 下面使用大写的来说明,, 具体用什么看你用什么编译器.... Sleep函数的一般形式: ...
     在VC中使用带上头文件
      #include <windows.h>
      注意:
      在VC中Sleep中的第一个英文字符为大写的"S"
      在标准C中是sleep, 不要大写.. 下面使用大写的来说明,, 具体用什么看你用什么编译器. 简单的说VC用Sleep, 别的一律使用sleep.
      Sleep函数的一般形式:
      Sleep(unisgned long);
      其中,Sleep()里面的单位,是以毫秒为单位,所以如果想让函数滞留1秒的话,应该是Sleep(1000);
      例:
      #include <windows.h>
      int main()
      {
      int a;
      a=1000;
      Sleep(a);/* VC 使用Sleep*/
      return 0;
      }
    
    usleep功能:
    暂停执行。 语法: void usleep(int micro_seconds); 返回值: 无 函数种类: PHP 系统功能 内容说明:本函数可暂时使程序停止执行。参数 micro_seconds 为要暂停的毫秒数(微妙还是毫秒?)。 注意:这个函数不能工作在 Windows 操作系统中。参见:usleep() 与sleep()类似,用于延迟挂起进程。进程被挂起放到reday queue。
      只是一般情况下,延迟时间数量级是秒的时候,尽可能使用sleep()函数。
      且,此函数已被废除,可使用nanosleep。
      如果延迟时间为几十毫秒,或者更小,尽可能使用usleep()函数。这样才能最佳的利用CPU时间
    
    delay:
    函数名: delay 
      功 能: 将程序的执行暂停一段时间(毫秒) 
      用 法: void delay(unsigned milliseconds); 
      程序例: 
      /* Emits a 440-Hz tone for 500 milliseconds */ 
      #include<dos.h> 
      int main(void) 
      { 
      sound(440); 
      delay(500); 
      nosound(); 
      return 0; 
      }
      (由于delay读音像地雷,在各大OI灌水区通用……) 
    
    
    delay()是循环等待,该进程还在运行,占用处理器。   
    sleep()不同,它会被挂起,把处理器让给其他的进程。
    
    sleep()参数指定暂停时间,单位是s   
    delay()参数指定暂停时间,单位是ms
    展开全文
  • Delay_ms延时函数详解

    万次阅读 2017-11-13 21:24:40
    void Delay_ms(unsigned int time) { unsigned char n; while(time>0) { for(n=0;n;++n) { asm("nop"); } time--; } } 在流程中加入延时函数的原因是:单片机执行命令的速度太快(如果选择1MHz的晶振...

    void Delay_ms(unsigned int time)
    {
        unsigned char  n;
       while(time>0)
        {
        for(n=0;n<187;++n)
      {
    asm("nop");
    }
    time--;
    }
    }

    在流程中加入延时函数的原因是:单片机执行命令的速度太快(如果选择1MHz的晶振频率,AVR执行大多数指令的时间仅仅是1),任由单片机;连续改变端口输出的话,由于人眼辨别物体的速度跟不上,我们将看不到任何闪烁的效果,所以加入延时来放慢端口电平的变化速度


    软件延时的基本原理是多次重复执行指令,比如1条指令执行需要1微妙的时间,那么执行一千条这个指令 就会消耗一毫秒的时间;  其中asm("nop");语句是插入汇编指令的写法。表示在for循环中插入一条nop指令,这是一个空操作指令;它的执行将消耗掉一个cpu周期,因为我们的目的就是延时,所以空操作就可以;

    但是C语言书写的fof循环编译器会加入很多我们看不到的底层实现代码,它们的执行也需要时间,所以循环次数远小于1000;


    注意:软件延时只能用到要求不高的场合,因为软件延时会无端的浪费掉单片机的资源,延时也容易被打断就不准确了
    展开全文
  • 常用的延时函数delay()

    2020-07-29 14:21:47
    这是一个常用的延时功能模块,编程有一 定的用处。
  • C51延时函数delay的编写

    万次阅读 多人点赞 2017-02-26 13:43:28
    例如,要写一个延迟10ms的delay函数:(12M晶振) void delay_10ms() { unsigned char i,j,k; for(i=5;i>0;i--) { for(j=4;j>0;j--) { for(k=248;j>0;j--); }

    例如,要写一个延迟10ms的delay函数:(12M晶振)

    void delay_10ms()
    {
         unsigned char i,j,k;
         for(i=5;i>0;i--)
         {
               for(j=4;j>0;j--)
               {
                       for(k=248;j>0;j--);
                }
          }
    }
    原理:3层for循环,循环次数是 NUM = 4X5X248 = 4960次,由每次循环都有条件判断(如 i >0)和自减语句(如 i--),因此每次循环又耗费两个机器周期

         所以,总耗费的机器周期为 SUM = NUM x 2 = 9920个

         又因为 12M 晶振频率,每一个机器周期为 1us,所以 这个函数话费的时间 为9920us = 9.920 ms 约等于10ms,而把赋值语句,压栈出栈操作计算在内,加起来差不多10ms

    展开全文
  • 【stm32】delay详解

    千次阅读 2019-11-01 12:40:41
    什么是SysTick CM3 内核的处理器,内部包含了一个 SysTick 定时器,SysTick 是一个 24 位的倒计数定时器,当计数到 0 时,将从RELOAD 寄存器中自动重装载定时初值,开始新一轮计数。只要不把它在 SysTick 控制及状态...

    1 首先看函数:

    1.1 当使用ucos时才有以下部分:
    主要实现宏定义与基本函数定义。

    #if SYSTEM_SUPPORT_OS							//如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于UCOS).
    //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    //首先是3个宏定义:
    //    delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    // delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    //然后是3个函数:
    //  delay_osschedlock:用于锁定OS任务调度,禁止调度
    //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    //    delay_ostimedly:用于OS延时,可以引起任务调度.
    
    //本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
    //支持UCOSII
    #ifdef 	OS_CRITICAL_METHOD						//OS_CRITICAL_METHOD定义了,说明要支持UCOSII				
    #define delay_osrunning		OSRunning			//OS是否运行标记,0,不运行;1,在运行
    #define delay_ostickspersec	OS_TICKS_PER_SEC	//OS时钟节拍,即每秒调度次数
    #define delay_osintnesting 	OSIntNesting		//中断嵌套级别,即中断嵌套次数
    #endif
    
    //支持UCOSIII
    #ifdef 	CPU_CFG_CRITICAL_METHOD					//CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII	
    #define delay_osrunning		OSRunning			//OS是否运行标记,0,不运行;1,在运行
    #define delay_ostickspersec	OSCfg_TickRate_Hz	//OS时钟节拍,即每秒调度次数
    #define delay_osintnesting 	OSIntNestingCtr		//中断嵌套级别,即中断嵌套次数
    #endif
    
    
    //us级延时时,关闭任务调度(防止打断us级延迟)
    void delay_osschedlock(void)
    {
    #ifdef CPU_CFG_CRITICAL_METHOD   				//使用UCOSIII
    	OS_ERR err; 
    	OSSchedLock(&err);							//UCOSIII的方式,禁止调度,防止打断us延时
    #else											//否则UCOSII
    	OSSchedLock();								//UCOSII的方式,禁止调度,防止打断us延时
    #endif
    }
    
    //us级延时时,恢复任务调度
    void delay_osschedunlock(void)
    {	
    #ifdef CPU_CFG_CRITICAL_METHOD   				//使用UCOSIII
    	OS_ERR err; 
    	OSSchedUnlock(&err);						//UCOSIII的方式,恢复调度
    #else											//否则UCOSII
    	OSSchedUnlock();							//UCOSII的方式,恢复调度
    #endif
    }
    
    //调用OS自带的延时函数延时
    //ticks:延时的节拍数
    void delay_ostimedly(u32 ticks)
    {
    #ifdef CPU_CFG_CRITICAL_METHOD
    	OS_ERR err; 
    	OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);	//UCOSIII延时采用周期模式
    #else
    	OSTimeDly(ticks);							//UCOSII延时
    #endif 
    }
     
    //systick中断服务函数,使用ucos时用到
    void SysTick_Handler(void)
    {	
    	if(delay_osrunning==1)						//OS开始跑了,才执行正常的调度处理
    	{
    		OSIntEnter();							//进入中断
    		OSTimeTick();       					//调用ucos的时钟服务程序               
    		OSIntExit();       	 					//触发任务切换软中断
    	}
    }
    #endif
    

    1.2 使用ucos的delay函数

    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    //延时nus
    //nus为要延时的us数.		    								   
    void delay_us(u32 nus)
    {		
    	u32 ticks;
    	u32 told,tnow,tcnt=0;
    	u32 reload=SysTick->LOAD;					//LOAD的值	    	 
    	ticks=nus*fac_us; 							//需要的节拍数	  		 
    	tcnt=0;
    	delay_osschedlock();						//阻止OS调度,防止打断us延时
    	told=SysTick->VAL;        					//刚进入时的计数器值
    	while(1)
    	{
    		tnow=SysTick->VAL;	
    		if(tnow!=told)
    		{	    
    			if(tnow<told)tcnt+=told-tnow;		//这里注意一下SYSTICK是一个递减的计数器就可以了.
    			else tcnt+=reload-tnow+told;	    
    			told=tnow;
    			if(tcnt>=ticks)break;				//时间超过/等于要延迟的时间,则退出.
    		}  
    	};
    	delay_osschedunlock();						//恢复OS调度									    
    }
    //延时nms
    //nms:要延时的ms数
    void delay_ms(u16 nms)
    {	
    	if(delay_osrunning&&delay_osintnesting==0)	//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)	    
    	{		 
    		if(nms>=fac_ms)							//延时的时间大于OS的最少时间周期 
    		{ 
       			delay_ostimedly(nms/fac_ms);		//OS延时
    		}
    		nms%=fac_ms;							//OS已经无法提供这么小的延时了,采用普通方式延时    
    	}
    	delay_us((u32)(nms*1000));					//普通方式延时  
    }
    #else //不用OS时
    

    1.3 不使用ucos的delay函数

    //延时nus
    //nus为要延时的us数.		    								   
    void delay_us(u32 nus)
    {		
    	u32 temp;	    	 
    	SysTick->LOAD=nus*fac_us; 					//时间加载	  		 
    	SysTick->VAL=0x00;        					//清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;	//开始倒数	  
    	do
    	{
    		temp=SysTick->CTRL;
    	}while((temp&0x01)&&!(temp&(1<<16)));		//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;	//关闭计数器
    	SysTick->VAL =0X00;      					 //清空计数器	 
    }
    //延时nms
    //注意nms的范围
    //SysTick->LOAD为24位寄存器,所以,最大延时为:
    //nms<=0xffffff*8*1000/SYSCLK
    //SYSCLK单位为Hz,nms单位为ms
    //对72M条件下,nms<=1864 
    void delay_ms(u16 nms)
    {	 		  	  
    	u32 temp;		   
    	SysTick->LOAD=(u32)nms*fac_ms;				//时间加载(SysTick->LOAD为24bit)
    	SysTick->VAL =0x00;							//清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;	//开始倒数  
    	do
    	{
    		temp=SysTick->CTRL;
    	}while((temp&0x01)&&!(temp&(1<<16)));		//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;	//关闭计数器
    	SysTick->VAL =0X00;       					//清空计数器	  	    
    } 
    

    1.4 无论是否使用ucos的初始化函数

    //初始化延迟函数
    //当使用OS的时候,此函数会初始化OS的时钟节拍
    //SYSTICK的时钟固定为HCLK时钟的1/8
    //SYSCLK:系统时钟
    void delay_init()
    {
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    	u32 reload;
    #endif
    	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	//选择外部时钟  HCLK/8
    	fac_us=SystemCoreClock/8000000;				//为系统时钟的1/8  
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    	reload=SystemCoreClock/8000000;				//每秒钟的计数次数 单位为M  
    	reload*=1000000/delay_ostickspersec;		//根据delay_ostickspersec设定溢出时间
    												//reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右	
    	fac_ms=1000/delay_ostickspersec;			//代表OS可以延时的最少单位	   
    
    	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//开启SYSTICK中断
    	SysTick->LOAD=reload; 						//每1/delay_ostickspersec秒中断一次	
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//开启SYSTICK    
    
    #else
    	fac_ms=(u16)fac_us*1000;					//非OS下,代表每个ms需要的systick时钟数   
    #endif
    }	
    

    2 什么是SysTick

    CM3 内核的处理器,内部包含了一个 SysTick 定时器,SysTick 是一个 24 位的倒计数定时器,当计数到 0 时,将从RELOAD 寄存器中自动重装载定时初值,开始新一轮计数。只要不把它在 SysTick 控制及状态寄存器中的使能位清除,就永不停息。 STM32 的内部 SysTick 来实现延时既不占用中断,也不占用系统定时器。
    SysTick 是 MDK 定义了的一个结构体(在 core_m3.h 里面),里面包含 CTRL、LOAD、VAL、CALIB 等 4 个寄存器,

    2.1 SysTick->CTRL 的各位定义如图所示:
    在这里插入图片描述
    2.2 SysTick-> LOAD 的定义如图所示:
    在这里插入图片描述
    2.3 SysTick-> VAL 的定义如图 所示:
    在这里插入图片描述
    2.4 SysTick-> CALIB 不常用

    2.5 ucos下的SysTick以及如何实现delay_ms与delay_us

    ucos 运行需要一个系统时钟节拍(类似 “心跳”),而这个节拍是固定的(由 OS_TICKS_PER_SEC 宏定义设置),比如要求 5ms 一次(即可设置OS_TICKS_PER_SEC=200),在 STM32 上面,一般是由 SysTick 来提供这个节拍,也就是SysTick要设置为 5ms 中断一次,为 ucos 提供时钟节拍,而且这个时钟一般是不能被打断的(否则就不准了)。

    因为在 ucos 下 SysTick 不能再被随意更改,如果我们还想利用 SysTick 来做 delay_us 或者delay_ms 的延时,就必须想点办法了,这里我们利用的是时钟摘取法。以 delay_us 为例,比如
    delay_us(50),在刚进入 delay_us 的时候先计算好这段延时需要等待的 SysTick 计数次数,这里
    为 50 * 9(假设系统时钟为72Mhz,那么SysTick每增加1,就是1/9us)(SysTick每增加9就是1us)(SysTick的频率为div8),然后我们就一直统计SysTick 的计数变化,直到这个值变化了 50*9,一旦检测到变化达到或者超过这个值,就说明延时 50us 时间到了。这样,我们只是抓取 SysTick 计数器的变化,并不需要修改 SysTick 的任何状态,完全不影响 SysTick 作为 UCOS 时钟节拍的功能,这就是实现 delay 和操作系统共用SysTick 定时器的原理。

    2.6外部8M晶振原因

    Systick 的时钟来自系统时钟 8 分频,正因为如此,系统时钟如果不是 8 的倍数(不能被 8 整除),则会导致延时函数不准确,这也是我们推荐外部时钟选择 8M 的原因。

    3 函数详解

    3.1 delay_init

    delay_init 函数使用了条件编译,来选择不同的初始化过程,如果不使用 OS 的时候,只是设置一下 SysTick 的时钟源以及确定 fac_us 和 fac_ms 的值。而如果使用 OS 的时候,则会进行一些不同的配置,这里的条件编译是根据 SYSTEM_SUPPORT_OS 这个宏来确定的,该宏在 sys.h 里面定义。

    void delay_init()
    {
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    	u32 reload;
    #endif
    	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	//选择外部时钟  HCLK/8
    	fac_us=SystemCoreClock/8000000;				//为系统时钟的1/8  
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    	reload=SystemCoreClock/8000000;				//每秒钟的计数次数 单位为M  
    	reload*=1000000/delay_ostickspersec;		//根据delay_ostickspersec设定溢出时间
    												//reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右	
    	fac_ms=1000/delay_ostickspersec;			//代表OS可以延时的最少单位	   
    
    	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//开启SYSTICK中断
    	SysTick->LOAD=reload; 						//每1/delay_ostickspersec秒中断一次	
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//开启SYSTICK    
    
    #else
    	fac_ms=(u16)fac_us*1000;					//非OS下,代表每个ms需要的systick时钟数   
    #endif
    }	
    
    • SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);这一句把SysTick的时钟选择外部时钟,SysTick 的时钟源自 HCLK 的 8 分频,假设我们外部晶振为 8M,然后倍频到 72M,那么 SysTick 的时钟即为 9Mhz,也就是SysTick 的计数器 VAL 每减 1,就代表时间过了 1/9us。
    • fac_us=SystemCoreClock/8000000;这句话就是计算在 SystemCoreClock 时钟频率下延时
      1us 需要多少个 SysTick 时钟周期。
    • fac_ms=(u16)fac_us*1000;就是计算延时 1ms 需要多少个 SysTick 时钟周期,它自然是 1us
      的 1000 倍。

    在不使用 OS 的时候:fac_us为 us 延时的基数,也就是延时 1us时候SysTick->LOAD 所应设置的值。fac_ms 为 ms 延时的基数,也就是延时 1ms,SysTick->LOAD 所应设置的值。fac_us为 8 位整形数据,fac_ms 为 16 位整形数据。

    当使用 OS 的时候,fac_us还是 us 延时的基数,不过这个值不会被写到 SysTick->LOAD寄存器来实现延时,而是通过时钟摘取的办法实现的。而 fac_ms 则代表 ucos自带的延时函数所能实现的最小延时时间(如 delay_ostickspersec=200,那么 fac_ms 就是 5ms)。

    3.2 不使用ucos的delay_us

    该函数用来延时指定的 us,其参数 nus 为要延时的微秒数。

    void delay_us(u32 nus)
    {		
    	u32 temp;	    	 
    	SysTick->LOAD=nus*fac_us; 					//时间加载	  		 
    	SysTick->VAL=0x00;        					//清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;	//开始倒数	  
    	do
    	{
    		temp=SysTick->CTRL;
    	}while((temp&0x01)&&!(temp&(1<<16)));		//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;	//关闭计数器
    	SysTick->VAL =0X00;      					 //清空计数器	 
    }
    

    实现一次延时 nus的操作:

    • 先把要延时的 us 数换算成 SysTick 的时钟数,然后写入 LOAD 寄存器。
    • 然后清空当前寄存器 VAL 的内容,再开启倒数功能。
    • 等到倒数结束,即延时了 nus。
    • 最后关闭 SysTick,清空 VAL 的值。

    nus 的值,不能太大,必须保证 nus<=(2^24)/fac_us,否则将导致延时时间不准确。 temp&0x01,这一句是用来判断 systick 定时器是否还处于开启状态,可以防止 systick 被意外关闭导致的死循环

    3.3 ucos下的delay_us

    void delay_us(u32 nus)
    {		
    	u32 ticks;
    	u32 told,tnow,tcnt=0;
    	u32 reload=SysTick->LOAD;					//LOAD的值	    	 
    	ticks=nus*fac_us; 							//需要的节拍数	  		 
    	tcnt=0;
    	delay_osschedlock();						//阻止OS调度,防止打断us延时
    	told=SysTick->VAL;        					//刚进入时的计数器值
    	while(1)
    	{
    		tnow=SysTick->VAL;	
    		if(tnow!=told)
    		{	    
    			if(tnow<told)tcnt+=told-tnow;		//这里注意一下SYSTICK是一个递减的计数器就可以了.
    			else tcnt+=reload-tnow+told;	    
    			told=tnow;
    			if(tcnt>=ticks)break;				//时间超过/等于要延迟的时间,则退出.
    		}  
    	};
    	delay_osschedunlock();						//恢复OS调度									    
    }
    
    • 利用时钟摘取法,ticks 是延时 nus 需要等待的 SysTick 计数次数(也就是延时时间),told 用于记录最近一次的 SysTick->VAL 值,然后 tnow 则是当前的SysTick->VAL 值,通过他们的对比累加,实现 SysTick 计数次数的统计,统计值存放在 tcnt 里面,然后通过对比 tcnt 和 ticks,来判断延时是否到达,从而达到不修改 SysTick 实现 nus 的延时,从而可以和 OS 共用一个 SysTick。
    • delay_osschedlock 和 delay_osschedunlock 是 OS 提供的两个函数,用于调度上锁和解锁,这里为了防止 OS 在 delay_us 的时候打断延时,可能导致的延时不准,所以我们利用这两个函数来实现免打断,从而保证延时精度!同时,此时的 delay_us,可以实现最长 2^32us 的延时,大概是 4294 秒。

    3.4 不使用ucos的delay_ms

    void delay_ms(u16 nms)
    {	 		  	  
    	u32 temp;		   
    	SysTick->LOAD=(u32)nms*fac_ms;				//时间加载(SysTick->LOAD为24bit)
    	SysTick->VAL =0x00;							//清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;	//开始倒数  
    	do
    	{
    		temp=SysTick->CTRL;
    	}while((temp&0x01)&&!(temp&(1<<16)));		//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;	//关闭计数器
    	SysTick->VAL =0X00;       					//清空计数器	  	    
    } 
    

    注意:单次延时时间不能超过1864ms,原因如下:
    同delay_us大致一样,LOAD 仅仅是一个 24bit 的寄存器,延时的 ms 数不能太长。否则超出了 LOAD 的范围,高位会被舍去,导致延时不准。最大延迟 ms 数可以通过公式:nms<=0xffffff81000/SYSCLK 计算。SYSCLK 单位为 Hz,nms 的单位为 ms。如果时钟为 72M,那么 nms 的最大值为 1864ms。超过这个值,建议通过多次调用 delay_ms 实现,否则就会导致延时不准确。

    3.5 ucos下的delay_ms

    void delay_ms(u16 nms)
    {	
    	if(delay_osrunning&&delay_osintnesting==0)	//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)	    
    	{		 
    		if(nms>=fac_ms)							//延时的时间大于OS的最少时间周期 
    		{ 
       			delay_ostimedly(nms/fac_ms);		//OS延时
    		}
    		nms%=fac_ms;							//OS已经无法提供这么小的延时了,采用普通方式延时    
    	}
    	delay_us((u32)(nms*1000));					//普通方式延时  
    }
    
    • 该函数中,delay_osrunning 是 OS 正在运行的标志,delay_osintnesting 则是 OS 中断嵌套次数,必须 delay_osrunning 为真,且 delay_osintnesting 为 0 的时候,才可以调用 OS 自带的延时函数进行延时(可以进行任务调度),delay_ostimedly 函数就是利用 OS 自带的延时函数,实现任务级延时的,其参数代表延时的时钟节拍数(假设 delay_ostickspersec=200 ,那么delay_ostimedly (1),就代表延时 5ms)。

    • 当 OS 还未运行的时候,我们的 delay_ms 就是直接由 delay_us 实现的,OS 下的 delay_us可以实现很长的延时而不溢出!,所以放心的使用 delay_us 来实现 delay_ms,不过由于 delay_us的时候,任务调度被上锁了,所以还是建议不要用 delay_us 来延时很长的时间,否则影响整个系统的性能。

    • 当 OS 运行的时候,我们的 delay_ms 函数将先判断延时时长是否大于等于 1 个 OS 时钟节拍(fac_ms),当大于这个值的时候,我们就通过调用 OS 的延时函数来实现(此时任务可以调度),不足 1 个时钟节拍的时候,直接调用 delay_us 函数实现(此时任务无法调度)。

    展开全文
  • 头文件Delay.h(网上很难找到的,建议下载后收藏,并放到keil的INC文件夹中,以后就可以直接调用了)
  • 计算机网络系列学习:Delay

    千次阅读 2015-09-30 01:21:45
    对网络传输过程中的各种延时进行整理。
  • delay的几个函数说明

    千次阅读 2019-06-20 13:08:52
    delay下面的主要函数是delay_init,delay_us和delay_ms。 非OS的时候,可以很简单 void delay_init(u8 SYSCLK) { SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); fac_us=SYSCLK/8; //每个us需要...
  • delay() 方法

    2019-06-16 02:14:06
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 一、 在线Cron表达式生成器 ...二、介绍 cronExpression定义时间规则,Cron表达式由6或7个空格分隔的时间字段组成:秒 分钟 小时 日期 月份 星期 年(可选); 字段 允许值 允许的特殊字符 秒 0-59 , - * / ...
  • Xilinx IODELAY动态延迟的调用

    千次阅读 2017-10-21 16:58:45
    Xilinx SELECTIO IP核调用配作可变输入延时时其信号接口如下表所示: 接口名 方向 注释 DATA_IN_FROM_PINS Input ...DELAY_BUSY Output IODELAY校准和相位变化正在进行忙信号 DELAY_CLK Input FPG
  • 按键精灵脚本-windows桌面自动化操作

    千次阅读 2017-03-16 11:10:19
    使用很简单,重复性的动作,点击录制,之后就会出现相应的代码,把延迟时间减少一些'==========...Delay 6000 LeftDoubleClick 1 Delay 78 MoveTo 528, 460 Delay 80 LeftDown 1 MoveTo 449, 460 Delay 80 LeftUp 1 Mov
  • defer、delay和postpone的区别?

    万次阅读 2017-09-08 11:04:34
    defer、delay和postpone的区别? (1)defer指「推迟」,一般属于主动或有计划的行为,例如: He decided to defer his departure for a week. 他決定推迟一星期启程。 (2)delay本意指「暂时阻挡」,但常...
  • scrapy中有一个参数:DOWNLOAD_DELAY 或者 download_delay 可以设置下载延时,不过Spider类被初始化的时候就固定了,爬虫运行过程中没发改变,随机延时,可以降低被封ip的风险 代码示例 random_delay_middleware...
  • jquery delay()延迟执行 认知

    万次阅读 2016-06-07 10:21:26
    功能需求:想做一个点击事件 然后... 所以想到了 jquery 里面的延迟执行函数delay();$('.radiobox').click(function(){ $('.login-info').fadeIn(300).delay(3000).fadeOut(400); });连续点击过程中发现:点击多少
  • SQL Server的WAITFOR DELAY注入

    千次阅读 2017-04-26 15:32:45
    SQL Server的WAITFOR DELAY注入
  • 自定义的delay()函数(C语言)

    千次阅读 2014-03-27 13:34:30
    #include void my_delay(long int delay_t) { clock_t start_time; //the start time start_time=clock(); while((clock()-start_time) }
  • set_max_delay

    千次阅读 2018-11-29 19:36:39
    现在的解决办法是使用set_max_delay 和set_min_delay来约束,但是这个延迟的值具体怎么计算,  set_output_delay为负值表示留的margin更大,对于hold更悲观; 对于setup更乐观。   我觉得如果是top level的话...
  • Task.Delay()方法

    万次阅读 2018-12-17 17:13:20
    Task.Delay方法只会延缓异步方法中后续部分执行时间,当程序执行到await表达时,一方面会立即返回调用方法,执行调用方法中的剩余部分,这一部分程序的执行不会延长。另一方面根据Delay()方法中的参数,延时对异步...
  • 取一个信号的上升沿或下降沿信号,可以通过将信号delay后,然后将原信号和delay信号,通过不同的与非操作,获取上升沿信号或下降沿信号: reg delay; // delay信号 always @ ( posedge clk or negedge rstn )  if...
1 2 3 4 5 ... 20
收藏数 309,454
精华内容 123,781
关键字:

delay