delay_delayqueue - CSDN
  • 在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函数

    2018-04-18 10:28:57
    在VC中使用带上头文件 #include &lt;windows.h&gt; 注意: 在VC中Sleep中的第一个英文字符为大写的"S" 在标准C中是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.h(网上很难找到的,建议下载后收藏,并放到keil的INC文件夹中,以后就可以直接调用了)
  • 例如,要写一个延迟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

    展开全文
  • Delay line 延迟线 今天我们将讨论 Delay 和 Vibrato 两种音频特效的技术原理和实现细节。 Delay 和 Vibrato 都是基于 Delay line 实现的。Delay line 作为音频特效中重要的基础组件,它很容易实现,并且稍作修改就...

    Delay line 延迟线

    今天我们将讨论 Delay 和 Vibrato 两种音频特效的技术原理和实现细节。

    Delay 和 Vibrato 都是基于 Delay line 实现的。Delay line 作为音频特效中重要的基础组件,它很容易实现,并且稍作修改就能够应用实现于不同的音效。

    Delay line 非常简单,它能功能是将一个信号进行延迟。通过使用多条 delay line,并加以不同的信号延迟,然后将这些信号相加在一起,我们就能够创建大量的音频特效。

    在模拟信号中,delay line 的实现相当复杂,需要引入物理扩展(例如弹簧)来延迟波的传播。

    在数字信号中,delay line 通常使用 ”循环缓冲区” 的数据结构来实现延迟。循环缓冲区本质上可以用一个数组实现,用一个索引来指向下一个存放信号的位置,当索引超过缓冲区大小时,将其重新置于开始位置。这样一来,就像往一个圈里顺时针填数据,当我们需要延迟信号时,计算逆时针回退的个数即可。

    下面是 delay line 的一种实现,更多细节大家可以参看代码

    template <typename T>
    class DelayLine
    {
    public:
        void clear() noexcept
        {
            std::fill(raw_data_.begin(), raw_data_.end(), T(0));
        }
        /**
         * return the size of delay line
         */
        size_t size() const noexcept
        {
            return raw_data_.size();
        }
    
        /**
         * resize the delay line
         *
         * @note resize will clears the data in delay line
         */
        void resize(size_t size) noexcept
        {
            raw_data_.resize(size);
            least_recent_index_ = 0;
    
            clear();
        }
    
        /**
         * push a value to delay line
         */
        void push(T value) noexcept
        {
            raw_data_[least_recent_index_] = value;
            least_recent_index_ = (least_recent_index_ == 0) ? (size() - 1):(least_recent_index_ - 1);
        }
    
        /**
         * returns the last value
         */
        T back() const noexcept
        {
            return raw_data_[(least_recent_index_ + 1) % size()];
        }
    
        /**
         * returns value with delay
         */
        T get(size_t delay_in_samples) const noexcept
        {
            return raw_data_[(least_recent_index_ + 1 + delay_in_samples) % size()];
        }
        
         /**
         * Returns interpolation value
         */
        T getInterpolation(float delay) const noexcept
        {
            int previous_sample = static_cast<int>(std::floorf(delay));
            int next_sample = static_cast<int>(std::ceilf(delay));
            float fraction = static_cast<float>(next_sample) - delay;
    
            return fraction*get(previous_sample) + (1.0f-fraction)*get(next_sample);
        }
    
        /**
         * set value in specific delay
         */
        void set(size_t delay_in_samples, T new_val) noexcept
        {
            raw_data_[(least_recent_index_ + 1 + delay_in_samples) % size()] = new_val;
        }
    
    private:
        size_t least_recent_index_{0};
        std::vector<T> raw_data_;
    };
    

    Delay 延迟

    Delay 音效非常简单,但应用非常广泛。最简单的情况下,将声音进行延迟并与原始信号相加就可以使的乐器的声音更加生动活泼,或者用更长时间的延迟,来达到二重奏的效果。很多熟悉的音效(例如 Chorus、Flanger、Vibrato 和 Reverb)也是基于 Delay 实现的。

    Basic Delay 基本延迟

    Basic delay 会在指定延迟时间后播放音频。根据应用的不同,延迟时间可能从几毫秒到几秒,甚至更长。这里是一小段 basic delay 算法结果。Basic delay 通常也被称为 Echo(回声)效果。
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o4pYgOua-1583193401645)(音频特效:Delay 和 Vibrato.resources/C3053E8A-7537-47F9-89CB-45891AEC396E.png)]

    Basic delay 算法原理部分很简单,通常是将带有延迟的信号与原始信号相加。其中 y[n]y[n] 表示输出信号,x[n]x[n]表示原始信号,NN表示延迟(单位是采样个数),gg表示延迟信号的增益
    y[n]=x[n]+gx[nN] y[n] = x[n] + gx[n - N]

    利用 Z 变换,得到传递函数为:

    Y(z)=X(z)+gzNX(z)H(z)=Y(z)X(z)=1+gzN=zN+gzN \begin{aligned} Y(z) &= X(z) + gz^{-N}X(z) \\ H(z) &= \frac{Y(z)}{X(z)} = 1+gz^{-N} = \frac{z^N+g}{z^N} \end{aligned}

    因为传递函数 H(z)H(z) 的所有极点都在单位圆内,因此 basic delay 在所有情况下都是稳定的。

    Dalay with Feedback 反馈延迟

    Basic delay 使用场景比较受限,因为它仅仅产生单个回声。大多数音频延迟单元还具有反馈控制,它能够将延迟输出的信号再发送到输入,如下图。反馈使声音不断重复,如果反馈增益小于 1,那么每次回声都会变得更加安静。从理论上讲,回声将永远重复,但它们最终会变得非常安静,以至于你无法听到。
    delay with feedback
    根据上图,我们可以写出反馈延迟的差分方程:
    y[n]=x[n]+gffd[n]whered[n]=x[nN]+gfbd[nN] y[n] = x[n] + g_{ff}d[n] \quad \text{where} \quad d[n] = x[n-N] + g_{fb}d[n-N]
    然后可以转换为只与 y[n]y[n]x[n]x[n] 相关差分方程:
    y[nN]=x[nN]+gffd[nN]d[n]=gfbgffy[nN]+(1gfbgffx[nN])y[n]=gfby[nN]+x[n]+(gffgfb)x[nN] \begin{aligned} y[n-N] &= x[n-N] + g_{ff}d[n-N] \\ d[n] &= \frac{g_{fb}}{g_{ff}}y[n-N] + (1-\frac{g_{fb}}{g_{ff}}x[n-N])\\ y[n] &= g_{fb}y[n-N] + x[n] + (g_{ff} - g_{fb})x[n-N] \end{aligned}
    计算其传递方程:
    H(z)=Y(z)X(z)=zN+gffgfbzNgfb H(z) = \frac{Y(z)}{X(z)} = \frac{z^N + g_{ff} - g_{fb}}{z^N-g_{fb}}
    因此,系统的极点在 gfbN\sqrt[N]{g_{fb}},这就说明当 gfb<1\vert g_{fb}\vert < 1 时系统是稳定的。这个结果符合直觉,因为只有反馈增益小于1时,回声才会随着时间越来越小。

    这里是反馈延迟的算法输出。可以听到反馈延迟效果很像我们在大山里喊叫的效果,比起 basic delay,反馈延迟有多次回声,每次回声音量逐渐变小。

    反馈延迟的实现大致如下,通过 delay line 来获取延迟信号,并且往 delay line 中记录带有反馈的信号。如果 feedback 为0,那么反馈延迟将退化为 basic delay。

    void DelayEffect::processBlock(AudioBuffer<float> &buffer)
    {
        const int num_channels = buffer.getNumChannels();
        const int num_samples = buffer.getNumSamples();
    
        for(int c = 0; c < num_channels; ++c)
        {
            float* channel_data = buffer.getWritePointer(c);
            auto& dline = dlines_[c];
            size_t delay_samples = delay_length_in_sample_[c];
    
            for(int i = 0; i < num_samples; ++i)
            {
                const float in = channel_data[i];
                const float delay_val = dline.get(delay_samples);
                float out = 0.0f;
    
                out = (dry_mix_ * in + wet_mix_ * delay_val);
    
                dline.push( in + feedback_ * delay_val);
    
                channel_data[i] = out;
            }
        }
    }
    

    Vibrato 颤音

    颤音指的是音调周期性微小变化。传统意义上,颤音并不是音效效果,而是歌手和乐器演奏者使用的一种技术。例如在小提琴上,通过在指板上有节奏地前后摇动手指,稍微改变琴弦的长度来产生颤音。但是在音频信号中,我们可以使用调制的 delay line 来实现颤音。

    前面提到的两种延迟算法,它们的延迟长度是固定,不随时间变化的那种。颤音与它们最大的不同在于其延迟长度随着时间变化而变化,而这种变化会导致音调的变化,这里我们举个例子来说明,假设:
    M[n]=MmaxΔmn M[n] = M_{max}-\Delta m * n

    这时候 :
    y[n]=x[nMmax+Δmn]=x[(1+Δm)nMmax] y[n] = x[n-M_{max} + \Delta m * n] = x[(1+\Delta m)*n - M_{max}]

    在这里插入图片描述

    也就是说,原来信号频率提升了 1+Δm1+\Delta m 倍。如果 Δm<0\Delta m < 0 那就是降低了频率
    频率的变化和 MmaxM_{max} 无关,只和 Δm\Delta m 有关

    fration[n]=f(1+Δm)f=1+Δm=1(M[n]M[n1]) f_{ration}[n] = \frac{f*(1+\Delta m)}{f} = 1+\Delta m = 1 - (M[n] - M[n-1])

    Low-Frequency Oscillator 低频振荡器

    为了达到颤音的效果,我们需要模拟那种音调周期性变化的感觉,而延迟长度的变化会引起音调变化,因此如果我们让延迟长度发生周期性变化,那么音调也是周期性变化的。

    为了延迟的长度周期性变化,我们可以用一个低频振荡器(Low-Frequency Oscillator; LFO)来控制它,以正弦 LFO 为例,公式为:
    M[n]=Wsin(2πnf/fs) M[n] = W\sin(2\pi nf/f_s)
    其中,WW调节变换的范围;ff是 LFO 的频率,影响音调的变化周期;fsf_s表示采样率。音调的变化可以计算为:
    M[n]M[n1]=W(sin(2πnf/fs)sin(2π(n1)f/fs))2πfWcos(2πnf/fs) \begin{aligned} M[n] - M[n-1] &= W(\sin(2\pi nf/f_s) - \sin(2\pi(n-1)f/f_s)) \\ &\approx 2\pi fW\cos(2\pi nf/f_s) \\ \end{aligned}
    fration[n]=1(M[n]M[n1])12πfWcos(2πnf/fs) f_{ration}[n] = 1 - (M[n] - M[n-1]) \approx 1 - 2\pi fW\cos(2\pi nf/f_s)
    因此音调的变化是个周期函数,一会上一会下的。

    这里是颤音算法的输出结果,颤音应用到人声上会产生一种滑稽的效果,挺有趣的。

    颤音的实现大致如下,通过 lfo 来得到延迟的长度,根据长度从 delay line 中获取数据。有一点与之前不同的是,当延迟长度不是整数时,我们采用了插值的方法,这样可以让信号更加平滑。

    void VibratoEffect::processBlock(AudioBuffer<float> &buffer) {
        const int num_channels = buffer.getNumChannels();
        const int num_samples = buffer.getNumSamples();
        float phase = 0.0f;
    
        assert(num_channels <= dlines_.size());
    
        for(int c = 0; c < num_channels; ++c)
        {
            phase = phase_;
            float* channel_data = buffer.getWritePointer(c);
            auto& dline = dlines_[c];
    
            for(int i = 0; i < num_samples; ++i)
            {
                const float in = channel_data[i];
    
                // get delay from lfo
                float delay_second = sweep_width*lfo_.lfo(phase, LFO::WaveformType::kWaveformSine);
                float delay_sample = delay_second * getSampleRate();
    
                // get interpolation delay value
                channel_data[i] = dline.getInterpolation(delay_sample);
    
                // push input to delay line
                dline.push(in);
    
                // update phase
                phase += lfo_freq*invert_sample_rate_;
                if(phase >= 1.0f)
                {
                    phase -= 1.0f;
                }
            }
        }
    
        phase_ = phase;
    }
    

    总结

    以上介绍了延迟和颤音两种音效,并给出了详细实现,它们都是基于 delay line 实现的,简单却又有用。

    展开全文
  • delay

    2017-10-17 16:07:23
    // TestConsole.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include <windows.h>int _tmain(int argc, _TCHAR* argv[]) { LARGE_INTEGER frequence; LONGLONG l1=0,l2=0; ...
  • 对网络传输过程中的各种延时进行整理。
  • 【stm32】delay详解

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

    2018-11-19 16:02:41
    input delay, output delay在vivado中使用范围  转载:通过作者使用总结情况,IO口时序约束主要使用在以下情况: 1. 数据交换频率较高  由于IO时序约束一般计算值都是在几纳秒,当FPGA和外部数据交换频率较低...
  • Group Delay and Phase Delay

    2016-01-21 15:14:48
    Group Delay 群延迟 Phase Delay 相位延迟 两个不同的概念,但都是指延迟时间。延迟故名思义就是信号从进入系统到从系统出来时的延迟。好比龙头上接了一根皮管,你拧开龙头,皮管那头水不会立马出来,...
  • 什么是Pin Delay? 芯片内部,核心单元到封装引脚之间的距离成为Pin Delay。在高速电路设计中,需要考虑芯片的Pin Delay来减少走线长度误差。 Pin Delay怎么计算? 在厂商提供的资料中,Pin Delay通常取Min Delay和...
  • jQuery.delay()方法简介

    2020-04-15 18:25:48
    之所以说简介,就是因为这个方法真的很简单。这个方法从 jQuery 1.4 开始加入进来。中文文档中也早就有了,但是悄悄的添加进去的,很不起眼,不容易引起人的关注。...$(‘#foo’).slideUp(300).delay(800).f
  • set_max_delay

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

    2019-01-11 19:30:45
    GUI_Delay()函数 使用GUI_Delay()函数时,对于其延时时间不确定,明明设置为最小值1,延时时间 仍旧太长,不能达到需求。遂决定研究明白其实现机理。 uC/OS-II使用OSTimeDly()函数实现延时,其单位是OS_TICKS...
  • 关于TCP Delay ACK的概念我就不多说了,到处复制粘贴标准文献以及别人的文章只能让本文篇幅加长而降低被阅读完的欲望,再者这也不是什么论文,附录参考文献几乎很少有人去看,所以我把这些都略过了。和风吹的干皮鞋...
  •   在前面的博客中,介绍了output_delay的基础。output_delay就是从FPGA管脚输出到下游芯片之间的时钟和数据之间的关系。   output_delay的约束,就是希望输出时钟落在数据的合适的区间:   dMin = bskew   ...
  • 今天在使用DC设置随路时钟的时候发现里两个比较容易混淆的设置:max_delay/min_delay和input_delay/output_delay。 1)max_delay/min_delay设置指定路径的最大延迟和最小延迟。  如果电路完全是有组合逻辑电路构成的...
  • 从测试结果看采用Task.Delay(1000).Wait()似乎更合理,但大家在实际应用中似乎更多使用await Task.Delay(1000),包括MSDN上的例子。 ``` CancellationTokenSource cts = new CancellationTokenSource(); ...
  • HAL库延时函数HAL_Delay()遇坑,初学HAL库感受着它强大的封装库可以拿来直接用,对于初学者很容易上手,看来以后小学生都能写单片机了 问题:延时函数一直用的HAL_Delay()毫秒级延时,但是在中断中调用延时函数却...
1 2 3 4 5 ... 20
收藏数 299,062
精华内容 119,624
关键字:

delay