Generieren Swept-Sine-Wellen

Wie kann ich formulieren Sie eine Gleichung für die Erzeugung eines swept-sine-wave. Ich bin neu in der Signalverarbeitung und finden nicht viel über das Thema zu generieren, swept-sine-Wellen online. Bitte zeigen Sie mir einige Quellen, die ich verwenden können, um zu generieren, eine Gleichung, und verwenden Sie einen code.
Danke.

  • Können Sie das erzeugen einer nicht-swept-sine-wave?
  • Du meinst ein Frequenz-sweep? Ich schrieb ein Programm, daß einmal, vor Jahren. Leider habe ich nicht mehr, aber ich erinnere mich, dass ich brauchte, um zu lösen eine Differentialgleichung (auf dem Papier) zu finden, die Formel für die Welle als Funktion der Zeit.
  • Nach dieser die Gleichung ist x(t) = sin(k*t^2), wo k ist die sweep-rate.
  • Möglich, Duplikat der so erstellen Sie eine Sinus-generator, können nahtlos übergang zwischen den Frequenzen ?
InformationsquelleAutor user3453339 | 2014-03-23
  1. 3

    Der einfachste Weg, dies zu tun, ist die Verwendung einer phase-Akkumulator - dies ist eine einfache Methode, und es sorgt für eine phase der Kontinuität, wie ändert sich die Frequenz.

    Generieren festen Frequenz Sinus-dies können Sie tun, (pseudo-code):

    //
//A = sine wave amplitude
//fs = sample rate (Hz)
//f = sine wave frequency (Hz)
//
phi = 0;                      //phase accumulator
delta = 2 * pi * f / Fs;      //phase increment per sample
for each sample
    output = A * sin(phi);    //output sample value for current sample
    phi += delta;             //increment phase accumulator

    Für eine gefegt Sinus-würde Sie Hochfahren und die Frequenz Linear, d.h. die Rampe bis delta Linear.

    //
//A = sine wave amplitude
//fs = sample rate (Hz)
//f0 = initial frequency (Hz)
//f1 = final frequency (Hz)
//T_sweep = duration of sweep (s)
//
phi = 0;                      //phase accumulator
f = f0;                       //initial frequency
delta = 2 * pi * f / Fs;      //phase increment per sample
f_delta = (f1 - f0) / (Fs * T_sweep);
                              //instantaneous frequency increment per sample
for each sample
    output = A * sin(phi);    //output sample value for current sample
    phi += delta;             //increment phase accumulator
    f += f_delta;             //increment instantaneous frequency
    delta = 2 * pi * f / Fs;  //re-calculate phase increment
    • Der obige pseudocode funktioniert wie erwartet, wenn übersetzt JavaScript. Beste Antwort die ich gesehen habe, wie es tatsächlich enthält ein Beispiel, anstatt bloßer Aussagen.
    InformationsquelleAutor Paul R
  2. 0

    kompilieren mit gcc FILE.c -lm -o FILE

    Wird das Programm generiert ein mono 16-bit - "gefegt" Sinus-Welle. Als bonus, es zeigt auch, fegen amplitude.

    //http://www.purplemath.com/modules/grphtrig.htm

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdarg.h>
#include <string.h>

const double 
    radians = (M_PI * 2);

typedef struct SineWave {

double
    rate,           //sample rate
    frequency,      //oscillation Hz.
    amplitude,      //amplitude
    phase,          //current phase
    phaseStep;      //phase step

    struct transition {

        double
            amplitude,
            amplitudeStep,
            frequency,
            frequencyStep;

    } transition;

} SineWave;

SineWave * sine_wave(double frequency, double amplitude, double rate) {
    SineWave * sw = calloc(1, sizeof(SineWave));
    sw->frequency = frequency, sw->amplitude = amplitude, sw->rate = rate;
    return sw;
}

//close enough comparison..
//http://stackoverflow.com/a/18975072
int double_equals(double a, double b)
{
    return abs(a - b) < 0.001;
}

double sine_wave_sample(SineWave * sw) {
    double sample = sw->amplitude * sin(sw->phase);
    sw->phase += sw->phaseStep;
    if (sw->transition.frequencyStep) {
        sw->frequency += sw->transition.frequencyStep;
        sw->phaseStep = radians * sw->frequency / sw->rate;
        if (double_equals(sw->frequency, sw->transition.frequency)){
            sw->transition.frequencyStep = 0;
            sw->frequency = sw->transition.frequency;
        }
    }
    if (sw->transition.amplitudeStep) {
        sw->amplitude += sw->transition.amplitudeStep;
        if (double_equals(sw->amplitude, sw->transition.amplitude)) {
            sw->transition.amplitudeStep = 0;
            sw->amplitude = sw->transition.amplitude;
        }
    }
    return sample;
}

void sine_wave_frequency_transition(SineWave * sw, double frequency, double duration) {
    sw->transition.frequency = frequency;
    sw->transition.frequencyStep = (frequency - sw->frequency) / (sw->rate * duration);
}

void sine_wave_amplitude_transition(SineWave * sw, double amplitude, double duration) {
    sw->transition.amplitude = amplitude;
    sw->transition.amplitudeStep = (amplitude - sw->amplitude) / (sw->rate * duration);
}

//test
int main(int argc, char ** argv) {

    SineWave * mono = sine_wave(0, 0, 44100); //start with "nothing"

    //transition to 500 Hz by .5 seconds.
    sine_wave_frequency_transition(mono, 500, .5);

    //transition to 50% amplitude by 1 second
    sine_wave_amplitude_transition(mono, SHRT_MAX * .5, 1);

    //1 second of samples total
    long long samples = mono->rate * 1;

    short sample;
    while (samples--) {
        sample = sine_wave_sample(mono);
        fwrite(&sample, sizeof(sample), 1, stdout);
    }

    return 0;
}
    InformationsquelleAutor Hypersoft Systems
Schreibe einen Kommentar