Comment implémenter un oscillateur numérique?

J'ai un système de traitement du signal numérique à virgule flottante qui fonctionne à un taux d'échantillonnage fixe de $f_s = 32768$ échantillons par seconde implémenté à l'aide d'un processeur x86-64. En supposant que le système DSP est verrouillé de manière synchrone sur tout ce qui compte, quelle est la meilleure façon de mettre en œuvre un oscillateur numérique à une fréquence $f$ ?

Plus précisément, je veux générer le signal:

Une idée est de garder une trace d'un vecteur $(x,y)$ que nous faisons tourner d'un angle $\Delta\phi = 2\pi f/f_s$ à chaque cycle d'horloge.

En tant qu'implémentation de pseudocode Matlab (l'implémentation réelle est en C):

%% Initialization code

f_s = 32768;             % sample rate [Hz]
f = 19.875;              % some constant frequency [Hz]

v = [1 0];               % initial condition     
d_phi = 2*pi * f / f_s;  % change in angle per clock cycle

% initialize the rotation matrix (only once):
R = [cos(d_phi), -sin(d_phi) ; ...
     sin(d_phi),  cos(d_phi)]

Ensuite, à chaque cycle d'horloge, nous faisons tourner un peu le vecteur:

%% in-loop code

while (forever),
  v = R*v;        % rotate the vector by d_phi
  y = v(1);       % this is the sine wave we're generating
  output(y);
end

Cela permet à l'oscillateur d'être calculé avec seulement 4 multiplications par cycle. Cependant, je m'inquiéterais de l'erreur de phase et de la stabilité de l'amplitude. (Dans des tests simples, j'ai été surpris que l'amplitude ne meure pas ou n'explose pas immédiatement - peut-être que l' sincosinstruction garantit $\sin^2+\cos^2=1$ ?).

Quel est le bon moyen de le faire?

Vous avez raison de dire que l'approche strictement récursive est vulnérable à l'accumulation d'erreur à mesure que le nombre d'itérations augmente. Un moyen plus robuste pour cela est généralement d'utiliser un oscillateur à commande numérique (NCO) . Fondamentalement, vous disposez d'un accumulateur qui garde la trace de la phase instantanée de l'oscillateur, mis à jour comme suit:

À chaque instant, il vous reste donc à convertir la phase accumulée dans le NCO en sorties sinusoïdales souhaitées. La façon dont vous procédez dépend de vos besoins en termes de complexité de calcul, de précision, etc. Une façon évidente consiste à calculer simplement les sorties comme

en utilisant la mise en œuvre de sinus / cosinus dont vous disposez. Dans les systèmes à haut débit et / ou embarqués, le mappage de la phase aux valeurs sinus / cosinus se fait souvent via une table de recherche. La taille de la table de recherche (c'est-à-dire la quantité de quantification que vous effectuez sur l'argument de phase en sinus et cosinus) peut être utilisée comme compromis entre la consommation de mémoire et l'erreur d'approximation. La bonne chose est que la quantité de calculs requis est généralement indépendante de la taille de la table. De plus, vous pouvez limiter la taille de votre LUT si nécessaire en profitant de la symétrie inhérente aux fonctions cosinus et sinus; il vous suffit de stocker un quart de période de la sinusoïde échantillonnée.

Si vous avez besoin d'une précision supérieure à ce qu'une LUT de taille raisonnable peut vous donner, vous pouvez toujours regarder l'interpolation entre les échantillons de table (interpolation linéaire ou cubique, par exemple).

Un autre avantage de cette approche est qu'il est trivial d'incorporer une modulation de fréquence ou de phase à cette structure. La fréquence de la sortie peut être modulée en variant conséquence, et la modulation de phase peut être implémentée en ajoutant simplement à directement.$\delta$$\phi[n]$

Ce que vous avez est un oscillateur très bon et efficace. Le problème potentiel de dérive numérique peut en fait être résolu. Votre variable d'état v comporte deux parties, l'une est essentiellement la partie réelle et l'autre la partie imaginaire. Appelons alors r et i. Nous savons que r ^ 2 + i ^ 2 = 1. Au fil du temps, cela peut dériver de haut en bas, mais cela peut facilement être corrigé par multiplication avec un facteur de correction de gain comme celui-ci

Évidemment, cela coûte très cher, mais nous savons que la correction de gain est très proche de l'unité et nous pouvons l'approcher avec une simple expansion de Taylor à

De plus, nous n'avons pas besoin de le faire sur chaque échantillon, mais une fois tous les 100 ou 1000 échantillons est plus que suffisant pour maintenir cette stabilité. Ceci est particulièrement utile si vous effectuez un traitement basé sur les trames. La mise à jour une fois par image est très bien. Voici un rapide Matlab calcule 10 000 000 d'échantillons.

%% seed the oscillator
% set parameters
f0 = single(100); % say 100 Hz
fs = single(44100); % sample rate = 44100;
nf = 1024; % frame size

% initialize phasor and state
ph =  single(exp(-j*2*pi*f0/fs));
state = single(1 + 0i); % real part 1, imaginary part 0

% try it
x = zeros(nf,1,'single');
testRuns = 10000;
for k = 1:testRuns
  % overall frames
  % sample: loop
  for i= 1:nf
    % phasor multiply
    state = state *ph;
    % take real part for cosine, or imaginary for sine
    x(i) = real(state);
  end
  % amplitude corrections through a taylor exansion aroud
  % abs(state) very close to 1
  g = single(.5)*(single(3)-real(state)*real(state)-imag(state)*imag(state) );
  state = state*g;
end
fprintf('Deviation from unity amplitude = %f\n',g-1);

Vous pouvez éviter la dérive d'amplitude instable si vous ne le faites pas mettre à jour récursivement le vecteur v. Au lieu de cela, faites pivoter votre vecteur prototype v vers la phase de sortie actuelle. Cela nécessite toujours certaines fonctions trigonométriques, mais une seule fois par tampon.

Aucune dérive d'amplitude et fréquence arbitraire

pseudocode:

init(freq)
  precompute Nphasor samples in phasor
  phase=0

gen(Nsamps)
    done=0
    while done < Nsamps:
       ndo = min(Nsamps -done, Nphasor)
       append to output : multiply buf[done:done+ndo) by cexp( j*phase )
       phase = rem( phase + ndo * 2*pi*freq/fs,2*pi)
       done = done+ndo

Vous pouvez supprimer la multiplication, les fonctions trigonométriques requises par cexp et le module restant sur 2pi si vous pouvez tolérer une translation de fréquence quantifiée. par exemple, fs / 1024 pour un tampon de phaseur de 1024 échantillons.