精华内容
下载资源
问答
  • unity中的简单延时方法

    千次阅读 2017-09-06 14:51:32
    在unity中我们经常会需要考虑一件事,如何让一个物体或者功能在特定的条件下出现,这时我们就可以考虑应用...下面需要讲的的是两次比较常见的延时方法,一个是unity自带的Invoke和InvokeRepeating,还有一个是协程。

    unity中的简单延时方法

        在unity中我们经常会需要考虑一件事,如何让一个物体或者功能在特定的条件下出现,这时我们就可以考虑应用延时的方式来解决,我们可以通过设定不同的时间点,让物体干不同的事情,从而达到想要的效果。下面需要讲的的是两种比较常见的延时方法,一个是unity自带的InvokeInvokeRepeating,还有一个是协程。

    一、场景的搭建

            首先我们先搭建一个简单的场景,为了达到直观的效果,我们先创建两个Cube,一个Cube用来验证Invoke和InvokeRepeating的方法,另一个用来验证协程。我们可以通过不同时间段改变Cube的材质来体现延时的效果。比如让Cube从初始的白色通过不同时间段,由白变红,再由红变黄,最后再变绿,通过改变颜色变换时需要的时间来达到延时效果。

    二、功能实现

    我们在其中一个Cube中添加一个自定义脚本delayedOne。

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class delayedOne : MonoBehaviour
    {
        public MeshRenderer skin;  //定义一个网格渲染器
    	void Start ()
        {
            skin = this.transform.GetComponent<MeshRenderer>();  //获取网格渲染器
            skin.material.color = Color.red;   //让物体材质变为红色
            Invoke("changeOne", 2f);           //延时方法
            // "changeOne", 2f, 1f);
        }
        private void changeOne()
        {
            skin.material.color = Color.yellow; //材质变为黄色
            Invoke("changeTwo", 3f);
        }
        private void changeTwo()
        {
            skin.material.color = Color.green;  //材质变为绿色
        }
    }

        在脚本中,主要用到Invoke这个延时方法。在使用Invoke这个方法之前,我们要先写一个延时的时候需要执行的方法,提供Invoke这个方法去调用别的方法来达到延时目的。Invoke的书写格式是在括号里添加需要调用的方法的方法名,后边跟着延时的时间。在脚本中我添加了2秒的时间,系统就会在过完2秒后执行changeOne方法,让物体材质变黄。别的方法里也可以添加Invoke方法,能达到嵌套的效果。而InvokeRepeating方法里多加了一个时间,那个时间指定的是重复执行方法的时间间隔。

    在另一个Cube中添加自定义脚本delayedTwo。

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class delayedTwo : MonoBehaviour
    {
        public MeshRenderer skin;
    	void Start ()
        {
            skin = this.transform.GetComponent<MeshRenderer>();
            skin.material.color = Color.red;
            StartCoroutine("changeSkin");  //开始协程
    	}
    
        IEnumerator changeSkin()  //协程方法
        {
            yield return new WaitForSeconds(2f);  //暂停协程,2秒后执行之后的操作
            skin.material.color = Color.yellow;
            yield return new WaitForSeconds(3f);  //3秒后执行之后的操作
            skin.material.color = Color.green;
        }
    }
    
        在脚本中主要运用协程来控制延时方法,要想使用协程先写方法,以IEnumerator开头,自定义名字,在方法中用yield return new WaitForSeconds()来暂停协程,括号里填时间,设定多少秒后执行之后的操作。脚本中先暂停协程,2秒后开始执行材质变黄操作,之后暂停3秒后执行材质变绿操作。协程方法写完后就是启动协程,用StartCoroutine加方法名来启动协程。

    三、验证结果

            运行程序,通过观察我们可以看出虽然使用的方法不同,但两个Cube所体现的效果是相同的。

            

    两个Cube同时从红变为黄再变为绿,两种不同的方法由于设定的延时相同,就能达到同样的效果。

    四、总结

    总之,unity中常用的延时方法就这两种,在Invoke方法中确定了调用方法,在确定延时时间就能实现延时功能,而协程也是通过调用方法,确定暂停协程的时间来达到延时效果,只要确定了延时的时间,我们便能通过调用方法来实现延时。

        

    展开全文
  • 编写延时函数的简单方法

    千次阅读 2019-08-13 10:42:35
    过程参考如下: 在编译器下建立一个新项目,也可以利用已有项目。...编写一段关于延时的函数,主要利用for循环,代码如下: void delay_ms(unsigned int ms) { unsigned int i; unsigned char j; for(i=0...

    过程参考如下:

    在编译器下建立一个新项目,也可以利用已有项目。此过程中需要注意,单片机晶振的选择,因为for循环里指令的执行时间和晶振有直接关系,本例中晶振使用11.0592M。

    编写一段关于延时的函数,主要利用for循环,代码如下:

    void delay_ms(unsigned int ms)

    {

    unsigned int i;

    unsigned char j;

    for(i=0;i

    {

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

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

    }

    }

    其中ms是输入参数,如果输入1,就是要求程序延时1ms。

    j变量是调整程序运行的时间参数。调整j的数值,使1次循环的时间在1ms。

    将此程序编译通过,然后利用软件仿真,调整时间。

    下面这个sec就是程序运行到现在的这一行所用的时间。

    两次时间差就是延时函数使用的时间,如果与1ms相差比较多,用户可以调整j参数的值,使延时时间尽量接近1ms。如增大j的值for(j=0;j<105;j++);

    此方法得出延时函数,在晶振不同的情况下,延时时间会不准。软件调试结果,这个程序的延时时间为:1.01779ms,一般的单片机系统中都可以应用。

    下面来说说汇编的传统计算方法:

    指令周期、机器周期与时钟周期

    指令周期:CPU执行一条指令所需要的时间称为指令周期,它是以机器周期为单位的,指令不同,所需的机器周期也不同。

    时钟周期:也称为振荡周期,一个时钟周期 =晶振的倒数。

    MCS-51单片机的一个机器周期=6个状态周期=12个时钟周期。

    MCS-单片机的指令有单字节、双字节和三字节的,它们的指令周期不尽相同,一个单周期指令包含一个机器周期,即12个时钟周期,所以一条单周期指令被执行所占时间为12*(1/12000000)=1us。

    了解了上面这些我们来看一个例子

    ;============延时1秒子程序========================

    DELAY_1S: ;延时子程序,12M晶振延时1.002035秒

    MOV R4,#10

    L3: MOV R2 ,#200 ;1指令周期

    L1: MOV R3 ,#249 ;1指令周期

    L2: DJNZ R3 ,L2 ;2指令周期

    DJNZ R2 ,L1 ;2指令周期

    DJNZ R4 ,L3 ;2指令周期

    RET ;2指令周期

    ;循环体延时时间: [(249*2+1+2)*200+1+2]*10*12/12000000=1.002030s

    ;加上ACALL指令和第一条mov指令以及最后一条RET指令算出来整个函数的时间为1.002035s

    ;================================================

    通常选用的是11.0592MHZ的晶振:

    [(249*2+1+2)*200+1+2]*10*12/11059200=1.08727213541666666...S

    汇编延时子程序的延时计算问题

    对于程序

    DELAY: MOV R0,#00H

    DELAY1: MOV R1,#0B3H

    DJNZ R1,$

    DJNZ R0,DELAY1

    查指令表可知 MOV一个机器周期,DJNZ 指令需用两个机器周期,而一个机器周期时间长度为12/11.0592MHz,所以该段程序执行时间为:

    ((0B3×2+1+2)×256+1)×12÷11059200=100.2789mS

    第一层:DJNZ R1,$:执行了B3H次,一次两个周期,所以为0B3×2;

    第二层:MOV R1,#0B3H为一个周期,DJNZ R0,DELAY1为两个周期,这样循环一次就是0B3×2+1+2个周期;第二层的执行次数本来是255次,但因为赋首值为0,而DJNZ是先减1,再比较的,所以就应该是256次。

    这样的话,整个循环执行完应该是(0B3×2+1+2)×256+1次。再加上开始赋值这一句,就是((0B3×2+1+2)×256+1)了

    还说明一下:

    nop指令或者_nop_(); 函数占一个机器周期,在stc单片机的12T模式下一个机器周期是一个振荡周期的12分频,如果你的晶振是12MHZ,那你的一个机器周期就是1微秒.一个nop指令的执行时间也就是1US

    当在6T模式(下载的时候可选择模式)下12M晶振的时候,一个nop就是0.5US了.

    展开全文
  • QT延时方法

    万次阅读 2017-03-22 13:13:33
    (转自: ...) ...void QTimer::singleShot ( int msec, QObject * receiver, const char* member ) [static]  ...//6为需要延时的秒数 ...我们可以对这两个函数进行简单的封装,从而达到真正的sleep的作用。

    (转自:http://blog.sina.com.cn/s/blog_613cfe940100kacm.html

    1、

    void sleep(unsigned int msec)
    {
        QTime dieTime = QTime::currentTime().addMSecs(msec);
        while( QTime::currentTime() < dieTime )
            QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

     

    2、

    void QTimer::singleShot ( int msec, QObject * receiver, const char* member ) [static]  

    样例:
     #include<QApplication>
     #include<QTimer>
     int main(int argc, char *argv[])
     {
      QApplication app(argc, argv);
      QTimer::singleShot(600000,&app, SLOT(quit()));
      ...
      return app.exec();
     }

    3、以毫秒计

        QTime n=QTime::currentTime();
        QTime now;
        do{
             qDebug()<<"jjmm";
            now=QTime::currentTime();
        }   while(n.msecsTo(now)<=1);


    4、以秒计

    QDateTime n2=QDateTime::currentDateTime();
      QDateTime now;
      do{
      now=QDateTime::currentDateTime();
      } while(n2.secsTo(now)<=6);//6为需要延时的秒数

    5、tingsking18(http://blog.csdn.net/tingsking18/article/details/5304254)

    关于sleep函数,我们先来看一下他的作用:sleep函数是使调用sleep函数的线程休眠,线程主动放弃时间片。当经过指定的时间间隔后,再启动线程,继续执行代码。sleep函数并不能起到定时的作用,主要作用是延时。在一些多线程中可能会看到sleep(0);其主要目的是让出时间片。sleep函数的精度非常低,当系统越繁忙的时候它精度也就越低,有时候我们休眠1秒,可能3秒后才能继续执行。它的精度取决于线程自身优先级、其他线程的优先级,以及线程的数量等因素,所以说sleep函数是不能用来精确计时的。

    Qt为我们提供了几个可以用于线程Sleep的函数,分别是:

    void QThread::sleep ( unsigned long secs )   [static protected]

    void QThread::msleep ( unsigned long msecs )   [static protected]

    void QThread::usleep ( unsigned long usecs )   [static protected]

    sleep的单位分别是秒、毫秒、微秒。

    但是现在问题出来了,请仔细看上面的函数定义,函数的访问权限都是protected,这就意味着,我们必须在QThread或者他的继承类中使用这三个函数。

    但是我们可能需要在非继承QThread的类中来使用sleep函数。那这该这么办呢?下面我就给大家提供几种解决方法。

     

     

    1.    processEvents

        QTime dieTime = QTime::currentTime().addMSecs(svalue);

        while( QTime::currentTime() < dieTime )

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);

    调用processEvents会让Qt继续处理线程所在的消息队列中未处理的消息,直到消息队列中没有消息可以处理。当进行长时间的操作的时候可以调用此函数(比方说拷贝文件)。这个函数可能和我们要使用msleep的本意有差别,但是使用它可以在svalue时间内处理events,从而达到类似sleep的目的。

     

    2.        QWaitCondition

           QWaitCondition wait;

           wait.wait(time);

    wait的单位是milliseconds,但是wait和sleep的作用是不同的。

    sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后,线程不一定立即恢复执行。这是因为在那个时刻,其它线程可能正在运行而且没有被调度为放弃执行,除非

    (a)“醒来”的线程具有更高的优先级。

    (b)正在运行的线程因为其它原因而阻塞。

    wait()会使调用它的线程暂停执行,被调对象进入等待状态,直到被唤醒或等待时间到。

     

    3. 查看sleep的源代码,使用Qt在win下和*nix下的sleep函数

    Windows下的sleep的代码为:

    void QThread::sleep(unsigned long secs)

    {

        ::Sleep(secs * 1000);

    }

    sleep的单位为秒。

     

    linix下sleep的代码为:

    void QThread::sleep(unsigned long secs)

    {

        struct timeval tv;

        gettimeofday(&tv, 0);

        struct timespec ti;

        ti.tv_sec = tv.tv_sec + secs;

        ti.tv_nsec = (tv.tv_usec * 1000);

        thread_sleep(&ti);

    }

     

    static void thread_sleep(struct timespec *ti)

    {

        pthread_mutex_t mtx;

        pthread_cond_t cnd;

     

        pthread_mutex_init(&mtx, 0);

        pthread_cond_init(&cnd, 0);

     

        pthread_mutex_lock(&mtx);

        (void) pthread_cond_timedwait(&cnd, &mtx, ti);

        pthread_mutex_unlock(&mtx);

     

        pthread_cond_destroy(&cnd);

        pthread_mutex_destroy(&mtx);

    }

    我们可以对这两个函数进行简单的封装,从而达到真正的sleep的作用。

    展开全文
  • STM32延时函数的四种方法

    万次阅读 2020-06-12 10:01:15
    这个比较简单,让单片机做一些无关紧要的工作来打发时间,经常用循环来实现,在某些编译器下,代码会被优化,导致精度较低,用于一般的延时,对精度不敏感的应用场景中。 //微秒级的延时 void

    目录

    1、普通延时

    2、定时器中断

    3、查询定时器

    4、汇编指令


    单片机编程过程中经常用到延时函数,最常用的莫过于微秒级延时delay_us()和毫秒级delay_ms()。本文基于STM32F207介绍4种不同方式实现的延时函数。

    1、普通延时

    这种延时方式应该是大家在51单片机时候,接触最早的延时函数。这个比较简单,让单片机做一些无关紧要的工作来打发时间,经常用循环来实现,在某些编译器下,代码会被优化,导致精度较低,用于一般的延时,对精度不敏感的应用场景中。

    //微秒级的延时
    void delay_us(uint32_t delay_us)
    {    
      volatile unsigned int num;
      volatile unsigned int t;
    
      
      for (num = 0; num < delay_us; num++)
      {
        t = 11;
        while (t != 0)
        {
          t--;
        }
      }
    }
    //毫秒级的延时
    void delay_ms(uint16_t delay_ms)
    {    
      volatile unsigned int num;
      for (num = 0; num < delay_ms; num++)
      {
        delay_us(1000);
      }
    }

    上述工程源码仓库:https://github.com/strongercjd/STM32F207VCT6/tree/master/02-Template

    2、定时器中断

    定时器具有很高的精度,我们可以配置定时器中断,比如配置1ms中断一次,然后间接判断进入中断的次数达到精确延时的目的。这种方式精度可以得到保证,但是系统一直在中断,不利于在其他中断中调用此延时函数,有些高精度的应用场景不适合,比如其他外设正在输出,不允许任何中断打断的情况。

    STM32任何定时器都可以实现,下面我们以SysTick 定时器为例介绍:

    初始化SysTick 定时器:

    /* 配置SysTick为1ms */
    RCC_GetClocksFreq(&RCC_Clocks);
    SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);

    中断服务函数:

    void SysTick_Handler(void)
    {
      TimingDelay_Decrement();
    }
    void TimingDelay_Decrement(void)
    {
      if (TimingDelay != 0x00)
      { 
        TimingDelay--;
      }
    }

    延时函数:

    void Delay(__IO uint32_t nTime)
    {
      TimingDelay = nTime;
      while(TimingDelay != 0);
    }

    上述工程源码仓库:https://github.com/strongercjd/STM32F207VCT6/tree/master/02-Template

    3、查询定时器

    为了解决定时器频繁中断的问题,我们可以使用定时器,但是不使能中断,使用查询的方式去延时,这样既能解决频繁中断问题,又能保证精度。

    STM32任何定时器都可以实现,下面我们以SysTick 定时器为例介绍。

    STM32的CM3内核的处理器,内部包含了一个SysTick定时器,SysTick是一个24位的倒计数定时器,当计到0时,将从RELOAD寄存器中自动重装载定时初值。只要不把它在SysTick控制及状态寄存器中的使能位清除,就永不停息。

    SYSTICK的时钟固定为HCLK时钟的1/8,在这里我们选用内部时钟源120M,所以SYSTICK的时钟为(120/8)M,即SYSTICK定时器以(120/8)M的频率递减。SysTick 主要包含CTRL、LOAD、VAL、CALIB 等4 个寄存器。

                                           ▼CTRL:控制和状态寄存器

                                           ▼LOAD:自动重装载除值寄存器

                                            ▼VAL:当前值寄存器

                                     ▼CALIB:校准值寄存器

    使用不到,不再介绍

    示例代码

    void delay_us(uint32_t nus)
    {
      uint32_t temp;
      SysTick->LOAD = RCC_Clocks.HCLK_Frequency/1000000/8*nus;
      SysTick->VAL=0X00;//清空计数器
      SysTick->CTRL=0X01;//使能,减到零是无动作,采用外部时钟源
      do
      {
        temp=SysTick->CTRL;//读取当前倒计数值
      }while((temp&0x01)&&(!(temp&(1<<16))));//等待时间到达
      SysTick->CTRL=0x00; //关闭计数器
      SysTick->VAL =0X00; //清空计数器
    }
    void delay_ms(uint16_t nms)
    {
      uint32_t temp;
      SysTick->LOAD = RCC_Clocks.HCLK_Frequency/1000/8*nms;
      SysTick->VAL=0X00;//清空计数器
      SysTick->CTRL=0X01;//使能,减到零是无动作,采用外部时钟源
      do
      {
        temp=SysTick->CTRL;//读取当前倒计数值
      }while((temp&0x01)&&(!(temp&(1<<16))));//等待时间到达
      SysTick->CTRL=0x00; //关闭计数器
      SysTick->VAL =0X00; //清空计数器
    }

    上述工程源码仓库:https://github.com/strongercjd/STM32F207VCT6/tree/master/04-Delay

    4、汇编指令

    如果系统硬件资源紧张,或者没有额外的定时器提供,又不想方法1的普通延时,可以使用汇编指令的方式进行延时,不会被编译优化且延时准确。

    STM32F207在IAR环境下

    /*!
     *  @brief 	软件延时 
     *  @param	ulCount:延时时钟数
     *  @return none
     *	@note 	ulCount每增加1,该函数增加3个时钟
     */
    void SysCtlDelay(unsigned long ulCount)
    {
        __asm("    subs    r0, #1\n"
              "    bne.n   SysCtlDelay\n"
              "    bx      lr");
    }

    这3个时钟指的是CPU时钟,也就是系统时钟。120MHZ,也就是说1s有120M的时钟,一个时钟也就是1/120 us,也就是周期是1/120 us。3个时钟,因为执行了3条指令。

    使用这种方式整理ms和us接口,在Keil和IAR环境下都测试通过。

    /*120Mhz时钟时,当ulCount为1时,函数耗时3个时钟,延时=3*1/120us=1/40us*/
    /*
    SystemCoreClock=120000000
    
    us级延时,延时n微秒
    SysCtlDelay(n*(SystemCoreClock/3000000));
    
    ms级延时,延时n毫秒
    SysCtlDelay(n*(SystemCoreClock/3000));
    
    m级延时,延时n秒
    SysCtlDelay(n*(SystemCoreClock/3));
    */
    
    #if defined   (__CC_ARM) /*!< ARM Compiler */
    __asm void
    SysCtlDelay(unsigned long ulCount)
    {
        subs    r0, #1;
        bne     SysCtlDelay;
        bx      lr;
    }
    #elif defined ( __ICCARM__ ) /*!< IAR Compiler */
    void
    SysCtlDelay(unsigned long ulCount)
    {
        __asm("    subs    r0, #1\n"
           "    bne.n   SysCtlDelay\n"
           "    bx      lr");
    }
    
    #elif defined (__GNUC__) /*!< GNU Compiler */
    void __attribute__((naked))
    SysCtlDelay(unsigned long ulCount)
    {
        __asm("    subs    r0, #1\n"
           "    bne     SysCtlDelay\n"
           "    bx      lr");
    }
    
    #elif defined  (__TASKING__) /*!< TASKING Compiler */                           
    /*无*/
    #endif /* __CC_ARM */

    上述工程源码仓库:https://github.com/strongercjd/STM32F207VCT6/tree/master/03-ASM

     

    备注:

    理论上:汇编方式的延时也是不准确的,有可能被其他中断打断,最好使用us和ms级别的延时,采用for循环延时的函数也是如此。采用定时器延时理论上也可能不准确的,定时器延时是准确的,但是可能在判断语句的时候,比如if语句,判断延时是否到了的时候,就在判断的时候,被中断打断执行其他代码,返回时已经过了一小段时间。不过汇编方式和定时器方式,只是理论上不准确,在实际项目中,这两种方式的精度已经足够高了。

     

    点击查看本文所在的专辑,STM32F207教程

     

    关注公众号,第一时间收到文章更新。评论区不能及时看到,需要交流可以到公众号沟通

    展开全文
  • golang利用redis实现简单延时队列

    千次阅读 2019-05-08 19:45:57
    利用zadd将数据添加到zset中,每个数据的score值设置为数据的延时时间+当前时间戳,后台goroutine不断zrange轮询zset,取出score值小于当前时间戳的数据,然后再对数据进一步处理,这样就实现了简单延时队列的功能。...
  • 批处理延时方法

    千次阅读 2011-05-15 22:46:00
    <br />转自:http://josephdong.blog.163.com/blog/static/17743897200941435746574/<br />举个例子,我们要延时5秒打开gdh.txt这个文件,可以用以下几个方法 方法一:ping  缺点:时间精度为1秒,...
  • ARM 汇编 简单延时函数心得

    千次阅读 2019-10-31 19:50:25
    最近在学习arm开发板,记录下学习的心得,也以防自己以后忘记了, 方便自己回顾旧知识,同时也希望该篇文章能帮助到有需要的朋友。...delay: //延时函数的函数名 ldr r2, =0xfffff //伪指令,把r3赋值为0xfffff ...
  • 一种Cortex-M内核中的精确延时方法

    千次阅读 热门讨论 2018-11-10 20:37:39
    本文介绍一种Cortex-M内核中的精确延时方法 前言 为什么要学习这种延时的方法? 多时候我们跑操作系统,就一般会占用一个硬件定时器——SysTick,而我们一般操作系统的时钟节拍一般是设置100-1000HZ,也就是1ms...
  • 测量图像传输延时的一个简单方法

    千次阅读 2020-03-11 19:19:51
    0. 背景 在有opencv的环境下,使用某家的云远程传输图像 using namespace cv; //计算当前时间 double t; t = (double)getTickCount()/ getTickFrequency();... 有更方便的测量图像传输延迟的方法,欢迎大神们留言!
  • qt延时 QT中简单延时办法

    万次阅读 2014-07-08 11:04:51
    来自 http://www.qtgtk.com/qt延时-qt中简单延时办法/ QEventLoop eventloop; QTimer::singleShot(time, &eventloop, SLOT(quit())); eventloop.exec(); 其中time代表延时时长。若QEventLoop是跨...
  • Android 延时执行任务的三种简单方法

    千次阅读 2017-01-20 10:02:30
    开启一个新的线程 new Thread() { @Override public void run() { try { Thread.sleep
  • VxWorks几种常用的延时方法

    千次阅读 2019-04-29 10:12:19
    嵌入式系统中,一个任务往往需要在特定的延时之后执行一个指定的动作,比如等待外设以确保数据可靠,控制扬声器发声时间以及串口通信...taskdelay()提供了一个简单的任务睡眠机制,也常用于需要定时/延时机制的应用...
  • C++常用的延时方法

    千次阅读 2017-05-11 10:04:12
    (—)使用_sleep()函数  #include using namespace std;...//延时5秒  (二)使用Delay(int time)函数  #include void Delay(int time)//time*1000为秒数  {  clock_t now = clock
  • STM32的几种延时方法

    千次阅读 2018-08-05 16:33:19
    这个比较简单,让单片机做一些无关紧要的工作来打发时间,经常用循环来实现,不过要做的比较精准还是要下一番功夫。下面的代码是在网上搜到的,经测试延时比较精准。 //粗延时函数,微秒 void delay_us(u16...
  • 1 taskDelay taskDelay(n)使调用该函数的任务延时n个tick(内核时钟周期)。该任务在指定的时间内主动放弃CPU,...在没有中断触发时,taskDelay 能方便地实现,且不影响系统整体性能。例如写数据至EEPROM,EEPROM需
  • C++中一种常用的简单延时子程序!

    千次阅读 2018-06-14 10:07:19
    1. 最简单最笨的方法,就是利用for循环的方式,即让编译器多次执行循环步骤,把时间浪费在数数的过程中。代码如下:#include&lt;iostream&gt; using namespace std; void main() { char BELL = '\a'; //...
  • 安卓延时方法(推荐第三种)

    千次阅读 2019-03-27 11:05:07
    后记:第一种我运行程序崩溃了,第二种需要catch exception,第三种完美运行,强推 后后记:第一种崩溃的原因是我在非... 很简单的一种我才用的,一共有三种,今天先写第一种吧1、TimeerTask(定时器) Timer timer...
  • 通过实际项目的练习,掌握了几种android基本定时器和延时的用法,这里我想总结一下作为自己的收获,下面列出的是比较简洁的模式,方便简单地在程序中直接调用。 一、三种常用的定时器 1.Handler类的postDelayed...
  • STM32 在RVMDK下简单延时计算

    千次阅读 2011-10-14 16:43:58
    为了改写ARF2496K无线2.4G驱动,需要移植到STM32主控上来,所以就想先简单的控制 I/O 时序,去完成这个实验。 第一步先完成寄存器的读写,第二步便完成正常收发,而且暂时不用考虑移植到UCOSII。 查看了ARF2496K ...
  • 有时会有这样的需求,比如人物死亡之后5秒尸体消失、子弹的痕迹10秒之后消失…… 我们怎么可以方便的延时调用我们自己写的函数呢? 以下代码用两种方式延时执行自定义函数。一种是Invoke函数,另一种是协程。 using ...
  • 延时方法及其定时精度分析

    千次阅读 2006-08-09 17:21:00
    Delphi中,通常可以用以下三种方法来实现程序的延时,即TTtimer控件,Sleep函数,GetTickCount函数。但是其精度是各不相同的。 一、三种方法简单介绍 1)TTtimer控件 TTtimer控件的实质是调用Windows API定时...
  • 写几个简单延时函数

    千次阅读 2014-07-17 11:58:59
    因为主频为16MHz //16-bit count, 4 cycles/loop ...根据上篇的延时写几个简单延时函数 void delay_1us(void) //延时1us {  _delay_loop_2(4); } void delay_us(unsigned int n) //延时nus {  unsigned
  • VB.NET的几种延时方法

    万次阅读 2016-12-27 14:48:38
    优点: 简单 缺点: Sleep期间程序(其实是该线程)没有任何响应。 2. Timer(定时器)  定时器有3种。Forms.Timer/ Timers.Timer/ Threading.Timer  第一种是在当前线程启动事件处理,第二种在事件发生...
  • VB 里常用的延时方法

    千次阅读 2015-06-17 17:01:02
    这种方法虽然也很简单,但却有有一个致命缺陷,那就是Timer函数返回的是从午夜开始到现在经过的秒数。所以Timer返回的最大值也只是60*60*24-1秒,如果从一天的23:59:58秒开始计时等待5秒,那么程序会永远地循环下去。要...
  • 多图像合成为延时视频的方法

    千次阅读 2020-06-13 15:05:22
    听起来容易吗?实际上可能会有些棘手。 如何在Mac上制作定时录像 如果您有一堆照片-所有这些都必须编辑-将它们变成逻辑的视觉流程并不是那么简单。有些相机具有延时功能,但是在处理成千上万张图像时,您需要一个...
  • setUserVisibleHint方法实现延时加载
  • STM32延时函数的三种方法:普通延时、SysTick 定时器延时(1.中断方式;2.非中断方式)   单片机编程过程中经常用到延时函数,最常用的莫过于微秒级延时delay_us( )和毫秒级delay_ms( )。 1.普通延时法 (1)...
  • vb延时的几种方法

    万次阅读 2017-09-22 10:09:00
    作者:iamlaosong1、一般延时一个应用接口需要限制运行速度,需要在循环中加个延时函数,这个延时不需要多么精确,要求有个几秒延时,网上用的比较多的就是用Timer函数编写,Timer是VBA自带的函数,用起来比较方便,...
  • STM32实现毫秒级精确延时方法

    千次阅读 2020-12-16 22:49:00
    使用MCU内核寄存器实现毫秒级精确延时方法 在进行STM32进行开发时,使用到延时函数的频率非常高,但HAL库只提供了毫秒级的延时函数,最小延时时间是1ms,在某些应用场合下不能达到要求。下面这种方法可达到毫秒级...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,631
精华内容 46,252
关键字:

很简单的延时方法