Wobulateur UHF 4GHz ADF4351 + AD9850 + ESP32 + ILI9341

ELECTRONIQUE PROGRAMMABLE

Théorie et Applications

J'avais déjà réalisé, il y a plusieurs années, un tel géné UHF utilisant un ADF4351, mais sur une base arduino Mega2560. Le temps passant les library utilisées, surtout la lib UTFT sont devenues obsolètes, et celles qui leurs ont succédé posent des problèmes de dépendances au point que je ne peux plus moi-même assurer les mises à jour. Les encodeurs rotatifs pas à pas eux aussi posent problème, ils vieillissent très mal !

J'ai donc décidé de faire un nouvel appareil basé cette fois sur un ESP32 (beaucoup plus puissant et rapide que le Mega2560) et un afficheur ILI9341 avec écran tactile permettant de se passer des encodeurs mécaniques.

1 - Première vidéo : la saisie de la fréquence au stylet
2 - Le schéma de ma carte ESP32 + ILI9341 2.8
3 - Le schéma complet du géné HF - UHF wobulé
4 - Le code source (fichier main.cpp)
5 - VIDEO : Wobulation 300MHz
6 - Le signal 300MHz wobulé vu à l'oscilloscope
7 - Signal 4MHz généré par le module AD9850
8 - PREMIERE LUEUR !
9 - Wobulations avec l'AD9850
10 - Formule de Thomson

11 - Premier test en très basse fréquence (80kHz)
12 - Test de transfos FI 455kHz et 10.6MHz
13 - Test d'un filtre céramique 10.7MHz
14 - Circuit avec C = 270 pF et une self inconnue :
15 - Circuit avec C = 82 pF
16 - Circuit avec C = 47 pF
17 - Circuit avec C = 18 pF
18 - Circuit avec C = 10 pF
19 - Wobulation avec l'ADF4351 - circuit LC - 170MHz
20 - Filtre en Pi 2.4GHz

21 - Wobulation de ce filtre en Pi - 2.4GHz
22 - Test d'un autre filtre 2.4GHz
23 - petite capture d'écran...
24 - Le détecteur d'amplitude AM
25 - Un autre détecteur AM
26 - Quelques boucles d'induction et diverses selfs enrobées
27 - Les modules DDS AD9850 & ADF4351
28 - L'afficheur 2.8 et le module ESP32
29 - Le board (carte perso reliant l'afficheur à l'ESP32 )
30 - Cet appareil dans son boîtier

31 - Disposition des modules dans la boite
32 - Affichage bande passante et facteur de qualité
33 - Facteur de qualité d'un filtre blindé FI 455MHz
34 - Facteur de qualité d'un filtre céramique 10.7MHz
35 - Facteur de qualité d'un quartz 16MHz
36 - Test par GPS de la précision de la fréquence de l'AD9850 et de celle du quartz 16MHz
37 - On va dorloter le quartz !
38 - documents

1 Première vidéo : la saisie de la fréquence au stylet
Fréquence sur 10 chiffres, jusqu'à 4.4GHz Remarque : l'image de l'oscillo c'est juste pour faire joli et pour montrer que ma carte est capable de lire rapidement des données sur la SDcard et d'afficher des images. Elle permet aussi les copies d'écran vers la SDcard. Voir pour patienter mon article : "https://www.silicium628.fr/article_i.php?id=167" qui utilise déjà cette même carte.

2 Le schéma de ma carte ESP32 + ILI9341 2.8
Cette carte perso remplace la célèbre "carte jaune CYD" avec des fonctions inutiles en moins et beaucoup de ports GPIO libres en plus. J'ai utilisé cette carte une première fois pour le petit récepteur radio SW-AM, FM, AIRband présenté ICI : Récepteur radio à TEF6686 + ILI9341 + SDcard

3 Le schéma complet du géné HF - UHF wobulé
Le seul circuit imprimé c'est celui de la carte qui relie l'ESP32 devKit à l'afficheur 2.8" ILI9341 + lecteur SDcard (encadré par les pointillés bleus).

4 Le code source (fichier main.cpp)

CODE SOURCE en C++

/* ************************************************************************************
	Gene UHF et Wobulateur AD9850 + ADF4351  
	par Silicium628
	pour ma carte (fab : JLCPCB) ESP32 Wroom + afficheur 2.8" TFT 240x320  + SDcard
 
	Cette version utilise la SDcard
 
************************************************************************************ */
 
// REMARQUES: 
// 1) lorsque la carte est connectée sur un bus USB de l'ordinateur,
// un terminal série tel que CuteCom affichera beaucoup de choses en temps réel.
// 2) Pour s'y retrouver dans le code, le plus simple est de partir de la fonction 'loop()' qui appelle les autres 
// 3) Le fichier User_Setup dans le dossier 'lib/TFT_eSPI' est spécifique à cette configuration
// pour ce qui concerne les connexions mais aussi les limitations de fréquence du bus SPI
 
 
#include <Arduino.h>
#include "main.h"
#include "ADF4351-ESP32.h"
#include "AD9850-ESP32.h"
 
String version = "3.1.1"; 
 
#include "FS.h"
#include "SD.h"
#include "Wire.h"
#include <stdint.h>
 
#include <Free_Fonts.h>
#include "TFT_eSPI.h" // Hardware-specific library
#include "SPI.h"
// #include "Digit_Font.h"
#include <XPT2046_Touchscreen.h>
 
#include "constantes2_628.h"
#include "Couleurs_AEC.h"
 
int style = 0; // 0 bleu, 1 vert, 3 jaune
 
ADF4351 CarteADF4351;
AD9850  CarteAD9850;
 
 
#define SPI_READ_FREQUENCY 16000000
 
#define XPT2046_IRQ 36
#define XPT2046_MOSI 32 //T_DI 32
#define XPT2046_MISO 39 //T_DO 39
#define XPT2046_CLK 25
#define XPT2046_CS 33
 
const int GPIO_SDA = 21; 
const int GPIO_SCL = 22; 
 
const int analogPin = 35;
const int boutonPin1 = 4; // GPIO4
 
//const int GPIO_BL = 4; // pour LED backlight ILI9341- INUTILISE POUR CETTE APPLICATION - relier backlight à +3v3
// donc le GPIO4 est libre...
 
const int _DX = 320;
const int _DY = 240;
 
SPIClass mySpi = SPIClass(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
 
SPIClass mySpi2 = SPIClass(HSPI);
 
TFT_eSPI TFT = TFT_eSPI(); // Configurer le fichier User_Setup.h de la bibliothèque TFT_eSPI au préalable
 
TFT_eSprite sprite_frq = TFT_eSprite(&TFT); // grands chiffres en haut
TFT_eSprite sprite_freq_W_min = TFT_eSprite(&TFT);
TFT_eSprite sprite_freq_W_max = TFT_eSprite(&TFT);  
 
uint16_t FRQ_x0;
uint16_t FRQ_y0;
 
const uint64_t F_min_AD9850  = 1;
const uint64_t F_max_AD9850  =   52000000; // 52 MHz , au delà le signal est pourri !
 
const uint64_t F_min_ADF4351 =   33000000;
const uint64_t F_max_ADF4351 = 4400000000;
 
 
struct ETALON_TS // etalon touch screen
{
    int16_t x0;
    int16_t dx;
	int16_t y0;
    int16_t dy;
};
 
ETALON_TS eTS;
 
struct POINT
{
	uint16_t x;
	uint16_t y;
};
 
// coordonnées des points de calibrage de l'écran tactile 
// (calibration ? étalonnage ?? ajustage ??? boaf, m'enfin !!)
POINT A, B;
 
uint8_t SDcardOk=0;
 
uint16_t x_touch, y_touch;
uint16_t memo_x_touch, memo_y_touch;
 
uint16_t compte1=0;
uint16_t compte2=0;
 
uint8_t num_capture = 0;
 
uint64_t frequence=10000; 
uint32_t pas_W = 0; // pas (de wobulation)
//uint64_t freq_W_min;
uint64_t freq_W_max;
uint64_t Fmin, Fmax;
 
 
double F_9850;	// fréquence à envoyer à l'AD9850 (en 1/10 Hz)
double F_4351;	// fréquence à envoyer à l'ADF4351 (en MHz avec décimales)
 
//boolean le_pas_est_choisi = false; 
boolean soft_setup =false;
boolean do_capt_screen = false;
 
boolean stop1=false;
boolean en_boucle = false;
 
uint16_t JAUNE_chiffres = 65504; 
uint16_t VERT_chiffres = 2016;
 
TOUCH_BOUTON bt_RAZ;
 
//fréquences presets
TOUCH_BOUTON bt_455k;
TOUCH_BOUTON bt_4M;
TOUCH_BOUTON bt_10_7M;
TOUCH_BOUTON bt_27M;
TOUCH_BOUTON bt_35M;
TOUCH_BOUTON bt_41M;
TOUCH_BOUTON bt_144M;
TOUCH_BOUTON bt_432M;
TOUCH_BOUTON bt_2400M;
 
 
TOUCH_BOUTON bt_AD9850;
TOUCH_BOUTON bt_ADF4351;
 
TOUCH_BOUTON bt_mode_GENE;
TOUCH_BOUTON bt_mode_WOBU;
 
TOUCH_BOUTON bt_STOP_1; // du balayage fréquenciel
//TOUCH_BOUTON bt_STOP_2; // de la boucle de déplacement du curseur
 
TOUCH_BOUTON bt_polarite;
 
TOUCH_BOUTON bt_gain_P; // gain +
TOUCH_BOUTON bt_gain_M; // gain -
 
TOUCH_BOUTON bt_pas_P; // incrémente le pas de wobulation suivant la suite 1,2,5...
TOUCH_BOUTON bt_pas_M;
uint8_t num_pas=0;
 
TOUCH_BOUTON bt_boucle; 
 
TOUCH_BOUTON bt_calibrate;
TOUCH_BOUTON bt_TEST;
 
CHF_PAD chf_pad1;
 
enum OUTPUT_MODE {MODE_9850, MODE_4351}; 
OUTPUT_MODE out_mode1;
OUTPUT_MODE memo_out_mode1;
 
enum FONCTION_MODE {MODE_ACCUEIL, MODE_GENE, MODE_WOBU}; 
FONCTION_MODE f_mode1;
//FONCTION_MODE memo_f_mode1;
 
enum POLARITE {_DIR, _INV};
POLARITE polarite1 = _DIR;
 
uint32_t liste_pas_W_a[3] = {1, 2, 5}; // num 0 à 3
uint64_t liste_pas_W_b[7] = {1, 10, 100, 1000, 10000, 100000, 1000000}; // numéros 0 à 6
 
uint16_t memo_img[200*32];
float tableau_acq[320];
 
 
void init_sprites()
{
	sprite_frq.createSprite(315, 45);
	sprite_frq.setTextDatum(MR_DATUM); // alignement du texte
 
	sprite_freq_W_min.createSprite(80, 8);
	sprite_freq_W_max.createSprite(80, 8);
}
 
 
void init_variables_globales()
{
	FRQ_x0 = 2;	
	FRQ_y0 = 30;
 
	//frequence = 4123456789; // 4.12 GHz
	frequence = 60000000;  // 60MHz
}
 
 
void init_1_bouton(uint8_t n_font, uint16_t xi, uint16_t yi, uint8_t dx, uint8_t dy, String si, TOUCH_BOUTON *bouton_i)
{
	bouton_i->init(xi, yi, dx, dy, 3, GRIS_5);
	bouton_i->cliked = false;
	bouton_i->selected = false;
	bouton_i->label = si;
	bouton_i->affiche(BLANC, VERT, n_font);
}
 
 
void popup(uint16_t x, uint16_t y, String s1, String s2)
{
	TFT.readRect(x, y, 200, 32, memo_img); // memorise image avant de tracer le texte
 
	TFT.fillRect(x, y, 200, 32, NOIR);
	TFT.drawRect(x, y, 200, 32, VERT);
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF1); // 1ere ligne en 'gros' caractères
	TFT.drawString(s1, x+2, y+2);
	TFT.setFreeFont(FF0); // 2eme ligne en plus petits caractères (mais elle peut donc être plus longue)
	TFT.drawString(s2, x+2, y+20);
	delay(1000);
	TFT.pushRect(x, y, 200, 32, memo_img);
}
 
 
 
void test_bouton_physique1()
{
	int v = digitalRead(boutonPin1);
	if (v == 0) 
	{
		capture_ecran();
	}
}
 
 
 
// Fonction optimisée pour l'afficheur ILI9341 320x240 avec la  library 'TFT_eSPI'
// ne convient PAS pour les ESP32 Wroom + afficheur 3.5" TFT 480x320
void capture_ecran() // enregistre image bmp 320x240 RGB565 (5+6+5 = 16bits/px)
{
Serial.println("capture_ecran()"); 
 
	if (SDcardOk==0) 
	{
		Serial.println("SDcard absente, capture ecran impossible"); 
		return;
	}
 
	int32_t x, y;
	uint16_t color565;
 
	uint8_t  lineBuffer8[(320*2)];
	uint16_t lineBuffer16[320];
	uint8_t octet_A, octet_B;
	String s1, s2;	
 
	s1 ="/bmp565/capture";
	s1 += String(num_capture);
	s1 += ".bmp" ;
 
Serial.print("s1= "); Serial.println(s1);
 
	while(SD.exists(s1) &&  num_capture <= 50) 
	{
		num_capture ++;
		s1 ="/bmp565/capture";
		s1 += String(num_capture);
		s1 += ".bmp" ;
	}
	if (num_capture >= 50)
	{
		popup(40, 150, "Nb de CPT > 50 !", "Voir sur la SDcard"+s1);
		num_capture =0;
	} 
 
	File file1 = SD.open(s1, FILE_WRITE); // crée le fichier si pas présent
	delay(20);
	if (file1)
	{
		// création entête bmp565 - 138 octets; voir bmp565_header[] dans le fichier main.h
		for(uint8_t i=0; i<138; i++) { file1.write(bmp565_header[i]); }
		TFT.setTextColor(VERT, NOIR);
		for (int16_t y=239; y>=0; y--)
		{
			TFT.readRect(0, y, 320, 1, lineBuffer16); // lit une ligne
			s2=String(y/24);
			TFT.drawString(s2, 2, 2); // pour terminer par une écriture
 
			uint16_t i=0;
			for (int16_t x=0; x<320; x++) //320
			{
				uint16_t color565px = lineBuffer16[x];  // BBBBBrrr rrrVVVVV 
				octet_A = (color565px & 0b1111111100000000) >> 8;
				octet_B = (color565px & 0b0000000011111111);
 
				lineBuffer8[i]   = octet_A;
				lineBuffer8[i+1] = octet_B;
				i+=2;
			}	
			file1.write(lineBuffer8, sizeof(lineBuffer8)); 
		} 
		file1.close();
		num_capture ++;
 
		// TFT.fillScreen(NOIR);
 
		popup(40, 150, "   Capture OK", "    "+s1);
 
 
		delay(2000);
	}
}
 
 
 
void printTouchToDisplay() // pour TEST positions lors de la conception de l'interface graphique
{
// dessine une petite croix jaune au points d'appuis du stylet
 
	init_1_bouton(1, 235, 114, 30, 15, "TEST", &bt_TEST);
 
	uint16_t memo_seg_H[22];
	uint16_t memo_seg_V[22];
	uint16_t memo_x, memo_y;
 
	TFT.setFreeFont(FM9);
	TFT.setTextColor(BLEU_CLAIR, NOIR);
	//TFT.drawString("TEST TOUCH screen", 80, 120);
 
	TFT.readRect(x_touch-10, y_touch, 20, 1, memo_seg_H); 
	TFT.readRect(x_touch, y_touch-10, 1, 20, memo_seg_V);
	while(1)
	{
		if (ts.tirqTouched() && ts.touched()) 
		{
			get_XY_touch();
			TFT.readRect(x_touch-10, y_touch, 20, 1, memo_seg_H); // memorise image avant de tracer le trait
			delay(10);
			TFT.pushRect(memo_x_touch-10, memo_y_touch, 20, 1, memo_seg_H); // efface avec l'image enregistrée
			delay(10);
			TFT.drawFastHLine(x_touch-10, y_touch, 20, JAUNE);
			delay(10);
 
			TFT.readRect(x_touch, y_touch-10, 1, 20, memo_seg_V); // memorise image avant de tracer le trait
			delay(10);
			TFT.pushRect(memo_x_touch, memo_y_touch-10, 1, 20, memo_seg_V); // efface avec l'image enregistrée
			delay(10);
			TFT.drawFastVLine(x_touch, y_touch-10, 20, JAUNE);
 
			String s1;
			s1 = String(x_touch)+ "    ";
			TFT.drawString(s1, 120, 130);
			s1 = String(y_touch)+ "    ";
			TFT.drawString(s1, 120, 154);
			delay(10);
 
			test_clic_bouton_TEST();
		}
	}
} 
 
 
 
void affiche_box_FRQ(uint16_t couleur) // autour de la fréquence (gros chiffres)
{
	TFT.drawRect(0, FRQ_y0 -17, 319, 48, couleur);
}
 
 
 
void acquisition_reponse()
{
	uint16_t valeurLue = analogRead(analogPin); // = 0..4095
 
}
 
 
void out_frequence()
{
	if (out_mode1 == MODE_9850)
	{
		F_9850 = 10.0 * frequence;
		CarteAD9850.out_F(F_9850);
	}
 
	if (out_mode1 == MODE_4351)
	{
		F_4351 = (double) frequence / 1e6;
		CarteADF4351.setFreq(F_4351);
		CarteADF4351.Write_All_Register();
	}
}
 
 
void affiche_frequence(uint64_t frq)
{	
	uint16_t couleur_chiffres;
	uint16_t couleur_fond;
 
	if(style == 0) { couleur_chiffres = VERT_chiffres; couleur_fond = NOIR; }
	if(style == 1) { couleur_chiffres = BLANC; couleur_fond = BLEU; }
	if(style == 2) { couleur_chiffres = JAUNE_chiffres; couleur_fond = NOIR; }
 
	sprite_frq.fillRect(0, 0, 320, 45, couleur_fond); // couleur_fond efface
 
	sprite_frq.setTextColor(couleur_chiffres, couleur_fond); 
	String Str_frq = formatage_frq(frq);  // ajoute les points (.) séparateurs des milliers
	sprite_frq.drawString(Str_frq, 320, 30, 6);  //320, 32, 6
	sprite_frq.pushSprite(FRQ_x0, 14);
 
	affi_mode();
	out_frequence();
 
}
 
 
void encadre_chiffre(uint16_t x)
{
	TFT.drawRect(x, 18, 28, 44, BLANC);
}
 
 
void efface_bande_boutons()
{
	TFT.fillRect(0, 61, 319, 19, NOIR);
	TFT.drawRect(0, 61, 319, 19, BLANC);
}
 
 
void affi_boutons_gene() // boutons presets de fréquences
{
	efface_bande_boutons();
 
	TFT.setFreeFont(FF0);
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("presets->", 5, 65);
 
	if (out_mode1 == MODE_9850)
	{
		uint16_t x = 60;
		init_1_bouton(1, x, 65, 30, 10, "455k", &bt_455k); 	x+=35;
		init_1_bouton(1, x, 65, 20, 10, "4M", &bt_4M); 		x+=25;
		init_1_bouton(1, x, 65, 30, 10, "10.7", &bt_10_7M); x+=35;
		init_1_bouton(1, x, 65, 25, 10, "27M", &bt_27M); 	x+=30;
 
	}
 
	if (out_mode1 == MODE_4351)
	{
		uint16_t x = 60;
		init_1_bouton(1, x, 65, 25, 10, "35M", &bt_35M); 	x+=30;
		init_1_bouton(1, x, 65, 25, 10, "41M", &bt_41M); 	x+=30;
		init_1_bouton(1, x, 65, 30, 10, "144M", & bt_144M); x+=35;
		init_1_bouton(1, x, 65, 30, 10, "432M", & bt_432M); x+=35;
		init_1_bouton(1, x, 65, 30, 10, "2.4G", & bt_2400M);
	}
 
	TFT.drawRect(1, 61, 319, 19, BLANC);
}
 
 
 
void affi_select_PAS()
{
	efface_bande_boutons();
	init_1_bouton(1, 3, 63, 35, 15, "PAS-", &bt_pas_P);
	init_1_bouton(1, 43, 63, 35, 15, "PAS+", &bt_pas_M);
 
	init_1_bouton(1, 83, 63, 40, 15, "BOUCLE", &bt_boucle);
}
 
 
uint64_t calcul_pas_w(uint8_t n) // progression 1,2,5,10,20...[5e6]re
{
	if (n>21) {return 0;}
	int b=0;
	for(int i=0; i<7; i++)
	{
		if(n<3) {return liste_pas_W_a[n] * liste_pas_W_b[b];}
		b++; n-=3;
	}
	return 0;
}
 
 
 
void init_boutons_choix_MODULE()
{
	init_1_bouton(2,  45, 90, 90, 25, " AD9850",  &bt_AD9850);
	init_1_bouton(2, 175, 90, 90, 25, " ADF4351", &bt_ADF4351);
	init_1_bouton(1, 5, 210, 60, 18, "calibrate", &bt_calibrate);
 
}
 
 
void init_boutons_choix_MODE()
{
	init_1_bouton(1, 80, 0, 60, 15, "GENE",  &bt_mode_GENE);
	init_1_bouton(1, 160, 0, 60, 15, "WOBU", &bt_mode_WOBU);
}
 
 
 
void init_affichages()
{
Serial.println("init_affichages()"); 	
	TFT.fillRect(0, 0, 319, 239, NOIR);
 
	TFT.setTextColor(BLANC, NOIR);
 
	TFT.drawRect(0, 0, 320, 240, BLANC); // cadre principal pourtour de l'écran
	//TFT.setFreeFont(FF0);
	//TFT.setTextColor(BLANC, BLEU);
	//String s1 = "v:" + version;
	//TFT.drawString(s1, 2, 2);
 
	while (!Serial && (millis() <= 1000));
 
	TFT.setFreeFont(FF0);
 
	init_1_bouton(1, 285, 0, 30, 12, "RAZ", &bt_RAZ);
 
	affi_boutons_gene();
 
/*
	TFT.fillRect(3,  80, 115, 3, ORANGE); // barres horizontales colorées 
	TFT.fillRect(135, 80, 105, 3, VERT);
	TFT.setFreeFont(FF0);
	TFT.setTextColor(ORANGE, NOIR);
	TFT.drawString("AD9850", 45, 80);
	TFT.setTextColor(VERT, NOIR);
	TFT.drawString("ADF4351", 165, 80);
*/
	affiche_box_FRQ(GRIS_3); // autour de la fréquence (gros chiffres JAUNE ou VERT)
 
	bt_RAZ.affiche(BLANC, VERT, 1); 
	bt_TEST.affiche(BLANC, VERT, 1); 
 
	TFT.drawRect(0, 0, 319, 240, BLANC); // cadre principal pourtour de l'écran
 
}
 
 
void affi_page_info()
{
// affiche une page d'information:
 
	TFT.fillScreen(NOIR);
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF1);
	uint16_t y=0;
	TFT.drawString("DOUBLE GENE UHF - WOBULATEUR", 0, y);	y+=40;
 
	TFT.setTextColor(ORANGE, NOIR);
	TFT.drawString("AD9850  -> 0 to 35Hz MHz", 0, y);	y+=20;
	TFT.setTextColor(VERT, NOIR);
	TFT.drawString("ADF4351 -> 35 MHz to 4.4 GHz", 0, y);	y+=40;
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF1);
	String s1="version " + version;
	TFT.drawString(s1, 0, y);	y+=20;
 
	TFT.setTextColor(CYAN, NOIR);
	TFT.setFreeFont(FF1);
	TFT.drawString("Silicium628", 0, y);	y+=40;
 
	delay(1000);
}
 
 
void init_SDcard()
{
	Serial.println("---------------------");
	Serial.println("init_SDcard()");	
	String s1;
 
	TFT.fillRect(0, 0, 480, 320, NOIR); // efface tout l'écran
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF1);
 
 	if(!SD.begin(5, mySpi2)) 
	{ 
		Serial.println("Card Mount Failed");
		SDcardOk=0;
	} 
	else 
	{ 
		Serial.println("SDcard OK");	
		SDcardOk=1;
		TFT.fillRect(0, 0, 480, 320, VERT);
		delay(100);
	}
 
    uint8_t cardType = SD.cardType();
 
    if(cardType == CARD_NONE)
    {
		Serial.println("NO SDcard"); 
		SDcardOk=0;
        return;
    }
 
	Serial.print("SDcard Type: ");
	if(cardType == CARD_SD) {Serial.print("SDSC");}
    else if(cardType == CARD_SDHC) {Serial.println("SDHC");}
 
	uint32_t cardSize = SD.cardSize() / (1024 * 1024);
	s1=(String)cardSize + " GB";
	Serial.println(s1); Serial.println();
 
	delay (100);
	TFT.fillRect(0, 0, 480, 320, NOIR); // efface
}
 
 
uint16_t read_16(File fp)
{
    uint8_t low;
    uint16_t high;
    low = fp.read();
    high = fp.read();
    return (high<<8)|low;
}
 
 
uint32_t read_32(File fp)
{
    uint16_t low;
    uint32_t high;
    low = read_16(fp);
    high = read_16(fp);
    return (high<<8)|low;   
}
 
 
void affi_image_from_SD(String filename, uint16_t x0, uint16_t y0)
{
Serial.println("----------------------------");
Serial.println("affi_image_from_SD()");
 
	uint8_t bmp_data[2]={0,0};
	uint8_t  a, b;
	uint16_t x=0;
	uint16_t y=0;
	int16_t xmax;
 
	uint32_t seekOffset;
  	uint16_t w, h, row, col;
 
 
	File fp = SD.open(filename, "r");
	if (!fp) { Serial.println("ERREUR open file on SD"); return; }
 
	uint16_t etiq1 = read_16(fp);
 
// test bmp_header	
	if (etiq1 == 0x4D42) 
	{
		read_32(fp);
		read_32(fp);
		seekOffset = read_32(fp);
Serial.print("seekOffset ="); Serial.println(seekOffset); // 138
 
		Serial.print("seekOffset= "); Serial.println(seekOffset); 
		read_32(fp);
		w = read_32(fp);
		h = read_32(fp);
		Serial.print("w= "); Serial.println(w); // 75
		Serial.print("h= "); Serial.println(h); // 50
		Serial.println(read_16(fp)); // 1
		Serial.println(read_16(fp)); // 16
		Serial.println(read_16(fp)); // 3
		fp.seek(seekOffset);
	}	
 
	y += h;
	xmax = w;
	if(xmax%2 == 1) {xmax +=1;}
 
	uint16_t padding = (4 - ((w * 2) & 2)) & 2;
	uint8_t lineBuffer[(w*2) + padding];
 
	for (row = 0; row < h; row++) 
	{
		fp.read(lineBuffer, sizeof(lineBuffer));
		uint8_t*  bptr = lineBuffer;
		uint16_t* tptr = (uint16_t*)lineBuffer;
 
		for (uint16_t col = 0; col < w; col++)
		{
			a = *bptr++;
			b = *bptr++;
			*tptr++ = (a <<8 | b);
		}
		TFT.pushImage(x0 + x, y0 + y, w, 1, (uint16_t*)lineBuffer);
		y--;			
	}
	fp.close();
}
 
 
void write_fichier_params() // sur la SDcard
{
Serial.println("write fichier '/params.txt'");	
 
	File file1 = SD.open("/params.txt", FILE_WRITE);
	String s1;
 
	/*
	s1 ="[couleur_fond]";
	s1 += "<";
	s1 += String(couleur_fond_ecran); 
	s1 +=">";
	file1.println(s1); 
*/
 
	s1 ="[frequence]";
	s1 += "<";
	s1 += String(frequence); 
	s1 +=">";
	file1.println(s1); 
 
	s1 ="[Ax]";
	s1 += "<";
	s1 += String(A.x); 
	s1 +=">";
	file1.println(s1); 
 
	s1 ="[Ay]";
	s1 += "<";
	s1 += String(A.y); 
	s1 +=">";
	file1.println(s1); 
 
	s1 ="[Bx]";
	s1 += "<";
	s1 += String(B.x); 
	s1 +=">";
	file1.println(s1); 
 
	s1 ="[By]";
	s1 += "<";
	s1 += String(B.y); 
	s1 +=">";
	file1.println(s1); 
 
 
	file1.close();
	delay(100);
}
 
 
void TS_calibrate()  // calibrage de l'écran tactile
{
	uint8_t L = 20;
	boolean ok; 
	String s1;
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF1);
 
// traitement point A
	TFT.fillScreen(NOIR);
	TFT.drawString("Cliquez sur le point A", 20, 50);
	delay(300);
	TFT.drawFastVLine(10, 0, L, JAUNE);
	TFT.drawFastHLine(0, 10, L, JAUNE);  
	ok = false;
	while (! ok)
	{
		if (ts.tirqTouched() && ts.touched()) 
		{
			memo_y_touch = y_touch;
			TS_Point p = ts.getPoint();
			s1 = "Ax=" + String(p.x) + "     "; TFT.drawString(s1, 50, 100);
			s1 = "Ay=" + String(p.y) + "     "; TFT.drawString(s1, 50, 120);
			delay(100);
 
			if( (p.x<600) && (p.y < 600)) // évite de valider une position irréaliste 
			{
				A.x = p.x; // point A : variable globale
				A.y = p.y;
				ok = true;
			}
		}	
	}	
 
// traitement point B
	TFT.fillScreen(NOIR);
	delay(300);
	TFT.drawString("Cliquez sur le point B", 20, 70);
	TFT.drawFastVLine(310, 230-L/2, L, JAUNE);
	TFT.drawFastHLine(310-L/2, 230, L, JAUNE);
	ok = false;
	while (! ok)
	{
		if (ts.tirqTouched() && ts.touched()) 
		{
			memo_y_touch = y_touch;
			TS_Point p = ts.getPoint();
			s1 = "Bx=" + String(p.x) + "     "; TFT.drawString(s1, 50, 150);
			s1 = "By=" + String(p.y) + "     "; TFT.drawString(s1, 50, 170);
			delay(100);
 
			if( (p.x>3600) && (p.y > 3400)) // évite de valider une position irréaliste
			{
				B.x = p.x;
				B.y = p.y;
				ok = true;
			}
		}	
	}
 
	if(SDcardOk==1)
	{	
		TFT.fillScreen(NOIR);
		TFT.drawString("Ok", 20, 60);
		TFT.setFreeFont(FF0);
		TFT.drawString("Write fichier params sur la SD", 10, 90);
		write_fichier_params();
		delay(1000);
	}
 
	TFT.fillScreen(NOIR);
	init_affichages();
 
	//TS_verif();
	//printTouchToDisplay(); // POUR TESTER LA CALIBRATION DE L'ECRAN TACTILE
}
 
 
String read_line_params(uint16_t line_num)
{
	int i = 1;
	char buffer[64];
	String s;	
 
	File file = SD.open("/params.txt", "r");
 
	while (file.available())
	{
		int l = file.readBytesUntil('\n', buffer, sizeof(buffer));
		buffer[l] = 0;
		if (line_num == i)
		{
			s = buffer;
			file.close();
			return(s);
		}  
		i++;
	}
	return "";
}
 
 
int32_t extract_params(String ligne, String label)
{
	String s2;
	uint32_t valeur = 0;
	int p1, p2;
 
	p1 = ligne.indexOf('[');	p2 = ligne.indexOf(']');
	s2 = ligne.substring(p1+1, p2);
 
	if (s2 == label)
	{
		p1 = ligne.indexOf('<');	p2 = ligne.indexOf('>');
		s2 = ligne.substring(p1+1, p2);
		valeur = s2.toInt();
		return valeur;
	}
	return -1;
}
 
 
void read_params() // lecture du fichier '/params.txt' en SD	
{
	Serial.println("lecture du fichier '/params.txt' en SD");
	String s1;
	int valeur;
 
	s1 = "Z";
	uint8_t n=1;
	while (s1 !="") 
	{
		s1 =  read_line_params(n); // retourne(par exemple): [couleur_fond]<267> 
 
		//valeur = extract_params(s1, "frequence");
		//if(valeur != -1) {frequence = valeur;}
 
		valeur = extract_params(s1, "Ax");
		if(valeur != -1) {A.x = valeur;}
 
		valeur = extract_params(s1, "Ay");
		if(valeur != -1) {A.y = valeur;}
 
		valeur = extract_params(s1, "Bx");
		if(valeur != -1) {B.x = valeur;}
 
		valeur = extract_params(s1, "By");
		if(valeur != -1) {B.y = valeur;}
 
		n++;
	}
}
 
 
void affi_mode()
{
	TFT.setFreeFont(FF0);
	if (out_mode1 == MODE_9850)
	{
		TFT.setTextColor(VERT, NOIR);
		TFT.drawString("AD9850 ", 20, 3);
	}
	if (out_mode1 == MODE_4351)
	{
		TFT.setTextColor(CYAN, NOIR);
		TFT.drawString("ADF4351", 20, 3);
	}
 
	TFT.setFreeFont(FF1);
 
	if (out_mode1 != memo_out_mode1)
	{
		if(f_mode1 == MODE_GENE)  { affi_boutons_gene(); }
		if(f_mode1 == MODE_WOBU)  { affi_select_PAS(); }
	}	
	memo_out_mode1 = out_mode1;
}
 
 
void efface_grand_cadre() // en épargnant la bande des boutons (1M..100k..10k..1HZ)
{
	TFT.fillRect(1, 80, 317, 159, NOIR);
}
 
 
void trace_sinusoide()
{
	float y;
	float v;
	for (uint16_t n=0; n<320; n++)
	{
		v = (float)n/20.0;
		y = 180-50*sin(v);
		TFT.drawPixel(n, (int)y, VERT);
	}
}	
 
 
void setup()
{
	if (soft_setup == false)
	{
		soft_setup = true;
	// étalonnage touch screen;  ces valeurs peuvent varier d'un afficheur à l'autre
	// pour l'instant il faut les fixer ici à la main...
		eTS.x0 = -30;	eTS.y0 = -30;
		eTS.dx =  11;	eTS.dy =  14;
 
		Serial.begin(115200);
		delay(20);
		Serial.println("setup A"); 
 
		pinMode(boutonPin1, INPUT_PULLUP); // bouton physique
 
		pinMode(ADF_CLK, OUTPUT);
		pinMode(ADF_DATA, OUTPUT);
		pinMode(ADF_LE, OUTPUT);
		pinMode(ADF_CE, OUTPUT);
 
		pinMode(AD_WCL, OUTPUT);
		pinMode(AD_D7, OUTPUT);
		pinMode(AD_FQU, OUTPUT);
		pinMode(AD_RESET, OUTPUT);
 
		//pinMode(GPIO_BL, OUTPUT);
		//digitalWrite(GPIO_BL, HIGH); 
 
		init_variables_globales();
 
		Wire.begin(GPIO_SDA, GPIO_SCL, 2000000); 
		//Tuner_Init(tuner_init_tab9216);
		//affiche_frequence(frequence);
 
		// Start the SPI for the touch screen and init the TS library
		mySpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS); 
		ts.begin(mySpi);
		ts.setRotation(1);// 1 ou 3 à voir, suivant disposition de l'afficheur
 
 
	// mySpi2 -> pour le lecteur de SDcard
	// mySpi2 -> partage du bus SPI - mêmes valeurs de GPIO (sck=14, miso=12)	
	// que pour l'afficheur ILI9341 , sauf CS=5. Voir sur le schéma ainsi que le fichier User_Setup.h 
		mySpi2.begin(14, 12, 13, 5); 
 
		init_SDcard();
		delay(20);
 
		if (SDcardOk == true) 
		{ 
			read_params(); // sur la SDcard
		}
 
		TFT.init();
		TFT.setRotation(1);// 1 ou 3 à voir, suivant disposition de l'afficheur
		TFT.fillScreen(VERT);
 
		init_sprites();
 
		affi_page_info();
		delay(2000);
 
	//	TS_calibrate();
 
		// si les coordonnées des points de calibrage sont aux fraises...
		if ( (A.x <300) || (A.x >700) || (A.y <200) || (A.y >600) || 
		(B.x < 3500) || (B.x > 3900) || (B.y <3400) || (A.y >3800) )
		{
			TS_calibrate();
		}
 
		out_mode1 = MODE_9850;
		style = 0;
		frequence = 4000000;
	}
 
	Serial.println("setup B"); 
 
	init_affichages();
	affi_image_from_SD("/scope2.bmp", 0, 90);
	affiche_frequence(frequence); // et met à jour Fd0
	delay(500);
 
	//f_mode1 = MODE_ACCUEIL;
	efface_grand_cadre(); // grand cadre en partie basse
 
	chf_pad1.init();
 
	CarteADF4351.init();
	CarteADF4351.mute(0);
 
	CarteAD9850.reset();
	delay(10);
	CarteAD9850.out_F(10000.0);
 
	init_boutons_choix_MODE();
	bt_mode_GENE.selected = true;
	bt_mode_GENE.affiche(NOIR, JAUNE, 2);
	f_mode1 = MODE_GENE;
 
	bt_mode_WOBU.selected = false; // l'autre bouton
	bt_mode_WOBU.affiche(BLANC, GRIS_3, 2);
 
 
	affiche_frequence(frequence);
 
	efface_grand_cadre();
 
	affi_mode();
	trace_sinusoide();
	init_boutons_choix_MODULE();
 
/*	
	for(int n=0; n<21; n++)
	{
		uint64_t v = calcul_pas_w(n);
		Serial.println(v);  // pour test
	}
*/	
 
// les 2 lignes suivantes me servent à afficher une image destinée au site web.
	//affi_image_from_SD ("/bmp565/capture0.bmp", 0, 0);
	//while(1);
 
 
	Serial.println("Fin du Setup"); 
	Serial.println("-----------------------");
 
}
 
 
void get_XY_touch() // pour affi 320 x 240px
{
	TS_Point p = ts.getPoint();
	float dx = B.x - A.x;
	float ech_x = 290.0 / dx;//300
	float x0 = A.x;
 
	float dy = B.y - A.y;
	float ech_y = 210.0 / dy; //230
	float y0 = A.y;
 
	memo_x_touch = x_touch;
	memo_y_touch = y_touch;
 
	x_touch = 12 + uint16_t( (p.x - x0) * ech_x); //x_touch = 10 + uint16_t( (p.x - x0) * ech_x); 
	if(x_touch > 319){x_touch = 0;}
	y_touch = 15 + uint16_t( (p.y - y0) * ech_y);  //y_touch = 10 + uint16_t( (p.y - y0) * ech_y); 
	if(y_touch > 239){y_touch = 0;} 
}
 
 
void test_clic_boutons(TOUCH_BOUTON *bouton_i)
{
	uint16_t c1 = NOIR;
	uint16_t c2 = VERT;
 
 	if ((x_touch > bouton_i->x0) && (x_touch < (bouton_i->x0 )+ bouton_i->read_dx()) 
	&& ( y_touch > ((bouton_i->y0)) ) && (y_touch < ((bouton_i->y0) + (bouton_i->read_dy())) ) ) 
	{
		bouton_i->cliked = true;
		bouton_i->selected = true;
		//bouton_i->affiche(BLANC, c2, 1);
		delay(100);
	} 
}
 
 
int test_clic_boutons_inc_dec() // boutons placés derrière les chiffres de la fréquence
{
	int8_t num_bouton = -1;
	uint64_t facteur;
 
	TOUCH_BOUTON  bt_Hi, bt_Li;
	for(uint8_t n=0; n<10; n++)
	{
		bt_Hi = chf_pad1.bt_pad_H[n];
		test_clic_boutons(&bt_Hi); 
		if(bt_Hi.cliked) { num_bouton = n; }
 
		bt_Li = chf_pad1.bt_pad_L[n];
		test_clic_boutons(&bt_Li); 
		if(bt_Li.cliked) { num_bouton = n+10; }
	}
 
	if(num_bouton != -1)
	{	
		if (num_bouton<10)	
		{
			facteur = pow(10, 9-num_bouton);
			frequence += facteur;
		}
		if ((num_bouton>=10) && (num_bouton<20))
		{
			facteur = pow(10, 19-num_bouton);
			if (frequence > facteur) {frequence -= facteur;}
			else {frequence = 1;}
		}
 
		if (frequence == 0) {frequence = 1;}	
		//if (frequence > 4400000000) {frequence = 4400000000;}
 
		if (out_mode1 == MODE_9850)
		{
			if (frequence < F_min_AD9850) {frequence = F_min_AD9850;}
			if (frequence > F_max_AD9850) {frequence = F_max_AD9850;} // au delà le signal est possible, mais très dégradé !
		}
 
		if (out_mode1 == MODE_4351)
		{
			if (frequence < F_min_ADF4351) {frequence = F_min_ADF4351;}
			if (frequence > F_max_ADF4351) {frequence = F_max_ADF4351;}
		}
 
		affiche_frequence(frequence);		
		delay(100);
	}
	return num_bouton;
}
 
 
 
void draw_AEC(uint16_t x0, uint16_t y0, uint16_t L, uint8_t sens)
{
// ligne arc-en-ciel	
// affiche une ligne de pixels colorés à partir de la variable 'couleurs_aec' mémorisée en PROGMEM (voir fichier Couleurs_AEC.h)
// L = longueur de la ligne
 
//Serial.println("draw_draw_AEC()");
	uint16_t x, i, j;
	uint16_t y1;
	uint16_t couleur_i;
 
	for (int16_t i=0; i<L; i++)
	{
		float f = 470.0/L * i; // pour balayer toute l'échelle des couleurs disponibles
		j=uint16_t(f);
 
		couleur_i = couleurs_aec[2*j] | couleurs_aec[2*j+1]<<8;
 
		if (sens==0){x=i;} else {x=L-i;}
 
		TFT.drawFastVLine(x0+x, y0, 20, couleur_i);
 
	}
}
 
void test_clic_bts_choix_module()  // AD9850  - ADF4351
{
	test_clic_boutons(&bt_AD9850); 
	if (bt_AD9850.cliked) 
	{
		bt_AD9850.cliked = false;
		bt_AD9850.affiche(BLANC, VERT_2, 2);
 
		bt_ADF4351.selected = false; // l'autre bouton
		bt_ADF4351.affiche(BLANC, VERT_2, 2);
 
		out_mode1 = MODE_9850;
		style = 0;
		frequence = 4000000;
		affiche_frequence(frequence);
 
		affi_boutons_gene();
		f_mode1 = MODE_GENE;
	}
 
	test_clic_boutons(&bt_ADF4351); 
	if (bt_ADF4351.cliked) 
	{
		bt_ADF4351.cliked = false;
		bt_ADF4351.affiche(BLANC, BLEU, 2);
 
		bt_AD9850.selected = false; // l'autre bouton
		bt_AD9850.affiche(BLANC, VERT_2, 2);
 
		out_mode1 = MODE_4351;
		style = 1;
		frequence = 100000000;
		affiche_frequence(frequence);
 
		affi_boutons_gene();
		f_mode1 = MODE_GENE;
	}
 
}
 
 
void test_clic_bts_MODE()  // GENE - WOBU
{
	test_clic_boutons(&bt_mode_GENE); 
	if (bt_mode_GENE.cliked) 
	{
		bt_mode_GENE.cliked = false;
		bt_mode_GENE.affiche(NOIR, JAUNE, 2);
 
		bt_mode_WOBU.selected = false; // l'autre bouton
		bt_mode_WOBU.affiche(NOIR, GRIS_4, 2);
 
		f_mode1 = MODE_GENE;
		out_mode1 = MODE_9850;
		style = 0;
		frequence = 4000000;
		affiche_frequence(frequence);
 
		bt_mode_GENE.selected = true;
		bt_mode_GENE.affiche(NOIR, JAUNE, 2);
		affi_boutons_gene();
		efface_grand_cadre();
		init_boutons_choix_MODULE();
		TFT.drawRect(0, 0, 319, 240, BLANC); // cadre principal pourtour de l'écran
		bt_AD9850.selected=true;
		bt_AD9850.affiche(BLANC, VERT_2, 2);
	}
 
 
	test_clic_boutons(&bt_mode_WOBU); 
	if (bt_mode_WOBU.cliked) 
	{
		bt_mode_WOBU.cliked = false;
		bt_mode_WOBU.affiche(NOIR, JAUNE, 2);
 
		bt_mode_GENE.selected = false; // l'autre bouton
		bt_mode_GENE.affiche(NOIR, GRIS_4, 2);
 
		f_mode1 = MODE_WOBU;
		num_pas = 15;
		pas_W = calcul_pas_w(num_pas);
 
		affi_select_PAS();
		affi_grille();
 
		GO();
		setup();
	}
}
 
 
void test_clic_bt_calibrate()
{
	test_clic_boutons(&bt_calibrate ); 
	if (bt_calibrate.cliked) 
	{
		bt_calibrate.cliked = false;
		TS_calibrate();
		soft_setup = false;
		setup();
	}
}
 
 
void test_clic_bouton_RAZ()
{
	test_clic_boutons(&bt_RAZ ); 
 
	if (bt_RAZ.cliked) 
	{
		bt_RAZ.affiche(BLANC, ROUGE, 1);
		delay(50);
		bt_RAZ.cliked = false;
		bt_RAZ.selected = true;
		bt_RAZ.affiche(BLANC, ROUGE, 1);
 
		frequence =0;
		affiche_frequence(frequence);
 
		bt_RAZ.cliked = false;
		bt_RAZ.selected = false;
		bt_RAZ.affiche(BLANC, ROUGE, 1);
 
		delay(300);
		//init_affichages();
	}
}
 
 
 
void deselecte_bts_preset()
{
	if (out_mode1 == MODE_9850)
	{
		bt_455k.selected = false; 	bt_455k.affiche(BLANC, VERT, 1);
		bt_4M.selected = false; 	bt_4M.affiche(BLANC, VERT, 1);
		bt_10_7M.selected = false; 	bt_10_7M.affiche(BLANC, VERT, 1);
		bt_27M.selected = false; 	bt_27M.affiche(BLANC, VERT, 1);
	}
 
	if (out_mode1 == MODE_4351)
	{
		bt_35M.selected = false; 	bt_35M.affiche(BLANC, VERT, 1);
		bt_41M.selected = false; 	bt_41M.affiche(BLANC, VERT, 1);
		bt_144M.selected = false; 	bt_144M.affiche(BLANC, VERT, 1);
		bt_432M.selected = false; 	bt_432M.affiche(BLANC, VERT, 1);
		bt_2400M.selected = false; 	bt_2400M.affiche(BLANC, VERT, 1);
	}
}
 
 
void test_clic_bt_455k()
{
	test_clic_boutons(&bt_455k); 
	if (bt_455k.cliked) 
	{
		deselecte_bts_preset();
		bt_455k.cliked = false;
		bt_455k.selected=true;
		bt_455k.affiche(BLANC, VERT, 1);
		frequence =455000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
void test_clic_bt_4M()
{
	test_clic_boutons(&bt_4M); 
	if (bt_4M.cliked) 
	{
		deselecte_bts_preset();
		bt_4M.cliked = false;
		bt_4M.selected=true;
		bt_4M.affiche(BLANC, VERT, 1);
		frequence =4000000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
void test_clic_bt_10_7M()
{
	test_clic_boutons(&bt_10_7M); 
	if (bt_10_7M.cliked) 
	{
		deselecte_bts_preset();
		bt_10_7M.cliked = false;
		bt_10_7M.selected=true;
		bt_10_7M.affiche(BLANC, VERT, 1);
		frequence =10700000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
void test_clic_bt_27M()
{
	test_clic_boutons(&bt_27M); 
	if (bt_27M.cliked) 
	{
		deselecte_bts_preset();
		bt_27M.cliked = false;
		bt_27M.selected=true;
		bt_27M.affiche(BLANC, VERT, 1);
		frequence =27000000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
 
void test_clic_bt_35M()
{
	test_clic_boutons(&bt_35M); 
	if (bt_35M.cliked) 
	{
		deselecte_bts_preset();
		bt_35M.cliked = false;
		bt_35M.selected=true;
		bt_35M.affiche(BLANC, VERT, 1);
		frequence =35000000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
 
void test_clic_bt_41M()
{
	test_clic_boutons(&bt_41M); 
	if (bt_41M.cliked) 
	{
		deselecte_bts_preset();
		bt_41M.cliked = false;
		bt_41M.selected=true;
		bt_41M.affiche(BLANC, VERT, 1);
		frequence =41000000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
 
void test_clic_bt_144M()
{
	test_clic_boutons(&bt_144M); 
	if (bt_144M.cliked) 
	{
		deselecte_bts_preset();
		bt_144M.cliked = false;
		bt_144M.selected=true;
		bt_144M.affiche(BLANC, VERT, 1);
		frequence =144000000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
 
void test_clic_bt_432M()
{
	test_clic_boutons(&bt_432M); 
	if (bt_432M.cliked) 
	{
		deselecte_bts_preset();
		bt_432M.cliked = false;
		bt_432M.selected=true;
		bt_432M.affiche(BLANC, VERT, 1);
		frequence =432000000;
		affiche_frequence(frequence);
		delay(300);
	}
}
 
void test_clic_bt_2400M()
{
	test_clic_boutons(&bt_2400M); 
	if (bt_2400M.cliked) 
	{
		deselecte_bts_preset();
		bt_2400M.cliked = false;
		bt_2400M.selected=true;
		bt_2400M.affiche(BLANC, VERT, 1);
		frequence =2400000000;
		affiche_frequence(frequence);
		delay(200);
	}
}
 
 
 
void affi_pasW()
{
	String s1 = formatage_frq(pas_W); // ajoute les points (.) séparateurs des milliers
	String s2 = supp_zeros(s1);
 
	TFT.fillRect(130, 63, 120, 12, NOIR); // efface
	TFT.setFreeFont(FF1);	
	TFT.setTextColor(JAUNE);
	TFT.drawString("P=" + s2, 130, 63);
}
 
/*
void calcul_Fmin_Fmax()
{
	Fmin = frequence - 160 * pas_W;
	Fmax = frequence + 160 * pas_W;
}
*/
 
void test_clic_bt_pas_P()
{
	test_clic_boutons(&bt_pas_P); 
	if (bt_pas_P.cliked) 
	{
		bt_pas_P.cliked = false;
 
		if (num_pas>0) {num_pas --;}
 
		pas_W = calcul_pas_w(num_pas);
		affi_pasW();
 
		calcul_Fmin_Fmax(frequence);
		affi_freq_W_min_max();
		delay(200);
	}
}
 
 
void test_clic_bt_pas_M()
{
	test_clic_boutons(&bt_pas_M); 
	if (bt_pas_M.cliked) 
	{
		bt_pas_M.cliked = false;
 
		num_pas ++;
		if (num_pas>20) {num_pas = 20;}
 
		pas_W = calcul_pas_w(num_pas);
		affi_pasW();	
 
		calcul_Fmin_Fmax(frequence);
		affi_freq_W_min_max();
		delay(300);
	}
}
 
 
void test_clic_bt_boucle()
{
	test_clic_boutons(&bt_boucle); 
	if (bt_boucle.cliked) 
	{
		bt_boucle.cliked = false;
 
		en_boucle = ! en_boucle;
		if (en_boucle == true) { bt_boucle.affiche(NOIR, VERT, 1);} 
		else {bt_boucle.affiche(BLANC, GRIS_4, 1);} 
 
		delay(300);
	}
}
 
 
void affi_trace_passe_bas()
{
// (Filtre passe-bas de second ordre RLC) pour exemple...
// https://www.silicium628.fr/article_i.php?id=112
	float d1, d2,d3, T;
	float x = 5;
	float m=0.25;
 
	for(int n=0; n<800; n++)
	{
		x= n/100.0;
		d1 = 1 - x*x;
		d2 = 2*m*x;
		d3 = d1*d1 + d2*d2;
		T = 1/sqrt(d3);
		uint16_t y = int(70.0 *T);
		TFT.drawPixel(n, 240-y, BLEU);
	}
}
 
 
String formatage_frq(uint64_t frq_i) // ajoute les points (.) séparateurs des milliers
{
	String s1 = String(frq_i);
	s1 = "000000000" + s1;
	uint8_t L= s1.length();
	String sU = s1.substring(L-3); 		// Hz
	String sK = s1.substring(L-6, L-3); // kHz
	String sM = s1.substring(L-10, L-6);// MHz
	return sM + "." + sK + "." + sU + " ";
}
 
 
String supp_zeros(String s_i) // supprime les zéros et les points de séparation des milliers non significatifs
{
	String s1;
 
	while (s_i.substring(0, 1) == "0") 	{s_i = s_i.substring(1); } 
	if(s_i[0] == '.') {s_i = s_i.substring(1); } 
	while (s_i.substring(0, 1) == "0") 	{s_i = s_i.substring(1); } 
	if(s_i[0] == '.') {s_i = s_i.substring(1); } 
	while (s_i.substring(0, 1) == "0") 	{s_i = s_i.substring(1); } 
	return s_i;
}
 
 
void affi_freq_W_min_max() // et les affiche verticalement
{
	// la réquence centrale est celle choisie et affichée en gros chiffres en haut
	String Str_frq;
 
	Str_frq = formatage_frq(Fmin);
	TFT.fillRect(6, 150, 8, 89, NOIR); // efface
	sprite_freq_W_min.drawString(Str_frq, 0, 0);
	TFT.setPivot(10, 190);
	sprite_freq_W_min.pushRotated(-90, NOIR);
 
	TFT.fillRect(305, 150, 8, 89, NOIR); // efface
	Str_frq = formatage_frq(Fmax);	
	sprite_freq_W_max.drawString(Str_frq, 0, 0);
	TFT.setPivot(310, 190);
	sprite_freq_W_max.pushRotated(-90, NOIR);
}
 
 
 
 
void boucle_affi_curseur()
{
// dessine un trait vertical au point cliqué par le stylet
	if (pas_W==0) {return;}
	if(f_mode1 != MODE_WOBU) {return;}
 
	efface_bande_boutons();
	TFT.setFreeFont(FF1);	
	//TFT.setTextColor(BLEU_CLAIR);
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("parcourir au stylet <>", 2, 64);
 
/*
	init_1_bouton(1, 300, 63, 15, 16, "X", &bt_STOP_2);
	bt_STOP_2.selected = true;
	bt_STOP_2.affiche(BLANC, ROUGE, 2);
*/
 
	uint16_t memo_seg_V[100]= {0};
	uint16_t memo_x;
	int64_t frq_i, memo_frq_i;
 
	TFT.setFreeFont(FM9);
	TFT.setTextColor(BLEU_CLAIR, NOIR);
 
	uint16_t couleur1 = JAUNE;
	boolean stop2 = false;
	while (! stop2)
	{
		if (ts.tirqTouched() && ts.touched()) 
		{
			memo_x = x_touch;
			get_XY_touch();
 
			if ((x_touch>15)&&(x_touch<300) && (memo_x>15) && (memo_x<300) && (y_touch > 80))	
			{
				TFT.pushRect(memo_x, 120, 1, 100, memo_seg_V); // efface avec l'image enregistrée			
				TFT.readRect(x_touch, 120, 1, 100, memo_seg_V); // memorise image avant de tracer le trait
				if ((x_touch>18)&&(x_touch<296)) {TFT.drawFastVLine(x_touch, 120, 100, BLEU_CLAIR);}
 
				String s1;
				memo_frq_i = frq_i;
 
				frq_i = frequence - 160*pas_W + x_touch * pas_W;
 
				if (frq_i <0) {frq_i =0;}
 
				if (frq_i != memo_frq_i)
				{
					if(frq_i==0) {couleur1 = ROUGE;} else couleur1 = JAUNE;
					s1 = formatage_frq(frq_i) + " Hz ";
					TFT.drawString(s1, 80, 82);
					//delay(5);
				}
			}
/*
			test_clic_boutons(&bt_STOP_2 ); 
			if (bt_STOP_2.cliked) 
			{
				bt_STOP_2.cliked = false;
				stop2 = true;
				efface_bande_boutons();
			}
*/
		}
		test_bouton_physique1();
	}
	TFT.setFreeFont(FF1);	
	TFT.setTextColor(VERT, GRIS_6);
	TFT.drawString("Choisir GENE ou WOBU" ,50, 150);
 
	//setup();
}
 
 
void affiche_gain(float gain)
{
	TFT.fillRect(230, 110, 70, 15, NOIR); // efface  140
	TFT.setFreeFont(FF1);	
	TFT.setTextColor(BLANC);
	TFT.drawString("g=" +String(gain), 230, 110);
}
 
 
void calcul_Fmin_Fmax(uint64_t Fi)
{
	if(Fi > 160*pas_W)	{Fmin = Fi - 160*pas_W;} else Fmin = 0;
	Fmax = Fi + 160 * pas_W;
}
 
 
 
void affi_bande_passante()
{
/*
	rappels : B = bande passante à -3dB. en rapport de tensions (r=v0/v1)
	1 decibel = 10 Log(r) en rapport de puissances; Log est ici le logarithme décimal, et pas le log népèrien
	1 decibel = 20 Log(r) en rapport de tensions, c'est le cas ici.
 
	-3	= 20 Log(r))
	Log(r) = -3/20
	r = 10^(-3/20) = 10^(-0.3) = 0.707 = 1/racine(2)
	le Q est donc calculé en prenant comme bande passante le seuil de tension = tension max / racine(2)
 
	Calculs simples :
	en puissance : 10 Log(1/2) = -3dB
	en tension : 20 Log(1/racine(2)) = -3dB (ce calcul donne en fait -3.01029995663981 dB) :-)
 
	B = F0/Q
	BxQ = F0
	Q = F0/B
 
	Pour connaitre les fréquences F1 et F2 (bornant la bande passante) il nous faut le tableau de toutes les valeurs mesurées.
	soit 320 floats	et les analyser une par une.
 
*/
	float v_max=0;
	float v_min=4000;
	float v_bp;
	float vn;
	uint16_t y1, y2;
	uint16_t nA, nB;
	String s1;
 
	TFT.fillRect(2, 80, 237, 16, NOIR); // efface dans la bande d'affichage des résultats
	//TFT.fillRect(230, 80, 79, 16, NOIR); // efface dans la bande d'affichage des résultats (partie droite)
	TFT.setFreeFont(FF1);
	TFT.setTextColor(BLANC, NOIR);
 
	//init_1_bouton(1, 300, 63, 15, 16, "X", &bt_STOP_2);
	//bt_STOP_2.selected = true;
	//bt_STOP_2.affiche(BLANC, ROUGE, 2);
 
// recherche de la valeur min :
	for(int n=0; n<320; n++)
	{
		vn = tableau_acq[n];
		if (v_min > vn ) {v_min = vn;}
	}
 
 
// recherche de la valeur max :
	for(int n=0; n<320; n++)
	{
		vn = tableau_acq[n];
		if (v_max < vn ) {v_max = vn;}
	}
 
	//float r = v_max / 1.414;
	//v_bp = uint16_t(r);
 
	v_bp = v_min + (v_max - v_min) / 1.414;
 
	if (polarite1 == _DIR) 
	{
		y1 =  230 - v_max;
		y2 =  230 - v_bp;
	} 
	else 
	{
		y1 = 90 + v_max;
		y2 = 90 + v_bp;
	}	
 
	if(y1 < 100) {y1=100;}
	if(y2 < 100) {y2=100;}
 
	TFT.drawFastHLine(16, y1, 280, GRIS_4);
	TFT.drawFastHLine(16, y2, 280, GRIS_4);
 
// affiche les Freq min et max de la bande passante :
 
// recherche les point de croisement de la courbe avec la ligne horizontale à -3dB
// en deux temps pour éviter les détections multiples intempestives ; la première est la bonne !
 
// find left match ; en partant de la gauche
	for(int n=0; n<320; n++)
	{
		vn = tableau_acq[n];
		if (vn > v_bp) 
		{
			TFT.drawFastVLine(n, 100, 130, GRIS_4);
			nA=n;
			break;
		}
	}
 
// find right match	; en partant de la droite
	for(int n=319; n>0; n--)
	{
		vn = tableau_acq[n];
		if (vn > v_bp) 
		{
			TFT.drawFastVLine(n, 100, 130, GRIS_4);
			nB=n;
			break;
		}
	}
 
	TFT.setFreeFont(FF0);
	s1 = String(v_max);
	TFT.drawString("Vmax=" + s1, 3, 100); 
	s1 = String(v_min);
	TFT.drawString("Vmin=" + s1, 3, 110); 
 
 
// affiche (en texte) la valeur de la fréquence correspondant au maximum de la courbe :
		TFT.setFreeFont(FF1);
		uint16_t xM;
		xM = (nA+nB) /2;
		TFT.drawFastVLine(xM, 100, 130, GRIS_5);
 
		uint64_t F0 = frequence - 160*pas_W + xM * pas_W;
 
		s1 = formatage_frq(F0); // ajoute les points (.) séparateurs des milliers
		s1 = supp_zeros(s1); // supprime les zéros et les points de séparation des milliers non significatifs
		TFT.setTextColor(JAUNE, NOIR);
		TFT.drawString("F0=" + s1, 100, 220); // valeur max
 
		uint64_t Bp = (nB-nA)*pas_W;
		s1 = formatage_frq(Bp); 
		s1 = supp_zeros(s1);
		TFT.drawString("Bp=" + s1, 3, 80);  // bande passante
 
		float Q =(float)F0 / (float)Bp;
 
		TFT.fillRect(210, 80, 108, 16, NOIR);
		TFT.drawString("Q=" + String(Q, 2), 210, 80); 
		TFT.drawRect(0, 0, 319, 240, BLANC); // cadre principal pourtour de l'écran (le string a peut-être dépassé !)
}
 
 
 
 
void balayage_freq(uint64_t F0)  // wobulation "autour" de la fréquence centrale F0
{
	compte1++;
	Serial.print("compte1="); Serial.println(compte1);
 
	if ((pas_W == 0) || (f_mode1 != MODE_WOBU))
	{
		stop1 = true;
		return;
	}
 
	uint16_t memo_seg_V[100]= {0};
	int16_t memo_n;
 
	TFT.setFreeFont(FM9);
	TFT.setTextColor(BLEU_CLAIR, NOIR);
 
	uint16_t couleur1;// = JAUNE;
 
	uint16_t valeurLue1 = 230;
	uint16_t valeurLue2 = 230;
	uint16_t valeurLue3 = 230;
 
	float gain=0.3;
	float memo_gain;
	float vf;
 
	int64_t frq_i; // peut-être négatif
 
	uint16_t v1;
	uint16_t memo_v1;
	uint16_t x;
 
	boolean boucle_attente;
 
 
	TFT.fillRect(80, 1, 150, 12, NOIR);  // efface les boutons GENE & WOBU en haut
	TFT.drawRect(0, 0, 319, 240, BLANC); // retrace le cadre principal pourtour de l'écran
	TFT.drawRect(0, 79, 319, 18, BLANC);
	TFT.drawFastHLine(1, 13, 318, GRIS_4);
	TFT.drawFastHLine(1, 14, 318, GRIS_4);
 
	TFT.setFreeFont(FF0);
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("WOBULATION", 120, 3);
 
	TFT.drawString("gain:" +String(gain), 190, 120);
 
	stop1 = false;
	while (! stop1)
	{
		calcul_Fmin_Fmax(F0);
 
		compte2++;
		Serial.print("compte2="); Serial.println(compte2);
		//TFT.fillRect(1, 80, 317, 159, NOIR);
		//calcul_Fmin_Fcenter(F0);
 
		//TFT.setFreeFont(FF1);	
		//TFT.setTextColor(BLANC, NOIR);
		//TFT.drawString("F0", 150, 220);
 
		boucle_attente = ! en_boucle; // le boolean en_boucle est positionné par le bouton 'bt_boucle'
		x=1;
		for(uint16_t n=0; n<320; n++)
		{
			x++;
			//Fmax = F0 + 160 * pas_W;
			//frq_i = F0 + n * pas_W;
 
			if(n<160){frq_i  = F0 - (160-n) * pas_W;}
			if(n>=160){frq_i = F0 + (n-160) * pas_W;}
 
			if (frq_i >0) 
			{
				frequence = frq_i;
				couleur1 = JAUNE;
			} 
			else 
			{
				frequence = 0;
				couleur1 = GRIS_1;
			}
 
			out_frequence();
			delay(1);
			memo_v1 = v1;
			valeurLue1 = analogRead(analogPin); //acquisition_réponse   0..4095 
			delay(1);
			valeurLue2 = analogRead(analogPin); 
			delay(1);
			valeurLue3 = analogRead(analogPin); 
 
			vf = (float (valeurLue1) + float (valeurLue2) + float (valeurLue3))/3.0; 
			vf *= gain;
			tableau_acq[n]= vf;
 
			v1 = uint16_t(vf);
			if (v1 > 230-100) // écrétage de l'affichage (partie haute)
			{
				v1 = 230-100; 
				gain -= 0.01; // ajuste le gain
				boucle_attente = false; // pour ne pas boucler plus bas, ce qui permet de repasser auto et de réajuster
			}  
 
			if ((x>15) && (x<300) )//&& (memo_n>15) && (memo_n<300))	à voir
			{
				TFT.drawFastVLine(x, 100, 131, NOIR); // efface
				TFT.drawFastVLine(160, 200, 30, 10976); // trait vertical au centre (F0)
				if (n%10 == 0) { TFT.drawFastVLine(n, 220, 19, 10976); }// petits traits verticaux en bas	
				uint16_t y1, y2;
 
				if (frequence == 0) {v1=memo_v1;}
 
				if (polarite1 == _DIR) {y1 =  230 - memo_v1;  y2 = 230 - v1;} 
				else {y1 = 90 + memo_v1;  y2 = 90 + v1;}
 
				if(y1 < 100) {y1=100;}
				if(y2 < 100) {y2=100;}
 
				TFT.drawLine(x-1, y1, x, y2, couleur1); // trait entre [P(n-1)] et [P(n)] ...(signal)
			}	
 
			memo_n=n;
 
			if (ts.tirqTouched() && ts.touched()) 
			{
				memo_y_touch = y_touch;
				get_XY_touch();
 
				frequence = F0; // sinon le calcul des F min et max sera faux
 
				int num_bouton = test_clic_boutons_inc_dec();  // on peut changer la Freq centrale pendant le balayage
				if (num_bouton != -1) {F0 = frequence;}
 
				//test_clic_bts_pas(); // on peut changer le pas pendant le balayage
 
				bt_polarite.cliked = false;
				test_clic_boutons(&bt_polarite ); 
				if (bt_polarite.cliked) 
				{
					bt_polarite.cliked = false;
					if (polarite1 == _DIR) { polarite1 = _INV; bt_polarite.label = "INV"; bt_polarite.affiche(BLANC, ROUGE, 1); } 
					else { polarite1 = _DIR; bt_polarite.label = "DIR"; bt_polarite.affiche(NOIR, VERT, 1); }
					delay(300);
				}
 
				bt_gain_P.cliked = false;
				test_clic_boutons(&bt_gain_P ); // gain plus
				if (bt_gain_P.cliked) 
				{
					bt_gain_P.cliked = false;
					gain +=0.01;
					if (gain <0.1) {gain = 0.1;}
					TFT.setFreeFont(FF0);
					TFT.drawString("gain=" +String(gain), 130, 80); 
					affiche_gain(gain);
					delay(100);			
				}
 
				bt_gain_M.cliked = false;
				test_clic_boutons(&bt_gain_M );  // gain moins
				if (bt_gain_M.cliked) 
				{
					bt_gain_M.cliked = false;
					gain -= 0.01;
					if (gain >1.0) {gain = 1.0;}
					affiche_gain(gain);
					delay(100);	
				}
 
				test_clic_bt_pas_P();  // pas +
				test_clic_bt_pas_M();  // pas -
 
				bt_boucle.cliked = false;
				test_clic_bt_boucle();
				boucle_attente = ! en_boucle;
 
				bt_STOP_1.cliked = false;
				test_clic_boutons(&bt_STOP_1 ); 
				if (bt_STOP_1.cliked) 
				{
					bt_STOP_1.cliked = false;
					stop1 = true;
					popup(40, 150, "Fin Wobulation", "Restart...");
					break;
				}
			}
 
			if(gain != memo_gain) { affiche_gain(gain); memo_gain = gain;}
			test_bouton_physique1(); // bouton poussoir câblé sur entrée analogique
 
		} // de "for(uint16_t n=0; n<320; n++)"
 
		frequence = F0; // sinon le calcul des F min et max sera faux
		if (! stop1)  // par le bouton "bt_STOP_1"
		{
			affi_bande_passante();
			affiche_gain(gain);
			if(boucle_attente == true)
			{
				while ( !(ts.tirqTouched() && ts.touched()) )  // BOUCLE attente clic
				{
					test_bouton_physique1(); // bouton poussoir câblé sur entrée analogique
				}
			}
 
		}
		//delay(300);
 
	} // "de while (! stop1)"
 
	//popup(40, 150, " ici 1", "    ");
	frequence = F0;
}
 
 
 
void GO()
{
	//if (pas_W == 0) {return;}
	bt_STOP_1.label = "X";
	bt_STOP_1.affiche(BLANC, ROUGE, 2);
	delay(100); // évite de redéclencher le bouton intempestivement
	TFT.fillRect(6, 82, 150, 10, NOIR); // efface le texte "Choisir un pas"
	affi_freq_W_min_max();  	// affiche verticalement
	balayage_freq(frequence);   // wobulation "autour" de la fréquence centrale F0
	//popup(40, 150, " ici 2", "    ");
}
 
 
void affi_grille()
{
	efface_grand_cadre();
	TFT.drawFastVLine(160, 100, 139, 10976);
	for (int n =1; n<32; n++)
	{
		TFT.drawFastVLine(10*n, 220, 19, 10976);	
	}
 
	TFT.drawFastHLine(1, 231, 318, GRIS_6); // zero en bas
	TFT.drawFastHLine(1, 98, 318, GRIS_6);  // max en haut
 
	init_1_bouton(1, 300, 62, 15, 15, "X", &bt_STOP_1);
	bt_STOP_1.selected = true;
	bt_STOP_1.affiche(BLANC, ROUGE, 2);
 
	init_1_bouton(1, 255, 63, 30, 15, "DIR", &bt_polarite);
	bt_polarite.selected = true;
	bt_polarite.affiche(NOIR, GRIS_2, 1);
 
	init_1_bouton(1, 300, 100, 15, 15, "+", &bt_gain_P);
	bt_gain_P.selected = true;
	bt_gain_P.affiche(NOIR, BLEU_CLAIR, 1);
 
	init_1_bouton(1, 300, 120, 15, 15, "-", &bt_gain_M);
	bt_gain_M.selected = true;
	bt_gain_M.affiche(NOIR, BLEU_CLAIR, 1);
 
/*
	if(le_pas_est_choisi == false)
	{	
		TFT.setFreeFont(FF1);
		TFT.setTextColor(BLANC, ROUGE);
		TFT.drawString("Choisir un pas", 80, 150);
	}
*/
}
 
 
 
void test_clic_bouton_TEST()
{
	test_clic_boutons(&bt_TEST ); 
 
	if (bt_TEST.cliked) 
	{
		bt_TEST.affiche(BLANC, ROUGE, 1);
		delay(10);
		Serial.println("-------------------------------");
		Serial.println("bt_TEST.cliked");
		bt_TEST.cliked = false;
		bt_TEST.selected = true;
		bt_TEST.affiche(BLANC, ROUGE, 1);
 
		//affi_nuances_de_gris();
		TS_calibrate();
 
		//TFT.fillScreen(NOIR); // effface
		//draw_AEC(0, 100, 320, 1);
		//delay(300);
 
		bt_TEST.cliked = false;
		bt_TEST.selected = false;
		bt_TEST.affiche(BLANC, ROUGE, 1);
 
		//init_affichages();
		//affiche_frequence(frequence);
		//affiche_frequence(1);
	}
}
 
double nb=0;
 
 
void test_clic_bts_preset()
{
	if(f_mode1 == MODE_WOBU) {return;}
 
	if (out_mode1 == MODE_9850)
	{			
		test_clic_bt_455k();
		test_clic_bt_4M();
		test_clic_bt_10_7M();
		test_clic_bt_27M();
	}
	if(out_mode1 == MODE_4351)
	{		
		test_clic_bt_35M();
		test_clic_bt_41M();
		test_clic_bt_144M();
		test_clic_bt_432M();
		test_clic_bt_2400M();
	}
}
 
 
 
void loop() 
{
	if (ts.tirqTouched() && ts.touched()) 
	{
		memo_y_touch = y_touch;
		get_XY_touch();
 
		test_clic_boutons_inc_dec(); // boutons cachés derrière les chiffres de la fréquence
		test_clic_bouton_RAZ();
 
		if((f_mode1 == MODE_ACCUEIL) || (f_mode1 == MODE_GENE))
		{		
			test_clic_bts_choix_module();
		}
		if(f_mode1 == MODE_GENE) { test_clic_bts_preset(); } 
		if(f_mode1 == MODE_WOBU)
		{
			test_clic_bt_pas_M();
			test_clic_bt_pas_P();
			//test_clic_bt_boucle();
		}
 
		test_clic_bt_calibrate();
 
		//if(f_mode1 == MODE_WOBU) { test_clic_bts_pas(); }
		test_clic_bts_MODE();
 
		/*
		if(stop1 == true) 
		{
			stop1= false;
			affi_bande_passante();
			//boucle_affi_curseur();
		*/
	}
 
	test_bouton_physique1();
 
	delay(20); //20
 
	// uint16_t valeurLue1 = analogRead(analogPin);
	// frequence = valeurLue1;
	// //Serial.println(valeurLue1);
	// affiche_frequence(frequence);
 
}
 
 
/** ***************************************************************************************
	CLASS TOUCH_BOUTON  // affiche un nombre ou un petit texte dans un rectangle
	ainsi que (en plus petit) deux valeurs supplémentaires, par ex: les valeurs mini et maxi					
********************************************************************************************/
 
// Constructeur
TOUCH_BOUTON::TOUCH_BOUTON()
{
 
}
 
 
 
 
void TOUCH_BOUTON::init(uint16_t x_i, uint16_t y_i, uint8_t dx_i, uint8_t dy_i, uint8_t dr_i, uint16_t couleur_i)
{
	x0 = x_i;
	y0 = y_i;
	dx = dx_i;
	dy = dy_i;
	dr = dr_i;
	couleur = couleur_i;
 
	cliked = false;
	selected = false;
}
 
 
 
void TOUCH_BOUTON::affiche(uint16_t coul_txt, uint16_t coul_fill_select, uint8_t n_font)
{
	uint16_t couleur_contour = GRIS_5;
 
	TFT.setTextColor(coul_txt);
 
	if(selected) 
	{
		TFT.fillRoundRect(x0, y0, dx, dy, dr, coul_fill_select);
	}  
	else 
	{
		TFT.fillRoundRect(x0, y0, dx, dy, dr, couleur); // efface
		TFT.drawRoundRect(x0, y0, dx, dy, dr, couleur_contour); // retrace juste le contour
	}
 
	//FM9 FMB9 FSS9... voir le fichier FrSD_Fonts.h
	if (n_font == 1) { TFT.setFreeFont(FF0);}
	if (n_font == 2) { TFT.setFreeFont(FM9);}
	if (n_font == 3) { TFT.setFreeFont(FMB9);}
	if (n_font == 4) { TFT.setFreeFont(FSS9);} 
 
	TFT.drawString(label, x0+3, y0 - (2*n_font) + (dy-4)/2);
}
 
 
uint8_t TOUCH_BOUTON::read_dx()
{
	return dx;
}
 
 
uint8_t TOUCH_BOUTON::read_dy()
{
	return dy;
}
 
 
/** ***************************************************************************************
	CLASS CHF_PAD  // boutons invisibles pour incrémenter/décrémenter les chiffres de la fréquence
********************************************************************************************/
// Constructeur
CHF_PAD::CHF_PAD()
{
 
}
 
void CHF_PAD::init()
{
	for(uint8_t n=0; n<=9; n++) // 1 9
	{
		bt_pad_H[n].init(x_ch[n], 16, 25, 22, 3, GRIS_3); //18
		//bt_pad_H[n].affiche(BLANC, VERT, 1);  // pour visualiser la position des boutons
 
		bt_pad_L[n].init(x_ch[n], 38, 25, 22, 3, GRIS_3); //40
		//bt_pad_L[n].affiche(BLANC, ROUGE, 1);
	}
 
}

Le programme complet (optimisé pour PlatformIO sous VScode) comprenant les "lib" et "include"... se trouve dans le fichier "documents.zip" au bas de cet article.

21 avril 2026 : La partie ADF4351 (30MHZ..2.4GHz) fonctionne, la fréquence choisie et affichée est réellement synthétisés et sortie sur le connecteur SMA. Je vous monterai des photos de l'ensemble en fonctionnement connecté sur un petit analyseur de spectre (tinySA).

25 avril 2026 : Les deux DDS (AD9850 et ADF4351) fonctionnent ! Le schéma a été mis à jour (libération du GPIO21) et le programme a été enrichi en conséquence. Nous avons là un double générateur de fréquence couvrant de 0 à 4.4 GHz sans trou. Reste à ajouter la fonction de wobulation.

26 avril 2026 : La programmation de la partie wobulation avance. On peut choisir la fréquence centrale et le pas de wobulation (avec 7 petits boutons sur l'afficheur). Reste à écrire la boucle de wobulation.

29 avril 2026 : Cette fois la boucle de wobulation est écrite. Il faut maintenant écrire la fonction d'acquisition de la réponse du circuit testé (actuellement j'affiche la réponse d'un filtre passe-bas du second ordre, par calcul dans le programme).
voir la fonction "void affi_trace_passe_bas()" dans le main.cpp

9 mai 2026 : L'acquisition de la réponse du circuit à tester est maintenant active, le résultat se dessine (rapidement) en temps réel sur l'afficheur. Le fonctionnement est correct tant pour les "basses" fréquences avec le module AD9850 que pour la VHF et l'UHF avec le module ADF4351. J'ai testé en particulier un fonctionnement OK pour 1350MHz.

5 VIDEO : Wobulation 300MHz

Le côté saccadé du signal est dû au temps d'analyse du "tinySA Spectrum Analyser" (dans cette configuration). Le signal de sortie de la carte ADF4351 est parfaitement fluide (vu à l'oscilloscope Hantek DSO2D50 - 500MHz).

6 Le signal 300MHz wobulé vu à l'oscilloscope

On voit que la variation de fréquence se fait d'une manière fluide (bien que, ici, par pas de 1MHz, 320 pas en tout, soit 160 pas de part et d'autre de la fréquence centrale égale à 300MHz, 1 pas de 1MHz par pixel horizontal sur l'afficheur ILI9341).

7 Signal 4MHz généré par le module AD9850

8 PREMIERE LUEUR !

En astronomie, la première lumière est la première utilisation pratique d'un nouvel instrument, généralement un télescope pour prendre une image. Ici il s'agit du premier résultat d'une wobulation complète, à savoir : Génération en boucle du signal wobulé (ici 16MHz) Attaque du circuit à tester (ici un quartz 16.000000 MHz) détection de la réponse du circuit (redressement par deux diodes UHF polarisées afin de se débarrasser du seuil de conduction) Acquisition temps réel du résultat Affichage en temps réel sur l'afficheur ILI9341 On peut voir la justesse de l'affichage par comparaison avec l'oscilloscope connecté en parallèle. Il me reste à mettre à jour le schéma (ajout du détecteur d'amplitude polarisé) mais aussi de finaliser le programme principal (ajout d'un réticule gradué et correction de quelque bugs lors du changement de mode [géné <-> wobu] ). Le programme complet (optimisé pour PlatformIO sous VScode) comprenant les "lib" et "include"... se trouve dans le fichier "documents.zip" au bas de cet article. 21 avril 2026 : La partie ADF4351 (30MHZ..2.4GHz) fonctionne, la fréquence choisie et affichée est réellement synthétisés et sortie sur le connecteur SMA. Je vous monterai des photos de l'ensemble en fonctionnement connecté sur un petit analyseur de spectre (tinySA). 25 avril 2026 : Les deux DDS (AD9850 et ADF4351) fonctionnent ! Le schéma a été mis à jour (libération du GPIO21) et le programme a été enrichi en conséquence. Nous avons là un double générateur de fréquence couvrant de 0 à 4.4 GHz sans trou. Reste à ajouter la fonction de wobulation. 26 avril 2026 : La programmation de la partie wobulation avance. On peut choisir la fréquence centrale et le pas de wobulation (avec 7 petits boutons sur l'afficheur). Reste à écrire la boucle de wobulation. 29 avril 2026 : Cette fois la boucle de wobulation est écrite. Il faut maintenant écrire la fonction d'acquisition de la réponse du circuit testé (actuellement j'affiche la réponse d'un filtre passe-bas du second ordre, par calcul dans le programme). voir la fonction "void affi_trace_passe_bas()" dans le main.cpp 9 mai 2026 : L'acquisition de la réponse du circuit à tester est maintenant active, le résultat se dessine (rapidement) en temps réel sur l'afficheur. Le fonctionnement est correct tant pour les "basses" fréquences avec le module AD9850 que pour la VHF et l'UHF avec le module ADF4351. J'ai testé en particulier un fonctionnement OK pour 1350MHz.

9 Wobulations avec l'AD9850

Nous allons expérimenter avec le circuit LC en // ci-dessus. Le signal d’excitation issu du DDS AD9850 sera appliqué au circuit résonnant LC // au moyen d'une boucle d'induction (5 spires diamètre 10mm) visible en haut de la photo. Le circuit LC à tester (monté sur une mini platine à mini connecteurs permettant de changer facilement les composants) est relié au détecteur d'amplitude à diodes Schottky (le petit module blindé) par un câble coaxial diamètre 2,8mm ayant (nous indique le fabriquant) une capacité de 100 pF/m (à ne pas confondre avec l'impédance caractéristique de 50 ohm) Ce câble auquel on peut ajouter les deux connecteurs SMA aux extrémités totalise une longueur de 13mm. Ce qui nous permet d'estimer la capacité totale de l'ensemble à 0.13x100pF = 13pF. Ces 13 pF viennent s'ajouter à la valeur des condensateurs que nous connecterons en parallèle sur l'inductance L.

10 Formule de Thomson

Dans la suite de l'expérimentation nous utiliserons la Formule de Thomson (la 1ere ci-dessus), et celles directement dérivées donnant les valeurs de L en fonction de la fréquence et de C ainsi que la valeur de C en fonction de la fréquence et de L.

11 Premier test en très basse fréquence (80kHz)

C'est un circuit LC résonnant parallèle. La self est un modèle enrobé (au tout premier plan, coiffée par la boucle d'induction). Le condensateur est un 1nF céramique. Le calcul 1/(2pi.sqrt(L.C)) donne une fréquence de résonance de 73.41Hz. Ce qui correspond au résultat affiché par le wobulo. Erreur 10%, ce qui colle bien avec la précision donnée pour ces composants. Remarque : J'ai ajouté une capa de 100nF sur la sortie du détecteur (qui est l'entrée du convertisseur A/N de l'ESP32) pour lisser le signal, qui sans cela se trouve légèrement bruité, surtout pour les analyses à des fréquences inférieures à 1MHz.

12 Test de transfos FI 455kHz et 10.6MHz

Voilà qui devrait plaire aux nostalgiques des "postes à transistors" des années 70', juste après la disparition des dinosaures. La 'fréquence intermédiaire' 455kHz, différence entre celle reçue à l'antenne (PO et GO) et l'oscillateur local était utilisée pour la modulation d'amplitude. Celle de 10.6MHz (ou 10.7) MHz servait pour la gamme FM (88..108MHz). Et les ondes courtes ?? me rappelle plus ! On utilisait aussi des filtres à résonateur céramique...

13 Test d'un filtre céramique 10.7MHz
	Comme quoi le wobulateur s’accommode tout aussi bien de ces composants. Toutefois les petits transfos FI et ce filtre sont testé isolés de leur utilisation normale. C'est à dire que lorsqu'ils sont en place dans un récepteur de radio et que vous ne voulez pas les dessouder, ou simplement que vous voulez connaître leur comportement in situ, la manip risque d'être un peu plus délicate.

14 Circuit avec C = 270 pF et une self inconnue :
Appliquons (avec un tableur LibreOffice Calc, je vous donne la feuille de calcul dans le fichier "documents.zip" au bas de l'article) la formule qui donne la valeur de L en fonction de F et de C: (en ajoutant les 13pF du coax à la valeur de C). Nous obtenons L = 937,70nH

15 Circuit avec C = 82 pF
Remplaçons le condensateur par un 82pF sans changer la bobine L et calculons la fréquence que nous devrions obtenir. Le calcul donne 16,863 MHz L'expérience ci-contre donne une fréquence de 16,500 MHz. L'erreur est de 2%... Sachant que la précision des condensateurs céramiques "ordinaires" est plutôt de 20%... C'est pas mal. REMARQUES : C'est la racine carrée de C qui intervient dans la formule... Vous pouvez aussi trouver des céramiques avec une précision de 2%.

16 Circuit avec C = 47 pF
Remplaçons le condensateur par un 47pF sans changer la bobine L et calculons la fréquence que nous devrions obtenir. Le calcul donne 21,218 MHz L'expérience ci-contre donne une fréquence de 21,100 MHz. L'erreur est de 0,6% (21218 / 21100=1.006). Waouh!

17 Circuit avec C = 18 pF
Remplaçons le condensateur par un 18pF sans changer la bobine L et calculons la fréquence que nous devrions obtenir. Le calcul donne 29,519 MHz L'expérience ci-contre donne une fréquence de 28,800 MHz (vu de près, un peu plus ! ) L'erreur est de 2%.

18 Circuit avec C = 10 pF
L'erreur et de 4%.
On constate donc que le wobulateur ne fait pas "n'importe quoi" ! Mais il faut éviter les erreurs expérimentales, comme par exemple négliger l'influence des capacités parasites.

19 Wobulation avec l'ADF4351 - circuit LC - 170MHz
Capture d'écran de l'afficheur 320x240	Le filtre 170MHz expérimental (!) en composants classiques

20 Filtre en Pi 2.4GHz
Vu la valeur des composants il est clair qu'on ne va pas pouvoir aller beaucoup plus haut en fréquence avec la technologie SMD (surface mounted component = en français CMS composant monté en surface).	C'est un double face, l'autre face est entièrement métallisée = GND. Détail important : plusieurs vias non visibles ici relient les GND des deux faces.

21 Wobulation de ce filtre en Pi - 2.4GHz
La réponse du filtre LC (capture d'écran de l'afficheur ILI9341 2.8" + touchScreen). 2300 MHz affiché en haut c'est la fréquence centrale du balayage (trait vertical au centre). 2510 MHz c'est la fréquence qui correspond au curseur (trait vertical plus petit à droite) positionné ici manuellement (au stylet) sur la fréquence de résonnance.	Le filtre perso 2400 MHz en question, réalisé en composants CMS. A ces fréqences on ne travaille plus avec des composants classiques !

22 Test d'un autre filtre 2.4GHz
	La face arrière est totalement métallisée. Comme on peut le voir j'avais bricolé ce filtre pour je ne sais plus quelle raison. A ces fréquences et surtout au delà, on utilise plutôt des technologies "Microstrip Bandpass Filter" comme ici, voire des résonateurs à cavités résonnantes qui ont un Q très élevé (>30 000) et donc une bande passante extrêmement étroite.

23 petite capture d'écran...
	Où l'on voit de nouvelles fonctions: bouton 'INV' d'inversion (haut-bas) de l'affichage Bouton 'STOP' du balayage, fait entrer dans le mode 'déplacement curseur' (latéralement, au stylet) boutons '+' et '-' pour régler le gain affichage de la valeur du gain. (voir fonction 'void balayage_freq(uint64_t F0)')

24 Le détecteur d'amplitude AM

Il est annoncé fonctionner de 0.1MHz à 3.3 GHz. La sérigraphie est particulièrement discrète. A part ce numéro... J'en avais deux dont un HS, j'ai ouvert son blindage pour voir sa constitution: Il y a une double diode Schottky dans un boîtier SMD "type transistor" + 2 condensateurs et 2 résistances qui se battent en duel. Il n'est pas alimenté. On peut le réaliser avec deux diodes Schottky 1N6263 (pour des fréquences <1GHz). Les signaux à analyser étant de faible amplitude (400mV) et descendant jusqu'à 0V, j'ai dû polariser sa sortie avec R=220k au +3V3. Attention: ces composants sont fragiles. Pas de surtensions, pas de décharges électrostatiques ! Quelques précisions concernant le petit schéma d'interconnexion ci-dessus : R1=220k sert à faire passer un faible courant dans le détecteur afin de polariser ses diodes Schottky (dans le sens passant) juste à leur seuil de conduction pour ne pas manquer les signaux faibles. R2=15k parcourue elle aussi par ce courant de repos sert à décaler le potentiel envoyé au CAN de l'ESP32 parce que ce dernier ne démarre pas la conversion depuis zéro V, mais depuis une faible tension positive. Les condensateurs évitent de récupérer du bruit sur l'alim. J'ai également utilisé des détecteurs logarithmiques AD8302 et AD8318. Fragiles eux aussi !

25 Un autre détecteur AM
Ce modèle non-blindé (et moins cher) fonctionne tout aussi bien que le précédent. Il a l'avantage de montrer ses composants. L'espèce de transistor SMD (qui n'en est pas un) est marqué XH8 sur celui que j'utilise, on le retrouve sous l'appellation "SCHOTTKY BARRIER RECTIFIER".	Certains fournisseurs montrent une photo sur laquelle on peut lire 'P2A'... qui peut correspondre à plein de choses ! Voir par exemple : https://smd.yooneed.one/code5032.html#code5032 Le marquage des composants SMD c'est, à mes yeux, un peu le bazar !

26 Quelques boucles d'induction et diverses selfs enrobées
Ces boucles s'utilisent pour coiffer l'inductance d'un circuit LC à tester (qui doit être électriquement relié au détecteur). La plus petite destinée aux fréquences VHF compte deux spires, la plus grande qui donne satisfaction pour des fréquences de l'ordre du MHz voire bien moins (je l'ai testée à 80 kHz, comme vu plus haut) compte une cinquantaine de spires.	Vue d'ensemble de tout cela. Les selfs enrobées ressemblent furieusement à des résistances à couche métallique (verdâtres elles aussi). Attention à ne pas tout confondre !

27 Les modules DDS AD9850 & ADF4351

28 L'afficheur 2.8 et le module ESP32
Il s'agit du modèle ILI9341 2.8" AVEC écran tactile (touch screen). Il est aussi proposé en version no-touch qui ne convient pas étant donné que tout se fait au stylet sur l'écran. Donc attention lors de l'achat.	Un grand classique.

29 Le board (carte perso reliant l'afficheur à l'ESP32 )

Je l'ai donné(e) à fabriquer par JLPCB. Je vous fournis tous les documents Kicad dans le fichier 'documents.zip' au bas de l'article.

30 Cet appareil dans son boîtier
	Cette face avant est constituée par une feuille de papier imprimée à l'imprimante laser puis plastifiée avec une plastifieuse classique. Le tout est collé sur le dessus du couvercle après découpe de l'emplacement de l'afficheur. Quant aux boutons, il s'agit évidemment d'une image pour faire joli (!) sachant qu'aucun bouton n'est nécessaire pour faire fonctionner l'appareil, tout se fait au stylet sur l'écran tactile.

31 Disposition des modules dans la boite
L'afficheur ILI9341 est caché sous la carte d’interconnexion avec l'ESP32, disposés dans le couvercle. Les deux modules HF sont placés dans le fond de la boite.

32 Affichage bande passante et facteur de qualité
14 juin 2026 : Ajout de nouvelles fonctions : Calcul et affichage de la fréquence de résonance d'un circuit oscillant Calcul et affichage de la bande passante à -3dB en tension, soit Vmax/sqrt(2) Calcul et affichage du facteur de qualité 'Q' Quelques précisions : 0007.000.000 c'est 7 MHz, fréquence centrale de la vobulation, qui correspond horizontalement au centre de l'affichage à 160px du bord, l'affichage faisant 320px de large. On peut la modifier à tout moment, avec le stylet directement sur les gros chiffres en haut. F0=6.020.000 (= 6020kHz = 6,020 MHz) c'est la fréquence de résonance du circuit LC testé. P=20.000 (= 20kHz) est la valeur du pas de vobulation. Chaque pas correspond horizontalement à 1 pixel. L'affichage fait 320 px de large. Bp=760.000 (= 760kHz) c'est la largeur bande passante mesurée. g=0.15 c'est le gain vertical (qui se règle automatiquement en cas d’écrêtage du signal). Il peut aussi se modifier par les boutons [+] et [-] Q=7.92 c'est le facteur de qualité. S'il semble trop faible on peut faire une réclamation à la poste :))
J'ai également retourné l'affichage (à 180 deg) pour pouvoir utiliser l'appareil avec l'écran à droite et non plus à gauche, ce qui permet de ne pas être géné par la connectique lorsqu'on utilise le stylet sur l'écran, du moins pour les droitiers, je m'excuse pour les gauchers... mais sachez qu'il n'y a qu'une ligne de code à modifier, cherchez : `TFT.setRotation(1);// 1 ou 3 à voir, suivant disposition de l'afficheur`

33 Facteur de qualité d'un filtre blindé FI 455MHz
On mesure un Q=20.68. C'est déjà mieux que le circuit LC précédent. Bande passante 22KHz (= +/- 11kHz) c'est ce qu'on attend d'un filtre FI modulé en amplitude des signaux BF = 0..9 kHz (les bandes latérales de part et d'autre de la porteuse étant = +/- 9kHz). Tiens, tiens... C'est bizarre, la fréquence de résonance est exactement égale à 455kHz ! Ben non, j'ai juste tourné le noyau avec un tournevis pour obtenir ce résultat !

34 Facteur de qualité d'un filtre céramique 10.7MHz
Cette fois le Q n'est plus de 7.92 mais de 254.3. Certes les courbes de résonance se ressemblent mais à y regarder de plus près le pas d'analyse n'est plus de 20kHz mais vaut P=2.000 (=2kHz)

35 Facteur de qualité d'un quartz 16MHz

Le quartz 16MHz est inséré en série entre la sortie de l'AD9850 et le détecteur d'amplitude. Sur la première saisie d'écran on constate deux pics de transmission. Sur les captures suivante on zoome sur chacun d'eux. Le premier se situe à la fréquence = 16.004MHz soit très proche des 16 MHz attendu. On peut se demander si le léger décalage fréquentiel provient de la précision du générateur ou de celle du quartz (ou les deux ?) Le Q monte à 2800 ce qui est bien supérieur à ce que donne un circuit LC. Le second pic se produit à 16.109500 MHz, ce qui s'éloigne de la fréquence nominale, mais en contrepartie son Q s'élève à 18950 (Le pas d’analyse et respectivement de 1000 Hz, 200 Hz et 50Hz). L'article 'Quartz (électronique)' sur Wikipédia dit : `Un quartz peut être modélisé comme un circuit électrique possédant deux fréquences de résonance proches l'une de l'autre, l'une à faible impédance (série), et l'autre à haute impédance (parallèle).` puis plus loin : `Pour que le quartz fonctionne à sa fréquence nominale en mode parallèle, il faut que la capacité équivalente du circuit actif présenté au quartz soit celle spécifiée par le constructeur.` Nous voilà prévenus ! Quant à la Loi de Murphy, elle nous rapelle : `"Un oscillateur à quartz oscille forcément sur une autre fréquence que celle prévue... s’il oscille ! "`

36 Test par GPS de la précision de la fréquence de l'AD9850 et de celle du quartz 16MHz
Dans le paragraphe précédent nous avons constaté que le quartz 16 MHz (marqué 16.0000MHz sur son boîtier) présentait une fréquence de résonance de 16.004 MHz mesurée par le wobulateur. Je me devais donc d'expérimenter afin de savoir lequel des deux était le plus juste, le quartz ou l'AD9850 ? Il se trouve que je suis en mesure de le faire, avec mon Géné VHF 1Hz à 100MHz à DDS AD9951 piloté par GPS. J'ai donc généré un signal = 16MHz par le géné GPS et un autre signal de 16 MHZ également par le wobu en mode géné. J'ai alors connecté les deux signaux sur un oscilloscope en mode Lissajous et j'ai réglé très finement la fréquence du wobu pour obtenir une figure stable. RESULTAT : La synchronisation se produit lorsque le wobu affiche 16.000202 MHz. L'ADF9850 s'en sort donc très bien (200Hz d’écart) et le quartz avec son 16.004800 est mis KO par 24 à 1 ! L'erreur 4800Hz est en effet 24 fois supérieure à celle de 202 Hz. Toutefois nous avons vu plus haut que : `Pour que le quartz fonctionne à sa fréquence nominale en mode parallèle, il faut que la capacité équivalente du circuit actif présenté au quartz soit celle spécifiée par le constructeur.` Donc on peut penser que ce quartz utilisé correctement serait plus précis.
Et n'oublions pas que ce n'est pas pour rien qu'on a inventé les oscillateurs TCXO, les OCXO, les horloges atomiques au rubidium (j'en ai une d'occase qui m'a coûté environ 100€) et les horloges atomiques au césium (alors là c'est beaucoup beaucoup plus cher). Mais avec le GPS on dispose d'une horloge au césium gratos !

37 On va dorloter le quartz !
Fort des connaissances acquises précédemment nous ne pouvions pas en rester là ! Il fallait absolument tester ce quartz en le plaçant dans un environnement qui lui convient. J'ai donc ajouté un condensateur céramique de 12pF en parallèle. Et cette fois le résultat est excellent. Non seulement la fréquence est 100 fois plus précise mais en plus le Q est passé de 2860 à 9700. On retiendra que lorsqu'on utilise un quartz il faut le faire sérieusement.

38 documents
Code source complet en C++ Version du code source adaptée à l’éditeur VScode/PlatformIO Vous trouverez dans ce fichier 'documents.zip' le code source complet ainsi que des fichiers à placer sur la SDcard. Remarque: En phase de développement, mises à jour quasi quotidiennes -> des fonctions en plus, une ergonomie améliorée, des bugs en moins ! Voir le n° de version au début du fichier main.cpp documents.zip

39 -

Liens...

Pour me joindre : silicium628@free.fr
Un site complémentaire à celui-ci ; Electro & Robot

1303

[ Retour Accueil ]

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