Pierre/shipheart-appli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
shipheart-appli/sources/bdd_synchro.c
T

1071 lines
51 KiB
C
Raw Permalink Blame History

//**********************************************************************************************************************************************************************************
// 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
}
}
Reference in New Issue View Git Blame Copy Permalink