numerically controlled oscillator (NCO)

Version imprimable

23/05/2007, 17h28
sandball22

numerically controlled oscillator (NCO)

Bonjour, je dois faire un NCO ( numerically controlled oscillator ) en c. Quelqu'un à t-il d'jà réalisé cela? Car je ne vois pas trop comment le faire. Je ne trouve d'algorithme!

Merci de votre aide.
23/05/2007, 18h28
diogene

- Avec un accumulateur dont la sortie est réduite modulo N.
L'accumulateur réalise l'opération acc = (acc+x)modulo(N). La fréquence est fixée par le nombre x placé à l'entrée de l'accumulateur et par le cadencement de l'accumulateur et on obtient en sortie acc qui est la phase (la valeur N correspondant à 2*pi) de l'oscillateur.
- La fréquence est donnée par Freq = x/N/T, T étant le temps entre deux accumulations.
- On peut réaliser un déphasage en initialisant l'accumulateur.
- Si on souhaite une sortie sinusoïdale, il suffit de calculer le sinus de la phase en sortie ou utiliser une table.

Citation:

Envoyé par sandball22

Bonjour, je dois faire un NCO ( numerically controlled oscillator ) en c. Quelqu'un à t-il d'jà réalisé cela? Car je ne vois pas trop comment le faire. Je ne trouve d'algorithme!

Quelle est le format des données de sortie ? Binaire, analogique ?

Pour binaire, c'est simple :

[unixoide]
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void oscillator(double frequence_hz) { /* demi-periode en micro-secondes : HPus = 1E6 / (2 x Fhz) */ unsigne long half_period_us = 5E5 / frequence_hz; for (;;) { output(1); usleep(half_period_us); output(0); usleep(half_period_us); } }
Mais c'est sans garantie, car usleep() fait ce qu'il peut. Pour avoir de la précision, il faut utiliser un générateur matériel (timer) qui est fait pour ça, et qu'il suffit de programmer correctement. C'est pour quelle plateforme ?

Les formats en entrées et en sortie doivent etre en binaire.

x doit être sur 24bits. Je dois utilser une table. La sortie de cette table sera sur 16bits. Avez-vous déjà réalisé ceci en c?

J'ia trouvé un programme en C++ mais je ne le comprend pas trop. Je ne sais pas si cela fait bien ce qu'à décrit diogene.
.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
namespace SPUC {
/*!   \brief NCO with 32 bit accumulator
  \ingroup pll
*/
//!:
//!    Numerically controlled oscillator (with 32 bits accumulator)
//!    returns the top (mask_bits) MSBs from accumulator
//!    Useful for carrier recovery where top bits used for input to
//!    sine,cos lookup table.
//!    FCW : frequency control word
//!    ACC : accumulator 
//!    Frequency must be set through interface routines set_frequency
//!    or reset_frequency.
//!    Load routine is to allow frequency to be updated (typically with
//!    a loop filter).
//!    When not changing frequency call "clock" routine.
class nco
{
public:
	unsigned long phase;
//	char v[20];
 
protected:
	unsigned long acc;
	unsigned long fcw;
	unsigned long new_fcw;
	unsigned long mask_bits;
 
public:
	//! Constructor
	nco(long bits=8);
	//! Reset object
	inline void reset() { phase = new_fcw = fcw = acc = 0; }
	//! Set frequency control word
	inline void set_frequency(unsigned long freq) { fcw = freq; }
	//! Set frequency control word and register for frequency control word
	inline void reset_frequency(unsigned long freq) { new_fcw = fcw = freq; }
//! Return current phase
	inline long get_phase(void) { return(phase);}
//! Load new frequency control word
	inline void load(long loop_filter_out) {new_fcw = fcw + loop_filter_out;}
//! Clock NCO with new frequency control word input
	long clock(long loop_filter_out);
//! Clock NCO without changing frequency control word
	long clock();
};
} // namespace SPUC 
#endif

.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
// Set nco.h for description.
#include <spuc.h>
#include <nco.h>
namespace SPUC {
nco::nco(long bits) {
			acc = fcw = new_fcw = phase = 0;
			mask_bits = MASK_NEG_HI(bits);
}
long nco::clock() {
		acc += new_fcw;
		phase = acc & mask_bits; // truncate 
		return(phase);
}
long nco::clock(long loop_filter_out) {
		new_fcw = fcw + loop_filter_out;
		return(clock());
}
} // namespace SPUC

24/05/2007, 10h05
Emmanuel Delahaye

Citation:

Envoyé par sandball22

Les formats en entrées et en sortie doivent etre en binaire.

x doit être sur 24bits. Je dois utilser une table. La sortie de cette table sera sur 16bits. Avez-vous déjà réalisé ceci en c?

Alors c'est du numérique (24-bit / 16-bit) et non du binaire ! (1-bit).

Je ne connais pas. Il y a des math là-dessous et je sens que ça ne va pas me plaire... Je connais mes limites...
24/05/2007, 11h17
diogene

Citation:

Je ne sais pas si cela fait bien ce qu'à décrit diogene.

Oui, c'est basé sur ce principe.
24/05/2007, 13h37
sandball22

Mais il manque du code non?
24/05/2007, 15h38
diogene
Citation:

Mais il manque du code non?

Pratiquement pas.
Code:

1 2 3 4 5 long nco::clock() { acc += new_fcw; phase = acc & mask_bits; // truncate return(phase); }
réalise effectivement le NCO.

Ce qui manque :
- la partie "lookup table" adressée à partir du retour de clock()
- le système de cadencement qui doit appeler clock() à intervalles réguliers
Mais cela dépend du détail du projet que tu veux réaliser.
24/05/2007, 16h04
sandball22

L'entrée est codée sur 24 bits et en sortie de mes tables est codé sur 16bits

cf page 1

www.nova-eng.com/downloads/ip_digifrec.pdf
24/05/2007, 16h14
diogene

Quel est en fait la nature de ton projet ?
Es-tu censé écrire en C un programme faisant la même chose que ce circuit ?
24/05/2007, 16h18
sandball22

Je dois transcrire en c le Nco (page 3). Il n'y a pas besoin de retranscrire exactement comme sur le schéma, mais le même principe.
24/05/2007, 16h26
sandball22

C'est plus claire?
24/05/2007, 16h29
diogene

Alors, il ne te manque pas plus que signalé à la réponse #8 si tu n'a pas à programmer le changement de fréquence.
24/05/2007, 16h34
sandball22

Ou sont les tables? je comprend pas comment ces fichiers peuvent fonctionner.
24/05/2007, 16h44
diogene
Citation:

Ou sont les tables? je comprend pas comment ces fichiers peuvent fonctionner.

Tu crées au départ une table contenant les sinus que tu adresses à partir de la phase. En gardant les notations utilisées avant, ca donne qq chose du genre
Code:

1 2 3 4 5 6 7 int Sinus[256]; .... for (i=0; i<256; i++) Sinus = 32767*sin(2*M_PI/256*i); .... Sortie = Sinus[clock()];
24/05/2007, 16h49
sandball22

Je suis un peu perdu la.
24/05/2007, 16h52
diogene

Alors commence par transcrire l'équivalent de long nco::clock() en C. On reviendra ensuite sur le problème de la table

Si je ne m'occupe pas des tables, il suffit juste de re transcrire
Code:

1 2 3 4 5 long nco::clock() { acc += new_fcw; phase = acc & mask_bits; // truncate return(phase); }
en c?

24/05/2007, 18h11
diogene

sandball22 : Oui, commençons par là
28/05/2007, 11h02
sandball22

1 pièce(s) jointe(s)

J'ai réalisé le NCO mais voila ce que j'obtiens en sortie (cf piece jointe).
Est-ce convenable?
28/05/2007, 11h51
Emmanuel Delahaye

Citation:

Envoyé par sandball22

J'ai réalisé le NCO mais voila ce que j'obtiens en sortie (cf piece jointe).
Est-ce convenable?

Non. Enfin ça dépend du taux de distorsion harmonique acceptable. Avec un tel signal, à vue de nez, je dirais entre 10 et 20%...
29/05/2007, 17h51
diogene

Citation:

J'ai réalisé le NCO mais voila ce que j'obtiens en sortie (cf piece jointe).
Est-ce convenable?

Le résultat semble correct. la forme obtenue doit être due au fait que la fréquence demandée est élevée (apparemment 1/6 de la fréquence de cadencement de l'accumulateur). Pour améliorer les choses, il faudrait faire suivre la sortie d'un filtrage.