//**********************************************************************************************************************************************************************************
//	Fichier BDD_SYNCHRO.C 
//
//	Contient les fonctions de synchronisation de la BDD avec l'appli
//
//**********************************************************************************************************************************************************************************

 //#define __DEBUG_TIMING_SYNCHRO_BDD		// Si cette ligne est active, affiche à chaque synchro (T=1s) le temps d'exécution de la boucle complète, avec et sans l'appel à la fonction 'enregistrement_mesures()'. 


// Include :
#include "main.h"

// Prototypes :
void synchro_bdd(void);


// Variables globales :

 
//**********************************************************************************************************************************************************************************
//	Fonction SYNCHRO_BDD
//
//	Fonction initialisant l'accès à la base de données...
//**********************************************************************************************************************************************************************************
void synchro_bdd(void)
{
int8_t val_8;
int16_t val_16;
uint8_t val_u8;
uint16_t val_u16;
uint32_t val_u32;
float val_f;
bool flag_synchro_web = FALSE;
bool flag_synchro_wifi = FALSE;
bool flag_scan_wifi_sta = FALSE;
bool flag_demande_maj_nmea = FALSE;
uint16_t i, j, k;
char *ptr[MAX_NOMBRE_CHAMPS_INTERNES];
char requete[MAX_LONGUEUR_REQUETE_MYSQL];
MYSQL_RES *result = NULL;	
MYSQL_ROW row = NULL;
time_t now;
struct tm date;
struct tm date_fin;
char chaine_date_fin[MAX_LONGUEUR_DATE_COURANTE];
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
	
	
	// Lecture "fréquente" du flag de synchro dans la BDD :
	if (bdd.compteur_synchro == 0)
	{
		bdd.compteur_synchro = PERIODE_CHECK_SYNCHRO_WEB;
		
		sprintf(requete, "SELECT Valeur FROM TB_Systeme WHERE Nom='Synchro' AND Valeur!=0 "); 
		mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
		result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
		while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
		{
			i = atoi(row[0]);
			
			sprintf(requete, "UPDATE TB_Systeme SET Valeur='0' WHERE Nom='Synchro'");		// RAZ du flag de synchro dans la BDD (faite immédiatement car le traitement ensuite peut être long)
			mysql_query(bdd.pointeur, requete);	
			
			switch(i)
			{
				case 1: 				// Demande de synchro
				{
					flag_synchro_web = TRUE; 
					break;
				}
				case 2: 				// Changement de config 
				{
//printf("Demande de resynchro reçue\n");					
					re_configuration_systeme();
					break;
				}
				default : ;
			}
		}
		mysql_free_result(result);	//Libération du jeu de résultat
	}
	
	
	// Synchronisation avec la BDD toutes les secondes si aucune demande spécifique n'a été reçue OU synchro immédiate si demande reçue :
	if (((bdd.compteur == 0) || flag_synchro_web) && (systeme.flag_cm3p_ready))
	{

#ifdef __DEBUG_TIMING_SYNCHRO_BDD		
		uint32_t deb, fin_1, fin;
		deb = clock();		
#endif
		
		bdd.compteur = PERIODE_MAJ_BDD;						// A priori, toute les secondes (cf GESTION_BDD.H). NB : si la demande vient du web, on relance la tempo asynchrone...	
		
		
		
		
// ********************************************************************************************************************************************************
// SYSTEME
// ********************************************************************************************************************************************************
	
		// Recherche d'une condition d'archivage :
		now = time (NULL);							// lire l'heure courante,
		date = *localtime (&now);					// et la convertir en heure locale.
		
		if (date.tm_sec == 0)						// Si on n'est pas sur une minute ronde, on ne fait rien...
		{
			now = now - 1;							// On se met 1s avant (donc xx:xx:59). Un peu "symbolique" mais permet de bien marquer que c'est la FIN de la période (et on enregistre ensuite les mesures d'énergie avec cette valeur...)
			date_fin = *localtime (&now);			// Conversion en heure locale
			strftime (chaine_date_fin, MAX_LONGUEUR_DATE_COURANTE, "%Y-%m-%d %H:%M:%S", &date_fin);		// Passage en chaine au format SQL. Exemple : "2023-12-19 13:04:59"

			if ((date.tm_min % 5) == 0)				// Si on est sur "5min rondes" :
			{
				if (date.tm_min == 0)					// Si on est sur une "heure ronde" :
				{
					sprintf(tmp, "Periode de type 2 détectée avec Fin = %s", chaine_date_fin);
					affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);	
					archivage_bdd(chaine_date_fin, BDD_TYPE_ARCHIVAGE_1_HEURE);							// Déclenchera d'abord un archivage de Type 3 avant d'enchainer directement sur un archivage de Type 2
				}
				else 									// Sinon, c'est qu'on est sur xx:05, xx:10, xx:15... (mais PAS sur xx:00)
				{
					if ((date.tm_hour == 0) && (date.tm_min == 5))		// La purge est volontairement décalée à 00h05 car l'archivage de 00h00 fait un Type 3 puis un Type 2 dans la foulée. Ici, on fera "juste" un Type 3 avant de faire la purge.
					{
						sprintf(tmp, "Periode de type 3 + purge détectée avec Fin = %s", chaine_date_fin);
						affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);	
						archivage_bdd(chaine_date_fin, BDD_TYPE_ARCHIVAGE_5_MINUTES_ET_PURGE);
					}
					else
					{
						sprintf(tmp, "Periode de type 3 détectée avec Fin = %s", chaine_date_fin);
						affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);	
						archivage_bdd(chaine_date_fin, BDD_TYPE_ARCHIVAGE_5_MINUTES);
					}
				}				
			}
		}


		// Recherche des nouvelles consignes reçues depuis le web :
		sprintf(requete, "SELECT Nom, Valeur FROM TB_Systeme "); 
		mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
		result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
		while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
		{
			//---------------------------------------------------------------
			if (strstr(row[0], "New_bip") != NULL) 
			{
				if (row[1][0] != 0)			// On ne traite que si Valeur != "" :
				{
					i = 0;
					ptr[i] = strtok (row[1],"/");			// Extraction du premier segment avant le premier '/'		ATTENTION : si aucun délimiteur trouvé, la fonction renvoit la chaine entière (et pas NULL...)
					while ((ptr[i] != NULL) && (i < MAX_NOMBRE_CHAMPS_INTERNES))
					{		
						i ++;
						ptr[i] = strtok (NULL, "/");		// Extraction du segment suivant le prochain '/'
					}
					
					// Check du nombre de champs trouvés :
					if (i != 4)
					{
						sprintf(tmp, "La demande de New_bip n'a pas un format acceptable (%i segments pour 4 attendus). La demande est rejetée...", i);
						affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
					}
					else if (strlen(ptr[0]) >= MAX_LONGUEUR_NOM_FICHIER)
					{
						sprintf(tmp, "Le nom de fichier reçu via le champ New_bip est trop long (%li caractères pour %i max). La demande est rejetée...", strlen(ptr[0]), MAX_LONGUEUR_NOM_FICHIER);
						affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
					}
					else emission_bip(ptr[0], atoi(ptr[1]), atoi(ptr[2]), atoi(ptr[3]));			// NB : si 'atoi()' rencontre une erreur, il retourne '0' qui sera traité sans problème par 'emission_bip()'
				}

				// RAZ de la demande dans la BDD :
				sprintf(requete, "UPDATE TB_Systeme SET Valeur='' WHERE Nom='New_bip' ");	
				mysql_query(bdd.pointeur, requete);	
			}
			//---------------------------------------------------------------
			if (strstr(row[0], "Consigne_modem") != NULL) 
			{
				val_8 = atoi(row[1]);
				if ((val_8 == 0) || (val_8 == 1))
				{									
					modem.consigne = val_8;
					
					// RAZ de la demande dans la BDD :
					sprintf(requete, "UPDATE TB_Systeme SET Valeur='-1' WHERE Nom='Consigne_modem' ");	
					mysql_query(bdd.pointeur, requete);	
					
					// Enregistrement dans l'historique :
					enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_MODEM_DEMANDE_ACTIVATION, 0, modem.consigne, NULL);	
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Veille") != NULL) 
			{
				val_u8 = atoi(row[1]);
				if ((val_u8 != systeme.veille) && (val_u8 <= SYSTEME_VEILLE_PROFONDE))
				{									
					systeme.veille = val_u8;
					
					if (systeme.veille == 0) set_luminosite_ecran(ecran.consigne_backlight);
					else set_luminosite_ecran(0);
					
					// Enregistrement dans l'historique :
					enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_CHANGEMENT_VEILLE, 0, systeme.veille, NULL);	
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Demande_decouverte_ow") != NULL) 
			{
				val_u8 = atoi(row[1]);
				if (val_u8 == 1)
				{									
					c_bus_down_commande_config_ow();			// Envoi de la demande au Compagnon. 
					// NB : à la fin de la découverte réseau, le Compagnon va remonter une commande 'c_bus_up_commande_etat_entrees_ow' avec un code 
					// particulier (code_reinit) qui permettra automatiquement au CM4, et de façon synchrone, d'émettre une commande 'c_bus_down_reponse_annuaire_ow()'
					
					// RAZ de la demande dans la BDD :
					sprintf(requete, "UPDATE TB_Systeme SET Valeur='0' WHERE Nom='Demande_decouverte_ow' ");	
					mysql_query(bdd.pointeur, requete);						
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Demande_connexion_serveur") != NULL) 
			{
				val_u8 = atoi(row[1]);
				switch (val_u8)
				{				
					default:
					case MODEM_DEMANDE_UTILISATEUR_AUCUNE: break;
					
					case MODEM_DEMANDE_UTILISATEUR_DOWNLOAD: 
					{
						if (modem.compteur_periode_download > MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI) modem.compteur_periode_download = MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI;
						break;
					}
					case MODEM_DEMANDE_UTILISATEUR_UPLOAD: 
					{
						if (modem.compteur_periode_upload > MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI) modem.compteur_periode_upload = MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI;
						break;
					}
					case MODEM_DEMANDE_UTILISATEUR_DOWNLOAD_UPLOAD: 
					{
						if (modem.compteur_periode_download > MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI) modem.compteur_periode_download = MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI;
						if (modem.compteur_periode_upload > MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI) modem.compteur_periode_upload = MODEM_DEMANDE_UTILISATEUR_TEMPO_MINI + 1;		// A priori, on force l'Upload à passer après le download. 
						break;
					}
				}
				
				if (val_u8 != MODEM_DEMANDE_UTILISATEUR_AUCUNE)			// RAZ de la demande dans la BDD :
				{
					sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Demande_connexion_serveur' ", MODEM_DEMANDE_UTILISATEUR_AUCUNE);	
					mysql_query(bdd.pointeur, requete);
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Demande_reboot") != NULL) 
			{
				if (strcmp(row[1], "Reboot") == 0) 
				{
					// RAZ du flag dans la BDD :
					sprintf(requete, "UPDATE TB_Systeme SET Valeur='' WHERE Nom='Demande_reboot' ");	
					mysql_query(bdd.pointeur, requete);	
					
					// Lancement de la réinit :
					lancement_reinit(0);			// La valeur 0 indique d'utiliser la valeur par défaut
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Aube_nautique") != NULL) 
			{
				if ((strlen(row[1]) == 5) && (row[1][2] == ':'))		// Doit être de la forme "hh:mm"
				{
					tmp[0] = row[1][0];
					tmp[1] = row[1][1];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_AUBE_NAUTIQUE].heures = atoi(tmp);
					tmp[0] = row[1][3];
					tmp[1] = row[1][4];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_AUBE_NAUTIQUE].minutes = atoi(tmp);
					systeme.heures_speciales[HEURE_SPECIALE_AUBE_NAUTIQUE].secondes = 0;
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Lever_soleil") != NULL) 
			{
				if ((strlen(row[1]) == 5) && (row[1][2] == ':'))		// Doit être de la forme "hh:mm"
				{
					tmp[0] = row[1][0];
					tmp[1] = row[1][1];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_LEVER_SOLEIL].heures = atoi(tmp);
					tmp[0] = row[1][3];
					tmp[1] = row[1][4];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_LEVER_SOLEIL].minutes = atoi(tmp);
					systeme.heures_speciales[HEURE_SPECIALE_LEVER_SOLEIL].secondes = 0;
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Zenith") != NULL) 
			{
				if ((strlen(row[1]) == 5) && (row[1][2] == ':'))		// Doit être de la forme "hh:mm"
				{
					tmp[0] = row[1][0];
					tmp[1] = row[1][1];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_ZENITH].heures = atoi(tmp);
					tmp[0] = row[1][3];
					tmp[1] = row[1][4];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_ZENITH].minutes = atoi(tmp);
					systeme.heures_speciales[HEURE_SPECIALE_ZENITH].secondes = 0;
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Coucher_soleil") != NULL) 
			{
				if ((strlen(row[1]) == 5) && (row[1][2] == ':'))		// Doit être de la forme "hh:mm"
				{
					tmp[0] = row[1][0];
					tmp[1] = row[1][1];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_COUCHER_SOLEIL].heures = atoi(tmp);
					tmp[0] = row[1][3];
					tmp[1] = row[1][4];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_COUCHER_SOLEIL].minutes = atoi(tmp);
					systeme.heures_speciales[HEURE_SPECIALE_COUCHER_SOLEIL].secondes = 0;
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Crepuscule_nautique") != NULL) 
			{
				if ((strlen(row[1]) == 5) && (row[1][2] == ':'))		// Doit être de la forme "hh:mm"
				{
					tmp[0] = row[1][0];
					tmp[1] = row[1][1];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_CREPUSCULE_NAUTIQUE].heures = atoi(tmp);
					tmp[0] = row[1][3];
					tmp[1] = row[1][4];
					tmp[2] = 0;
					systeme.heures_speciales[HEURE_SPECIALE_CREPUSCULE_NAUTIQUE].minutes = atoi(tmp);
					systeme.heures_speciales[HEURE_SPECIALE_CREPUSCULE_NAUTIQUE].secondes = 0;
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Demande_maj_nmea") != NULL) 
			{
				val_u8 = atoi(row[1]);
				if (val_u8 == 1) 
				{									
					flag_demande_maj_nmea = TRUE;		// Flag traité en fin de cette fonction...
					
					// RAZ de la demande dans la BDD :
					sprintf(requete, "UPDATE TB_Systeme SET Valeur='0' WHERE Nom='Demande_maj_nmea' ");	
					mysql_query(bdd.pointeur, requete);						
				}
			}

		} 
		mysql_free_result(result);	//Libération du jeu de résultat
		
		// Recherche des nouveaux paramètres de config reçus depuis le web :
		sprintf(requete, "SELECT Nom, Valeur FROM TB_Configuration "); 
		mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
		result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
		while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
		{
			//---------------------------------------------------------------
			if (strstr(row[0], "Fuseau_horaire") != NULL) 
			{
				val_8 = atoi(row[1]);
				if (val_8 != systeme.fuseau_horaire)
				{
					if ((val_8 >= -14) && (val_8 <= 12)) systeme.fuseau_horaire = val_8;
				}
			}
			//---------------------------------------------------------------
			if (strstr(row[0], "Heure_ete") != NULL) 
			{
				val_u8 = atoi(row[1]);
				if (val_u8 != systeme.heure_ete)
				{
					if ((val_u8 == 0) || (val_u8 == 1)) systeme.heure_ete = val_u8;
				}
			}
			//---------------------------------------------------------------
			if (strstr(row[0], "Validation_leds") != NULL) 
			{
				val_u16 = atoi(row[1]);
				if ((val_u16 != ecran.validation_leds) && (val_u16 <= 1))
				{									
					ecran.validation_leds = val_u16;
					
					if (systeme.veille == SYSTEME_VEILLE_AUCUNE) 
					{
						if (ecran.validation_leds == 0) c_bus_down_commande_cde_backlight(ecran.consigne_backlight, 0);
						else c_bus_down_commande_cde_backlight(ecran.consigne_backlight, ecran.consigne_leds);
					}
					else 
					{
						if (ecran.validation_leds == 0) c_bus_down_commande_cde_backlight(0, 0);
						else c_bus_down_commande_cde_backlight(0, ecran.consigne_leds);
					}
					
					// Enregistrement dans l'historique :
					enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_LEDS_CHANGEMENT_CONSIGNE, 0, ecran.consigne_leds, NULL);	
				}
			}
			//---------------------------------------------------------------
			if (strstr(row[0], "Consigne_leds") != NULL) 
			{
				val_f = atof(row[1]);
				if ((val_f != ecran.consigne_leds) && (val_f >=LEDS_CONSIGNE_MIN) && (val_f <= LEDS_CONSIGNE_MAX))
				{									
					ecran.consigne_leds = val_f;
										
					if (systeme.veille == SYSTEME_VEILLE_AUCUNE) 
					{
						if (ecran.validation_leds == 0) c_bus_down_commande_cde_backlight(ecran.consigne_backlight, 0);
						else c_bus_down_commande_cde_backlight(ecran.consigne_backlight, ecran.consigne_leds);
					}
					else 
					{
						if (ecran.validation_leds == 0) c_bus_down_commande_cde_backlight(0, 0);
						else c_bus_down_commande_cde_backlight(0, ecran.consigne_leds);
					}
					
					// Enregistrement dans l'historique :
					enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_LEDS_CHANGEMENT_CONSIGNE, 0, ecran.consigne_leds, NULL);	
				}
			}
			//---------------------------------------------------------------
			if (strstr(row[0], "Consigne_backlight") != NULL) 
			{
				val_f = atof(row[1]);
				if ((val_f != ecran.consigne_backlight) && (val_f >=ECRAN_CONSIGNE_MIN) && (val_f <= ECRAN_CONSIGNE_MAX))
				{									
					ecran.consigne_backlight = val_f;
					
					if (systeme.veille == SYSTEME_VEILLE_AUCUNE) set_luminosite_ecran(ecran.consigne_backlight);		// Mise à jour de la luminosité de l'écran avec cette nouvelle valeur
					
					// Enregistrement dans l'historique :
					enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_BACKLIGHT_CHANGEMENT_CONSIGNE, 0, ecran.consigne_backlight, NULL);	
				}
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Consigne_volume") != NULL) 
			{
				val_f = atof(row[1]);
				if (val_f != audio.consigne_volume)	set_volume(val_f, AUDIO_SET_VOLUME_ECHO_ON);			// Mise à jour de la consigne de volume (les tests de validité et la mise à jour du volume se font dans la fonction...)
			}
			//---------------------------------------------------------------
			else if (strstr(row[0], "Wifi_new_config") != NULL) 
			{
				val_8 = atoi(row[1]);
				if (val_8 == 1) flag_synchro_wifi = TRUE;
				else if (val_8 == 2) flag_scan_wifi_sta = TRUE;
				//reseaux.wifi_new.sta.flag_dde_scan = TRUE;
			}
			
		} 
		mysql_free_result(result);	//Libération du jeu de résultat
		
		
		// Mise à jour de la config du Wifi :
		if (flag_synchro_wifi)
		{
			// Récupération des valeurs de la BDD :
			sprintf(requete, "SELECT Nom, Valeur FROM TB_Configuration WHERE (Nom='Wifi_sta_cde' OR Nom='BSSID_Wifi_sta' OR Nom='Wifi_ap_cde' OR Nom='Wifi_ap_ssid' OR Nom='Wifi_ap_pwd' OR Nom='Wifi_ap_canal') "); 
			mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
			result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
			while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
			{
				if (strcmp(row[0], "Wifi_sta_cde") == 0) reseaux.wifi_new.sta.cde = atoi(row[1]);
				else if (strcmp(row[0], "Wifi_ap_cde") == 0) reseaux.wifi_new.ap.cde = atoi(row[1]);
				else if (strcmp(row[0], "BSSID_Wifi_sta") == 0) 
				{
					if (strlen(row[1]) < MAX_RESEAUX_WIFI_STA_TAILLE_BSSID) strcpy(reseaux.wifi_new.sta.bssid, row[1]);
				}
				else if (strcmp(row[0], "Wifi_ap_ssid") == 0) 
				{
					if (strlen(row[1]) < MAX_RESEAUX_WIFI_AP_TAILLE_SSID) strcpy(reseaux.wifi_new.ap.ssid, row[1]);
				}
				else if (strcmp(row[0], "Wifi_ap_pwd") == 0) 
				{
					if (strlen(row[1]) < MAX_RESEAUX_WIFI_AP_TAILLE_PWD) strcpy(reseaux.wifi_new.ap.pwd, row[1]);
				}
				else if (strcmp(row[0], "Wifi_ap_canal") == 0) reseaux.wifi_new.ap.canal = atoi(row[1]);
			}
			
			// Mise à jour des infos du réseau STA en cours d'utilisation :
			if (reseaux.wifi_new.sta.cde == ON) 			// Le mode STA est ON (sinon, pas la peine d'aller chercher des infos complémentaires qui ne seront pas utilisées)
			{
				if (reseaux.wifi_new.sta.bssid[0] != 0)			// Si 'BSSID_Wifi_sta' n'est pas vide :
				{
					sprintf(requete, "SELECT Nom, Psk FROM TB_Wifi_sta WHERE Bssid='%s' ", reseaux.wifi_new.sta.bssid); 
					mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
					result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
					while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
					{
						if (strlen(row[0]) < MAX_RESEAUX_WIFI_STA_TAILLE_SSID) strcpy(reseaux.wifi_new.sta.ssid, row[0]);
						else strcpy(reseaux.wifi_new.sta.ssid, "");

						if (strlen(row[1]) < MAX_RESEAUX_WIFI_STA_TAILLE_PSK) strcpy(reseaux.wifi_new.sta.psk, row[1]);
						else strcpy(reseaux.wifi_new.sta.psk, "");
					}
				}
				else 											// Si 'BSSID_Wifi_sta' est vide :
				{
					strcpy(reseaux.wifi_new.sta.ssid, "");		// ... on passe le SSID et le PSK à vide également
					strcpy(reseaux.wifi_new.sta.psk, "");
				}
			}
			
			// Enregistrement dans l'historique :
			sprintf(tmp, "Sta_cde=%i, Sta_ssid=%s, Sta_psk=%s, Ap_cde=%i, Ap_ssid=%s, Ap_pwd=%s, Ap_canal=%i", reseaux.wifi_new.sta.cde, reseaux.wifi_new.sta.ssid, reseaux.wifi_new.sta.psk, reseaux.wifi_new.ap.cde, reseaux.wifi_new.ap.ssid, reseaux.wifi_new.ap.pwd, reseaux.wifi_new.ap.canal);
			enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_WIFI_MISE_A_JOUR_CONFIG, 0, 0, tmp);	
			
			// Positionnement du flag pour prise en compte par le gestionnaire de réseaux :
			reseaux.wifi_new.flag_new_config = TRUE;
		}

		// Lancement du scan Wifi STA :
		if (flag_scan_wifi_sta) reseaux.wifi_new.sta.flag_dde_scan = TRUE;

		// Remise au repos du flag de synchro Wifi de la BDD :
		if ((flag_synchro_wifi) || (flag_scan_wifi_sta))
		{
			sprintf(requete, "UPDATE TB_Configuration SET Valeur=-1 WHERE Nom='Wifi_new_config' ");	 
			mysql_query(bdd.pointeur, requete);	
		} 
		
		// Mise à jour de la présence d'une fiche jack dans la BDD :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Presence_jack' ", audio.etat_presence_jack);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de l'adresse IP du port Ethernet :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%s' WHERE Nom='Adresse_ip_ethernet' ", reseaux.ethernet.adresse_ip);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de l'adresse IP du port Wifi_sta :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%s' WHERE Nom='Adresse_ip_wifi_sta' ", reseaux.wifi.sta.adresse_ip);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de l'adresse IP du port Wifi_ap :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%s' WHERE Nom='Adresse_ip_wifi_ap' ", reseaux.wifi.ap.adresse_ip);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de l'état du modem dans la BDD :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Etat_modem' ", modem.etat);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de la présence de la carte SIM dans la BDD :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Presence_sim' ", modem.etat_presence_sim);	
		mysql_query(bdd.pointeur, requete);	
		
		// Mise à jour de l'état de la 4G-LTE dans la BDD :
		if (modem.etat_4g_lte == OFF) sprintf(requete, "UPDATE TB_Systeme SET Valeur=0 WHERE Nom='Etat_4g_lte' ");	
		else
		{
			val_16 = entree_no(TYPE_ENTREES_PREDEFINIES, 0, ENTREE_PREDEFINIE_RSRP);									// 0 est l'adresse de ShipBase
			if (val_16 < 0) sprintf(requete, "UPDATE TB_Systeme SET Valeur=0 WHERE Nom='Etat_4g_lte' ");				// Si l'entrée n'existe pas (retour de -1), on considère la valeur à 0
			else
			{
				if (entrees.predefinies.entrees[val_16].valeur <= -112) sprintf(requete, "UPDATE TB_Systeme SET Valeur=1 WHERE Nom='Etat_4g_lte' ");
				else if (entrees.predefinies.entrees[val_16].valeur <= -103) sprintf(requete, "UPDATE TB_Systeme SET Valeur=2 WHERE Nom='Etat_4g_lte' ");
				else if (entrees.predefinies.entrees[val_16].valeur <= -85) sprintf(requete, "UPDATE TB_Systeme SET Valeur=3 WHERE Nom='Etat_4g_lte' ");
				else sprintf(requete, "UPDATE TB_Systeme SET Valeur=4 WHERE Nom='Etat_4g_lte' ");
			}
		}
		mysql_query(bdd.pointeur, requete);	
		
		// Mise à jour de l'état du GNSS dans la BDD :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Etat_gnss' ", gnss.etat);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de l'état du bus OW :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Defaut_bus_ow' ", entrees.ow.defaut_bus);	
		mysql_query(bdd.pointeur, requete);	

		// Mise à jour de l'état des ports USB :
		for (i = 0; i < USB_MAX_NOMBRE_PORTS; i ++)
		{
			if (usb.ports[i].flag_validite == FALSE) continue;
			if (i < 3) sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Defaut_port_usb_%i' ", usb.ports[i].defaut, (i+1));
			else sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='Defaut_port_usb_arriere' ", usb.ports[i].defaut);
			mysql_query(bdd.pointeur, requete);	
		}
		
		

// ********************************************************************************************************************************************************
// MODULES
// ********************************************************************************************************************************************************

		//------------------------------------------------------------------------------------------
		// Traitement des nouvelles demandes de mise à jour de l'EEPROM des modules :
		int8_t maj_eeprom_modules[MAX_NOMBRE_MODULES];
		for (i = 0; i < MAX_NOMBRE_MODULES; i ++) maj_eeprom_modules[i] = C_BUS_CONFIG_AUCUNE;
		
		sprintf(requete, "SELECT Adresse_k_bus, New_eeprom FROM TB_Modules_physiques WHERE Presence=1 AND New_eeprom!='-1' "); 
		mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
		result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
		while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
		{
			val_u8 = (uint8_t) atoi(row[0]);								// Adresse K-Bus
			maj_eeprom_modules[val_u8] = (int8_t) atoi(row[1]);				// Le flag de maj contient le mode de mise à jour demandé (-1=Rien, 1=write normal, 2=write config usine)

			// Remise à -1 (repos), la valeur de New_eeprom dans la BDD :
			sprintf(requete, "UPDATE TB_Modules_physiques SET New_eeprom='-1' WHERE Adresse_k_bus='%i'", val_u8);	
			mysql_query(bdd.pointeur, requete);	
		}
		mysql_free_result(result);	//Libération du jeu de résultat

		//------------------------------------------------------------------------------------------
		// Traitement des nouvelles commandes de modules :
		sprintf(requete, "SELECT Adresse_k_bus, New_cde FROM TB_Modules_config WHERE Presence=1 AND New_cde!='' "); 
		mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
		result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
		while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
		{
			val_u8 = (uint8_t) atoi(row[0]);								// Adresse K-Bus

			i = 0;
			ptr[i] = strtok (row[1],"/");			// Extraction du premier segment avant le premier '/'		ATTENTION : si aucun délimiteur trouvé, la fonction renvoit la chaine entière (et pas NULL...)
			while ((ptr[i] != NULL) && (i < MAX_NOMBRE_CHAMPS_INTERNES))
			{		
				i ++;
				ptr[i] = strtok (NULL, "/");		// Extraction du segment suivant le prochain '/'
			}
			
			// Check du nombre de champs trouvés :
			if (i != 2)
			{
				sprintf(tmp, "La demande de New_cde sur le module @%i n'a pas un format acceptable (%i segments pour 2 attendus). La demande est rejetée...", val_u8, i);
				affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			}
			else c_bus_down_commande_cde_carte(val_u8, (uint8_t) atoi(ptr[0]), (uint8_t) atoi(ptr[1]));		// On ne fait pas plus de vérification ici car elles seront faites dans la fonction qui, si besoin, rejettera la demande.
			
			sprintf(requete, "UPDATE TB_Modules_config SET New_cde='' WHERE Adresse_k_bus='%i'", val_u8);	
			mysql_query(bdd.pointeur, requete);			// Remise à -1 (repos), la valeur de Cde dans la BDD
		}
		mysql_free_result(result);	//Libération du jeu de résultat


		//------------------------------------------------------------------------------------------
		// Mise à jour des modules :
		for (i = 0; i < MAX_NOMBRE_MODULES; i ++)
		{
			if (systeme.modules_config[i].flag_presence == FALSE) continue;					// On ne taite que les modules présents
			
			// Mise à jour de l'EEPROM du module si besoin :
			if (maj_eeprom_modules[i] > C_BUS_CONFIG_AUCUNE)							// Si la demande n'est pas au moins un 'Read', 'Write normal' ou 'write config usine', on ne fait rien
			{
				// Recherche des valeurs de l'EEPROM stockées dans la BDD (et qui ont probablement été modifiées par QT puisqu'on demande une action de maj)
				// pour mise à jour de l'image stockée dans 'systeme.modules[].eeprom[]' :
				sprintf(requete, "SELECT Eeprom FROM TB_Modules_physiques WHERE Adresse_k_bus='%i'", i);				// NB : le contenu de l'EEPROM est stocké dans le module PHYSIQUE !	
//printf("Requete = [ %s; ]\n", requete);				
				mysql_query(bdd.pointeur, requete);									// Envoi de la requête à MYSQL
				result = mysql_store_result(bdd.pointeur);							// Récup des résultats de la requête
				while((row = mysql_fetch_row(result)))								// Boucle sur tous les résultats de la requête
				{
					if (row[0] == NULL) break;										// Si le champ EEPROM est NULL, on ne fait rien

					k = 0;
					for (j = 0; (j < MAX_TAILLE_EEPROM); j ++)						// On traite au maxi MAX_TAILLE_EEPROM
					{
						if (row[0][k] == 0) break;									// On s'arrête de traiter les octets quand on atteint le NULL de fin de chaine (le stockage en VARCHAR permet de ne pas aller au bout de la taille maximale).
						tmp[0] = row[0][k ++];											
						tmp[1] = row[0][k ++];
						tmp[2] = 0;
				
						systeme.modules_physiques[i].eeprom[j] = (uint8_t) strtol(tmp, NULL, 16);	// L'utilisation de 'strtol' permet de passer de l'hexa dans la chaine...
					}

					// Envoi vers le module des ces nouvelles valeurs (en tenant compte du mode demandé dans 'New_eeprom') :
					c_bus_down_commande_config_carte(i, maj_eeprom_modules[i]);
				}
				mysql_free_result(result);	//Libération du jeu de résultat
			}
			
			// Mise à jour de l'état du module :
			sprintf(requete, "UPDATE TB_Modules_config SET Mode_test=%i, Tension_etat=%i, Origine_reset=%i, Courant_masses=%.3f WHERE Adresse_k_bus=%i ", 
								systeme.modules_config[i].mode_test, 
								systeme.modules_config[i].alim_etat, 
								systeme.modules_config[i].origine_reset, 
								systeme.modules_config[i].courant_masses, 						// SDIR #318
								i);	
//printf("Requete = [ %s; ]\n", requete);									
			mysql_query(bdd.pointeur, requete);
			
			// Supervision des défauts d'alimentation et du mode test des modules :
			if (systeme.modules_config[i].alim_etat == CIRCUITS_TENSION_CARTE_OK)				// Alim du module = OK
			{
				if (systeme.modules_config[i].mode_test == OFF)								// Module en mode Normal
				{
					systeme.modules_config[i].etat_commande_carte = CIRCUITS_ETAT_COMMANDE_CARTE_OK;
				}
				else																	// Module en mode Test
				{
					systeme.modules_config[i].etat_commande_carte = CIRCUITS_ETAT_COMMANDE_CARTE_TEST;
				}
			}
			else																		// Alim du module = UNDERVOLTAGE
			{
				systeme.modules_config[i].etat_commande_carte = CIRCUITS_ETAT_COMMANDE_CARTE_UNDERVOLTAGE;
			}
		}	


// ********************************************************************************************************************************************************
// CIRCUITS
// ********************************************************************************************************************************************************
		
		//-------------------------------------------
		// Traitement des nouvelles consignes :
		sprintf(requete, "SELECT Cle_primaire, New_consigne, Consigne FROM TB_Circuits WHERE New_consigne!=-1 "); 
		mysql_query(bdd.pointeur, requete);											
		result = mysql_store_result(bdd.pointeur);									
		while((row = mysql_fetch_row(result)))										
		{
			i = atoi(row[0]);																			// Clé primaire du circuit
			int16_t no_circuit = circuit_cle_primaire(i);												// No du circuit

			j = atoi(row[1]);																			// New Consigne
			k = atoi(row[2]);																			// Consigne actuelle
			
			bool flag_consigne_valide = false;
	
			if (no_circuit >= 0) 																		// Si le n° de circuit n'a pu être trouvé, on ne traite pas la valeur.
			{
				switch(systeme.modules_config[circuits.circuits[no_circuit].adresse_module].type)						// Recherche du type de module :
				{
					case TYPE_CARTE_SHIPBASE :	{ if ((j == OFF) || (j == MAX_CONSIGNE_CIRCUIT)) flag_consigne_valide =  TRUE;		break;		}
					case TYPE_CARTE_SP812 :	
					case TYPE_CARTE_SP8DC :		{ if ((j >= OFF) && (j <= MAX_CONSIGNE_CIRCUIT)) flag_consigne_valide =  TRUE;		break;		}
					case TYPE_CARTE_SP4AC :		{ if ((j == OFF) || (j == MAX_CONSIGNE_CIRCUIT)) flag_consigne_valide =  TRUE;		break;		}		// SDIR #79
					default : ;
				}
					
				if (flag_consigne_valide) 																// Vérifie que la nouvelle valeur de consigne est valide.
				{	
					if ((uint16_t)circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_CONSIGNE].valeur_courante != j)	// On ne traite que si la nouvelle consigne est différente de l'ancienne :
					{
						k = j;																						// SDIR #79 - Permet la mise à jour dans la BDD dans tous les cas (yc les cas d'erreur)

						changement_consigne_circuit(no_circuit, j, CIRCUITS_ORIGINE_CONSIGNE_SHIPBASE, 0);
						
						enregistrement_historique(TYPE_SOURCE_HISTORIQUE_CIRCUITS, CIRCUIT_CHANGEMENT_CONSIGNE, i, j, NULL);				// Enregistrement dans l'historique
					}
				}
			}
			
			sprintf(requete, "UPDATE TB_Circuits SET New_consigne='-1', Consigne=%i WHERE Cle_primaire=%i ", k, i); 	// SDIR #79 - RAZ de la demande et mise à jour de la consigne dans la BDD
//printf("Requete = [ %s; ]\n", requete);			
			mysql_query(bdd.pointeur, requete);	
		} 
		mysql_free_result(result);

		//-------------------------------------------------------------
		// Traitement des nouvelles données, autre que les consignes :
		sprintf(requete, "SELECT Cle_primaire, Validation_cdes_events FROM TB_Circuits "); 
		mysql_query(bdd.pointeur, requete);											
		result = mysql_store_result(bdd.pointeur);									
		while((row = mysql_fetch_row(result)))										
		{
			i = atoi(row[0]);																			// Clé primaire du circuit
			int16_t no_circuit = circuit_cle_primaire(i);												// No du circuit

			// Mise à jour du flag de validation des commandes par events :
			if (no_circuit >= 0) circuits.circuits[no_circuit].validation_cdes_events = atoi(row[1]);	// On fait la mise à jour dans tous les cas (y compris si la valeur n'a pas changée) car c'est plus simple...	
		} 
		mysql_free_result(result);
		
		//--------------------------------------------------
		// Mise à jour de l'état des circuits vers la BDD :
		for (i = 0; i < circuits.nb; i ++)
		{
			if (!circuits.circuits[i].flag_dde_maj_bdd) continue;

			circuits.circuits[i].flag_dde_maj_bdd = FALSE;					// Reset du flag une fois la mise à jour faite dans la BDD

			if (circuits.circuits[i].adresse_module != 0)	circuits.circuits[i].etat_commande_carte = systeme.modules_config[circuits.circuits[i].adresse_module].etat_commande_carte;
			else circuits.circuits[i].etat_commande_carte = CIRCUITS_ETAT_COMMANDE_CARTE_OK;

			sprintf(requete, "UPDATE TB_Circuits SET Etat='%i', Origine_consigne=%i, ID_Origine_consigne=%i, Consigne='%f', Mode_test=%i, Etat_commande_carte=%i, \
							Tension=%f, Intensite=%f, Frequence=%f  WHERE Cle_primaire='%i'", 
							circuits.circuits[i].etat, circuits.circuits[i].origine_consigne, circuits.circuits[i].id_origine_consigne, circuits.circuits[i].variables[CIRCUIT_VARIABLE_CONSIGNE].valeur_courante, 
							circuits.circuits[i].mode_test, circuits.circuits[i].etat_commande_carte, 
							(systeme.modules_config[circuits.circuits[i].adresse_module].type != TYPE_CARTE_SP4AC) ? circuits.circuits[i].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante : circuits.circuits[i].variables[CIRCUIT_VARIABLE_TENSION_SECTEUR].valeur_courante, 
							circuits.circuits[i].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante, circuits.circuits[i].variables[CIRCUIT_VARIABLE_FREQUENCE].valeur_courante, 
							circuits.circuits[i].cle_primaire);	
//printf("Requete sur circuit n° %i = [ %s; ]\n", i, requete);			
			mysql_query(bdd.pointeur, requete);	
		}


// ********************************************************************************************************************************************************
// CAPTEURS
// ********************************************************************************************************************************************************

		// Mise à jour des valeurs dans la BDD quand une demande a été formulée :
		for (i=0; i<capteurs.nb; i++)
		{
			if ((!capteurs.capteurs[i].flag_validite) || (!capteurs.capteurs[i].flag_dde_maj_bdd)) continue;
			
			capteurs.capteurs[i].flag_dde_maj_bdd = FALSE;					// Reset du flag une fois la mise à jour faite dans la BDD
			
//			sprintf(requete, "UPDATE TB_Capteurs SET Valeur='%f', Etat='%i' WHERE Cle_primaire='%i'", capteurs.capteurs[i].variables[CAPTEUR_VARIABLE_VALEUR].valeur_courante, capteurs.capteurs[i].etat, capteurs.capteurs[i].cle_primaire);	
			// SDIR #135 :
			sprintf(requete, "UPDATE TB_Capteurs SET Valeur='%f', Valeur_brute='%.2f', Etat=%i, Etat_systeme=%i WHERE Cle_primaire=%i ", 
					capteurs.capteurs[i].variables[CAPTEUR_VARIABLE_VALEUR].valeur_courante, 
					capteurs.capteurs[i].valeur_brute, 
					capteurs.capteurs[i].etat, 
					capteurs.capteurs[i].etat_systeme, 
					capteurs.capteurs[i].cle_primaire);	
// printf("Requete = [ %s; ]\n", requete);	
			mysql_query(bdd.pointeur, requete);	
		}


// ********************************************************************************************************************************************************
// BATTERIES
// ********************************************************************************************************************************************************

		// Traitement des nouvelles commandes :
		sprintf(requete, "SELECT Cle_primaire, New_cde FROM TB_Batteries WHERE New_cde!='-1' "); 
		mysql_query(bdd.pointeur, requete);											
		result = mysql_store_result(bdd.pointeur);									
		while((row = mysql_fetch_row(result)))										
		{
			i = atoi(row[0]);																			// Clé primaire du circuit
			j = atoi(row[1]);																			// New Cde
			
			int16_t no_batterie = batterie_cle_primaire(i);												// No de la batterie
	
			if (no_batterie >= 0) 																		// Si le n° de batterie n'a pu être trouvé, on ne traite pas la valeur.
			{
				switch(j)						// Recherche du type de commande : 
				{
					//-----------------------------------------------
					case BATTERIE_COMMMANDE_FORCAGE_PLEINE_CHARGE :	
					{
						batteries.batteries[no_batterie].variables[BATTERIE_VARIABLE_SOC].valeur_courante = 100;
						batteries.batteries[no_batterie].eod = 0;

						enregistrement_historique(TYPE_SOURCE_HISTORIQUE_BATTERIES, BATTERIE_RX_CDE_FORCAGE_PLEINE_CHARGE, i, 0, NULL);

						break;
					}

					//-----------------------------------------------
					case BATTERIE_COMMMANDE_RESET_SOH :	
					{ 
						batteries.batteries[no_batterie].variables[BATTERIE_VARIABLE_SOH].valeur_courante = 100;

						enregistrement_historique(TYPE_SOURCE_HISTORIQUE_BATTERIES, BATTERIE_RX_CDE_RESET_SOH, i, 0, NULL);
						
						break;
					}

					//-----------------------------------------------
					case BATTERIE_COMMMANDE_RESET_COMPTEURS :	
					{ 
						batteries.batteries[no_batterie].nombre_cycles = 0;
						batteries.batteries[no_batterie].nombre_decharges_completes = 0;

						enregistrement_historique(TYPE_SOURCE_HISTORIQUE_BATTERIES, BATTERIE_RX_CDE_RESET_COMPTEURS, i, 0, NULL);

						break;
					}

					//-----------------------------------------------
					default : ;
				}	

				batteries.batteries[no_batterie].flag_dde_maj_bdd =  TRUE;			// Positionné même dans le cas d'une commande non valide (puisqu'on n'aura rien fait dans ce cas)
			}
			
			sprintf(requete, "UPDATE TB_Batteries SET New_cde='-1' WHERE Cle_primaire=%i ", i); 
//printf("Requete = [%s]\n", requete);			
			mysql_query(bdd.pointeur, requete);	
		} 
		mysql_free_result(result);



		// Mise à jour des valeurs dans la BDD quand une demande a été formulée :
		for (i=0; i<batteries.nb; i++)
		{
			if ((!batteries.batteries[i].flag_validite) || (!batteries.batteries[i].flag_dde_maj_bdd)) continue;
			
			sprintf(requete, "UPDATE TB_Batteries SET Nombre_cycles=%i, Flag_increment_cycles=%i, Nombre_decharges_completes=%i, Flag_increment_decharges_completes=%i, \
							Temperature='%f', Tension='%f', Courant_differentiel='%f', Courant_charge='%f', Courant_decharge='%f', \
							Soh='%f', Soc='%f', Autonomie='%f', \
							Tension_pleine_charge='%f', Eod='%f' WHERE Cle_primaire='%i'", 
					batteries.batteries[i].nombre_cycles, batteries.batteries[i].flag_increment_cycles, batteries.batteries[i].nombre_decharges_completes, batteries.batteries[i].flag_increment_decharges_completes,
					batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante, 
					batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_courante, 
					batteries.batteries[i].tension_pleine_charge,
					batteries.batteries[i].eod,
					batteries.batteries[i].cle_primaire);
// printf("Requete d'enregistement batteries = %s\n", requete);				
			mysql_query(bdd.pointeur, requete);	
			
			batteries.batteries[i].flag_dde_maj_bdd = FALSE;									// Reset du flag une fois la mise à jour faite dans la BDD
		}
		

// ********************************************************************************************************************************************************
// RESERVOIRS
// ********************************************************************************************************************************************************

		// Mise à jour des valeurs dans la BDD quand une demande a été formulée :
		for (i = 0; i < reservoirs.nb; i ++)
		{
			if ((!reservoirs.reservoirs[i].flag_validite) || (!reservoirs.reservoirs[i].flag_dde_maj_bdd)) continue;
			
			reservoirs.reservoirs[i].flag_dde_maj_bdd = FALSE;					// Reset du flag une fois la mise à jour faite dans la BDD
			
//			sprintf(requete, "UPDATE TB_Reservoirs SET Niveau='%f', Etat_entrees=%i WHERE Cle_primaire='%i'", reservoirs.reservoirs[i].variables[RESERVOIR_VARIABLE_NIVEAU].valeur_courante, reservoirs.reservoirs[i].etat_entrees, reservoirs.reservoirs[i].cle_primaire);
			// SDIR #288 :
			sprintf(requete, "UPDATE TB_Reservoirs SET Niveau='%f', Valeur_brute='%.2f', Etat_entrees=%i WHERE Cle_primaire='%i'", reservoirs.reservoirs[i].variables[RESERVOIR_VARIABLE_NIVEAU].valeur_courante, reservoirs.reservoirs[i].valeur_brute, reservoirs.reservoirs[i].etat_entrees, reservoirs.reservoirs[i].cle_primaire);

//printf("Requete d'enregistement réservoirs = %s\n", requete);				
			mysql_query(bdd.pointeur, requete);	
		}


// ********************************************************************************************************************************************************
// EVENEMENTS
// ********************************************************************************************************************************************************

		// Mise à jour des valeurs dans la BDD quand une demande a été formulée :
		for (i = 0; i < events.nb; i ++)
        {
            if (!events.events[i].flag_validite) continue;                      // Si l'event n'est pas valide, on ne le traite pas
			if (!events.events[i].flag_dde_maj_bdd)	continue;

			events.events[i].flag_dde_maj_bdd = false;
			
			sprintf(requete, "UPDATE TB_Events SET Etat_test=%i WHERE Cle_primaire=%i ", events.events[i].condition_test.etat_test, events.events[i].cle_primaire);
//printf("Requete d'enregistement events = [ %s; ]\n", requete);				
			mysql_query(bdd.pointeur, requete);	
		}



// ********************************************************************************************************************************************************
// ENTREES OW
// ********************************************************************************************************************************************************

		// Mise à jour des valeurs dans la BDD quand une demande a été formulée :
		// Note : 	On fonctionne ici sur les DEVICES (entrees.ow.devices[]) et PAS sur les ENTREES (entrees.ow.entrees[]). 
		//			En effet, on remonte l'état de tous les devices présents sur le réseau OW, y compris ceux qui ne sont pas utilisés par un capteur. 
		//			Au contraire, les ENTREES ne sont valides que pour celles utilisées par un capteur valide. 
		for (i=0; i<entrees.ow.nb_devices; i++)
		{		
			if (!entrees.ow.devices[i].flag_dde_maj_bdd) continue;			
			
			sprintf(requete, "UPDATE TB_One_wire SET Etat=%i, Valeur='%.3f' WHERE Rom_code='%s'", entrees.ow.devices[i].etat, entrees.ow.devices[i].valeur, entrees.ow.devices[i].rom_code);
// printf("Requete d'enregistement device OW = %s\n", requete);				
			mysql_query(bdd.pointeur, requete);	
			
			entrees.ow.devices[i].flag_dde_maj_bdd = FALSE;						// Reset du flag une fois la mise à jour faite dans la BDD
		}


// ********************************************************************************************************************************************************
// PGN NMEA2000
// ********************************************************************************************************************************************************

		// Mise à jour des valeurs dans la BDD quand une demande a été formulée :
		// Note : 	La table de référence est TB_Nmea2000. 
		// Le flag 'Tb_Systeme.Flag_demande_maj_nmea' est positionné par Qt lorsqu'une modification a été faite sur au moins une entrée de cette table. 
		// Il faut donc balayer les enregistrement pour mettre à jour quelques champs dans l'annuaire en cours et envoyer une commande au Compagnon pour 
		// qu'il prenne en compte les modifications (généralement, changer le mode Actif dans un sens ou dans l'autre). 
		
		if (flag_demande_maj_nmea)
		{
			// Sélection des PGN qui ont au moins un Field Actif :
			sprintf(requete, "SELECT PGN FROM TB_Nmea2000 WHERE Actif=1 GROUP BY Pgn "); 
//printf("Requete = [ %s; ]\n", requete);			
			mysql_query(bdd.pointeur, requete);											
			result = mysql_store_result(bdd.pointeur);									
			while((row = mysql_fetch_row(result)))										
			{
				for (i = 0; i < NMEA_MAX_NOMBRE_PGN; i ++)
				{
					val_u32 = atoi(row[0]);				// Pgn
					
					if (val_u32 == nmea.annuaire[i].pgn)
					{
						if (nmea.annuaire[i].actif != 1) 
						{
							nmea.annuaire[i].actif = 1;
							c_bus_down_commande_config_pgn_nmea(i);		// Envoi de la commande de config de ce Pgn au Compagnon puisque son état à changé.
						}
						break;
					}
				}
			} 
			mysql_free_result(result);
		
			// Sélection des PGN qui n'ont aucun Field Actif :
			sprintf(requete, "SELECT PGN FROM TB_Nmea2000 WHERE Pgn NOT IN (SELECT Pgn FROM TB_Nmea2000 WHERE Actif=1) GROUP BY Pgn "); 
//printf("Requete = [ %s; ]\n", requete);			
			mysql_query(bdd.pointeur, requete);											
			result = mysql_store_result(bdd.pointeur);									
			while((row = mysql_fetch_row(result)))										
			{
				for (i = 0; i < NMEA_MAX_NOMBRE_PGN; i ++)
				{
					val_u32 = atoi(row[0]);				// Pgn
					
					if (val_u32 == nmea.annuaire[i].pgn)
					{
						if (nmea.annuaire[i].actif != 0) 
						{
							nmea.annuaire[i].actif = 0;
							c_bus_down_commande_config_pgn_nmea(i);		// Envoi de la commande de config de ce Pgn au Compagnon puisque son état à changé.
						}
						break;
					}
				}
			} 
			mysql_free_result(result);
		}
		
	
// ********************************************************************************************************************************************************
// HEART-BEAT
// ********************************************************************************************************************************************************

		// Mise à jour du timestamp dans la BDD :
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%li' WHERE Nom='Heart_beat'", (uint64_t) time(NULL));	// Enregistrement du timestamp de MAINTENANT (permet sur les pages Web d'afficher les feux vert, orange ou rouge en fonction de la dernière valeur écrite par l'application)
		mysql_query(bdd.pointeur, requete);	


// ********************************************************************************************************************************************************
// MESURES
// ********************************************************************************************************************************************************

#ifdef __DEBUG_TIMING_SYNCHRO_BDD		
		fin_1 = clock();
#endif

		// Enregistrment des mesures des capteurs :
		enregistrement_mesures(BDD_ENREGISTREMENT_MESURE_NORMAL);

#ifdef __DEBUG_TIMING_SYNCHRO_BDD		
		fin = clock();
		sprintf(tmp, "Temps d'exécution synchro : sans mesures = %.0f µs ; avec mesures = %.0f µs (delta = %.0f µs)", ((float)(fin_1-deb)*1000000)/CLOCKS_PER_SEC, ((float)(fin-deb)*1000000)/CLOCKS_PER_SEC, ((float)(fin-fin_1)*1000000)/CLOCKS_PER_SEC);
		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);		
#endif
	
	}
}