Wobulateur digital à DDS AD9850 (résolution 1Hz) piloté par un ATmega8

ELECTRONIQUE PROGRAMMABLE

Théorie et Applications

Wobulateur digital à DDS AD9850
(résolution 1Hz)
piloté par un ATmega8

Cet article fait suite à celui décrivant un générateur HF 40MHz sinus basé sur ce même circuit DDS AD9850.

Sommaire :

2 - Le circuit DDS AD9850
3 - Le principe mis en oeuvre au sein du DDS (je vous traduis une toute petie partie du datasheet en anglais)

5 - Le schéma du Wobulateur
6 - Liaison série RS232 avec le PC:
8 - Partie logique

9 - Le Firmware en langage C:
10 - SOFT côté PC en C++ & Qt4
11 - Copies d'écran du logiciel pilote
12 - Test avec un quartz

1 -
	L'appareil tient sur un carte unique qui comprend le module AD9850, le microcontrôleur ATmega8 qui le pilote, fait les acquisitions analogiques grâce à son convertisseur A/N intégré, et assure la liaison RS232 avec le PC, et la partie analogique (ampli OP haute impédance à TL082).

2 Le circuit DDS AD9850
	On peut se procurer le AD9850 seul en boîtier SMD de folie (j'en ai soudé un, je déconseille l'aventure!), ou bien comme ici monté sur un module au pas de 2.54mm ce qui facilite grandement la réalisation du circuit imprime. Le AD9850 est un DDS (direct digital synthesis) qui synthétise directement un signal sinusoïdal à une fréquence précise. Dans le cas présent la fréquence peut être choisie entre 1Hz et plus de 40MHz avec une résolution de 0.0291 Hz lorsqu'il est piloté par une horloge (à quartz) de 125 MHz. En interne le DDS génère une sinusoïde numérique qu'il convertit en un signal analogique avec un convertisseur N/A. La fréquence du signal est déterminée par un mot de 32 bits. La résolution de 0.0291 est égale à la fréquence du quartz divisée par 2 puissance 32. (125E6 / 4294967296 = 0.0291)

3 Le principe mis en oeuvre au sein du DDS (je vous traduis une toute petie partie du datasheet en anglais)
La circuiterie interne du DDS est un diviseur digital de fréquence dont la résolution incrémentale (la finesse du pas) est déterminée par la fréquence de l'horloge de référence (ici 125MHz) divisée la 2^N nombre de bits du mot de commande de fréquence (un grand (32 bits) nombre binaire qui détermine la fréquence de sortie). L'accumulateur (la mémoire) de phase est un compteur à module variable qui incrémente (ajoute) le nombre enregistré à chaque fois qu'il reçoit une impulsion d'horloge. Lorsque le compteur déborde, il reboucle sur lui-même de sorte que le signal est généré continuellement. Le mot de commande de fréquence (il sera fourni par l'ATmega en fonction de la fréquence désirée) constitue la valeur du module du compteur, ce qui en fin de compte détermine la taille de l'incrément (delta phase) qui est ajouté dans l'accumulateur de phase lors de l'impulsion d'horloge suivante. Plus l'incrément est large et plus vite l'accumulateur se remplit et déborde ce qui produit une fréquence plus élevée. Le signal numérique de sortie est issu d'un calcul mathématique d'une fonction cosinus avec comme variable la valeur de la phase.

4 -
La fréquence de sortie est donnée par la formule ci-contre:

5 Le schéma du Wobulateur
Le premier étage redresse à large bande les signaux issus de la wobulation grâce à des diodes VHF polarisées afin de ne pas avoir de seuil de conduction. Le résultat est intégré par une cellule RC. On obtient une tension correspondant à l'enveloppe du signal, qui est alors amplifiée avec un AOP de type TL082. La diode redresse les alternances négatives ce qui permet de travailler au potentiel de masse côté gauche tout en la polarisant à partir d'une tension positive côté droit. Cet étage attaque l'entrée A/D du microcontrôleur ATmega8 qui numérise le signal obtenu avec son convertisseur analogique/numérique 10bits intégré. Puis les résultats des conversions sont envoyés au PC par une liaison RS232.

6 Liaison série RS232 avec le PC:
	Les ports série se faisant rares sur les PC récents et les portables, on peut avantageusement utiliser un petit adaptateur USB-RS232 du commerce basé sur une puce Prolific Technology PL2303, compatible Linux (sans drivers supplémentaires) fournissant un port série RS232 virtuel sous la forme /dev/ttyUSB0 (ou USB1...) Je l'utilise actuellement avec satisfaction. J'ai acheté ce convertisseur dans une "boutique" sur Ebay... Je vous laisse chercher.

7 -
	Il y a une alternative à cette solution: c'est la possibilité d'utiliser un convertisseur USB-RS232 offrant directement des niveaux de sortie TTL (0V -5V) (enfin c'est ce que j'ai cru comprendre en lisant la description du produit...) au lieu de -15V , +15V de la norme RS232. Ce qui doit permettre de simplifier encore l'électronique... Je précise: la photo ci-contre est recopiée depuis le site d'un vendeur sur eBay, moi je ne vends rien. J'en ai commandé un. Je vous tiens au courant...

8 Partie logique
Le mot de commande peut être chargé en mode parallèle ou en mode série. J'ai choisi le mode série pour économiser des ports de l'ATmega8. Les boutons sont lus sur un seul pin par le convertisseur analogique/numérique de l'ATmega. (on pourrait en théorie mettre jusqu'à 1024 boutons! en pratique disons une vingtaine pour garder une bonne marge de sécurité).

9 Le Firmware en langage C:

CODE SOURCE en langage C

/*==============================================================================
par Silicium628
derniere mise à jour 26 octobre 2012
================================================================================
Pilotage d'un circuit DDS AD9850 générateur de fréquence 0..40MHz sinus avec un quartz (pour le AD9850) de 125MHz
-Affichage LCD 2 x 20  caractères ("splitté entre deux ports de l'ATmega)
-Wobulateur (necessite la liaison RS232 avec le soft tournant sur le PC; les commandes sont effectuees depuis le PC)
================================================================================
*/
// #include <math.h>
 
 
#define F_CPU 16000000
 
#include <avr/io.h>
#include <util/delay.h>
 
#include "uart_628.c"
 
 
 
#define	pin_WCL				0b00000100
#define	pin_FQU				0b10000000	// sur port D
#define	pin_RESET			0b01000000
#define	pin_DATA			0b00001000
 
 
 
char * version = "2.1";
 
/*
RAPPEL variables avr-gcc (vérifiable avec le .map)
 
char				1   -128 .. 127 ou caractères
unsigned char		1  	0 .. 255 (equiv à byte du pascal)
uint8_t				1		(c'est la même chose que l'affreux 'unsigned char') 
char toto[n]		n
int					2  	-32768 .. 32767	
int16_t				2		idem 'int'
short int			2  	pareil que int (?)
unsigned int		2		0 .. 65535
uint16_t			2		idem 'unsigned int'
long int			4   -2 147 483 648 à 2 147 483 647
int32_t				4		32 bits	;	idem long int
unsigned long long	64-bit unsigned type. 
uint64_t			8		64-bit unsigned type. 
long long int		8	
unsigned long int	4	32 bits	;	0 .. 4 294 967 295  (4,2 x 10^9)
float				4
double				4	// (?)
 
La déclaration  char JOUR[7][9];
réserve l'espace en mémoire pour 7 mots contenant 9 caractères (dont 8 caractères significatifs).
*/
 
  uint64_t frequence;
  uint64_t pas_i;
  uint8_t pos;
  uint8_t digits_frq[8];
  uint8_t pas_wob = 2;  // soit 10e2 = 100
  uint64_t	Frq_W32; // valeur binaire destine a l'AD9850, vaut environ 68,72 x frequence en Hz.
  uint8_t phase;
  uint8_t nb_cycles = 0;
	uint8_t octet_recu;
	uint8_t buffer232[20];
	uint8_t compteur1; // pour tests
//	uint8_t flags = 0;
 
 
 
void init_ports (void)  // ports perso
// 0 = entree, 1=sortie   ;   les 1 sur les pins en entrees activent les R de Pull Up (tirage à VCC)
{
  PORTB = 0b00000000;
  DDRB |= 0b00001000;	// portB[3] = sortie (OC2)
 
  DDRC = 	0b11001111;	//PC4 en entree (acquisition signal) ; PC5 en entree (ADC5 - boutons)
 
  DDRD =  0b11111111;	//PD1 = TXD ; 
  PORTD = 0b00100000;	//PD0 = RXD 
}
 
 
 
void InitADC (void)
{
  ADCSRA = _BV(ADEN) | _BV(ADPS2);  // Activate ADC with Prescaler 16 --> 1Mhz/16 = 62.5kHz
  ADMUX = 5;    // Select pin ADC5 using MUX
}
 
 
 
void InitINTs (void)
/*
 TCCR2:
wgm21,20 =11 ->Fast PMW
com21,com20=01 ->Set OC2 on Compare Match, clear OC2 at TOP (valable pour le mode Fast PWM);  voir p:116
bits2,1,0:  prescaler (010 = 1/8)
*/
{
  TCCR2=	0b00000000;  // Timer2 non utilisé.
  TIMSK|=	0b00000000;  // INT Timer2 comp disable; INT Timer2 overflow disable;
  GICR|=	0b00000000;  // gere les INTs voir page 67 du pdf
  MCUCR|=	0b00000000;  // The falling edge of INT0 generates an interrupt request. p:67 du pdf
}
 
 
 
 
void init_variables(void)
{
/*	
1Hz ->		69
10Hz ->		687
100Hz ->	6872
1kHz ->		68719
10kHz ->	687195
100kHz ->	6871948
1MHz ->		68719477
10MHz ->	687 194 767
*/
uint8_t n;
	for (n=0; n<=7; n++)
	{
		digits_frq[n]=0;
	}	
	pos=3;
	digits_frq[pos]=1;
 
  Frq_W32=68719; 
 
  phase = 0;
}
 
 
 
void reset_DDS(void)
{
 _delay_us(1);
  PORTD |=  pin_RESET;
 _delay_us(1);
  PORTD &= ~pin_RESET; // l'operateur "~" donne le complement (inverse des bits). ne pas confondre avec l'opérateur "!"
 _delay_us(1);
}
 
 
void impulse_clk_W(void)  // sur pin W_CL
{
 _delay_us(1);
  PORTD |=  pin_WCL;
 _delay_us(1);
  PORTD &= ~pin_WCL; // l'operateur "~" donne le complement (inverse des bits). ne pas confondre avec l'opérateur "!"
 _delay_us(1);
}
 
 
void impulse_FQ_U(void)  // sur pin FQ_U
{
 _delay_us(1);
  PORTD |=  pin_FQU;
 _delay_us(1);
  PORTD &= ~pin_FQU; // l'operateur "~" donne le complement (inverse des bits). ne pas confondre avec l'opérateur "!"
 _delay_us(1);
}
 
 
void out_DDS(uint64_t freq_i)  // 40 bits vers AD9850; voir son datasheet
{
	uint8_t n;
 
//envoi de la frequence
  uint32_t masque;
 
	masque = 1;
  for (n=0;  n<= 31; n++)   // on sort le LSB (W0) en premier
	{
		masque += masque;	// revient à x2 le masque le '1' se deplacant de droite a gauche, 32 bits en tout
		if ( (freq_i & masque) != 0) {PORTD |=  pin_DATA;}	else { PORTD &= ~pin_DATA; }
 
		impulse_clk_W();
	}
 
  PORTD &= ~pin_DATA;				// (W32 toujours = 0)
  impulse_clk_W();
 
  PORTD &= ~pin_DATA;		// (W33 toujours = 0)
  impulse_clk_W();
 
  PORTD &= ~pin_DATA;		// (W34 = Power-Down = 0)
  impulse_clk_W();
 
// envoi de la phase (5 bits)
 
  for (n=0;  n<=4; n++)    // on sort le LSB (W35) en premier et le MSB en dernier.
	{
		masque = (1 << n);
		if (phase & masque) {PORTD |=  pin_DATA;} else { PORTD &= ~pin_DATA; }
 
		impulse_clk_W();
	}
// envoi impulsion FQ_UD
	impulse_FQ_U();
}
 
 
 
void calcul_Frq_W32(void)
{
// frequence = digits_frq[0]+digits_frq[1]*10+digits_frq[2]*100+digits_frq[3]*1000+digits_frq[4]*10000+digits_frq[5]*100000+digits_frq[6]*1000000+digits_frq[7]*10000000;  // pour affichage
// J'ai cessé de traiter des grands integers (64bits) pour la représentation de la frequence en decimal, donc commente la ligne precedente (pour gagner place en memoire)
 
	Frq_W32 = 
	(uint64_t)digits_frq[0]*(uint64_t)69
	+(uint64_t)digits_frq[1]*(uint64_t)687
	+(uint64_t)digits_frq[2]*(uint64_t)6872
	+(uint64_t)digits_frq[3]*(uint64_t)68719
	+(uint64_t)digits_frq[4]*(uint64_t)687195
	+(uint64_t)digits_frq[5]*(uint64_t)6871948
	+(uint64_t)digits_frq[6]*(uint64_t)68719477
	+(uint64_t)digits_frq[7]*(uint64_t)687194767;
// pour DDS
 
/* REMARQUE:
Les (uint64_t) forcent les calculs sur 64 bits et evitent le bug suivant mais consomment 1100 octets en memoire flash	
detail du bug sans les (uint64_t) -> les frequences entre 476 et 954 Hz ne sont pas synthetisees
476*68.72 = 32710	-> ok
477*68.72 = 32779  -> HS 
954*68.72 = 65558  -> reprise mais HS -> qq Hz 
*/	
}
 
 
 
void regle_Frq_00 (void)
{
	// on regle la frequence sur 0 (absence de signal de sortie)
	digits_frq[7]=0; digits_frq[6]=0; digits_frq[5]=0; digits_frq[4]=0; digits_frq[3]=0; digits_frq[2]=0; digits_frq[1]=0; digits_frq[0]=0;
	calcul_Frq_W32();
//	affiche_frequence();
}
 
 
 
 
void reception_params()
{
		uint8_t n;	
		uint8_t ok = 0;
 
		compteur1++;
 
		for (n=0; n<10; n++)
		{
			octet_recu=USART_RxByte();
			buffer232[n]=octet_recu;
		}
 
 
		pas_wob= 10*(buffer232[0]-48) + buffer232[1]-48;
 
		pas_i=1;
		for (n=1; n<= pas_wob; n++) {pas_i *= 2;}		
 
		for (n=0; n<8; n++)
		{
			digits_frq[n]=buffer232[n+2]-48;
		}	
		calcul_Frq_W32();
		out_DDS(Frq_W32);		
}
 
 
 
void balayage_wob(void)
{
	uint8_t octet_recu;
	uint32_t n;
	uint16_t valeur_lue;
	uint8_t n3H;
	uint8_t n3L;	
	uint8_t compteur2;
	uint64_t freq_i;	
 
	ADMUX = 4;    // Select pin ADC4 using MUX
 
	// attend feu vert du PC
	octet_recu=USART_RxByte();
	while (octet_recu !='G') {octet_recu=USART_RxByte();}
	{
 
		USART_TxStr("DAT");
		compteur2=0;
 
		freq_i = Frq_W32;
		out_DDS(freq_i);	
 
		for (n=0; n<510; n++)
		{
//acquisition
			_delay_ms(30); // bloqueur (de la valeur analogique mesuree) pendant l'acquisition
 
			ADCSRA |= _BV(ADSC);    //Start conversion - resolution 10bits
			while (ADCSRA & _BV(ADSC) ) {;}    // attend la fin de la converstion
			valeur_lue = ADCW;    // lit la value convertie			
			valeur_lue = 1024 - valeur_lue; // inversion y
 
			// valeur_lue=n; // pour test  (=ok)
 
			n3L=valeur_lue % 128; //codage sur 7 bits
			n3L &= 0b01111111; // 8eme bit de l'octet L toujours  = 0 - (cette ligne est en fait inutile)
			n3H=valeur_lue/128;	//codage sur 7 bits
			// on reserve le 8eme bit pour identifier l'octet (L ou H)
			n3H |= 0b10000000; // 8eme bit de l'octet H toujours  = 1
 
// envoi donnee vers PC				
			USART_TxByte(n3L);
			_delay_us(100);
			USART_TxByte(n3H);
			_delay_us(100);
 
			compteur2++;
 
			freq_i += pas_i;
			out_DDS(freq_i);
		}
	}
 
}
 
 
void wobulateur (void)
{
 
	uint8_t compteur;
 
 
	while(1)
	{	
		octet_recu=USART_RxByte(); 
 
		while ( (octet_recu != 'P') && (octet_recu != 'G'))  { 	octet_recu=USART_RxByte(); }
 
		if (octet_recu == 'P') 	{	reception_params();	}
		else if (octet_recu == 'G')	{	balayage_wob();	}		
 
	}
}
 
 
 
void test (void)
{
 
}
 
 
int main (void)
{
	init_variables(); 
	init_ports();
	InitADC();
	InitINTs();
	USART_Init();
 
	reset_DDS();
 
 
	_delay_ms(2000);
 
 
	uint8_t compteur;
	compteur=20;
 
	uint32_t f1;
	uint32_t f2;
	uint32_t f3;
 
	uint8_t a;
	uint8_t b;
	uint8_t c;	
 
 
	Frq_W32 = a*f1+b*f2+c*f3;
	calcul_Frq_W32();
 
	out_DDS(Frq_W32);
	out_DDS(Frq_W32);
 
 
	wobulateur();
 
 
 
}

10 SOFT côté PC en C++ & Qt4

CODE SOURCE en langage C

/*
INTERFACE D'ACQUISITION POUR WOBULATEUR 0-40MHz
auteur Silicium628
http://www.silicium628.fr
logiciel libre sous licence GNU
 
*/
 
 
#include "mainwindowimpl.h"
#include <stdio.h>
#include <unistd.h>
#include "rs232.h"
#include <math.h>
 
#include <QPainter>
#include <QMessageBox>
#include <QDir>
 
 
QString version = "7.2";
 
//	numport=16;        /* /dev/ttyUSB0
//	numport=17;        /* /dev/ttyUSB1 
    int  numport=16;
 
	int  bdrate=9600;       /* 9600 baud */
    unsigned char buf[100];
 
    QList<Acq_Rec> liste_mesures1, liste_mesures2, liste_mesures3, liste_mesures4, liste_mesures5;  	// 512 mesures par balayage
    unsigned char params[1030];
    unsigned char datas[1030];
    QString str_test;
 
	int num_octet_recu;
	int num_ligne;
    int num_pas_recu;
    int num_pas_desire;
    int digits_F_min[8];
    int digits_F_centrale[8];
    float pas;
    long int Freq_min_desiree, Freq_centrale_desiree, Freq_max_desiree;
//    long int Fmin, Fmax;
    long int Fmarqueur;
    int pos_marqueur, memo_pos_marqueur;
  //  long int graduation_x;
    long int pas_graduation=1000; //en Hz
    int num_pas_graduation;
//    int a_effacer=1;
 
    int cnx232_ok =0;
    int memo_y;
 
 
    QColor couleur_ecran = QColor::fromRgb(1, 92, 65, 255);
    QColor couleur_ligne = QColor::fromRgb(165, 42, 42, 255);
    QColor couleur_trace = QColor::fromRgb(66, 249, 112, 255);
 
    QColor couleur_memo1 = QColor::fromRgb(255, 85, 0, 255);
    QColor couleur_memo2 = QColor::fromRgb(255, 255, 0, 255);
    QColor couleur_memo3 = QColor::fromRgb(0, 255, 0, 255);
    QColor couleur_memo4 = QColor::fromRgb(0, 170, 255, 255);
 
    QColor couleur_marqueur = QColor::fromRgb(255, 255, 0, 255);
    QColor couleur_texte = QColor::fromRgb(66, 249, 112, 255);
    QColor vert = QColor::fromRgb(0, 255, 0, 255);
    QColor jaune = QColor::fromRgb(255, 255, 0, 255);
 
 
    QPen pen_trace(couleur_trace, 1, Qt::SolidLine);
    QPen pen_memo1(couleur_memo1, 1, Qt::SolidLine);
    QPen pen_memo2(couleur_memo2, 1, Qt::SolidLine);
    QPen pen_memo3(couleur_memo3, 1, Qt::SolidLine);
    QPen pen_memo4(couleur_memo4, 1, Qt::SolidLine);
 
    QPen pen_reticule(couleur_ligne, 1, Qt::SolidLine);
    QPen pen_marqueur(couleur_marqueur, 1, Qt::SolidLine);
 
 
 
MainWindowImpl::MainWindowImpl( QWidget * parent, Qt::WFlags f) 
	: QMainWindow(parent, f)
{
	setupUi(this);
    setWindowTitle("Wobulateur ATmega + AD9850 - Silicium628 - version " + version);
 
    Led1 = new QLed(frame2);
    Led1->setGeometry(QRect(20, 40, 20, 20));
    Led1->setCouleur(QColor (0,255,0));
    Led1->setForme(1);
    Led1->setEtat(0);
 
    Led2 = new QLed(frame3);
    Led2->setGeometry(QRect(140, 14, 20, 20));
    Led2->setCouleur(QColor (0,255,0));
    Led2->setForme(2);
    Led2->setEtat(0);
 
    Led3 = new QLed(frame1);
    Led3->setGeometry(QRect(175, 243, 20, 20));
    Led3->setCouleur(QColor (0,255,0));
    Led3->setForme(2);
    Led3->setEtat(0);
 
    scene = new QGraphicsScene(this);
    scene->setBackgroundBrush(couleur_ecran);
    graphicsView1->setScene(scene);
 
    groupe_reticule = new QGraphicsItemGroup();
    groupe_trace = new QGraphicsItemGroup();
    scene->addItem(groupe_trace);
 
    liste_mesures1.clear();
    timer1 = new QTimer(this);
 
    connect(timer1, SIGNAL(timeout()), this, SLOT(reception_RS232() ));
 
 
    comboBox1->addItem("ttyS0 (com1)");
    comboBox1->addItem("ttyS1 (com2)");
	comboBox1->addItem("ttyUSB0");
	comboBox1->addItem("ttyUSB1");
 
    comboBox1->setCurrentIndex(2);
 
    BoutonLed1 = new QBoutonLed(frame4);
    BoutonLed1->setGeometry(QRect(20, 20, 40, 40));
    BoutonLed1->setCouleur(QColor (0,255,0));
    connect(BoutonLed1, SIGNAL(toggled(bool)), this, SLOT(on_BoutonLed1_toggled(bool)));
    BoutonLed1->click();
    pushButton->setVisible(false);
 
 
 
    QPalette palette1 = frame1->palette();
    palette1.setColor( backgroundRole(), QColor( 220, 220, 220 ) );
    frame1->setPalette( palette1 );
    frame1->setAutoFillBackground( true );
 
    QPalette palette2 = frame2->palette();
    palette2.setColor( backgroundRole(), QColor( 220, 220, 220 ) );
    frame2->setPalette( palette2 );
    frame2->setAutoFillBackground( true );
 
    tracer_marqueur(1);
    spinBox_7->setValue(8);
    spinBox_PAS->setValue(12);
    spinBox2->setValue(6);
    compose_frequence();
    groupe_trace->setZValue(100);
 
}
//
 
void vider_buffers()
{
	int n;	
    liste_mesures1.clear();
	for (n=0; n<1024; n++)
	{
		buf[n]=0;
//		mesures[n][0]=0;
//		mesures[n][1]=0;
	}
}
 
 
void efface_params()
{
    int n;
    for(n=0; n<100; n++)
    {
        params[n]=0;
    }
}
 
 
void MainWindowImpl::tracer_1freq(int x_i, int y_i, QString sti)
{
// affichage 1 trait vertical
 
    if((x_i>0) && (x_i<512))
    {
        ligne1 = new QGraphicsLineItem(x_i,0,x_i,512);
        ligne1->setPen(pen_reticule);
        groupe_reticule->addToGroup(ligne1);
 
        texte_frq = new QGraphicsTextItem(sti);
        texte_frq->setDefaultTextColor(couleur_texte);
        texte_frq->setPos(x_i,y_i);
        if(x_i<450) // evite que l'ecriture ne deborde du cadre a droite
        {
            groupe_reticule->addToGroup(texte_frq);
        }
    }
}
 
 
 
void MainWindowImpl::tracer_reticule()
{
    int i,y;
    QString st1;
//ATTENTION: ne pas remplacer les "float" par de "int" (aucuns) sous peine de calculs faux (erreurs d'arrondis)
    float nb_graduations;
    float largeur_graduations; // en pixels
    float deltaF; //en Hz
    float Fmilieu, Fi;
 
 
    deltaF=Freq_max_desiree-Freq_min_desiree;
    nb_graduations = deltaF/pas_graduation;
 
 
    if ((nb_graduations>12)&&(num_pas_graduation<20))
    {
        num_pas_graduation++;
        spinBox2->setValue(num_pas_graduation);
         calcul_freq_pas_graduation();
         nb_graduations = deltaF/pas_graduation;
     }
 
    if ((nb_graduations<3)&&(num_pas_graduation>1))
    {
        num_pas_graduation--;
        spinBox2->setValue(num_pas_graduation);
        calcul_freq_pas_graduation();
        nb_graduations = deltaF/pas_graduation;
    }
    calcul_freq_pas_graduation();
 
// graguation centrale
    Fmilieu= (float)Freq_centrale_desiree;
    st1.setNum(Fmilieu);
    tracer_1freq(255, 490, st1);
 
 
//graduations de part et d'autre de la fréquence centrale
    if ((nb_graduations>0) && (nb_graduations <20))
    {
        largeur_graduations = 512 / (nb_graduations);
 
        for(i=1; i<=nb_graduations/2; i++)
        {
            if((i%2)==0){y=490;} else{y=20;}
            Fi=Fmilieu - i*pas_graduation;
            st1.setNum(Fi);
            tracer_1freq(255-i*largeur_graduations, y, st1);
 
            Fi=Fmilieu + i*pas_graduation;
            st1.setNum(Fi);
            tracer_1freq(255+i*largeur_graduations,y, st1);
        }
    }
 
// lignes horizontales
    for (i=0; i<=10; i++)
    {
       y=50*i;
     //  ligne1 = scene->addLine(0, y, 512, y, pen_reticule);
       ligne1 = new QGraphicsLineItem(0, y, 512, y);
       ligne1->setPen(pen_reticule);
       groupe_reticule->addToGroup(ligne1);
    }
    scene->addItem(groupe_reticule);
}
 
 
 
void MainWindowImpl::effacer_reticule()
{
    foreach( QGraphicsItem *item, scene->items( groupe_reticule->boundingRect() ) )
    {
        if( item->group() == groupe_reticule )  { delete item; }
    }
}
 
 
 
void MainWindowImpl::effacer_trace()
{
    foreach( QGraphicsItem *item, scene->items( groupe_trace->boundingRect() ) )
    {
        if( item->group() == groupe_trace )  { delete item; }
    }
}
 
 
void MainWindowImpl::effacer_marqueur()
{
    scene->removeItem(ligne_marqueur);
}
 
 
 
void MainWindowImpl::tracer_marqueur(int x)
{
    ligne_marqueur = new QGraphicsLineItem(x,0,x,512);
    ligne_marqueur->setPen(pen_marqueur);
    scene->addItem(ligne_marqueur);
}
 
 
void MainWindowImpl::tracer_1point(int n, QList<Acq_Rec> *liste_mesures_i, QPen pen_i)
{
    Acq_Rec mesure_i;
    int y1,y2;
    int n_max;
 
    n_max=liste_mesures_i->size(); // =512 apres aquisition 1 balayage complet
    if ((n>1)&&(n<n_max))
    {
 
        mesure_i=liste_mesures_i->at(n-1);
        y1=(128*mesure_i.Valeur[1]+mesure_i.Valeur[0])/2;    if (y1>1024) { y1=1024;}
 
        mesure_i=liste_mesures_i->at(n);
        y2=(128*mesure_i.Valeur[1]+mesure_i.Valeur[0])/2;    if (y2>1024) { y2=1024;}
 
        if ( (y1 != 0) && (y2 != 0))
        {
            segment_trace = new QGraphicsLineItem(n-1,y1,n,y2);
            segment_trace->setPen(pen_i);
            groupe_trace->addToGroup(segment_trace);
 
        }
    }
}
 
 
void MainWindowImpl::save_image_ecran()
{
    QString st1,nom1, filename;
    QImage image1 (512, 512, QImage::Format_RGB32 );
 
    QPainter painter1(&image1);
    scene->render(&painter1);
    int n =0;
 
    nom1=lineEdit13->text();
 
    int ok=0;
    while (ok!=1)
    {
        st1.setNum(n); // conversion num -> txt
        filename = QDir::homePath()+"/"+nom1+st1+".png";
        QFile f( filename );
        if  (!f.exists() ) { ok=1;  } else { n++;   }
    }
    image1.save(filename, "png", 50);
    QMessageBox::information(this, "copie d'ecran", "image cree: "+ filename);
}
 
 
 
void formate_nombre(QString *str_i)
{
    uint n;
    n=str_i->length();
    if (n>3) {str_i->insert(n-3, ' ');}
    if (n>6) {str_i->insert(n-6, ' ');}
    if (n>9) {str_i->insert(n-9, ' ');}
    *str_i+=" Hz";
}
 
 
 
 
void MainWindowImpl::reception_RS232()
{
    Acq_Rec mesure_i;
	int n;
	int i;
    int data_i;
    float Fi;
 
    QString st1;
//rappel: int PollComport(int comport_number, unsigned char *buf, int size)
 
    n = PollComport(numport, buf, 10);
    if(n >0)
    {
        for(i=0; i < n; i++)
        {
            datas[num_octet_recu] = buf[i];
            st1.setNum(buf[i]); // conversion num -> txt
  //          str_test+=st1;
            num_octet_recu++;
        }
 
       if (num_octet_recu>=10)
       {
           if ((datas[0]=='D')&&(datas[1]=='A')&&(datas[2]=='T'))
           {
               Led1->setCouleur(jaune);
               Led1->setEtat(1);
                for(i=0; i < n; i++)
                {
                    data_i = buf[i];
 
 
        //les donnees sont transmises sur deux fois 7 bits
        // le 8eme bit (bit7) determine si c'est l'octet de poids faible ou celui de poids fort qui est recu
                    if ((data_i & 128)==0)
                    {
                        st1.setNum(data_i); // conversion num -> txt
                        mesure_i.Valeur[0]=data_i;
                    }
                    else
                    {
                        data_i &= 127; // elimine le bit d'identification de poids
 
                        Fi = Freq_min_desiree+num_ligne*pas;
                        mesure_i.Freq=(long int)Fi;
                        mesure_i.Valeur[1]=data_i;
                        liste_mesures1<<mesure_i;
                        tracer_1point(num_ligne, &liste_mesures1, pen_trace);
 
                        progressBar1->setValue(num_ligne);
 
                        num_ligne++;
                    }
 
                    num_octet_recu++;
 
 
                    if (num_ligne >= 506)
                    {
                        num_octet_recu=0;
                        num_ligne=0;
                        progressBar1->setValue(0);
                        Led1->setCouleur(vert);
                        Led1->setEtat(1);
 
                    }
                }
            }
        }
    }
}
 
 
 
void MainWindowImpl::on_Btn_connect_pressed()
{
	QString st1; 
 
    Led1->setEtat(0);
 
    if (comboBox1->currentIndex()==0)
    {
        numport =0;
        st1="ttyS0";
    }
    if (comboBox1->currentIndex()==1)
    {
        numport =1;
        st1="ttyS1";
    }
    if (comboBox1->currentIndex()==2)
	{
		numport =16;	
		st1="ttyUSB0";
	}
    if (comboBox1->currentIndex()==3)
	{
		numport =17;	
		st1="ttyUSB1";
	}		
	num_octet_recu=0;
	num_ligne=0;
  if(OpenComport(numport, bdrate))
  {
    cnx232_ok=0;
    lineEdit1->setText("Ne peut pas ouvrir "+st1);
    pushButton->setVisible(true);
    Led2->setCouleur(QColor (255,0,0));
    Led2->setEtat(1);
  }
  else
  {
    cnx232_ok=1;
  	lineEdit1->setText("port "+st1+ " ouvert\n");
    pushButton->setVisible(false);
    Led2->setCouleur(QColor (0,255,0));
    Led2->setEtat(1);
 
  	timer1->start(2);
 
  }
}
 
 
 
 
 
void MainWindowImpl::MAJ_marqueur(int x_i)
{
    QString st1;
    //int n;
    effacer_marqueur();
    pos_marqueur = x_i;
    tracer_marqueur(pos_marqueur);
 
    Fmarqueur = Freq_min_desiree+pos_marqueur*pas;
    st1.setNum(Fmarqueur); // conversion num -> txt
    formate_nombre(&st1);
    lineEdit6->setText(st1);
}
 
 
 
void MainWindowImpl::on_horizontalSlider_sliderMoved(int position)
{
    MAJ_marqueur(position);
}
 
 
void MainWindowImpl::on_horizontalSlider_sliderReleased()
{
 
}
 
 
void MainWindowImpl::on_Btn_Go_pressed()
{
    if(cnx232_ok ==1)
    {
        num_octet_recu=0;
        num_ligne=0;
        //clear_tableau();
        vider_buffers();
 
        effacer_trace();
        Led1->setEtat(0);
 
        SendByte(numport, 'G');
        SendByte(numport, 'G');
    }
    else {  QMessageBox::information(this, "Erreur", "Pas de connexion RS232"); }
}
 
 
 
void MainWindowImpl::on_Btn_envoi_clicked()
{
/*
les valeurs numeriques sont transmises par RS232 digit par digit en clair (codage ascii des chiffres, codes 48..57 pour 0..9
et non par leur valeur directe (15 sera envoyé comme 1 suivi de 5 et non par la valeur 15)
ceci pour eviter des bugs lors de la transmisson de valeurs correspondant a des commandes RS232
*/
    int n;
 
 
    Led1->setEtat(0);
    Led3->setEtat(1);
 
    if(cnx232_ok !=1)  {  on_Btn_connect_pressed(); }
 
    effacer_trace();
    SendByte(numport, 'P'); //'P' comme 'Parametres'  (pas sur 2 digits puis frequence sur 8 digits)
//    SendByte(numport, '=');
//PAS sur 2 digits
    SendByte(numport, 48 + num_pas_desire /10); // unites (en chiffre 0..9)
    SendByte(numport, 48 + num_pas_desire %10); // dizaines
//FREQUENCE sur 8 digits
    for(n=0; n<8; n++)
    {
        SendByte(numport, 48+ digits_F_min[n]); // (en chiffre 0..9)
    }
 //   QTimer::singleShot(1000, this, SLOT(on_Btn_Go_pressed())); // laisse le temps de transmission puis de calcul pour l'ATmega
 
}
 
 
 
void MainWindowImpl::compose_frequence()
{
    QString st1;
    int i;
    Freq_centrale_desiree=0;
    for(i=0; i<8; i++)
    {
        Freq_centrale_desiree+= digits_F_centrale[i] * pow(10,i);
    }
    Freq_min_desiree=Freq_centrale_desiree-256*pas;
    if(Freq_min_desiree<0)
    {
        QMessageBox::information(this, "Attention", "Frequence min  < 0");
        Freq_min_desiree=0;
    }
 
    Freq_max_desiree=Freq_centrale_desiree+256*pas;
 
    if(Freq_max_desiree>49*1e6)
    {
        QMessageBox::information(this, "Attention", "Frequence max  > 49MHz");
        Freq_max_desiree=49*1e6;
    }
 
    digits_F_min[0]=(Freq_min_desiree/1) %10;
    digits_F_min[1]=(Freq_min_desiree/10) %10;
    digits_F_min[2]=(Freq_min_desiree/100) %10;
    digits_F_min[3]=(Freq_min_desiree/1000) %10;
    digits_F_min[4]=(Freq_min_desiree/10000) %10;
    digits_F_min[5]=(Freq_min_desiree/100000) %10;
    digits_F_min[6]=(Freq_min_desiree/1000000) %10;
    digits_F_min[7]=(Freq_min_desiree/10000000) %10;
 
 
    st1.setNum(Freq_min_desiree); // conversion num -> txt
    formate_nombre(&st1);
    lineEdit10->setText(st1);
 
    st1.setNum(Freq_centrale_desiree); // conversion num -> txt
    formate_nombre(&st1);
    lineEdit8->setText(st1);
 
    st1.setNum(Freq_max_desiree); // conversion num -> txt
    formate_nombre(&st1);
    lineEdit11->setText(st1);
 
    effacer_reticule();
    tracer_reticule();
    MAJ_marqueur(pos_marqueur);
 
    Led3->setEtat(0);
}
 
 
 
 
void MainWindowImpl::on_spinBox_8_valueChanged(int arg1)
{
    digits_F_centrale[7]=arg1;
    compose_frequence();
}
 
void MainWindowImpl::on_spinBox_7_valueChanged(int arg1)
{
    digits_F_centrale[6]=arg1;
    compose_frequence();
 
}
 
void MainWindowImpl::on_spinBox_6_valueChanged(int arg1)
{
    digits_F_centrale[5]=arg1;
    compose_frequence();
}
 
void MainWindowImpl::on_spinBox_5_valueChanged(int arg1)
{
    digits_F_centrale[4]=arg1;
    compose_frequence();
}
 
void MainWindowImpl::on_spinBox_4_valueChanged(int arg1)
{
    digits_F_centrale[3]=arg1;
    compose_frequence();
}
 
void MainWindowImpl::on_spinBox_3_valueChanged(int arg1)
{
    digits_F_centrale[2]=arg1;
    compose_frequence();
}
 
 
void MainWindowImpl::on_spinBox_2_valueChanged(int arg1)
{
    digits_F_centrale[1]=arg1;
    compose_frequence();
}
 
 
 
 
void MainWindowImpl::on_spinBox_PAS_valueChanged(int arg1)
{
    num_pas_desire=arg1;
    QString st1;
    pas = pow(2,num_pas_desire)/68.7194767;
 
    st1.setNum(pas); // conversion num -> txt
    if (num_pas_desire>15) {formate_nombre(&st1);}
    lineEdit9->setText(st1);
 
    compose_frequence(); // pour recalculer les freq min et max;
 
    effacer_reticule();
    tracer_reticule();
}
 
 
void MainWindowImpl::on_spinBox_1_valueChanged(int arg1)
{
    digits_F_centrale[0]=arg1;
    compose_frequence();
}
 
 
void MainWindowImpl::calcul_freq_pas_graduation()
{
    QString st1;
    long int liste_pas[21]={
    1,2,5,
    10,20,50,
    100,200,500,
    1000,2000,5000,
    10000,20000,50000,
    100000,200000,500000,
    1000000,2000000,5000000
    };
 
    pas_graduation = liste_pas[num_pas_graduation];
    st1.setNum(pas_graduation); // conversion num -> txt
    formate_nombre(&st1);
    lineEdit12->setText(st1);
 
}
 
 
void MainWindowImpl::on_spinBox2_valueChanged(int arg1)
{
    num_pas_graduation=arg1;
    calcul_freq_pas_graduation();
    compose_frequence();
}
 
 
void MainWindowImpl::on_Btn1_clicked()
{
    liste_mesures2=liste_mesures1;
}
 
 
void MainWindowImpl::on_Btn2_clicked()
{
    int n;
    for (n=0; n<512; n++) { tracer_1point(n, &liste_mesures2, pen_memo1);}
}
 
 
 
void MainWindowImpl::on_Btn_test_3_clicked()
{
    effacer_trace();
}
 
 
 
 
void MainWindowImpl::on_BoutonLed1_toggled(bool checked)
{
    if   (checked)
    {
      tracer_reticule();
      scene->addItem(groupe_reticule);
    }
    else
    {
      foreach( QGraphicsItem *item, scene->items(groupe_reticule->boundingRect() ))
      {
        if( item->group() == groupe_reticule ) {delete item; }
      }
    }
}
 
 
 
 
void MainWindowImpl::on_Btn1_2_clicked()
{
    liste_mesures3=liste_mesures1;
}
 
void MainWindowImpl::on_Btn2_2_clicked()
{
    int n;
    for (n=0; n<512; n++) { tracer_1point(n, &liste_mesures3, pen_memo2);}
}
 
void MainWindowImpl::on_Btn1_3_clicked()
{
    liste_mesures4=liste_mesures1;
}
 
void MainWindowImpl::on_Btn2_3_clicked()
{
    int n;
    for (n=0; n<512; n++) { tracer_1point(n, &liste_mesures4,pen_memo3);}
}
 
void MainWindowImpl::on_Btn1_4_clicked()
{
    liste_mesures5=liste_mesures1;
}
 
void MainWindowImpl::on_Btn2_4_clicked()
{
    int n;
    for (n=0; n<512; n++) { tracer_1point(n, &liste_mesures5,pen_memo4);}
}
 
 
void MainWindowImpl::on_comboBox1_currentIndexChanged(int index)
{
    Led2->setEtat(0);
}
 
 
void MainWindowImpl::on_pushButton_clicked()
{
    QMessageBox::information(this, "Aide", + "Essayez un autre port \n ou la commande (dans un terminal) \n 'sudo chown <your_user> /dev/ttyxxx' \n (change le proprietaire sous Linux)");
}
 
void MainWindowImpl::on_Btn_save_img_clicked()
{
    save_image_ecran();
}

11 Copies d'écran du logiciel pilote
L'appareil est entièrement pilotable depuis l'ordinateur, par le biais de la liaison RS232. Le soft est développé en C++ Qt4 avec l'IDE Qt Creator. Jusqu'à présent je travaillais avec l'IDE Qdevelop, mais ce dernier ne tourne plus correctement (se ferme en fin compilation) sous Mint13 Mate (base Ubuntu 12.04). Donc vive Qt Creator! (Les fichiers en C++ Qt4 .cpp et les interfaces graphiques .ui restent 100% compatible avec cet IDE).

12 Test avec un quartz
Voici la réponse d'un quartz de 8,000 000 MHz. On distingue nettement les deux fréquences de résonance série et parallèle, très proches. On reconnaît la réaction d'un circuit série pour une fréquence donnée et d'un circuit parallèle pour une fréquence légèrement supérieure. Quand on approche de la résonance série (Fs),l'impédance passe par un minimum, (pointe vers le bas sur l'image) puis remonte rapidement vers un maximum (pointe vers le haut) à la fréquence parallèle (Fp). Cela fait partie des choses qui peuvent créer des surprises dans les oscillateurs à quartz mal conçus...

13 -
	Il est tout à fait possible de zoomer, le pas de synthèse de l'AD9850 avec un quartz de 125MHz étant de 0,0291 Hz !!! (dans cette réalisation, le pas mini programmé par l'ATmega est de 1Hz). Nous remarquons que la fréquence 8,000MHz ne coïncide ni avec la résonance parallèle ni avec la résonance série. Mais ce test a été effectué sur "plaque d’essai" c'est à dire avec d'énormes capacités parasites en parallèle sur le quartz! et un rajout de capacité supplémentaire décale effectivement un peu plus la courbe. Donc il faudra voir le résultat obtenu avec un circuit imprimé bien propre. L'interface Qt4 à déjà évolué depuis la veille... L'échelle de graduation du réticule est semi-automatique par pas 1,2,5,10...

14 -
Nouvelle programmation QT4: utilisation des classes (objets) QGraphicsScene et QGraphicsItemGroup permettant de dessiner sur des calques superposés (layers, couches) pour le réticule, les graduations et la trace et donc d'effectuer des changements d'échelle dynamiques sans devoir refaire une acquisition.

15 -
06 octobre 2012: Quatre mémoires de trace sont maintenant disponibles. Utilité: Pouvoir comparer les résultats lors de la mise au point d'un filtre par exemple. (Sur la copie d'écran ci-dessus je me suis contenté de modifier l'échelle (le pas de wobulation) entre chaque tracés). Le rectangle vert en bas est un bouton_led, c'est à dire un bouton bistable (toggle) lumineux (lorsqu'il est enfoncé, gris sinon). J'ai créé cette classe Qt en dérivant un QPushbutton et en surchargeant la méthode paintEvent afin de dessiner un rectangle lumineux. Vous trouverez le source de cette classe dans les documents fournis. Remarque: avec tout ça, on pourrait se créer un petit scope numérique?

16 Evolution
13 octobre 2012: Le programme en Qt4 évolue. Des LED indiquent l'état de l'interface. La fenêtre principale voit sa hauteur diminuer afin d'être entièrement affichée sur l'écran des Netbook (Aspire One 1024x600)

17 -
	Ci-contre une image créée et enregistrée sur le disque dur par le programme lui-même (en cliquant sur le bouton "save" dans le cadre "Image") Il s'agit, vous l'aurez deviné, de l'analyse d'un petit transfo FI à 455kHz. La résonance n'est pas exactement calée sur 455KHz? En effet, et si l'on tourne la petite vis de réglage du transfo, on déplace la courbe...

18 Le board
27 octobre 2012: Voici l'implantation des composants, effectuée avec le logiciel libre de saisie de schéma et de routage Kicad (build 2012-01-19), sous l'OS libre et gratuit Linux (Mint13 mate).

19 Documents techniques
Voici les autres fichiers nécessaires à cette réalisation: documents.tar.gz TUTOS : tuto vidéo : Comment éditer le code source et le compiler avac QtCréator Comment installer Qt5 correctement	Aperçu du contenu de l'archive

20
J'ai voulu savoir s'il était possible de compiler un programme écrit en C++ Qt4 sur et pour l'ultra micro-ordinateur Raspberry Pi. J'ai donc googlelisé ici et là, et j'ai trouvé ce tuto, décrivant l'installation de qtcreator sur le Raspberry, et je l'ai suivi. Tutorial : apt-get install Qt4 on the Rasperry Pi Et j'ai été étonné du résultat; qtcreator a été installé en quelques instants, et une petite configuration plus tard j'ai pu éditer et compiler le soft pour le wobulateur décrit plus haut, sans changer une virgule au code source. Et l'exécutable fonctionne parfaitement sur le Raspberry pi comme vous pouvez le voir sur les images ci-dessous:

21 -
	Ci-contre une capture d'écran de qtcreator en cours d'exécution sur le Raspberry pi. La compilation du programme du wobulateur s'est bien déroulée, bien que nettement plus lentement (environ 2mn) que sur un PC AMD64 à 4GHz. L'exécutable obtenu fonctionne parfaitement sur le Raspberry. Pour obtenir les copies d'écran, j'utilise la commande "scrot -d 5" après avoir installé le paquet: ( sudo apt-get install scrot )

22 -

23 -

Liens...

40750

[ Retour Accueil ]

Ce site est développé en PHP avec des LOGICIELS LIBRES sous LINUX