479 lines
23 KiB
C
479 lines
23 KiB
C
//**********************************************************************************************************************************************************************************
|
|
// Fichier CIRCUITS.C
|
|
//
|
|
// Contient toutes les fonctions liées aux circuits
|
|
//**********************************************************************************************************************************************************************************
|
|
|
|
// #define __DEBUG_CIRCUITS // Décommenter cette ligne pour que les infos de debug soient affichées
|
|
|
|
// Include :
|
|
#include "main.h"
|
|
|
|
// Prototypes :
|
|
void gestion_circuits(void);
|
|
void gestion_circuit(uint16_t no_circuit);
|
|
int8_t changement_consigne_circuit(uint16_t no_circuit, uint8_t consigne, uint8_t origine_consigne, uint16_t id_origine_consigne);
|
|
int8_t init_circuits(void);
|
|
int16_t circuit_cle_primaire(uint16_t cle_primaire);
|
|
int16_t variable_circuit_cle_primaire(uint16_t cle_primaire);
|
|
|
|
// Variables globales :
|
|
struct Struct_circuits circuits;
|
|
|
|
|
|
//**********************************************************************************************************************************************************************************
|
|
// Fonction GESTION_CIRCUITS
|
|
//
|
|
//**********************************************************************************************************************************************************************************
|
|
void gestion_circuits(void)
|
|
{
|
|
uint16_t i, j;
|
|
float courant_total;
|
|
uint16_t circuit_maxi;
|
|
float courant_maxi;
|
|
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
|
|
|
|
|
|
if (!systeme.flag_cm3p_ready) return; // Evite que le traitement soit fait au milieu d'une reconfiguration...
|
|
|
|
switch(circuits.sequenceur.etat)
|
|
{
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_CIRCUITS_INIT :
|
|
{
|
|
if ((systeme.flag_cm3p_ready) && // Permet de s'assurer que le cycle d'init système est terminé. En particulier, on est sûr que 'init_bdd()' puis 'annuaire_k_bus()' ont été traités.
|
|
(circuits.sequenceur.compteur == 0))
|
|
{
|
|
|
|
affichage_debug(__FILE__, __LINE__, "------------------CIRCUITS INIT", TYPE_MESSAGE_DEBUG_WARNING);
|
|
|
|
circuits.sequenceur.etat = ETAT_SEQUENCEUR_CIRCUITS_REPOS;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_CIRCUITS_REPOS :
|
|
{
|
|
if (circuits.sequenceur.compteur == 0)
|
|
{
|
|
circuits.sequenceur.compteur = CIRCUITS_PERIODE_MISE_A_JOUR;
|
|
|
|
//------------------------------------------------
|
|
// Appel de Gestion_circuit pour chaque circuit :
|
|
for (i = 0; i < circuits.nb; i ++)
|
|
{
|
|
if (! circuits.circuits[i].flag_validite) continue;
|
|
|
|
// sprintf(tmp, "Circuit #%i : Consigne = %.2f ", i, circuits.circuits[i].variables[CIRCUIT_VARIABLE_CONSIGNE].valeur_courante);
|
|
// affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
|
|
|
|
gestion_circuit(i);
|
|
circuits.circuits[i].flag_dde_maj_bdd = TRUE; // On ne vérifie pas s'il y a eu évolution car ce serait un peu compliqué
|
|
}
|
|
|
|
//-----------------------------------------
|
|
// Supervision du courant total par carte :
|
|
for (i = 0; i < MAX_NOMBRE_MODULES; i ++)
|
|
{
|
|
if (systeme.modules_config[i].flag_presence == FALSE) continue; // On ne taite que les cartes présentes
|
|
if (systeme.modules_config[i].courant_maxi == 0) continue; // SI le seuil = 0, c'est que la fonction est dévalidée.
|
|
|
|
switch(systeme.modules_config[i].type)
|
|
{
|
|
case TYPE_CARTE_SP812 :
|
|
case TYPE_CARTE_SP8DC :
|
|
{
|
|
circuit_maxi = MAX_NOMBRE_CIRCUITS; // Valeur 'impossible' par défaut
|
|
courant_maxi = 0;
|
|
courant_total = 0;
|
|
|
|
// Recherche de tous les circuits de la carte :
|
|
for (j=0; j<circuits.nb; j++)
|
|
{
|
|
if (circuits.circuits[j].flag_validite == FALSE) continue; // On ne traite que les circuits valides... NB : On teste le flag de Validité (plutôt que Disponible) car on est sûr que la carte est présente (donc si le circuit est valide, il est disponible)
|
|
if (circuits.circuits[j].adresse_module != i ) continue; // ... et ceux piloté par cette carte...
|
|
if (circuits.circuits[j].no_circuit >= SP8XX_NOMBRE_CIRCUITS) continue; // ... et dont le n° de circuit est valide pour cette carte
|
|
|
|
// Calcul du courant total de la carte :
|
|
courant_total += circuits.circuits[j].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;
|
|
|
|
// Recehrche du circuit consommant le plus sur la carte (utile si on déclenche) :
|
|
if (circuits.circuits[j].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante > courant_maxi)
|
|
{
|
|
courant_maxi = circuits.circuits[j].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;
|
|
circuit_maxi = j;
|
|
}
|
|
}
|
|
|
|
// Action selon le dépassement ou non du seuil :
|
|
if (courant_total <= systeme.modules_config[i].courant_maxi) systeme.modules_config[i].courant_maxi_compteur = systeme.modules_config[i].courant_maxi_tempo; // Réarmement du compteur dès qu'on passe en dessous du seuil
|
|
else if (systeme.modules_config[i].courant_maxi_compteur == 0) // On dép&sse le seuil ET la tempo est expirée sans qu'on soit repassés sous le seuil :
|
|
{
|
|
if (circuit_maxi < MAX_NOMBRE_CIRCUITS) // Cas normal où on a trouvé le circuit qui consomme le plus sur la carte :
|
|
{
|
|
circuits.circuits[circuit_maxi].etat = ETAT_CIRCUIT_DELESTE;
|
|
|
|
changement_consigne_circuit(circuit_maxi, OFF, CIRCUITS_ORIGINE_CONSIGNE_DEFAUT, 0);
|
|
|
|
enregistrement_historique(TYPE_SOURCE_HISTORIQUE_CIRCUITS, CIRCUIT_DELESTAGE, circuits.circuits[circuit_maxi].cle_primaire, systeme.modules_config[i].courant_maxi, NULL); // Enregistrement dans l'historique
|
|
|
|
sprintf(tmp, "/!\\ Carte %i : Le courant total (%.3fA) est resté supérieur au seuil MAXI (%.3fA) pendant %i secondes consécutives. Le circuit %i est délesté car sa consommation est la plus élevée de la carte (%.3fA soit %.2f%% de la carte)", i, courant_total, systeme.modules_config[i].courant_maxi, systeme.modules_config[i].courant_maxi_tempo, circuit_maxi, courant_maxi, (courant_total != 0) ? ((courant_maxi*100)/courant_total) : 0);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
|
|
systeme.modules_config[i].courant_maxi_compteur = systeme.modules_config[i].courant_maxi_tempo; // Permet notamment d'attendre que la prise en compte du délestage du circuit le plus consommateur soit effective...
|
|
}
|
|
else // A priori, ne doit pas arriver car cela voudriat dire que'on a trouvé aucun circuit > 0A alors que le courant total dépasse 50A (par exemple)...
|
|
{
|
|
sprintf(tmp, "La détection de courant total a rencontér une erreur... La détection est dévalidée");
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
default : ;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------
|
|
default :
|
|
{
|
|
sprintf(tmp, "L'état du séquenceur Circuits est inconnu [%i]. Il est repositionné au REPOS", circuits.sequenceur.etat);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
circuits.sequenceur.etat = ETAT_SEQUENCEUR_CIRCUITS_REPOS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//**********************************************************************************************************************************************************************************
|
|
// Fonction GESTION_CIRCUIT
|
|
// Séquenceur dédié à chaque circuit
|
|
// Reçoit : le n° du circuit
|
|
// Retour : Rien
|
|
//**********************************************************************************************************************************************************************************
|
|
void gestion_circuit(uint16_t no_circuit)
|
|
{
|
|
int16_t no_entree_in_i;
|
|
int16_t no_entree_usb_i;
|
|
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
|
|
|
|
|
|
//==============================================================================================
|
|
// Mise à jour des valeurs obtenues par un autre biais que 'c_bus_up_commande_etat_circuits()' :
|
|
//==============================================================================================
|
|
switch(systeme.modules_config[circuits.circuits[no_circuit].adresse_module].type)
|
|
{
|
|
//------------------------
|
|
case TYPE_CARTE_SHIPBASE:
|
|
//------------------------
|
|
{
|
|
// Courant USB :
|
|
// NB : la notion de valeur plancher du courant USB est traitée dans 'commandes.c', vers la ligne 1800...
|
|
float courant_usb;
|
|
float in_i;
|
|
float usb_i;
|
|
|
|
no_entree_in_i = entree_no(TYPE_ENTREES_PREDEFINIES, 0, ENTREE_PREDEFINIE_IN_I);
|
|
if ((no_entree_in_i >=0) && (no_entree_in_i < MAX_NOMBRE_ENTREES_PREDEFINIES)) in_i = entrees.predefinies.entrees[no_entree_in_i].valeur;
|
|
else in_i = 0;
|
|
|
|
no_entree_usb_i = entree_no(TYPE_ENTREES_PREDEFINIES, 0, ENTREE_PREDEFINIE_USB_I);
|
|
if ((no_entree_usb_i >=0) && (no_entree_usb_i < MAX_NOMBRE_ENTREES_PREDEFINIES)) usb_i = entrees.predefinies.entrees[no_entree_usb_i].valeur;
|
|
else usb_i = 0;
|
|
|
|
if (systeme.modules_config[circuits.circuits[no_circuit].adresse_module].alim_valeur != 0) courant_usb = (usb_i * 5) / systeme.modules_config[circuits.circuits[no_circuit].adresse_module].alim_valeur; // Il est important de ramner le courant USB mesuré sur 5V sur la tension d'alimentation de ShipBase afin de l'extraire du courant de ShipBase.
|
|
else courant_usb = 0;
|
|
|
|
if (in_i <= courant_usb)
|
|
{
|
|
courant_usb = 0;
|
|
#ifdef __DEBUG_CIRCUITS
|
|
sprintf(tmp, "/!\\ Le courant USB (compensé en tension) [%.2f A] est supérieur ou égal au courant de ShipBase [%.2f A]. Le courant USB n'est pas pris en compte du tout (ramené à 0A)...", courant_usb, in_i);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
|
|
#endif
|
|
}
|
|
|
|
// Calculs spécifiques en fonction du "circuit" de Shipbase :
|
|
switch(circuits.circuits[no_circuit].no_circuit)
|
|
{
|
|
//----------------------------
|
|
case SB_CIRCUIT_NO_SHIPHEART : // Circuit correspondant à ShipBase sans les ports USB (appelé 'ShipHeart' dans la BDD)
|
|
{
|
|
// Tension :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante = systeme.modules_config[circuits.circuits[no_circuit].adresse_module].alim_valeur;
|
|
|
|
// Courant :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante = in_i - courant_usb;
|
|
#ifdef __DEBUG_CIRCUITS
|
|
sprintf(tmp, "Courant total ShipBase = [%.2f A], courant de ShipBase uniquement [%.2f A], courant USB (compensé en tension) = [%.2f A]", in_i, circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante, courant_usb);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
|
|
#endif
|
|
// Puissance :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].valeur_courante = circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante * circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;
|
|
|
|
break;
|
|
}
|
|
|
|
//-----------------------------
|
|
case SB_CIRCUIT_NO_USB_AVANT : // Circuit correspondant aux ports USB seulement (appelé 'ShipHeart - USB' dans la BDD)
|
|
{
|
|
// Tension :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante = 5; // Attention : on applique la règle mais c'est une valeur théorique...
|
|
|
|
// Courant :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante = usb_i; // Attention : c'est un courant "réel" sur 5V (non compensé en tension)
|
|
|
|
// Puissance :
|
|
if (courant_usb == 0) circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].valeur_courante = 0;
|
|
else circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].valeur_courante = usb_i * 5; // Calculé directemenr depuis le courant mesuré sur 5V.
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------------
|
|
case SB_CIRCUIT_NO_USB_ARRIERE : // Circuit correspondant aux ports USB seulement (appelé 'ShipHeart - USB arrière' dans la BDD)
|
|
{
|
|
// Tension :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante = 5; // Attention : on applique la règle mais c'est une valeur théorique...
|
|
|
|
break;
|
|
}
|
|
default : break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------
|
|
case TYPE_CARTE_SP812:
|
|
case TYPE_CARTE_SP8DC:
|
|
//------------------------
|
|
{
|
|
// Tension :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante = systeme.modules_config[circuits.circuits[no_circuit].adresse_module].alim_valeur;
|
|
|
|
// Puissance :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].valeur_courante = circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante * circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------
|
|
case TYPE_CARTE_SP4AC:
|
|
//------------------------
|
|
{
|
|
// Puissance :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].valeur_courante = circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION_SECTEUR].valeur_courante * circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------
|
|
default: ;
|
|
//------------------------
|
|
}
|
|
|
|
//====================================
|
|
// Intégration des cumuls du circuit :
|
|
//====================================
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].cumul += circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION].valeur_courante;
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].cumul += circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_FREQUENCE].cumul += circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_FREQUENCE].valeur_courante;
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].cumul += circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_PUISSANCE].valeur_courante;
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION_SECTEUR].cumul += circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_TENSION_SECTEUR].valeur_courante;
|
|
circuits.circuits[no_circuit].cumuls_nb_val ++; // MàJ du nombre d'échantillons dans le cumul
|
|
|
|
|
|
//===========================================
|
|
// Vérification de l'expiration du time-out :
|
|
//===========================================
|
|
if ((circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_CONSIGNE].valeur_courante > 0) &&
|
|
(circuits.circuits[no_circuit].time_out > 0) &&
|
|
(circuits.circuits[no_circuit].compteur_time_out == 0))
|
|
{
|
|
changement_consigne_circuit(no_circuit, OFF, CIRCUITS_ORIGINE_CONSIGNE_TIME_OUT, 0);
|
|
|
|
enregistrement_historique(TYPE_SOURCE_HISTORIQUE_CIRCUITS, CIRCUIT_EXPIRATION_TIME_OUT, circuits.circuits[no_circuit].cle_primaire, circuits.circuits[no_circuit].time_out, NULL); // Enregistrement dans l'historique
|
|
}
|
|
|
|
//========================================
|
|
// Surveillance du seuil haut de courant :
|
|
//========================================
|
|
switch(circuits.circuits[no_circuit].sequenceur.etat)
|
|
{
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_CIRCUIT_INIT :
|
|
{
|
|
circuits.circuits[no_circuit].sequenceur.etat = ETAT_SEQUENCEUR_CIRCUITS_REPOS;
|
|
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_CIRCUIT_REPOS :
|
|
{
|
|
// Recherche d'un dépassement de seuil de courant :
|
|
if ((circuits.circuits[no_circuit].intensite_seuil_haut > 0) &&
|
|
(circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante > circuits.circuits[no_circuit].intensite_seuil_haut))
|
|
{
|
|
circuits.circuits[no_circuit].sequenceur.compteur = circuits.circuits[no_circuit].intensite_seuil_haut_tempo / 10; // Le compteur est décrémenté toutes les 100ms.
|
|
circuits.circuits[no_circuit].sequenceur.etat = ETAT_SEQUENCEUR_CIRCUIT_CHECK_LIMITATION;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_CIRCUIT_CHECK_LIMITATION :
|
|
{
|
|
// Test de disparition du défaut avant expiration de la tempo :
|
|
if (circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante <= circuits.circuits[no_circuit].intensite_seuil_haut)
|
|
{
|
|
circuits.circuits[no_circuit].sequenceur.compteur = 0; // RAZ pour usage ultérieur
|
|
circuits.circuits[no_circuit].sequenceur.etat = ETAT_SEQUENCEUR_CIRCUIT_REPOS;
|
|
break;
|
|
}
|
|
|
|
// Expiration de la tempo de filtrage :
|
|
if (circuits.circuits[no_circuit].sequenceur.compteur == 0)
|
|
{
|
|
changement_consigne_circuit(no_circuit, OFF, CIRCUITS_ORIGINE_CONSIGNE_DEFAUT, 0);
|
|
|
|
enregistrement_historique(TYPE_SOURCE_HISTORIQUE_CIRCUITS, CIRCUIT_LIMITATION, circuits.circuits[no_circuit].cle_primaire, circuits.circuits[no_circuit].intensite_seuil_haut, NULL); // Enregistrement dans l'historique
|
|
|
|
circuits.circuits[no_circuit].etat = ETAT_CIRCUIT_LIMITATION;
|
|
circuits.circuits[no_circuit].sequenceur.etat = ETAT_SEQUENCEUR_CIRCUIT_REPOS;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
default :
|
|
{
|
|
sprintf(tmp, "L'état du séquenceur du circuit %i est inconnu [%i]. Il est repositionné au REPOS", no_circuit+1, circuits.circuits[no_circuit].sequenceur.etat);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
circuits.circuits[no_circuit].sequenceur.etat = ETAT_SEQUENCEUR_CIRCUIT_REPOS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//**********************************************************************************************************************************************************************************
|
|
// Fonction : Effectue toutes les actions nécessaires lors d'un changement de consigne du circuit
|
|
// Reçoit : Le n° de circuit, la valeur de consigne, l'origine de la consigne et l'ID de cette origine
|
|
// Retourne : 0 si aucune erreur. -1 si erreur
|
|
//**********************************************************************************************************************************************************************************
|
|
int8_t changement_consigne_circuit(uint16_t no_circuit, uint8_t consigne, uint8_t origine_consigne, uint16_t id_origine_consigne)
|
|
{
|
|
if (no_circuit > MAX_NOMBRE_CIRCUITS) return (-1);
|
|
if (consigne > MAX_CONSIGNE_CIRCUIT) return(-1);
|
|
|
|
// Mise à jour des variables du circuit :
|
|
circuits.circuits[no_circuit].variables[CIRCUIT_VARIABLE_CONSIGNE].valeur_courante = consigne;
|
|
circuits.circuits[no_circuit].origine_consigne = origine_consigne;
|
|
circuits.circuits[no_circuit].id_origine_consigne = id_origine_consigne;
|
|
|
|
// Emission d'une commande vers le Compagnon que si le circuit n'est pas sur ShipBase :
|
|
if (circuits.circuits[no_circuit].adresse_module != 0)
|
|
{
|
|
circuits.circuits[no_circuit].flag_changement_consigne_en_cours = true; // SDIR #179
|
|
c_bus_down_commande_cde_circuits(circuits.circuits[no_circuit].adresse_module); // Consigne du circuit envoyée au Compagnon
|
|
}
|
|
|
|
if (consigne > 0)
|
|
{
|
|
// RAZ du flag d'état du circuit à chaque fois qu'on l'active avec une consigne > 0 :
|
|
circuits.circuits[no_circuit].etat = ETAT_CIRCUIT_OK;
|
|
|
|
// Armement du time-out, si le circuit est ON et qu'un time-out est configuré dessus :
|
|
if (circuits.circuits[no_circuit].time_out > 0)
|
|
{
|
|
circuits.circuits[no_circuit].compteur_time_out = (circuits.circuits[no_circuit].time_out * 10); // Réarmement du time-out si le circuit est ON. NB : le time-out est exprimé en secondes mais, pour gagner en précision sur les petites durées, on a passé le décomptage en 100ms dans 'hardware.c' d'où le x10...
|
|
}
|
|
}
|
|
|
|
// Enregistrement du changement de consigne dans les mesures (qui ne sont faites que sur changement d'état pour les consignes) :
|
|
char date_vide[MAX_LONGUEUR_DATE_COURANTE] = ""; // Evite un warning depuis GCC14
|
|
enregistrement_mesure(SOURCE_MESURE_CIRCUIT, no_circuit, CIRCUIT_VARIABLE_CONSIGNE, date_vide, BDD_ENREGISTREMENT_MESURE_PONCTUEL);
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
|
|
//**********************************************************************************************************************************************************************************
|
|
// Fonction INIT_CIRCUITS
|
|
//
|
|
//**********************************************************************************************************************************************************************************
|
|
int8_t init_circuits(void)
|
|
{
|
|
uint16_t i;
|
|
|
|
circuits.sequenceur.etat = ETAT_SEQUENCEUR_CIRCUITS_INIT;
|
|
circuits.sequenceur.compteur = CIRCUITS_TEMPO_INIT;
|
|
|
|
for (i=0; i<MAX_NOMBRE_CIRCUITS; i++)
|
|
{
|
|
circuits.circuits[i].sequenceur.etat = ETAT_SEQUENCEUR_CIRCUIT_INIT;
|
|
circuits.circuits[i].flag_dde_maj_bdd = FALSE;
|
|
}
|
|
|
|
// Affichage du message de débug :
|
|
affichage_debug(__FILE__, __LINE__, "Initialisation des circuits\t\t: OK", TYPE_MESSAGE_DEBUG_OK);
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
//**********************************************************************************************************************************************************************************
|
|
// Fonction : Recherche le circuit dont la Clé_primaire est reçue en paramètre
|
|
// Reçoit : La Cle_primaire du circuit à rechercher
|
|
// Retourne : le numéro de circuit correspondant (ou -1 si aucun circuit valide ne correspond). La numérotation allant de 0 à MAX_NOMBRE_CIRCUITS - 1.
|
|
//**********************************************************************************************************************************************************************************
|
|
int16_t circuit_cle_primaire(uint16_t cle_primaire)
|
|
{
|
|
uint16_t i;
|
|
|
|
for (i = 0; i < circuits.nb; i ++)
|
|
{
|
|
if ((circuits.circuits[i].cle_primaire == cle_primaire) && (circuits.circuits[i].flag_validite)) return(i);
|
|
}
|
|
return (-1); // Si on est arrivé au bout de la boucle, on renvoi le code de 'non trouvé'.
|
|
}
|
|
|
|
|
|
//**********************************************************************************************************************************************************************************
|
|
// Fonction VARIABLE_CIRCUIT_CLE_PRIMAIRE
|
|
// Reçoit en paramètre :
|
|
// - La Cle_primaire de la variable à rechercher
|
|
// Retourne :
|
|
// - le numéro de variable correspondant (ou -1 si aucune variable valide ne correspond). La numérotation allant de 0 à MAX_NOMBRE_VARIABLES_CIRCUITS-1.
|
|
//**********************************************************************************************************************************************************************************
|
|
int16_t variable_circuit_cle_primaire(uint16_t cle_primaire)
|
|
{
|
|
uint16_t i;
|
|
|
|
for (i=0; i<MAX_NOMBRE_VARIABLES_CIRCUITS; i++)
|
|
{
|
|
if (circuits.variables[i].cle_primaire == cle_primaire) return(i);
|
|
|
|
}
|
|
return (-1); // Si on est arrivé au bout de la boucle, on renvoi le code de 'non trouvé'.
|
|
} |