/***********************************************************************
par Silicium628
derniere mise à jour 25 oct 2014
========================================================================
Generateur HF 200MHz - DDS AD9951 et ATmega8
-Affichage LCD 2 x 16  caractères
-base de temps = TCXO 20.000 MHz (quartz compensé en température)
************************************************************************/
 
 
/*
Quelques points clés du datasheet.pdf de l'AD9951 :
 
- Chip select can be tied low in systems that maintain control of SCLK (p:22) -> donc on ne pilotera pas le pin CSB
- CFR1<9> = 1. The serial data I/O pin (SDIO) is configured as an input only pin (3-wire serial programming mode). (p:15) . Ce n'est pas la valeur par défaut. il faut le programmer
 
*/
 
 
#define F_CPU 16000000
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <math.h>
 
#include "dm_lcd.c"  // l'attribution des pins/ports pour le LCD (et le type de LCD) est faite dans le fichier "dm_lcd.h"
#include "lcd_curseur.c"
 
#define	pin_RST					0b00010000		// (sortie) sur portD
#define	pin_SCLK				0b10000000		// (sortie) sur portD
#define	pin_SDI					0b01000000		// (sortie) sur portD
#define	pin_io_update		0b00100000		// (sortie) sur portD
#define	pin_SD0					0b00000010		// (ENTREE) sur portB
#define pin_mode				0b00100000		// (ENTREE) sur portC
 
 
char * version = "5.0";
 
 
	uint8_t IB; // INSTRUCTION BYTE
 
  uint64_t FTW;	// le mot de 32 bits à transmettre au AD9951 en mode série sur le pin SDIO
  uint32_t f_out , memo_f_out; // fréquence du signal de sortie sinusoïdal
 
 
	uint8_t pos; // position du multiplicateur
	uint8_t pos_curseur; // position du curseur (pour affichage)
 
  uint32_t pas;
  uint8_t etat;
  uint16_t compteur1; 
 
  uint8_t demande_calcul;
 
  float position;
 
 
/**
RAPPEL variables avr-gcc (vérifiable avec le .map)
 
char					1   -128 .. 127 ou caractères
unsigned char	1  	0 .. 255
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 octets  -2 147 483 648 à 2 147 483 647
int32_t				4	octets -> 32 bits	;	idem long int
long long int	8	octets -> 64 bits
unsigned long int	4	octets -> 32 bits	;	0 .. 4 294 967 295  (4,2 x 10^9)
uint32_t			4	32 bits	;	idem 'unsigned long int'
float					4
double				ATTENTION ! 4	octets (oui, 32 bits ! et pas 64 bits (8 octets) comme en C standard)
 
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).
**/
 
 
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)
{
  DDRB |= 0b11111101;	// portB[1] = entree (pin SDO inversé du AD9951 )
  PORTB = 0b00000000;
 
  DDRC = 	0b11011111;	// PINC[5] = entrée bouton poussoir (Mode)
  PORTC = 0b00100000;
 
  DDRD =  0b11110000; // portD[0] et portD[1] entrées codeur_ROTs ; portD[2] et portD[3] entrées INT0	et INT1
  PORTD = 0b00001111;
}
 
 
 
 
void InitINTs (void)
{
  GICR 		|=  0b11000000;  // gere les INTs - voir page 67 du pdf
  MCUCR		|=  0b00001010;  // The falling edge of INT0 generates an interrupt request. The falling edge of INT1 generates an interrupt request. p:67 du pdf
}
 
 
 
void init_variables(void)
{
	demande_calcul = 1;
	f_out = 10000000;
	pas = 1000;
	pos = 4;
 
}
 
 
 
void init_lcd()
{
	uint8_t i;
 
	lcd_init(LCD_DISP_ON_CURSOR); // cursor on
//cd_init(LCD_DISP_ON);  // cursor off
 
	lcd_cree_5_caract_echelle();
 
	lcd_clrscr();
}
 
 
 
void lcd_gotoxy_clrEOL (int x, int y)
// place le curseur en x,y et efface jusqu'a la fin de la ligne
{
	lcd_gotoxy(x, y);
	uint8_t i;
	for (i=x; i<20; i++){ lcd_puts(" "); }
	lcd_gotoxy(x, y);
}
 
 
 
 
void lcd_aff_nb (uint32_t valeur, uint8_t nb_chiffres, uint8_t nb_decimales, uint8_t affi_zeros)
{
//affiche un nombre en representation decimale
// affi_zeros = 1 affiche les zéros non significatifs à gauche.
	unsigned char r ;
	char tbl[7];
	char digit;
	uint8_t i;
 
	for (i=1; i<=nb_chiffres; i++) 
	{
		r=48 + valeur % 10; // modulo (reste de la division)
		valeur /= 10; // quotient
		tbl[i]=r;
	}
	uint8_t debut = 1-affi_zeros; // pour ne pas afficher des zeros à gauche du 1er chiffre
	for (i=1; i<=nb_chiffres; i++)
	{
		if (i== (nb_chiffres - nb_decimales +1) )  { lcd_puts("."); }
		digit = tbl[nb_chiffres +1 -i];
		if (digit != '0') {debut = 0;}
		if ((digit != '0') || (debut == 0)) {lcd_putc(digit);}
	}
}
 
 
void lcd_aff_nb_relatif (int16_t valeur, uint8_t nb_chiffres, uint8_t nb_decimales)
{
//affiche un nombre relatif (c.a.d positif ou négatif) en representation decimale
	unsigned char r ;
	char tbl[7];
	char digit;
	uint8_t i;
	uint8_t affi_zeros = 1; // affi_zeros = 1 affiche les zéros non significatifs à gauche.
 
	if (valeur <0)
	{
		valeur = -valeur;
		lcd_putc('-');
	}
	else
	{
		lcd_putc('+');
	}
 
	for (i=1; i<=nb_chiffres; i++) 
	{
		r=48 + valeur % 10; // modulo (reste de la division)
		valeur /= 10; // quotient
		tbl[i]=r;
	}
	uint8_t debut = 1-affi_zeros; // pour ne pas afficher des zeros à gauche du 1er chiffre
	for (i=1; i<=nb_chiffres; i++)
	{
		if (i== (nb_chiffres - nb_decimales +1) )  { lcd_puts("."); }
		digit = tbl[nb_chiffres +1 -i];
		if (digit != '0') {debut = 0;}
		if ((digit != '0') || (debut == 0)) {lcd_putc(digit);}
	}
}
 
 
 
void lcd_aff_nb_form3 (uint32_t valeur, uint8_t nb_chiffres)
{
//affiche un nombre en representation decimale en separant les groupes de 3 chiffres
	unsigned char r ;
	char tbl[7];
	uint8_t i;
 
	for (i=1; i<=nb_chiffres; i++) 
	{
		r=48 + valeur % 10; // modulo (reste de la division)
		valeur /= 10; // quotient
		tbl[i]=r;
	}
	for (i=1; i<= nb_chiffres; i++)
	{
		if ((((i-1) % 3) == 0 ) && (i>1))  { lcd_puts("."); }
		lcd_putc(tbl[nb_chiffres +1 -i]);
	}
}
 
 
 
void lcd_aff_bin (uint16_t valeur, uint8_t nb_digits)
{
//affiche un nombre en representation binaire
// 16 bits max
	uint8_t r ;
	char tbl[17];
	uint8_t i;
 
	for (i=1; i<=nb_digits; i++) 
	{
		r= 48 + valeur % 2; // modulo (reste de la division)
		valeur /= 2; // quotient
		tbl[i]=r;
	};
 
	for (i=1; i<=nb_digits; i++)
	{
		lcd_putc(tbl[nb_digits +1 -i]);
	}
}
 
 
 
void affiche_pas()
{
	lcd_gotoxy_clrEOL(0, 1);	
	lcd_puts("PAS = ");
 
	switch (pas)
	{
		case 1 : lcd_puts("1Hz");
		break;
 
		case 10 : lcd_puts("10Hz");
		break;
 
		case 100 : lcd_puts("100Hz");
		break;
 
		case 1000 : lcd_puts("1kHz");
		break;
 
		case 10000 : lcd_puts("10kHz");
		break;
 
		case 100000 : lcd_puts("100kHz");
		break;
 
		case 1000000 : lcd_puts("1MHz");
		break;
 
		case 10000000 : lcd_puts("10MHz");
		break;
 
		case 100000000 : lcd_puts("100MHz");
		break;
 
	}
}
 
 
void affiche_frequence()
{
 
	lcd_gotoxy(0, 0);	
	lcd_puts("F=");
	lcd_aff_nb_form3 (f_out, 9);
	lcd_puts(" Hz");
 
	uint8_t nb_chiffres = 9;
 
	pos_curseur = nb_chiffres+4-pos;
	if (pos > 3) {pos_curseur = nb_chiffres+3-pos;};
	if (pos > 6) {pos_curseur = nb_chiffres+2-pos;};
 
	lcd_gotoxy(pos_curseur, 0);
 
}
 
 
 
 
/*
void test_codeur_rot()
{
// pour test des états (diffèrent suivant modèles) du codeur rotatif pas à pas code gray
// le mien est toujours à 11 en position stable
// dans le sens CW il fait 11->01->00->10->11
// et par conséquent dans le sens CCW il fait  11->10->00->01->11	
	lcd_clrscr();
	while (1)
	{
		code_rot = PIND & 0b00000011;
		lcd_gotoxy(0,0);
		lcd_aff_bin (code_rot, 2);
		_delay_ms(10);
	}
}
*/
 
 
 
void impulse_clk(void)  // sur pin_SCLK
{
 _delay_us(5);  // temps necessaire à la stabilisation du niveau envoyé
  PORTD |=  pin_SCLK;
 _delay_us(5);
  PORTD &= ~pin_SCLK; // l'operateur "~" donne le complement (inverse des bits). ne pas confondre avec l'opérateur "!"
 _delay_us(5);
}
 
 
void impulse_IO_update(void)  // sur pin_SCLK
{
// _delay_us(10);
  PORTD |=  pin_io_update;
 _delay_us(10);
  PORTD &= ~pin_io_update; // l'operateur "~" donne le complement (inverse des bits). ne pas confondre avec l'opérateur "!"
 _delay_us(10);
 
}
 
 
 
void out_DDS(uint8_t octet_i)
{
// MSB first (= mode par defaut)
	uint8_t i;
 
//envoi de la frequence
  uint8_t masque; 
 
	for (i=0;  i < 8; i++)  
	{
		masque = 0b10000000 >> i; // le '1' se deplace de gauche a droite
		if ( (octet_i & masque) != 0) { PORTD |=  pin_SDI; }	 else { PORTD &= ~pin_SDI; }
		impulse_clk();
	}
}
 
 
void reset_DDS()
{
 _delay_ms(1);
  PORTD |=  pin_RST;
 _delay_ms(10);
  PORTD &= ~pin_RST; // l'operateur "~" donne le complement (inverse des bits). ne pas confondre avec l'opérateur "!"
 _delay_ms(10);
}
 
 
void init_DDS()
{
	uint8_t CFR1[4]; 
	uint8_t CFR2[3];
 
// ============================ REGISTRE CRF1 - 32 bits ===================================================================		
// Control Function Register No.1 (CFR1) (0x00)
 
 
//PREMIER OCTET :
 
// CFR1<0>: Not Used, Leave at 0 
// CFR1<1> SYNC_CLK Disable Bit;  CFR1<1> = 0 (default). The SYNC_CLK pin is active.
// CFR1<2>: Not Used
// CFR1<3>: External Power-Down Mode; CFR1<3> = 0 (default). The external power-down mode selected is the rapid recovery power-down mode. In this mode,
//when the PWRDWNCTL input pin is high, the digital logic  and the DAC digital logic are powered down. The DAC bias circuitry, PLL, oscillator, and clock input circuitry are not powered down.
// CFR1<4>: Clock Input Power-Down Bit; CFR1<4> = 0 (default). The clock input circuitry is enabled for operation. 
// CFR1<5>: DAC Power-Down Bit; 	CFR1<5> = 0 (default). The DAC is enabled for operation.
// CFR1<6>: Not Used
// CFR1<7>: Digital Power-Down Bit; CFR1<7> = 0 (default). All digital functions and clocks are active.
 
	CFR1[0]=0b00000000;
 
//DEUXIEME OCTET
 
// CFR1<8> = 0 (default). MSB first format is active.	
// CFR1<9>: SDIO Input Only; CFR1<9> = 1. The serial data I/O pin (SDIO) is configured as an input only pin (3-wire serial programming mode). (CE N'EST PAS LA VALEUR PAR DEFAUT)
// CFR1<10>: Clear Phase Accumulator; CFR1<10> = 0 (default). The phase accumulator functions as normal.
// CFR1<11>: Not Used
//CFR1<12>: Sine/Cosine Select Bit; CFR1<12> = 0 (default). The angle-to-amplitude conversion logic employs a COSINE function.
// CFR1<13>: Auto-Clear Phase Accumulator Bit; CFR1<13> = 0 (default), the current state of the phase accumulator remains unchanged when the frequency tuning word is applied.
// CFR1<14..15>: Not Used
 
	CFR1[1]=0b00000010; // CFR1<9>: SDIO Input Only;
 
//TROISIEME OCTET		
 
// CFR1<16..21>: Not Used
// CFR1<22>: Software Manual Synchronization of Multiple AD9951; CFR1<22> = 0 (default). The manual synchronization feature is inactive.
// CFR1<23>: Automatic Synchronization Enable Bit;  CFR1<23> = 0 (default). The automatic synchronization feature of multiple AD9951s is inactive. 
 
	CFR1[2]=0b00000000;
 
// CFR1<24>: Auto Shaped On-Off Keying Enable Bit (Only Valid when CFR1<25> Is Active High); CFR1<24> = 0 (default). When CFR1<25> is active, a Logic 0 on CFR1<24> enables the 
//manual shaped on-off keying operation. Each amplitude sample sent to the DAC is multiplied by the amplitude scale factor. See the Shaped On-Off Keying section for details	
// CFR1<25>: Shaped On-Off Keying Enable Bit; CFR1<25> = 0 (default). Shaped on-off keying is bypassed.
// CFR1<26>: Amplitude Ramp Rate Load Control Bit; CFR1<26> = 0 (default). The amplitude ramp rate timer is loaded only upon timeout (timer == 1) and is not loaded due to an I/O UPDATE input signal. 
// CFR1<31:27>: Not Used 
 
	CFR1[3]=0b00000000;
 
// ENVOI DE CETTE CONFIGURATION AU DDS : (voir page 22 : "Example Operation")
 
	IB= 0b00000000;
	out_DDS( IB); // instruction byte -> ordre d'ecrire dans le registre CRF1 (32 bits attendus)
 
	out_DDS( CFR1[3]);
	out_DDS( CFR1[2]) ;
	out_DDS( CFR1[1]);
	out_DDS( CFR1[0]);
 
	impulse_IO_update();
 
// ============================ REGISTRE CRF2 - 24bits ============ voir le pdf du composant =========================================================		
 
// CFR2<1:0>: Charge Pump Current Control Bits
// CFR2<2>: VCO Range Control Bit
/*
This bit is used to control the range setting on the VCO.
When CFR2<2> == 0 (default), the VCO operates in a range of
100 MHz to 250 MHz. When CFR2<2> == 1, the VCO operates
in a range of 250 MHz to 400 MHz.
*/
// CFR2<7:3>: Reference Clock Multiplier Control Bits
/*
This 5-bit word controls the multiplier value out of the clock-
multiplier (PLL) block. Valid values are decimal 4 to 20 (0x04 to
0x14). Values entered outside this range will bypass the clock
multiplier. See the Phase-Locked Loop (PLL) section for details
20 = 0b10100
*/		
// CFR2<8>: Not Used
// CFR2<9>: CRYSTAL OUT Enable Bit
// CFR2<10>: Hardware Manual Sync Enable Bit
// CFR2<11>: High Speed Sync Enable Bit
// CFR2<23:12>: Not Used
 
//CFR2[0] = 0b00100100; // bit2 =1 -> the VCO operates in a range of 250 MHz to 400 MHz;  bits7..3 = 0b00100 -> =  4  (REFCLK Multiplier) -> cas d'un Qx 100MHz
	CFR2[0] = 0b10100100; // bit2 =1 -> the VCO operates in a range of 250 MHz to 400 MHz;  bits7..3 = 0b10100 -> = 20  (REFCLK Multiplier) -> cas d'un Qx ou CTXO 20MHz
 
	CFR2[1] = 0b00000010; // bit CFR2<9>: CRYSTAL OUT Enable Bit -> =1
	CFR2[2] = 0b00000000;
 
	IB= 0b00000001;
	out_DDS(IB); // instruction byte -> ordre d'ecrire dans le registre CRF2	(24 bits attendus)
 
	out_DDS( CFR2[2]);
	out_DDS( CFR2[1]);
	out_DDS( CFR2[0]);
 
	impulse_IO_update();	
}
 
 
 
 
/***********************************************************************
f_out = FTW x SYSCLK / 2³² nous dit le datasheet
en en déduit :
 
FTW = f_out * 2³² / SYSCLK
// ici SYSCLK = 20MHz x 20 = 400 MHz = 4E8 //  **** cas d'un TCXO 20MHz ****
ici SYSCLK = 10MHz x 20 = 200 MHz = 2E8  // cas d'une synchro par GPS
 
//FTW = f_out * (2³² / 4E8) = f_out * (2³⁰ / 1E8) = 10.73741824 x f_out   **** cas d'un TCXO 20MHz ****
FTW = f_out * (2³² / 2E8) = 21.47483648 x f_out
 
************************************************************************/
 
 
void calcul_FTW()
{
	uint64_t y;
 
	y = f_out * 4294967296;
	FTW = y / 200000000;  // ici on introduit forcément une erreur d'arrondi, le résustat est à +/- 1 digit
	// pour une fréquence de sortie de 10MHz le glissemment par rapport au 10MHz étalon est de 26s pour une période de 100ns -> 3,8 E-9 soit 1seconde/3ans ce qui n'est pas si mal !!
	// si l'on veut ottenir la précision de E-12 du GPS, il faut envisager d'utiliser autre chose qu'un synthétiseur DDS 32 bits.
	// toutefois pour des fréquences multiples ou sous-multiples de 10MHz, ou dans un rapport fractionnaire simple, pas de problème, une simple PLL convient avec diviseur en logique câblée.
	// pour d'autres fréquences, il faut étudier la question de plus près.
 
}
 
 
 
void out_FTW()
{
	uint8_t octets[4];
 
	octets[0] =  FTW & 0b00000000000000000000000011111111;	
	octets[1] = (FTW & 0b00000000000000001111111100000000) >> 8;
	octets[2] = (FTW & 0b00000000111111110000000000000000) >> 16;
	octets[3] = (FTW & 0b11111111000000000000000000000000) >> 24;
 
	IB= 0b00000100;
	out_DDS( IB); // instruction byte -> ordre d'écrire 32 bits dans le registre 0x04
 
	out_DDS(octets[3]);
	out_DDS(octets[2]);
	out_DDS(octets[1]);
	out_DDS(octets[0]);
 
	impulse_IO_update();
}
 
 
/***********************************************************************
// traitement du codeur_rot()
 
// codeur incrémental code Gray avec en plus fonction bouton poussoir	
// le codeur rotatif utilisé est toujours à 11 en position stable
// dans le sens CW il fait 11->01->00->10->11
// et par conséquent dans le sens CCW il fait  11->10->00->01->11	
 
//	11
//	01	
//	00
//	10
//	11
 
// il suffit de connecter un bit sur le pin INT0 (PD2) et de déclencher l'INT sur front descendant (passage  de 0 à 1) 
// cette INT lira alors l'état de l'autre bit (connecté à PD0 par exemple). Cet état diffère suivant le sens de rotation 
 
************************************************************************/
 
 
ISR(BADISR_vect)
{
// évite de planter si une int est enable et pas de procedure associée écrite (ce qui fait reseter l'ATmega)
}
 
 
ISR (INT0_vect) 
{
//interruption sur front descendant sur l'entree Int0
// declenchee par la rotation du codeur_ROT (1)  ->  +/-frequence ou  +/-trim ajustement fréquence 8MHz pour étalonnage par GPS
 
	etat = PIND & 0b00000001; 
	//  +/-frequence
 
	if (etat == 0)
	{
		if (f_out >= pas) {f_out -= pas;}
	}
	else 
	{
		if ( (f_out+pas)  <= 200000000) {f_out += pas;}
		if ( (f_out+pas)  > 200000000) {f_out = 200000000;}
	}
 
	demande_calcul = 1;
}
 
 
ISR (INT1_vect)
{
//interruption sur front descendant sur l'entree Int0
// declenchee par la rotation du codeur_ROT (2) -> pas	
	uint8_t n;
 
	etat = PIND & 0b00000010;
 
	if (etat == 0) 
	{ 
		if (pos < 9) {pos++ ;}
	} 
	else 
	{
		if (pos > 1) {pos--;}
	}
 
	pas=1;
	for (n=1; n<pos; n++)
	{
		pas *=10;
	}
	demande_calcul = 1;
}
 
 
 
int main (void)
{
	cli();
 
	init_variables(); 
	init_ports();
	InitINTs();
 
	init_lcd();
 
	_delay_ms(100);	
 
	reset_DDS();	
	init_DDS();
 
	calcul_FTW();
	out_FTW();
 
	_delay_ms(100);	
 
	lcd_clrscr();
	lcd_puts("GeneHF AD9951");
	lcd_gotoxy(0,1);
	lcd_puts("version ");
	lcd_puts(version);
	_delay_ms(1000);
 
	lcd_clrscr();
 
	sei();	// enable interruptions
 
 
	while(1)
	{
		compteur1++;
		if (compteur1 >= 1000)
		{
/*			
			if ((PINC & pin_mode) == 0)
			{
					demande_calcul = 1;
					lcd_clrscr();
					lcd_puts("mode normal");
					_delay_ms(1000);
					lcd_command(LCD_DISP_ON_CURSOR);
					lcd_clrscr();
 
					f_out = memo_f_out;
					calcul_FTW();
					out_FTW();
					_delay_us(10);
 
					affiche_pas();	
					_delay_us(10);
					affiche_frequence();
					_delay_us(10);
			}
*/
 
			if(demande_calcul == 1)
			{
				cli();
				calcul_FTW();
				out_FTW();
				_delay_us(10);
 
				affiche_pas();	
				_delay_us(10);
				affiche_frequence();
				_delay_us(10);
 
				sei();
				demande_calcul = 0;
			}	
			compteur1=0;
		}
		_delay_us(100);
	}
}
 
 

/**
Firmware pour générateur de signaux à deux DDS : AD9951 et AD9850.
POUR carte Uno Mega2560 + afficheur 480x320 non tactile.
par Silicium628.
 
Ce fichier source "GeneHF_AD9951_MODUL.ino" est libre, vous pouvez le redistribuer et/ou le modifier selon
les termes de la Licence Publique Générale GNU.
 
En ce qui concerne certaines bibliothèques incluses, issues du domaine "Arduino", il faut voir au cas par cas.
**/
 
// REMARQUE : les ports utilisés doivent être définis dans les fichiers "AD9850.h" et  "AD9951.h"
 
//================================
#define version "v3.4"
//================================
 
#include <avr/io.h>
#include <stdint.h> 
#include <stdlib.h>
#include <util/delay.h>
#include <math.h>
 
 
#include "UTFT.cpp"
#include "uart2560_628.c"
 
#include <AD9951-628v6.cpp>;
#include <AD9850-628v1.cpp>;
 
 
 
//#include "timeout.h"   // comprend : #define F_CPU 16000000UL  // 16 MHz
 
 
 
#define portPIN_switch PINH
#define	pin_switch1	0b00000001
#define	pin_switch2	0b00000010
 
#define portPIN_RAZ PINK
#define	pin_RAZ	0b00000001
 
 
 
// Declare which fonts we will be using
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];
 
/****************************************************************************************************************************************************
//choisir le bon driver suivant, en fonction du type d'afficheur (tous deux des 480x320 qui se ressemblent, achetés au même fournisseur) ******
//la library correcte doit être installée dans le bon dossier ARDUINO, avec les permissions d'accès correctes !
 
UTFT TFT480(CTE32HR,38,39,40,41);
UTFT TFT480(HX8357C,38,39,40,41);
****************************************************************************************************************************************************/
 
UTFT TFT480(HX8357C,38,39,40,41);
 
 
AD9951 DDS_porteuse;
AD9850 DDS_modulation;
 
	uint16_t x_7seg, y_7seg;
 
  uint32_t f_porteuse , memo_f_porteuse; // fréquence du signal de sortie sinusoïdal
  uint32_t f_modulation , memo_f_modulation; // fréquence du signal de sortie sinusoïdal
 
  uint32_t FTW_entier;
 	uint8_t FTW_decim;
 
	uint8_t pos; // position du multiplicateur
	uint8_t pos_curseur_porteuse, pos_curseur_modulation; // position du curseur (pour affichage)
	uint8_t switches, memo_switches; //  8 bits permettant de mémoriser l'état de 8 inverseurs
 
  uint32_t pas_porteuse, pas_modulation;
  uint8_t etat;
  uint8_t depassement;
  uint16_t compteur1;
 
  uint16_t phase;
  uint32_t R3;
	double dP_r;
	uint16_t dP;
 
 
  uint8_t demande_calcul_porteuse, demande_calcul_modulation;
  float position;
 
 
 
/**
RAPPEL variables avr-gcc (vérifiable avec le .map)
 
char					1   -128 .. 127 ou caractères
unsigned char	1  	0 .. 255
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 octets  -2 147 483 648 à 2 147 483 647
int32_t				4	octets -> 32 bits	;	idem long int
long long int	8	octets -> 64 bits
unsigned long int	4	octets -> 32 bits	;	0 .. 4 294 967 295  (4,2 x 10^9)
uint32_t			4	32 bits	;	idem 'unsigned long int'
float					4
double				ATTENTION ! 4	octets (oui, 32 bits ! et pas 64 bits (8 octets) comme en C standard)
 
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).
**/
 
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)
 
  DDRD  = 0b11110000;
  PORTD = 0b00001111;
 
  DDRF  = 0b11111111;
  PORTF = 0b00000000;
 
  DDRH  = 0b11111100; 
  PORTH = 0b00000011;
 
  DDRJ  = 0b11111110; // PJ0 = RXD3  - PJ1 = TXD3 (attention c'est PJ1 qui est au bord du connecteur sur la carte Arduino mega2560)
  PORTJ = 0b00000001;
 
  DDRK  = 0b11111110; 
  PORTK = 0b00000001;
 
 // REMARQUE : les ports utilisés doivent être définis dans les fichiers "AD9850.h" et  "AD9951.h"
}
 
 
 
void int_EXT_setup()
{
	// voir 15. External Interrupts (ATmega2560.pdf p:109)
 
	EICRA |= 0b00001010;  // bits[1,0] = 10 -> int0 sur front descendant;  bits[3,2] = 10 -> int1 sur front descendant;   - p:110
	EIMSK |= 0b00000011;  // bit[0]=1 ->  INT0 enable  ; bit[1]=1 ->  INT1 enable  -   parag 15.2.3  EIMSK - p:111
}
 
 
 
void timer3_setup()
// Pour 
{
  cli();
  TIMSK3 = 0b00000010; // Bit 1 – OCIE3A: Timer/Counter1, Output Compare A Match Interrupt Enable  - p:161
 
  TCCR3A = 0b00000000;	//	p:154
  TCCR3B = 0b00001011;   // prescaler = 1/64 - CTC mode  - p:156 et tableau p:157
 
  OCR3A = 250;            // compare match register - fixe la période - 16MHz/64/250 = 1kHz
  sei();
}
 
 
 
void init_variables(void)
{
	demande_calcul_porteuse = 0;
	demande_calcul_modulation = 0;
 
//	f_porteuse = 100000;
//	f_modulation = 1000;
 
	f_porteuse = 12000000;
	f_modulation = 0;
 
	pos_curseur_porteuse = 5;
	pos_curseur_modulation = 2;
 
	pas_porteuse = 10000;
	switches =0;
	memo_switches =0;
 
	pas_modulation = 10;
//	adjust = 128;
	phase = 0;
	compteur1 =0;
	depassement =0;
 
	x_7seg =0;
	y_7seg =0;
}
 
 
 
 
ISR (INT0_vect) 
{
//interruption sur front descendant sur l'entree Int0
// declenchee par la rotation du codeur_ROT (1)  ->  +/-frequence
 
	etat = PIND & 0b00000100; 
 
	if ( (switches & 0b00000001) == 0)
	{
		if (etat == 0b00000100)
		{
			if (f_porteuse >= pas_porteuse) {f_porteuse -= pas_porteuse;}
		}
		else 
		{
			if ( (f_porteuse+pas_porteuse)  <= 120000000) {f_porteuse += pas_porteuse;}
			if ( (f_porteuse+pas_porteuse)  > 120000000) {f_porteuse = 120000000;}
		}
		demande_calcul_porteuse = 1;
	}
	else
	{
		if (etat == 0b00000100)
		{
			if (f_modulation >= pas_modulation) {f_modulation -= pas_modulation;}
		}
		else 
		{
			if ( (f_modulation+pas_modulation)  <= 40000000) {f_modulation += pas_modulation;}
			if ( (f_modulation+pas_modulation)  >  40000000) {f_modulation = 40000000;}
		}
		demande_calcul_modulation = 1;
	}
 
}
 
 
 
ISR (INT1_vect) 
{
//interruption sur front descendant sur l'entree Int1
// declenchee par la rotation du codeur_ROT (2) -> pas	
	uint8_t n;
	etat = PIND & 0b00001000;
 
	if ( (switches & 0b00000001) == 0) // saisie curseur porteuse
	{
		if (etat == 0) 
		{
			if (pos_curseur_porteuse > 1) {pos_curseur_porteuse--;}
		} 
		else 
		{
			if (pos_curseur_porteuse < 9) {pos_curseur_porteuse++ ;}
		}
		pas_porteuse=1;
		for (n=1; n<pos_curseur_porteuse; n++)	{	pas_porteuse *=10;	}
		demande_calcul_porteuse = 1;
	}
 
	else  // saisie curseur modulation
	{
		if (etat == 0) 
		{
			if (pos_curseur_modulation > 1) {pos_curseur_modulation--;}
		} 
		else 
		{
			if (pos_curseur_modulation < 8) {pos_curseur_modulation++ ;}
		}
		pas_modulation=1;
		for (n=1; n<pos_curseur_modulation; n++)	{	pas_modulation *=10; }
		demande_calcul_modulation = 1;
	}
}
 
 
 
ISR(TIMER3_COMPA_vect)
{
// ajustement de la fréquence par glissement de phase.
// ici 1kHz
//	portTEST ^= pin_TEST1; 
	compteur1++;
	if (compteur1 >= 100)
	{
// ici 10Hz
// ici on fait des sauts de phase (sauts dans le futur), c'est à dire qu'on raccourci la durée de la période
		compteur1=0;
		DDS_porteuse.out_POW(phase);
 		phase +=dP ;
 	}
}
 
 
void trace_ecran()
{
	TFT480.setColor(10, 10, 5);
	TFT480.fillRect(0, 14, 479, 309);
	trace_entete();
	efface_pannel_porteuse();
	efface_pannel_bas();
}
 
 
 
void trace_entete()
{
	TFT480.setColor(64, 64, 64);
  TFT480.fillRect(0, 0, 479, 13); // bandeau en haut
 
  TFT480.setColor(30, 30, 30);
  TFT480.fillRect(0, 300, 479, 319);  // bandeau en bas
 
 
//  TFT480.setBackColor(64, 64, 64);
  TFT480.setColor(255,255,255);
  TFT480.print("GENE 120MHz - AD9951 syncho par GPS + AD9850", CENTER, 1);
 
//  TFT480.setBackColor(64, 64, 64);
  TFT480.setColor(255,255,255);
  TFT480.print(version, 5, 300);
  TFT480.setColor(255,255,255);
  TFT480.print("ATmega2560 - ", 100, 300);
  TFT480.setColor(255,255,255);
  TFT480.print("Silicium628", 210, 300);
 
}
 
 
void TFT_aff_ICI()
{
	TFT480.setFont(BigFont);
  TFT480.setColor(255,255,255);
  TFT480.print("ICI", 0, 220);
}
 
 
 
 
void TFT_affiche_chiffre_7seg(uint8_t num)
{
	TFT480.setFont(SevenSegNumFont);
 	TFT480.printNumI(num, x_7seg, y_7seg); 
}
 
 
 
void TFT_aff_nb_form3 (uint32_t valeur, uint8_t nb_chiffres, uint8_t curseur, uint8_t R, uint8_t G, uint8_t B)
{
//affiche un nombre en representation decimale en separant les groupes de 3 chiffres
	unsigned char r ;
	char tbl[7];
	uint8_t i;
 
	curseur=nb_chiffres +1 -curseur;
 
	for (i=1; i<=nb_chiffres; i++) 
	{
		r=valeur % 10; // modulo (reste de la division)
		valeur /= 10; // quotient
		tbl[i]=r;
	}
	for (i=1; i<= nb_chiffres; i++)
	{
		TFT480.setColor(R,G,B);
 
		if (i==curseur)
		{
			TFT480.setColor(0,250,250);
		}
		TFT_affiche_chiffre_7seg(tbl[nb_chiffres +1 -i]);
		x_7seg+=30;
 
		uint8_t m, k, u;
		m =nb_chiffres-6;
		k =nb_chiffres-3;
		u =nb_chiffres;
 
		//if (i== 3)
		if (i== m)
		{
			TFT480.setFont(BigFont);
			TFT480.setColor(100,100,100);
			TFT480.print("M",x_7seg, y_7seg+30);
			x_7seg+=15;
		}
		//if (i== 6)
		if (i== k)
		{
			TFT480.setFont(BigFont);
			TFT480.setColor(100,100,100);
			TFT480.print("k",x_7seg, y_7seg+30);
			x_7seg+=15;
		}
		//if (i== 9)
		if (i== u)
		{
			TFT480.setFont(BigFont);
			TFT480.setColor(100,100,100);
			TFT480.print("Hz",x_7seg, y_7seg+30);
		}
 
	}
}
 
 
 
void affiche_frequence_porteuse(uint8_t R, uint8_t G, uint8_t B) 
{
	uint8_t x0=10;
	uint8_t y0=20;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(100,160,230); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("FREQ PORTEUSE", x0, y0); // Etiquette
 
	x_7seg = x0;
	y_7seg = y0+20;
 
	uint8_t p2;
	p2 = pos_curseur_porteuse;
	if ((switches & 0b00000001) == 0b00000001) {p2=0;} // pour ne pas afficher la surbrillance du "curseur" si le mode de saisie en cours concerne l'autre fréquence
 
	TFT_aff_nb_form3 (f_porteuse, 9, p2, R, G, B);
 
}
 
 
 
void affiche_frequence_modulation(uint8_t R, uint8_t G, uint8_t B) 
{
	uint8_t x0=10;
	uint8_t y0=110;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("FREQ MODULATION", x0, y0);
 
	x_7seg = x0+30;
	y_7seg = y0+20;
 
	uint8_t p2;
	p2 = pos_curseur_modulation;
	if ((switches & 0b00000001) == 0) {p2=0;} // pour ne pas afficher la surbrillance du "curseur" si le mode de saisie en cours concerne l'autre fréquence
 
	TFT_aff_nb_form3 (f_modulation, 8, p2, R, G, B);
}
 
/*
 
void affiche_adjust() 
{
	uint8_t x0=10;
	uint8_t y0=215;
 
	uint8_t x1;
	uint8_t y1;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("Adj FRQ", x0, y0);
 
	x1 = x0+120;
	y1 = y0;
 
	uint8_t p2;
	p2=0; // pour ne pas afficher la surbrillance du "curseur"
 
	TFT480.setColor(0,255,0);
	TFT480.print("   ", x1, y1);
	TFT480.printNumI(adjust-128, x1, y1);
}
*/
 
 
void affiche_phase() 
{
	uint8_t x0=10;
	uint8_t y0=255;
 
	uint8_t x1;
	uint8_t y1;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("Phase", x0, y0);
 
	x1 = x0+100;
	y1 = y0;
 
	uint8_t p2;
	p2=0; // pour ne pas afficher la surbrillance du "curseur"
 
	TFT480.setColor(0,255,0);
	TFT480.print("                    ", x1, y1);
	TFT480.printNumI(phase, x1, y1);
}
 
 
void efface_pannel_porteuse()
{
	uint16_t x1, y1, x2, y2;
	x1=5;
	y1=30;
	x2=350;
	y2=100;
 
	TFT480.setColor(10, 10, 5);
	TFT480.fillRect(x1, y1, x2, y2);
	TFT480.setColor(100, 100, 100);
	TFT480.drawRect(x1, y1, x2, y2);
}
 
 
void efface_pannel_bas()
{
	uint16_t x1, y1, x2, y2;
	x1=5;
	y1=190;
	x2=350;
	y2=290;
 
	TFT480.setColor(10, 10, 5);
	TFT480.fillRect(x1, y1, x2, y2);
	TFT480.setColor(100, 100, 100);
	TFT480.drawRect(x1, y1, x2, y2);
}
 
 
void affiche_phaseOff()
{
	uint8_t x1=340;
	uint8_t y1=250;
 
	TFT480.setFont(BigFont);
	TFT480.setColor(60,60,60);
	TFT480.print("phase adjust OFF", x1, y1);
 
}
 
 
void affiche_FTW_entier()
{
	uint8_t x0=10;
	uint8_t y0=200;
 
	uint8_t x1;
	uint8_t y1;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("FTW", x0, y0);
 
	x1 = x0+100;
	y1 = y0;
 
	TFT480.setColor(0,255,0);
	TFT480.print("          ", x1, y1);
	TFT480.printNumI(FTW_entier, x1, y1);
}
 
 
 
void affiche_FTW_decim()
{
	uint8_t x0=10;
	uint8_t y0=220;
 
	uint8_t x1;
	uint8_t y1;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("decim", x0, y0);
 
	x1 = x0+100;
	y1 = y0;
 
	TFT480.setColor(0,255,0);
	TFT480.print(".         ", x1, y1);
	TFT480.printNumI(FTW_decim, x1+10 , y1);
}
 
 
 
 
void affiche_dP_r()
{
	uint8_t x0=10;
	uint8_t y0=240;
 
	uint8_t x1;
	uint8_t y1;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(SmallFont);
	TFT480.print("dP_r", x0, y0);
 
	x1 = x0+100;
	y1 = y0;
 
	TFT480.setColor(200,255,0);
	TFT480.print("                    ", x1, y1);
	TFT480.printNumF(dP_r,5, x1, y1);
}
 
 
void affiche_dP()
{
	uint8_t x0=10;
	uint8_t y0=255;
 
	uint8_t x1;
	uint8_t y1;
 
	TFT480.setBackColor(0, 0, 0);
  TFT480.setColor(150,150,150); // couleur de l'étiquette uniquement
  TFT480.setFont(BigFont);
	TFT480.print("dP", x0, y0);
 
	x1 = x0+100;
	y1 = y0;
 
	TFT480.setColor(255,0,0);
	TFT480.print("    ", x1, y1);
	TFT480.printNumI(dP, x1, y1);
}
 
 
 
/**
 Le message à transmettre au module NEO-7M peut-être affiché par u-center
 -ouvrir le fenêtre Messages (par F9 ou menu View /  Messages View)
 -choisir dans la liste la fonction à programmer (ici: UBX / CFG(config)/ TP5(Timepulse5)
 -puis dans la liste déroulante qui apparait alors dans la partie droite de la fenêtre 'Messages, selectionner '0 - TIMEPULSE'
 -cocher les options qui vont bien (voir page sur mon site)
 -le message à transmettre s'affiche alors dans le cadre au dessous.
 
 pour UBX-CFG(config)-TP5(Timepulse5) 
 envoyé par u-center :
 B5 62 06 31 20 00 00 01 00 00 32 00 00 00 01 00 00 00 00 1B B7 00 00 00 00 00 00 00 00 80 00 00 00 00 6F 00 00 00 4C 95
 
 B5 62 c'est l'entete toujours la même
 
 Nous allons transmettre ces 40 octets au module NEO-6M avec l'USART de l'ATmega, ce qui nous permettra pas la suite de nous passer du programme u-center
**/
 
void config_NEO_7M_GPS()
{
  //configure le recepteur GPS NEO-7M afin qu'il génère un signal 12MHz
  // ce qui n'est pas le cas par défaut (1 Hz)
  uint8_t i;
 
  uint8_t paquet[]={0xB5,0x62,0x06,0x31,0x20,0x00,0x00,0x01,0x00,0x00,0x32,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
	0x1B,0xB7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x6F,0x00,0x00,0x00,0x4C,0x95 };
 
  for (i=0; i<40; i++)
  {
    USART_TxByte(paquet[i]); // utiliser TXD3 (se configure dans le fichier usart2560_628.c)
  }  
}
 
// ===================================================================================================================================================
 
 
 
void setup()
{
 // randomSeed(analogRead(0));
 
  init_ports();
	USART_Init();
 
 
  TFT480.InitLCD();
  TFT480.setFont(SmallFont);
  TFT480.clrScr();
 
  init_variables();
  int_EXT_setup();
  timer3_setup();
 
 
// ATTENTION : pour l'AD9951, faire le reset AVANT l'init parce que le reset efface tout.
	DDS_porteuse.reset();
 
 
//	DDS_porteuse.set_ref_clk(20000000, 20); // cas du TCXO 20MHz
//	DDS_porteuse.set_ref_clk(10000000, 20); //cas du GPS à 10MHz
	DDS_porteuse.set_ref_clk(12000000, 20); // cas du GPS à 12MHz
 
	DDS_porteuse.DDS_init();
 
	DDS_modulation.reset();
 
  trace_ecran();
  affiche_leds();
 
	config_NEO_7M_GPS();
 
	sei();	// enable interruptions
	demande_calcul_porteuse = 1;
	demande_calcul_modulation = 2;  // le AD9850 est un peu dur d'oreille au départ, il faut lui dire deux fois... (?)
 
}
 
 
void affiche_led_verte(uint8_t s)
{
	if(s==1)
	{
		TFT480.setColor(0,255,0); // vert
		TFT480.fillCircle(410, 240, 10); // allume la "led" (cercle)
	}
	else
	{
		TFT480.setColor(40,40,40); // gris
		TFT480.fillCircle(410, 220, 10); // éteint la "led" (cercle)
	}
}
 
 
void affiche_leds()
{
		if ( (switches & 0b00000001) == 0)
		{
			TFT480.setColor(0,255,0); // vert
			TFT480.fillCircle(380, 62, 10); // allume la "led" (cercle) rouge en haut
 
			TFT480.setColor(40,40,40); // gris
			TFT480.fillCircle(380, 152, 10); // éteint la "led" (cercle) rouge au milieu
 
		}
		else
		{
			TFT480.setColor(40,40,40); // gris
			TFT480.fillCircle(380, 62, 10);  // éteint la "led" (cercle) rouge en haut
			TFT480.setColor(0,255,0); // vert
			TFT480.fillCircle(380, 152, 10); // allume la "led" (cercle) rouge au milieu
 
		}
 
		if ( (switches & 0b00000010) == 0)
		{
 
			if (depassement == 1) {TFT480.setColor(255,255,0);} else {TFT480.setColor(0,255,0); }
			TFT480.fillCircle(380, 260, 10); // allume la "led" (cercle) verte ou jaune en bas	
		}
		else
		{
			efface_pannel_bas();
			affiche_phaseOff();
			TFT480.setColor(255,0,0); // rouge
			TFT480.fillCircle(380, 260, 10); // allume la "led" (cercle) rouge en bas	
		}		
}
 
 
 
void calcul_dP()
{
	if ( (switches & 0b00000010) == 0)
	{
		R3=f_porteuse/10; // voir ISR(TIMER3_COMPA_vect) -> on modifie à la fréquence de 10Hz.
		dP_r=16384.0 / 100;
		dP_r *= FTW_decim;
		dP_r *= R3;
		dP_r /= FTW_entier;
		dP= (uint16_t) dP_r;
	}
	else { dP = 0; }
 
}
 
 
void loop()
{
	uint8_t r1;
 
	while(1)
	{
//		memo_mode_saisie = mode_saisie;
		memo_switches = switches;
 
	//	mode_saisie = portPIN_switch  & pin_switch1; // mode_saisie = 0 ou 1 suivant la position du switch1
	//	if ((portPIN_switch  & pin_switch2) == 0) mode_saisie = 3;  // =2
 
		if ((portPIN_switch & pin_switch1) == pin_switch1) { switches |= 0b00000001; } else { switches &= 0b11111110; }
		if ((portPIN_switch & pin_switch2) == pin_switch2) { switches |= 0b00000010; } else { switches &= 0b11111101; }
 
		calcul_dP();
 
		if (memo_switches != switches)
		{
			affiche_leds();
			affiche_frequence_porteuse(0, 100, 255); // pour raffraichier la surbrillance des curseurs sur la bonne ligne de saisie.
			affiche_frequence_modulation(200, 200, 0);
			if  ((switches & 0b00000010) == 0)
			{
				efface_pannel_bas();
				if (depassement == 0)
				{
					affiche_FTW_entier();
					affiche_FTW_decim();
					affiche_dP_r();
					affiche_dP();
				}
			} 
		}
 
 
		if(demande_calcul_porteuse > 0)
		{
			demande_calcul_porteuse = 0;
			depassement = DDS_porteuse.calcul_FTW(f_porteuse, &FTW_entier, &FTW_decim); // effectue le calcul de TFW et retourne le reste de la division
 
			_delay_ms(1);
			if ( (switches & 0b00000010) == 0)
			{
				affiche_leds();
				efface_pannel_bas();
				if (depassement == 0)
				{
					affiche_FTW_entier();
					affiche_FTW_decim();
					affiche_dP_r();
					affiche_dP();
				}
			} 
 
			DDS_porteuse.out_FTW();
			_delay_ms(1);
			affiche_frequence_porteuse(0, 100, 255);
			_delay_ms(1);
		}
 
 
		if(demande_calcul_modulation > 0 )
		{
			demande_calcul_modulation --;
			DDS_modulation.calcul_FTW(f_modulation);
			DDS_modulation.out_FTW();
			_delay_us(10);
			affiche_frequence_modulation(200, 200, 0);
			_delay_us(10);
		}
 
		if((portPIN_RAZ & pin_RAZ) == 0) // RAZ des fréquences sur appui de l'encodeurs rotatif du haut (qui comprend un switch)
		{
			if ( (switches & 0b00000001) == 0) {f_porteuse =0; demande_calcul_porteuse += 1; } else {f_modulation =0; demande_calcul_modulation = 1;}
 
 
			if ((switches & 0b00000010) == 0)
			{ // soft reset
				switches == 0;
				TFT480.clrScr();
				TFT480.setColor(30, 30, 30);
				TFT480.fillRect(0, 150, 479, 200);  // bandeau
				TFT480.setColor(255,0,0);
				TFT480.print("SOFT RESET", CENTER, 160);
				_delay_ms(1000);
				TFT480.clrScr();
				setup();
			} 
 
		}
 
		_delay_ms(1);
 
 
 
	}
 
}