1600 lines
101 KiB
C
1600 lines
101 KiB
C
// **********************************************************************************************************************************************************************************
|
||
// Fichier MAIN.H
|
||
//
|
||
// Contient les principaux éléments à inclure :
|
||
// - fichiers INCLUDE
|
||
// - principaux DEFINE
|
||
// - les PROTOTYPAGES de fonction en EXTERN (les prototypes eux-mêmes sont à mettre dans le fichier contenant la fonction)
|
||
// - les DECLARATIONS de variables en EXTERN (les déclarations elles-mêmes sont à mettre dans le fichier *.c "principal" - dans le doute, dans MAIN.C)
|
||
//
|
||
// Ce fichier est destiné à être inclus dans TOUS les fichiers *.c du projet.
|
||
// **********************************************************************************************************************************************************************************
|
||
|
||
|
||
// **********************************************************************************************************************************************************************************
|
||
// Include :
|
||
// **********************************************************************************************************************************************************************************
|
||
|
||
#include <alsa/asoundlib.h>
|
||
#include <alsa/mixer.h>
|
||
#include <ctype.h>
|
||
#include <dirent.h>
|
||
#include <fcntl.h>
|
||
#include <float.h>
|
||
#include <gpiod.h> // Nécessaire pour E/S GPIO sur CM5
|
||
#include <ifaddrs.h>
|
||
#include </usr/include/json-c/json.h>
|
||
#include <math.h>
|
||
#include </usr/include/mariadb/mysql.h>
|
||
#include <netdb.h>
|
||
#include <net/if.h>
|
||
#include </usr/include/openssl/sha.h>
|
||
#include <signal.h>
|
||
#include <stdbool.h>
|
||
#include <stdint.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/mman.h>
|
||
#include <sys/reboot.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/time.h>
|
||
#include <sys/types.h>
|
||
#include <termios.h>
|
||
#include <time.h>
|
||
#include <unistd.h>
|
||
|
||
#include "audio.h"
|
||
#include "batteries.h"
|
||
#include "bdd.h"
|
||
#include "c_bus.h"
|
||
#include "c_commandes.h"
|
||
#include "capteurs.h"
|
||
#include "circuits.h"
|
||
#include "debug.h"
|
||
#include "ecran.h"
|
||
#include "entrees.h"
|
||
#include "events.h"
|
||
#include "fonctions.h"
|
||
#include "g_bus.h"
|
||
#include "g_commandes.h"
|
||
#include "gnss.h"
|
||
#include "hardware.h"
|
||
#include "localisation.h"
|
||
#include "m_bus.h"
|
||
#include "m_commandes.h"
|
||
#include "modem.h"
|
||
#include "nmea.h"
|
||
#include "reseaux.h"
|
||
#include "reservoirs.h"
|
||
#include "serial.h"
|
||
#include "sorties.h"
|
||
#include "systeme.h"
|
||
#include "usb.h"
|
||
|
||
|
||
|
||
// **********************************************************************************************************************************************************************************
|
||
// Define :
|
||
// **********************************************************************************************************************************************************************************
|
||
|
||
// Général :
|
||
#define OFF 0
|
||
#define ON 1
|
||
|
||
#define FALSE 0
|
||
#define TRUE 1
|
||
|
||
#define HIGH 1
|
||
#define LOW 0
|
||
|
||
#define CLEAR 0
|
||
#define SET 1
|
||
|
||
#define ENTREE 0
|
||
#define SORTIE 1
|
||
|
||
// Logique d'alarme :
|
||
#define LOGIQUE_ALARME_NEGATIVE -1 // L'alerte/alarme est déclenchée lorsque la valeur mesurée passe en-dessous du seuil bas.
|
||
#define LOGIQUE_ALARME_INTERVALLE 0 // L'alerte/alarme est déclenchée lorsque la valeur mesurée passe en-dessous du seuil bas ou au-dessus du seuil haut..
|
||
#define LOGIQUE_ALARME_POSITIVE 1 // L'alerte/alarme est déclenchée lorsque la valeur mesurée passe en-dessus du seuil haut.
|
||
#define LOGIQUE_ALARME_AUCUNE 2 // Aucune alerte/alarme n'est déclenchée
|
||
|
||
|
||
// **********************************************************************************************************************************************************************************
|
||
// Structures :
|
||
// **********************************************************************************************************************************************************************************
|
||
|
||
struct Struct_date
|
||
{
|
||
uint8_t jour;
|
||
uint8_t mois;
|
||
uint16_t annee;
|
||
};
|
||
struct Struct_heure
|
||
{
|
||
uint8_t heures;
|
||
uint8_t minutes;
|
||
uint8_t secondes;
|
||
};
|
||
struct Struct_sequenceur
|
||
{
|
||
uint8_t etat;
|
||
uint16_t compteur;
|
||
uint16_t compteur_time_out;
|
||
};
|
||
struct Struct_valeur_niveau
|
||
{
|
||
bool flag_validite; // Indique si ce point est valide ou pas.
|
||
float valeur; // Valeur exprimée dans la même unité que la variable concernée (donc dépend du 'Type_entrées').
|
||
float niveau; // Niveau, entre 0 et 100%
|
||
};
|
||
struct Struct_variable
|
||
{
|
||
uint16_t cle_primaire; // Clé primaire dans TB_Variables
|
||
float marge; // Marge provenant de TB_Variables
|
||
};
|
||
struct Struct_variables
|
||
{
|
||
float valeur_courante; // Valeurs courante (filtrées mais pas forcément stockées en BDD)
|
||
float valeur_bdd; // Dernières valeurs stockées en BDD
|
||
float last_mesure; // Dernières valeurs stockées en BDD dans TB_Mesures_batteries
|
||
double cumul; // Cumul des variables (intégration)
|
||
};
|
||
|
||
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Audio.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_boucle_audio
|
||
{
|
||
char nom_fichier[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier MP3 en cours d'utilisation
|
||
uint16_t nb_repetitions; // Nb de répétitions du son à chaque boucle
|
||
uint16_t periode_boucles; // Période en x100ms de chaque boucle
|
||
uint16_t nb_boucles; // Nb de boucles demandées
|
||
uint16_t compteur_boucles; // Compteur utilisé pour décompter le nb de boucles restant à exécuter
|
||
};
|
||
struct Struct_audio
|
||
{
|
||
float consigne_volume; // En % (0 à 100.00). Valeur issue de 'TB_Configuration.Consigne_volume'
|
||
uint16_t sortie_gpio_cm_do_audio_sd; // Prend la valeur de CM3P_DO_AUDIO_SD ou CM4_DO_AUDIO_SD selon la génération de ShipBase
|
||
uint16_t entree_gpio_cm_di_jack_detect; // Prend la valeur de CM4_DI_JACK_DETECT (ou 0 si CM3+ sur SBV1) selon la génération de ShipBase
|
||
uint8_t etat_presence_jack; // Indique si une prise jack est présente sur la sortie AUDIO (1) ou absente (0). Cette valeur est répliquée dans 'TB_Systeme.Presence_jack'
|
||
uint8_t fonction_jack; // Copie du champ 'TB_Configuration.Fonction_jack'. Indique l'effet de la présence d'une prise jack sur la sortie audio. 0= le son est coupé sur le HP quand la prise jack est présente, 1=le son est maintenu sur HP quand la prise jack est présente.
|
||
struct Struct_boucle_audio boucle;
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Batteries.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_batterie
|
||
{
|
||
uint16_t cle_primaire; // Valeur de Clé Primaire dans TB_Reservoirs
|
||
bool flag_validite;
|
||
int8_t etat_systeme; // 0: fonctionnement normal, -1: incohérence dans la config, -2: module physique affecté non disponible (absent ou type incompatible)
|
||
|
||
uint8_t adresse_module; // Indique l'adresse K-Bus du module sur laquelle sont positionnées l'entrée de la batterie (entre 0 et MAX_NOMBRE_MODULES-1).
|
||
uint8_t type_entrees; // '0=Non défini, 3= Voltage Input, 5=Prédéfni, 6=IBS. Les autres valeurs sont invalides.
|
||
uint16_t no_entrees; // Stocke le numéro de 'entrees.volt/predefini.entrees[]' selon type_entrees.
|
||
|
||
uint8_t type; // Liste de valeurs (image du champs 'Typ' dans TB_Batteries. Attention à ne pas confondre avec 'type_entrees' qui n'a rien à voir... Indique le type de batteries constituant le pack. 0=Non défini, 1=Pb – acide liquide, 2=Pb – AGM, 3=Pb – Gel, 4=Pb – Carbone, 10=Lithium
|
||
uint8_t tension_nominale; // 12 ou 24 (en Volts).
|
||
float capacite; // Indique, en Ah, la capacité du pack de batteries
|
||
float heures_capacite; // Durée pour laquelle la capacité est donnée
|
||
float coeff_peukert; // Coefficient de Peukert de la batterie. Toujours >=1.
|
||
float tension_pleine_charge; // Tension au-dessus de laquelle la batterie sera considérée comme complètement chargée (sous réserve d’autres paramètres et de durée). Exprimée en V.
|
||
float courant_pleine_charge; // Courant au-dessous duquel la batterie sera considérée comme complètement chargée (sous réserve d’autres paramètres et de durée). Exprimée en A.
|
||
uint16_t temporisation_pleine_charge; // Durée pendant laquelle tous les paramètres de validation de pleine charge doivent perdurer pour qu’un SOC de 100% soit déclaré. Exprimée en secondes.
|
||
float tension_charge_nulle; // Tension en-dessous de laquelle la batterie sera considérée comme complètement déchargée (sous réserve d’autres paramètres et de durée). Exprimée en V.
|
||
uint16_t temporisation_charge_nulle; // Durée pendant laquelle tous les paramètres de validation de charge nulle doivent perdurer pour qu’un SOC de 0% soit déclaré. Exprimée en secondes.
|
||
float resistance_interne; // Résistance interne de la batterie, à 25°C et plutôt pour des SOC faibles. Exprimée en mOhms.
|
||
float efficacite_charge; // Part d’énergie stockée dans la batterie vs l’énergie fournie à la batterie pendant la charge. Valeur entre ]0; 1].
|
||
float efficacite_decharge; // Part de l’énergie prélevée dans la batterie vs l’énergie fournie par la batterie aux consommateurs. Valeur entre ]0; 1].
|
||
float courant_repos; // Valeur en-dessous de laquelle la valeur absolue du courant différentiel sera considérée comme nul. Utilisé pour repasser en mode Open Voltage Mode (OVM) pour ajuster le SOC pendant les longues périodes dìnactivite. Exprimée en A.
|
||
uint32_t nombre_cycles; // Nombre de fois que la batterie a été déchargée à SOC<60% après avoir été rechargée à SOC=100%
|
||
uint8_t flag_increment_cycles; // Passe à 1 lorsque "Nombre_cycle" est incrémenté. Remis à 0 lorsque le SOC = 100%
|
||
uint32_t nombre_decharges_completes; // Nombre de fois que la batterie a été déchargée à SOC=0% après avoir été rechargée à SOC=100 %
|
||
uint8_t flag_increment_decharges_completes; // Passe à 1 lorsque "Nombre_decharges_completes" est incrémenté. Remis à 0 lorsque le SOC = 100%
|
||
|
||
uint8_t temperature_coeff_filtrage; // Entre 1 et 255.
|
||
|
||
uint8_t tension_coeff_filtrage; // Entre 1 et 255.
|
||
float tension_gain; // Coefficient à appliquer sur la tension lue sur l\'entrée [Valeur_réelle = valeur_lue_sur_l_entree x Tension_gain ].
|
||
|
||
uint8_t courant_differentiel_coeff_filtrage; // Entre 1 et 255.
|
||
|
||
uint8_t soc_coeff_filtrage; // Entre 1 et 255.
|
||
|
||
float eod; // En Ah. Energy of Discharge.
|
||
|
||
struct Struct_valeur_niveau points_tension_soc[MAX_NOMBRE_POINTS_TENSION_SOC_BATTERIE]; // Contient des couples '[tension]/[soc]'. Le 'SOC' de la batterie est calculé par extrapolation linéaire entre les deux points dont le 'SOC' est la plus proche du SOC actuel de la batterie.
|
||
struct Struct_valeur_niveau points_temperature_resistance_interne[MAX_NOMBRE_POINTS_TEMPERATURE_RESISTANCE_INTERNE_BATTERIE]; // Contient des couples "[température]/[résistance_interne]", séparés par des '';''. Les [températures] sont exprimées en °C. Les [résistances_internes] sont exprimées en mOhms. La résistance interne de la batterie sera calculée par extrapolation linéaire entre les deux points dont la température est la plus proche de la température actuelle du pack. Exemple : "10/5.2"
|
||
uint8_t mode_enregistrement_mesures; // 0:aucun enregistrement de mesures pour ce capteur, 1: enregistrement de la valeur du capteur lors de ses changements d'état, 2: enregistrement périodique de la valeur du capteur indépendamment de ses changements d'état, 3: enregistrement périodique ET sur changement d'état
|
||
uint8_t mode_enregistrement_historique; // 0:l'enregistrement dans l'historique des changements d'état du capteur ne sont pas réalisées, 1: les changements d'état du capteur sont enregistrées dans l'historique
|
||
|
||
struct Struct_variables variables[MAX_NOMBRE_VARIABLES_BATTERIES]; // Différentes valeurs de chaque variable de la batterie
|
||
uint16_t cumuls_nb_val; // Nombre d'échantillons stockés sur la période (identique pour toutes les variables qui sont cumulés dans des cumuls séparés mais en même temps)
|
||
|
||
bool flag_dde_maj_bdd; // Est utilisé pour signaler qu'un UPDATE de l'état de la BDD est nécessaire (RAZ dans Gestion_bdd.c)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de gestion de la batterie.
|
||
};
|
||
|
||
struct Struct_batteries
|
||
{
|
||
uint8_t compteur_affichage_debug; // Permet de ne pas déclencher l'affichage debug à chaque boucle mais seulement 1 fois sur N
|
||
struct Struct_variable variables[MAX_NOMBRE_VARIABLES_BATTERIES];
|
||
struct Struct_batterie batteries[MAX_NOMBRE_BATTERIES];
|
||
uint16_t nb; // Nb de batteries détectées dans 'bdd_init()'. Permet de réduire les boucles en exploitation à ce nombre plutôt que jusqu'à MAX_NOMBRE_BATTERIES. Attention : toutes les batteries dont le rang est < nb ne sont pas forcément valides.
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Bdd_init :
|
||
//---------------------------------------------------------------------------------------------
|
||
|
||
struct Struct_bdd
|
||
{
|
||
MYSQL *pointeur;
|
||
int16_t compteur_synchro; // Compteur spécifique utilisé pour vérifier fréquément si le flag de synchro a été positionné dans la BDD par un serveur web
|
||
int16_t compteur; // Compteur utilisé pour faire des mises à jour périodique, de façon asynchrone
|
||
int16_t compteur_enregistrement_mesures; // Compteur permettant de lancer un archivage des mesures à période fixe
|
||
};
|
||
|
||
struct Struct_scenarios
|
||
{
|
||
int last_minute; // Contient la minute de la dernière action traitée (permet de déclencher dès le début de la "nouvelle minute")
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// C_bus :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_commande_c_bus
|
||
{
|
||
uint8_t cde[C_BUS_MAX_TAILLE_CDE]; // Contient la commande complète à émettre ou reçue
|
||
uint16_t lg_cde; // Contient la longueur de la commande
|
||
uint16_t priorite; // Défini la priorité (uniquement pour le UP)
|
||
};
|
||
struct Struct_reponse_c_bus
|
||
{
|
||
uint8_t reponse[C_BUS_MAX_TAILLE_REPONSE]; // Contient la commande complète à émettre ou reçue
|
||
uint16_t lg_reponse; // Contient la longueur de la commande
|
||
bool flag_ready; // Indique que la réponse est prête à être émise
|
||
};
|
||
struct Struct_protocole_c_bus
|
||
{
|
||
uint16_t cs; // Valeur en cours du CS
|
||
uint16_t cs_recu; // Valeur de CS reçu
|
||
uint8_t ptr_cs_recu; // Permet de compter les 2 octets de CS après le STX de fin
|
||
bool flag_dle; // Indique que le dernier caractère traité était un DLE.
|
||
uint8_t sens; // Contient le sens de la commande en cours de réception ('D' ou 'U')
|
||
uint8_t repetitions; // Contient le nombre de répétitions effectuées sur la commande en cours (uniquement pour Tx en mode DOWN)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur du protocole
|
||
};
|
||
struct Struct_c_bus_up
|
||
{
|
||
struct Struct_commande_c_bus cde; // Commande reçue du Compagnon en cours de traitement
|
||
struct Struct_reponse_c_bus reponse; // Réponse à la commande reçue du Compagnon et qui va être émise
|
||
};
|
||
struct Struct_c_bus_down
|
||
{
|
||
struct Struct_commande_c_bus buffer_cdes[C_BUS_MAX_TAILLE_BUFFER_CDES]; // Buffer tournant contenant les commandes en attente d'émission sur le C_Bus UP
|
||
uint16_t ptr_debut_buffer_cdes; // Indique la position de la prochaine commande à émettre
|
||
uint16_t ptr_fin_buffer_cdes; // Indique la position de le dernière commande en attente d'émission
|
||
bool flag_attente_reponse; // Indique qu'une commande a été envoyée et qu'aucune trame de réponse n'a encore été obtenue
|
||
struct Struct_reponse_c_bus reponse; // Structure contenant la réponse à la dernière commande émise
|
||
};
|
||
struct Struct_c_bus
|
||
{
|
||
struct Struct_c_bus_up up; // Structure rassemblant les variables de gestion du bus montant
|
||
struct Struct_c_bus_down down; // Structure rassemblant les variables de gestion du bus descendant
|
||
struct Struct_protocole_c_bus protocole_rx; // Contient les informations de gestion du protocole en réception (donc reçoit les commandes Up et les réponses aux commandes Down)
|
||
struct Struct_protocole_c_bus protocole_tx; // Contient les informations de gestion du protocole en émission (donc émet les commandes Down et les réponses aux commandes Up)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau du C-Bus
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Capteurs.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_condition_booleenne
|
||
{
|
||
bool flag_validite;
|
||
int8_t type_condition; // 0=condition normale, >0=début de groupe de conditions avec l\'opérateur suivant : 1=Ou, 2=Et, 3=Ou Exclusif, 10=Plus, 11=Moins, 12=Multiplié, 13=Divisé, <0=fin de groupe de conditions (même valeurs que début mais en négatif)
|
||
uint8_t type_source; // 0=Non défini, 1=circuit, 2=capteur, 3=réservoir, 4=batterie.
|
||
uint16_t id_source; // Clé primaire dans la table correspondante à Type_source. L'ID est utilisée uniquement au démarrage car lors de l'init des capteurs, les circuits, réservoirs, batteries (et certains capteurs) ne sont pas encore initialisés...
|
||
uint16_t no_source; // N° de la source dans la structure correspondante (équivalent de la clé_primaire mais pointe directement sur l'entrée de la structure dans l'appli)
|
||
uint16_t id_variable; // Clé primaire dans la table TB_Variables. L'ID est utilisée uniquement au démarrage car lors de l'init des capteurs, les circuits, réservoirs, batteries (et certains capteurs) ne sont pas encore initialisés...
|
||
uint8_t no_variable; // N° de la variable du type concerné (entre 0 et MAX_NOMBRE_VARIABLES_PAR_xxxxxx)
|
||
uint8_t test; // 0=Non défini, 1=strictement inférieure au seuil, 2=inférieure ou égale au seuil, 3=égale au seuil, 4=supérieure ou égale au seuil, 5= strictement supérieure au seuil.
|
||
float seuil; // Valeur, exprimée en unités de l'ID_Variable.
|
||
};
|
||
|
||
struct Struct_parenthese_calcul_capteur_booleen
|
||
{
|
||
uint8_t operation;
|
||
bool resultat;
|
||
};
|
||
struct Struct_calcul_capteur_booleen
|
||
{
|
||
int16_t niveau;
|
||
struct Struct_parenthese_calcul_capteur_booleen parentheses[MAX_NOMBRE_CONDITIONS_PAR_CAPTEUR / 2];
|
||
};
|
||
|
||
struct Struct_conditions_booleennes
|
||
{
|
||
struct Struct_condition_booleenne conditions[MAX_NOMBRE_CONDITIONS_PAR_CAPTEUR];
|
||
};
|
||
|
||
struct Struct_capteur
|
||
{
|
||
uint16_t cle_primaire; // Valeur de Clé Primaire dans TB_Capteurs
|
||
bool flag_validite;
|
||
int8_t etat_systeme; // 0: fonctionnement normal, -1: incohérence dans la config, -2: module physique affecté non disponible (absent ou type incompatible)
|
||
|
||
|
||
uint8_t adresse_module; // Indique le n° de module sur laquelle sont positionnées les entrées du capteur (entre 0 et MAX_NOMBRE_MODULES-1).
|
||
uint8_t type_entrees; // '0=Non défini, 1=Entrée Auxiliaire, 2=Entrée Level Sensor, 3= Voltage Input, 4=entrée OW, 5=Prédéfni, 7=Nmea, 8=Can (ou J1939), 20=Booléen calculé, 21=numérique calculé. Les autres valeurs sont invalides.
|
||
uint16_t no_entrees[MAX_NOMBRE_ENTREES_PAR_CAPTEUR]; // Stocke le n° de 'entrees.aux/level_sensor/volt/ow/predefinie/nmea/j1939.entrees[]' ou 'capteurs.capteurs[]', selon 'type_entrees'.
|
||
uint8_t nb_entrees; // Précise le nombre de valeurs utiles dans 'no_entrees[]'. Pour les capteurs calculés, le nombre de conditions puisqu'elles sont comptées dans 'Entrees'
|
||
|
||
uint16_t id_variable; // Cle primaire dans TB_Variables indiquant quel type de variable est à utiliser pour le capteur
|
||
uint16_t no_variable; // Position dans 'capteurs.variables[]' de la variable affectée à ce capteur via 'id_variable'. Initialisée dans 'bdd_init()' à partir de 'id_variable'.
|
||
float offset; // Valeur d'offset à ajouter à la valeur lue avant son exploitation. Valeur_corrigée = (valeur_lue x Gain) + Offset
|
||
float gain; // Valeur de gain à appliquer à la valeur lue avant son exploitation. Valeur_corrigée = (valeur_lue x Gain) + Offset
|
||
float valeur_brute; // Contient la valeur brute du ou des capteurs. SDIR #135
|
||
uint8_t valeur_coeff_filtrage; // Image du champs 'Coeff_filtrage' dans TB_Capteurs
|
||
uint8_t mode_enregistrement_mesures; // 0:aucun enregistrement de mesures pour ce capteur, 1: enregistrement de la valeur du capteur lors de ses changements d'état, 2: enregistrement périodique de la valeur du capteur indépendamment de ses changements d'état, 3: enregistrement périodique ET sur changement d'état
|
||
uint8_t mode_enregistrement_historique; // 0:l'enregistrement dans l'historique des changements d'état du capteur ne sont pas réalisées, 1: les changements d'état du capteur sont enregistrées dans l'historique
|
||
|
||
struct Struct_conditions_booleennes conditions;
|
||
|
||
struct Struct_variables variables[MAX_NOMBRE_VARIABLES_PAR_CAPTEUR]; // Différentes valeurs de chaque variable du capteur
|
||
uint16_t cumuls_nb_val; // Nombre d'échantillons stockés sur la période (identique pour toutes les variables qui sont cumulés dans des cumuls séparés mais en même temps)
|
||
|
||
bool flag_dde_maj_bdd; // Est utilisé pour signaler qu'un UPDATE de l'état de la BDD est nécessaire (RAZ dans Gestion_bdd.c)
|
||
int8_t etat; // Indique si le capteur est normal (0), en alerte (1) ou en alarme (2). Ou s'il y a un défaut de capteur (-1) ou un défaut général (bus en CC, alimentation HS,...) (-2).
|
||
};
|
||
struct Struct_capteurs
|
||
{
|
||
struct Struct_variable variables[MAX_NOMBRE_VARIABLES_CAPTEURS]; // Attention : le fonctionnement de ce tableau pour les capteurs est différent du fonctionnement pour les batteries, circuits et réservoirs (la dimension est MAX_NOMBRE_VARIABLES_CAPTEURS et non MAX_NOMBRE_ENTREES_PAR_CAPTEUR)
|
||
struct Struct_capteur capteurs[MAX_NOMBRE_CAPTEURS];
|
||
uint16_t nb; // Nb de capteurs détectés dans 'bdd_init()'. Permet de réduite les boucles en exploitation à ce nombre plutôt que jusqu'à MAX_NOMBRE_CAPTEURS. Attention : tous les capteurs dont le rang est < nb ne sont pas forcément valides.
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Circuits.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_circuit_cumuls
|
||
{
|
||
double tension;
|
||
double intensite;
|
||
double frequence;
|
||
double puissance;
|
||
uint16_t nb_val; // Nombre d'échantillons stockés sur la période (identique pour tous les paramètres qui sont cumulés dans des variables séparées mais en même temps)
|
||
};
|
||
|
||
struct Struct_circuit
|
||
{
|
||
// Note importante : les circuits sont identifiés par leur 'no_circuit' sur une 'adresse_module'
|
||
// Ce numéro de circuit est compris entre 0 et (SP8xx_MAX_NOMBRE_CIRCUITS - 1) par exemple.
|
||
uint16_t cle_primaire; // Clé primaire dans la table 'TB_Circuits'
|
||
bool flag_validite; // Indique si ce circuit est valide (1) ou pas (0). La mise à jour de ce champs est uniquement manuelle ; cela permet, par exemple, de passer un circuit en NON AFFECTE.
|
||
int8_t etat_systeme; // 0: fonctionnement normal, -1: incohérence dans la config, -2: module physique affecté non disponible (absent ou type incompatible)
|
||
|
||
uint16_t adresse_module; // Indique l'adresse K-Bus du module par laquel le circuit est commandé (entre 0 et MAX_NOMBRE_MODULES-1).
|
||
uint16_t no_circuit; // Indique le n° de circuit sur la carte (entre 0 et MAX_NOMBRE_CIRCUITS_PAR_CARTE-1)
|
||
int16_t id_circuit_esclave; // Si 0, aucun circuit esclave. Si > 0, indique qu\'il a un circuit esclave (la valeur est l'ID de circuit). Si < 0 : indique qu\'il est lui-même l\'esclave d\'un autre circuit (l'ID du circuit maitre est alors la valeur absolue du paramètre). NB : Cet ID n'est utilisé qu'entre l'init et le chargement de l'annuaire des cartes et donc des circuits. Il est alors remplacé par 'no_circuit_esclave'.
|
||
int16_t no_circuit_esclave; // Si -1, aucun circuit esclave. Si >= 0, indique qu\'il a un circuit esclave (la valeur est le n° de circuit).
|
||
uint16_t id_batterie; // Indique à quelle batterie le circuit est affecté (hérité de sa carte d'appartenance). 0 si aucune batterie n'est définie.
|
||
uint8_t etat_commande_carte; // Etat de la commande du circuit mis à jour par le logiciel à partir des informations d'état de la carte. 0=Normal, 1=Undervoltage, 2=Test
|
||
uint8_t mode_cde; // Indique le mode de commande du circuit : 0=On-Off, 1=On-Off soft, 2=Variable soft et 3=Cadencé
|
||
|
||
uint8_t origine_consigne; // Contient l'origine de la consigne en cours : 0=ShipBase (ou, plus généralement, un User), >0=ID du capteur ayant généré le changement de consigne
|
||
uint16_t id_origine_consigne; // Contient l'ID ayant généré la consigne. Si 'origine_consigne'=Capteur, l'ID du capteur.
|
||
uint8_t mode_test; // Indique la position actuelle du switch de test du circuit (0=inactif, 1=activé)
|
||
|
||
struct Struct_variables variables[MAX_NOMBRE_VARIABLES_CIRCUITS]; // Différentes valeurs de chaque variable du circuit
|
||
uint16_t cumuls_nb_val; // Nombre d'échantillons stockés sur la période (identique pour toutes les variables qui sont cumulés dans des cumuls séparés mais en même temps)
|
||
|
||
uint8_t tension_coeff_filtrage; // Valeur du filtre IIR à utiliser pour calculer la valeur moyenne de la tension du le cicuit.
|
||
uint8_t intensite_coeff_filtrage; // Valeur du filtre IIR à utiliser pour calculer la valeur moyenne de l'intensité dans le cicuit.
|
||
uint8_t frequence_coeff_filtrage; // Valeur du filtre IIR à utiliser pour calculer la valeur moyenne de la fréquence dans le cicuit.
|
||
float intensite_seuil_haut; // Indique la valeur (en A) du seuil haut avant disjonction (inactif si 0)
|
||
uint16_t intensite_seuil_haut_tempo; // Tempo de filtrage entre le déclenchement et la disjonction (en ms)
|
||
uint8_t step_time; // Durée, en ms, de chaque pas de soft start/stop. Entre 10 et 255ms
|
||
uint16_t t_on; // Durée de l'impulsion ON en mode Cadencé (en 100ms)
|
||
uint16_t t_off; // Durée de l'impulsion OFF en mode Cadencé (en 100ms)
|
||
|
||
uint8_t mode_enregistrement_mesures; // Défini la façon dont les mesures de ce circuit (intensité) sont enregistrées : A définir...
|
||
uint8_t mode_enregistrement_historique; // Défini la façon dont les évènements de ce circuit sont enregistrées : A définir...
|
||
|
||
uint8_t etat; // Contient l'état actuel du circuit
|
||
uint32_t compteur_time_out; // Variable décomptée chaque seconde dans 'hardware.c' si sa valeur est > 0
|
||
uint32_t time_out; // Armé lors d'un changement de commande de OFF à ON (ou à toute valeur différente de OFF). La commande est ramenée automatiquement à OFF en fin de time-out. En secondes (0=aucun time-out).
|
||
bool flag_dde_maj_bdd; // Est utilisé pour signaler qu'un UPDATE de l'état de la BDD est nécessaire (RAZ dans Gestion_bdd.c)
|
||
bool flag_changement_consigne_en_cours; // Indique qu'une demande de changement est en cours => le prochain retour d'état du circuit sera ignoré (SDIR #179)
|
||
|
||
uint8_t validation_cdes_events; // Image du champ 'Validation_cdes_events' de TB_Circuits
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de gestion du circuit
|
||
};
|
||
struct Struct_circuits
|
||
{
|
||
struct Struct_variable variables[MAX_NOMBRE_VARIABLES_CIRCUITS];
|
||
struct Struct_circuit circuits[MAX_NOMBRE_CIRCUITS]; // Structure contenant, pour chaque circuit, toutes les informations de configuration, d'état et de consigne.
|
||
uint16_t nb; // Nb de circuits détectés dans 'bdd_init()'. Permet de réduite les boucles en exploitation à ce nombre plutôt que jusqu'à MAX_NOMBRE_CIRCUITS. Attention : tous les circuits dont le rang est < nb ne sont pas forcément valides.
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Debug.c
|
||
//---------------------------------------------------------------------------------------------
|
||
|
||
struct Struct_debug
|
||
{
|
||
int mode; // Mode de gestion des messages de debug.
|
||
char nom_fichier[MAX_LONGUEUR_NOM_FICHIER_DEBUG]; // Nom du fichier de debug à utiliser (si Mode le permet)
|
||
FILE *ptr_fichier; // Stocke le pointeur de fichier correspondant au fichier de debug.
|
||
|
||
// char ligne[MAX_LONGUEUR_LIGNE_FICHIER_LOG]; // Stocke la ligne en cours de construction (permets de n'avoir qu'une ligne même en cas d'appel successifs à des fonctions de bas niveau)
|
||
// int flag_erreur_detectee; // Si 0, aucune erreur n'a été détectée. Sinon, il faut conserver le(s) dernier(s) fichier(s) tournant(s)
|
||
// int franchise_suppression; // Indique si on doit conserver des fichiers postérieurs à un évènement (et si >0, le nombre de secondes).
|
||
};
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Ecran :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_ecran
|
||
{
|
||
float consigne_backlight; // En % (0 à 100.00). Valeur issue de 'TB_Configuration.Consigne_backlight'
|
||
float consigne_leds; // En % (0 à 100.00). Valeur issue de 'TB_Configuration.Consigne_leds'
|
||
int8_t validation_leds; // Valeur issue de 'TB_Configuration.Validation_leds' et indiquant si les LEDS doivent être activées ou non
|
||
|
||
uint16_t sortie_gpio_cm_pdown_hdmi_cmd_n; // Prend la valeur de CM3P_Pdown_HDMI_CMD_N ou CM4_Pdown_HDMI_CMD_N selon la génération de ShipBase
|
||
uint16_t sortie_gpio_cm_do_lcd_en_vgx; // Prend la valeur de CM3P_DO_LCD_EN_VGx ou CM4_DO_EN_LCD_VGx selon la génération de ShipBase
|
||
uint16_t sortie_gpio_cm_do_lcd_en_vdd; // Prend la valeur de CM3P_DO_LCD_EN_VDD ou CM4_DO_EN_LCD_VDD selon la génération de ShipBase
|
||
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Entrees :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_entree_aux
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t module; // Adresse du module portant l'entrée
|
||
uint8_t no; // Indique le N° d'entrée AUX affectée (1 à 32)
|
||
int8_t logique; // 0:logique normale; 1:logique inverséee
|
||
uint8_t valeur; // Dernier état connu de l'entrée (ON/OFF)
|
||
};
|
||
struct Struct_entree_level_sensor
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t module; // Adresse du module portant l'entrée
|
||
uint8_t no; // Indique le N° de la sortie Level Sensor affectée (1 à 8)
|
||
int8_t mode; // 0:inconnu, 1:0-10V, 2:500R, 3:4-20mA, 4:autotest
|
||
float valeur; // Valeur de l'entrée
|
||
};
|
||
struct Struct_entree_volt
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t module; // Adresse du module portant l'entrée
|
||
uint8_t no; // Indique le N° d'entrée VOLT affectée (1 à 4)
|
||
float valeur; // Dernier état connu de l'entrée
|
||
};
|
||
struct Struct_entree_nmea
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t module; // Adresse du module portant l'entrée
|
||
uint32_t pgn; // Indique le N° du PGN affecté à l'entrée
|
||
uint8_t field; // Indique le N° du Field du PGN affecté à l'entrée
|
||
float valeur; // Dernier état connu de l'entrée
|
||
};
|
||
struct Struct_entree_ow
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
bool flag_presence; // FALSE=absent, TRUE=présent
|
||
char rom_code[TAILLE_ROM_CODE_OW * 3]; // On a besoin de 3 caractères par octet (xx:) sauf pour le dernier (xx) + le NULL de fin
|
||
int8_t etat; // Contient le retour d'état du Compagnon pour ce device. 0=Ok, -1=erreur lors du dernier accès. NB : les tentatives d'accès continueront tant qu'une nouvelle découverte réseau ne sera pas lancée et l'absence définitive constatée (si c'est le cas...)
|
||
float valeur; // Dernier état connu de l'entrée. SDIR # 176
|
||
};
|
||
struct Struct_entree_predefinie
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t module; // Adresse du module portant l'entrée
|
||
uint8_t no; // Indique le N° d'entrée Prédéfinie affectée, de 1 (PAT) à 22 (SINR) voire au-delà. Cf 'entrees.h' pour la liste complète des n° et leur affectation
|
||
float valeur; // Valeur de l'entrée (mini = -32000 pour les Défauts Isolement à la masse et maxi = 20000µA pour les capteurs 4-20mA)
|
||
};
|
||
struct Struct_entree_core
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
char nom[MAX_LONGUEUR_NOM_ENTREE]; // Contient l'étiquette de l'entrée CORE
|
||
uint16_t no; // N° arbitraire, entre 0 et MAX_NOMBRE_ENTREES_CORE -1
|
||
float valeur; // Dernier état connu de l'entrée
|
||
};
|
||
struct Struct_entree_gpio
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t no; // Indique le N° de l'E/S GPIO affectée (0 à 53) => Contrairement aux autres entrées dont le n° commence à 1, on considère qu'on garde ici la numérotation du CM4, de GPIO#0 à GPIO#53. D'ailleurs, le n° correspond toujours au nom (le n° de GPIO#27 est... 27)
|
||
uint8_t pull; // 0=Aucune, 1=PULL_DOWN, 2=PULL_UP
|
||
int8_t logique; // 1:logique normale; -1:logique inverséee
|
||
uint8_t valeur; // Dernier état connu de l'entrée (ON/OFF)
|
||
};
|
||
|
||
struct Struct_device_ow
|
||
{
|
||
bool flag_dde_maj_bdd; // Indique si une mise à jour de la Valeur dans la BDD est nécessaire
|
||
int16_t no_entree; // Indice de 'entrees.ow.entrees[]' correspondant à ce device (ou -1 si aucune entrée n'est affectée à ce device). Permet d'affecter les retours de 'c_bus_up_commande_etat_entrees_ow()' à l'entrée correspondante.
|
||
char rom_code[TAILLE_ROM_CODE_OW * 3]; // On a besoin de 3 caractères par octet (xx:) sauf pour le dernier (xx) + le NULL de fin
|
||
uint8_t etat; // Cette valeur est utilisée pour mettre à jour TB_One_wire.Etat (alors que c'est entrees.ow.entrees[].etat qui sera utilisée pour mettre à jour le capteur qui utilise le device)
|
||
float valeur; // Cette valeur est utilisée pour mettre à jour TB_One_wire.Valeur (alors que c'est entrees.ow.entrees[].valeur qui sera utilisée pour mettre à jour le capteur qui utilise le device)
|
||
};
|
||
|
||
struct Struct_entrees_aux
|
||
{
|
||
struct Struct_entree_aux entrees[MAX_NOMBRE_ENTREES_AUXILIAIRES];
|
||
uint8_t nb; // Nb d'entrées trouvées comme étant affectées (à des batteries, à des capteurs,...)
|
||
// NB : il n'y a pas besoin de séquenceur car l'état des entrées AUX est remonté automatiquement par le Compagnon via des commandes UP.
|
||
};
|
||
struct Struct_entrees_level_sensor
|
||
{
|
||
struct Struct_entree_level_sensor entrees[MAX_NOMBRE_ENTREES_LEVEL_SENSOR];
|
||
uint8_t nb; // Nb d'entrées trouvées comme étant affectées (à des batteries, à des capteurs,...)
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
struct Struct_entrees_volt
|
||
{
|
||
struct Struct_entree_volt entrees[MAX_NOMBRE_ENTREES_VOLTAGE];
|
||
uint8_t nb; // Nb d'entrées trouvées comme étant affectées (à des batteries, à des capteurs,...)
|
||
// NB : il n'y a pas besoin de séquenceur car l'état des entrées VOLT est remonté automatiquement par le Compagnon via des commandes UP.
|
||
};
|
||
struct Struct_entrees_nmea
|
||
{
|
||
struct Struct_entree_nmea entrees[MAX_NOMBRE_ENTREES_NMEA];
|
||
uint8_t nb; // Nb d'entrées trouvées comme étant affectées (à des batteries, à des capteurs,...)
|
||
// NB : il n'y a pas besoin de séquenceur car l'état des entrées NMEA est remonté automatiquement par le Compagnon via des commandes UP.
|
||
};
|
||
struct Struct_entrees_ow
|
||
{
|
||
struct Struct_entree_ow entrees[MAX_NOMBRE_ENTREES_OW];
|
||
uint8_t defaut_bus; // Etat du bus OW dans son ensemble : 0 = Ok, 1 = défaut (a priori, CC)
|
||
uint8_t nb; // Nb d'entrées trouvées comme étant affectées (à des capteurs,...)
|
||
struct Struct_device_ow devices[MAX_NOMBRE_DEVICES_OW]; // Utilisé essentiellement au démarrage pour stocker le retour d'annuaire OW du Compagnon (Rom_code des devices physiquement présents)
|
||
uint8_t nb_devices;
|
||
bool flag_maj_annuaire_en_cours; // Positionné par Systeme.c et RAZ par la fonction 'enregistrement_annuaire_ow()'
|
||
bool flag_premieres_valeurs_recues; // Initilisé à 0. Mis à TRUE par la première réception de valeurs OW depuis le Compagnon.
|
||
};
|
||
struct Struc_entrees_predefinies
|
||
{
|
||
struct Struct_entree_predefinie entrees[MAX_NOMBRE_ENTREES_PREDEFINIES];
|
||
uint8_t nb; // Nb d'entrées trouvées comme étant affectées (à des batteries, à des capteurs,...)
|
||
};
|
||
struct Struct_entrees_core
|
||
{
|
||
struct Struct_entree_core entrees[MAX_NOMBRE_ENTREES_CORE];
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
struct Struct_entrees_gpio
|
||
{
|
||
struct Struct_entree_gpio entrees[MAX_NOMBRE_ENTREES_GPIO];
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
struct Struct_entrees
|
||
{
|
||
struct Struct_entrees_aux aux;
|
||
struct Struct_entrees_level_sensor level_sensor;
|
||
struct Struct_entrees_volt volt;
|
||
struct Struct_entrees_nmea nmea;
|
||
struct Struct_entrees_ow ow;
|
||
struct Struc_entrees_predefinies predefinies;
|
||
struct Struct_entrees_core core;
|
||
struct Struct_entrees_gpio gpio;
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Events.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_condition_horaire
|
||
{
|
||
bool flag_validite;
|
||
uint8_t jour; // [jour] de 1 (lundi) à 7 (dimanche) ou 8 (tous les jours)
|
||
uint8_t heure; // [heure] de 0 à 23, 24 (fin de nuit), 25 (aube nautique), 26 (aube), 27 (lever du soleil), 28 (zénith), 29 (coucher du soleil), 30 (crépuscule), 31 (crépuscule nautique) ou 32 (début de nuit)
|
||
uint8_t minute; // [minute] entre 00 et 59 (ignorée si [heure] est > 23)
|
||
};
|
||
struct Struct_condition_test
|
||
{
|
||
bool flag_validite;
|
||
uint8_t type_source; // 0=condition horaire seule, 1=circuit, 2=capteur, 3=réservoir, 4=batterie.
|
||
uint16_t no_source; // N° de la source dans la structure correspondante (équivalent de la clé_primaire mais pointe directement sur l'entrée de la structure dans l'appli)
|
||
uint8_t no_variable; // N° de la variable du type concerné (entre 0 et MAX_NOMBRE_VARIABLES_PAR_xxxxxx)
|
||
uint8_t test; // 0=Non défini, >0=Déclenche si la valeur du capteur devient : 1=strictement inférieure au seuil, 2=inférieure ou égale au seuil, 3=égale au seuil, 4=supérieure ou égale au seuil, 5= strictement supérieure au seuil.
|
||
float seuil; // Valeur, exprimée en unités de l'ID_Variable.
|
||
bool etat_test; // Contient l'état actuel du résultat du test (évalué toutes les 100ms)
|
||
};
|
||
struct Struct_conditions_horaires
|
||
{
|
||
uint16_t nb; // Nombre de conditions horaires configurées pour cet event
|
||
struct Struct_condition_horaire conditions[MAX_NOMBRE_CONDITIONS_HORAIRES_PAR_EVENT]; // Infos des conditions horaires de l'event
|
||
};
|
||
struct Struct_action_circuit
|
||
{
|
||
bool flag_validite;
|
||
uint16_t no_circuit;
|
||
int8_t action; // -2=Aucune action, -1=toggle, 0-100=consigne
|
||
};
|
||
|
||
struct Struct_action_circuits
|
||
{
|
||
struct Struct_action_circuit action[MAX_NOMBRE_ACTION_CIRCUITS_PAR_EVENT];
|
||
uint16_t nb; // Nombre d'actions sur circuits utilisées sur cet event (nb : il est possible qu'à l'intérieur de ce Nb, certaines actions soient dévalidées)
|
||
};
|
||
|
||
struct Struct_event
|
||
{
|
||
bool flag_validite; // Indique si l'event est valide ou pas
|
||
uint16_t cle_primaire; // Valeur de Clé Primaire dans TB_Events
|
||
uint8_t compteur_diviseur_gestion; // Si > 0, décrémenté à chaque fin de EVENTS_PERIODE_CHECK. Si = 0, traitement de 'gestion_event()' et rechargement avec 'diviseur_ecces'
|
||
uint8_t diviseur_gestion; // Exprimé en multiples de EVENTS_PERIODE_CHECK (100ms). Permet de ralentir le traitement de cet event, si besoin. 0=pas de division
|
||
|
||
uint16_t tempo; // Temporisation, en secondes. Il faut que le test soit positif de façon permanente pendant cette durée pour que l'event soit déclenché.
|
||
|
||
struct Struct_conditions_horaires conditions_horaires; // Infos des conditions horaires de l'event
|
||
struct Struct_condition_test condition_test; // Infos de test de l'event (il n'y en a qu'une par event)
|
||
|
||
uint8_t alarme_son; // 0=pas d'alarme, 1=alarme
|
||
uint8_t alarme_led; // 0=pas d'alarme, 1=alarme
|
||
uint8_t alarme_soutien; // 0=pas d'alarme, 1=alarme
|
||
uint8_t alarme_source; // 0=pas d'alarme, 1=alarme
|
||
uint8_t alarme_sms; // 0=pas d'alarme, 1=alarme
|
||
uint8_t alarme_email; // 0=pas d'alarme, 1=alarme
|
||
uint8_t alarme_message; // 0=pas d'alarme, 1=alarme
|
||
|
||
struct Struct_action_circuits action_circuits; // Infos des actions sur circuit de l'évènement
|
||
|
||
bool flag_dde_maj_bdd; // Permet d'indiquer à 'synchro_bdd.c' qu'une mise à jour deans la BDD est nécessaire
|
||
struct Struct_sequenceur sequenceur; // Séquenceur spécifique à l'évènement
|
||
};
|
||
|
||
|
||
struct Struct_events
|
||
{
|
||
struct Struct_event events[MAX_NOMBRE_EVENTS];
|
||
uint16_t nb; // Nombre d'évènements actuellement utilisés (permet de restreindre de MAX_NOMBRE_EVENTS à 'nb' les traitements)
|
||
|
||
uint8_t compteur_diviseur_conditions_horaires; // Permet de ne traiter les conditions horaires qu'un sous-multiple de EVENTS_PERIODE_CHECK
|
||
uint8_t derniere_minute_traitee; // Contient la valeur de la dernière minute traitée. Permet de n'effectuer une analyse des condtions horaires qu'une fois par minute.
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Fonctions.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_supervision_boucle_principale
|
||
{
|
||
int attente_premieres_mesures; // Permet de décaler le démarrage des mesures pour éviter les aléas de démarrage (notamment pour la valeur MIN)
|
||
time_t last_second; // Stocke la valeur de la dernière seconde lue (c'est à son changement qu'on met à zéro les compteurs)
|
||
int nb_en_cours; // Contient le nb de boucles en cours de comptage
|
||
int nb_boucles; // Nombre de boucles principales exécutées sur la dernière seconde.
|
||
int nb_secondes; // Indique le nombre de secondes correspondant au comptage dans 'nb_boucles' (permet de moyenner)
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// G_bus :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_commande_g_bus
|
||
{
|
||
uint8_t cde[G_BUS_MAX_TAILLE_CDE]; // Contient la commande complète à émettre ou reçue
|
||
uint16_t code; // Code de la commande (mis à jour automatiquement pour les commandes ASCII)
|
||
uint16_t lg_cde; // Contient la longueur de la commande
|
||
uint16_t priorite; // Défini la priorité (uniquement pour le Down)
|
||
uint8_t mode_protocole; // Précise comment le protocole va devoir traiter la commande (avec ou sans CR de fin par exemple) et/ou la réponse (si une réponse doit est attendue ou pas, par exemple)
|
||
uint16_t time_out; // Défini le time-out à utiliser pour cette commande (si 0, valeur par défaut de M-Bus)
|
||
int8_t max_repetitions; // Nombre maxi de répétitions pour l'échange en cours (si -1, valeur par défaut de M-Bus)
|
||
};
|
||
struct Struct_reponse_g_bus
|
||
{
|
||
uint8_t reponse[G_BUS_MAX_TAILLE_REPONSE]; // Contient la réponse complète reçue
|
||
uint8_t classe; // Valeur de CLASS reçue
|
||
uint8_t id; // Valeur d'ID reçue
|
||
uint16_t lg_reponse; // Contient la longueur de la réponse
|
||
uint16_t lg_reponse_attendue; // Contient le nombre d'octets qui sont attendus dans la réponse
|
||
uint8_t ck_a_attendu; // Contient l'octet A du CS attendu (en pratique, cette valeur est calculée au fil des réception et, comme celle-ci peut être exécutée en plusieurs appels de séquenceur, est stockée en variable globale)
|
||
uint8_t ck_b_attendu; // Contient l'octet B du CS attendu (en pratique, cette valeur est calculée au fil des réception et, comme celle-ci peut être exécutée en plusieurs appels de séquenceur, est stockée en variable globale)
|
||
uint8_t ck_a_recu; // Valeur de CK_A reçue
|
||
uint8_t ck_b_recu; // Valeur de CK_B reçue
|
||
uint8_t etat; // Indique l'état dans lequel se trouve le décodage de la commande
|
||
};
|
||
struct Struct_protocole_g_bus
|
||
{
|
||
uint8_t repetitions; // Contient le nombre de répétitions effectuées sur la commande en cours (en mode Tx)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur du protocole
|
||
};
|
||
struct Struct_g_bus_down
|
||
{
|
||
struct Struct_commande_g_bus buffer_cdes[G_BUS_MAX_TAILLE_BUFFER_CDES]; // Buffer tournant contenant les commandes en attente d'émission sur le G_Bus Down
|
||
uint16_t ptr_debut_buffer_cdes; // Indique la position de la prochaine commande à émettre
|
||
uint16_t ptr_fin_buffer_cdes; // Indique la position de la dernière commande en attente d'émission
|
||
bool flag_attente_reponse; // Indique qu'une commande a été envoyée et qu'aucune trame de réponse n'a encore été obtenue
|
||
struct Struct_reponse_g_bus reponse; // Structure contenant la réponse à la dernière commande émise
|
||
};
|
||
struct Struct_g_bus
|
||
{
|
||
uint8_t nb_refus_buffer; // Indique le nombre de refus CONSECUTIFS de nouvelle commande dans le buffer G-Bus
|
||
struct Struct_g_bus_down down; // Structure rassemblant les variables de gestion du bus descendant
|
||
struct Struct_protocole_g_bus protocole_rx; // Contient les informations de gestion du protocole en réception (donc reçoit les réponses aux commandes Down)
|
||
struct Struct_protocole_g_bus protocole_tx; // Contient les informations de gestion du protocole en émission (donc émet les commandes Down)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau du M-Bus
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Gnss.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_gnss
|
||
{
|
||
uint8_t etat; // Indique si les dernières acquisitions sont Ok (ON) ou non valides (Off)
|
||
uint16_t repetitions; // Utilisé pour l'attente de changement de status du modem au démarrage
|
||
uint32_t compteur_cycles_gnss; // Utilisé pour calculer le nombre de cycles successifs de lecture GNSS
|
||
uint32_t compteur_cycles_valides_gnss; // Utilisé pour calculer le nombre de cycles valides de lecture GNSS
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau du M-Bus
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Hardware.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_hardware
|
||
{
|
||
volatile uint32_t *gpio_base; // Attention, VOLATILE est impératif (permet de forcer le compilateur à ne PAS optimiser et donc à conserver tous les accès demandés)
|
||
uint32_t offset_gpio_out_set_0;
|
||
uint32_t offset_gpio_out_set_1;
|
||
uint32_t offset_gpio_out_clear_0;
|
||
uint32_t offset_gpio_out_clear_1;
|
||
uint32_t offset_gpio_pin_level_0;
|
||
uint32_t offset_gpio_pin_level_1;
|
||
|
||
int16_t dizaines_ms; // Utilisé pour générer les périodes de 100ms = 10 x dizaines_ms et les périodes de 1s = 100 x dizaines_ms.
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// M_bus :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_commande_m_bus
|
||
{
|
||
uint8_t cde[M_BUS_MAX_TAILLE_CDE]; // Contient la commande complète à émettre ou reçue
|
||
uint16_t code; // Code de la commande (mis à jour automatiquement pour les commandes ASCII)
|
||
uint16_t lg_cde; // Contient la longueur de la commande
|
||
uint16_t priorite; // Défini la priorité (uniquement pour le Down)
|
||
uint8_t mode_protocole; // Précise comment le protocole va devoir traiter la commande (avec ou sans CR de fin par exemple) et/ou la réponse (si une réponse doit est attendue ou pas, par exemple)
|
||
uint16_t time_out; // Défini le time-out à utiliser pour cette commande (si 0, valeur par défaut de M-Bus)
|
||
int8_t max_repetitions; // Nombre maxi de répétitions pour l'échange en cours (si -1, valeur par défaut de M-Bus)
|
||
};
|
||
struct Struct_reponse_m_bus
|
||
{
|
||
uint8_t reponse[M_BUS_MAX_TAILLE_REPONSE]; // Contient la réponse complète reçue
|
||
uint16_t lg_reponse; // Contient la longueur de la réponse
|
||
uint16_t lg_reponse_attendue; // Contient le nombre d'octets qui sont attendus dans la réponse (utilisé en mode FLUX_BINAIRE)
|
||
uint8_t etat; // Indique l'état dans lequel se trouve le décodage de la commande
|
||
};
|
||
struct Struct_protocole_m_bus
|
||
{
|
||
uint8_t repetitions; // Contient le nombre de répétitions effectuées sur la commande en cours (en mode Tx)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur du protocole
|
||
};
|
||
struct Struct_m_bus_down
|
||
{
|
||
struct Struct_commande_m_bus buffer_cdes[M_BUS_MAX_TAILLE_BUFFER_CDES]; // Buffer tournant contenant les commandes en attente d'émission sur le M_Bus Down
|
||
uint16_t ptr_debut_buffer_cdes; // Indique la position de la prochaine commande à émettre
|
||
uint16_t ptr_fin_buffer_cdes; // Indique la position de la dernière commande en attente d'émission
|
||
bool flag_attente_reponse; // Indique qu'une commande a été envoyée et qu'aucune trame de réponse n'a encore été obtenue
|
||
struct Struct_reponse_m_bus reponse; // Structure contenant la réponse à la dernière commande émise
|
||
};
|
||
struct Struct_m_bus
|
||
{
|
||
uint8_t nb_refus_buffer; // Indique le nombre de refus CONSECUTIFS de nouvelle commande dans le buffer M-Bus
|
||
struct Struct_m_bus_down down; // Structure rassemblant les variables de gestion du bus descendant
|
||
struct Struct_protocole_m_bus protocole_rx; // Contient les informations de gestion du protocole en réception (donc reçoit les réponses aux commandes Down)
|
||
struct Struct_protocole_m_bus protocole_tx; // Contient les informations de gestion du protocole en émission (donc émet les commandes Down)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau du M-Bus
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Main.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Modem.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_sms
|
||
{
|
||
uint8_t index; // Contient l'index du SMS dans le modem (a priori, de 0 à 24)
|
||
char numero_emetteur[MODEM_MAX_TAILLE_NUMERO_EMETTEUR_SMS];
|
||
char date[MAX_LONGUEUR_DATE_COURANTE];
|
||
char message[MODEM_MAX_TAILLE_MESSAGE_SMS];
|
||
};
|
||
|
||
struct Struct_http
|
||
{
|
||
int8_t etat; // 0 au repos, 1= lancement demandé, 2= échange HTTP en cours
|
||
bool flag_https; // Indique si l'échange est à faire en HTTP (0) ou HTTPS (1)
|
||
char token[(2 * MAX_LONGUEUR_TOKEN_SHA256) + 1]; // Utilisé pour s"identifier lors de toutes les connexions HTTP
|
||
char url[MAX_LONGUEUR_URL]; // Nom de l'URL à utiliser pour la connexion (attention : sans la requête éventuelle)
|
||
char requete[MAX_LONGUEUR_REQUETE_HTTP]; // Nom de la requête à envoyer au serveur
|
||
char nom_repertoire_destination[MAX_LONGUEUR_NOM_REPERTOIRE_LOCAL]; // Nom du répertoire sur lequel le fichier sera téléchargé
|
||
char nom_fichier_destination[MAX_LONGUEUR_NOM_FICHIER]; // Nom du fichier qui sera créé à destination
|
||
FILE *ptr_fichier_destination; // Stocke le pointeur de fichier correspondant au fichier downloadé
|
||
uint32_t no_paquet; // Permet de suivre le n° du paquet en cours de transmission (0=premier paquet du fichier)
|
||
uint32_t taille_fichier_local; // Contient le nombre d'octets lus dans le fichier local une fois l'upload effectué
|
||
uint32_t taille_fichier_serveur; // Contient le nombre d'octets du fichier présent sur le serveir FTP distant avant le download
|
||
uint8_t buffer[MAX_TAILLE_BUFFER_DOWNLOAD]; // Stocke le buffer en cours de réception
|
||
uint32_t lg_buffer; // Indique la longueur utile du buffer
|
||
|
||
int32_t status_connexion; // Contient le dernier status retourné par les fonctions de SHCONN de connexion au serveur (0= inconnu, -1=erreur, 1=connecté)
|
||
int32_t status_get; // Contient le dernier status retourné par les fonctions de GET REQ (en général, '200' est la valeur sans erreur ; entre 100 et 505)
|
||
uint32_t taille_retour_get; // Contient la taille du retour de requête, tel que retourné par le serveur.
|
||
uint32_t taille_buffer_rx; // Contient la taille du buffer tel que renvoyée par le modem et qui va être reçue.
|
||
};
|
||
|
||
struct Struct_modem
|
||
{
|
||
uint8_t consigne; // Indique si l'état demandé pour le modem est activé (1) ou désactivé (0)
|
||
uint8_t etat; // Indique si le modem est activé (1) ou pas (0)
|
||
uint8_t etat_liaison; // Indique si la liaison a été établie avec le modem (notamment la liaison série avec l'AUTOBAUD)
|
||
uint8_t etat_4g_lte; // Indique si le réseau est activé ou pas (via CNACT=1 notamment)
|
||
uint8_t etat_presence_sim; // Indique si la carte est présente (1) ou absente (0)
|
||
uint32_t max_taille_ftp_put; // Valeur retournée par la commande AT+FTPPUT=1 et qui indique la taille maxi du prochain put qui sera fait
|
||
uint16_t repetitions; // Utilisé pour l'attente de changement de status du modem au démarrage
|
||
struct Struct_http http; // Contient les éléments de la connexion HTTP en cours
|
||
struct Struct_sms sms_en_cours; // Contient les éléments du SMS en cours de réception
|
||
uint32_t compteur_periode_gnss; // Utilisé pour calculer à quel moment lancer une acquisition sur le GNSS
|
||
uint32_t compteur_cycles_gnss; // Utilisé pour calculer le nombre de cycles successifs de lecture GNSS
|
||
uint32_t compteur_cycles_valides_gnss; // Utilisé pour calculer le nombre de cycles valides de lecture GNSS
|
||
uint32_t compteur_periode_upload; // Utilisé pour calculer à quel moment lancer une vérification d'upload (est-ce qu'il y a des fichiers à uploader sur le serveur)
|
||
uint32_t compteur_periode_download; // Utilisé pour calculer à quel moment lancer une recherche des fichiers à downloader depuis le serveur
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau du M-Bus
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Nmea.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_pgn_nmea
|
||
{
|
||
uint32_t pgn;
|
||
bool flag_validite;
|
||
bool flag_presence;
|
||
int8_t actif; // si 0, on ne traite que le timestamp. Si 1 : on traite les données à chaque réception (sous réserve de la période mini pour calmer le jeu). Si -1, on ne traite rien du tout (car le PGN n'est pas dans le catalogue NMEA)
|
||
int8_t type; // L'une des valeurs dans 'nmea.h' déterminée par la catalogue NMEA2000.
|
||
uint16_t periode_mini; // En x100ms. Déterminée par la catalogue NMEA2000.
|
||
uint8_t priority; // De 0 à 7
|
||
uint8_t source; // De 0 à 253 normalement (254 = adresse NULL et 255 = broadcast, pas utilisé en Source)
|
||
uint32_t timestamp; // Timestamp de la dernière mise à jour.
|
||
uint8_t lg_data; // Entre 0 et NMEA_MAX_TAILLE_DATA_PGN = 223
|
||
uint8_t data[NMEA_MAX_TAILLE_DATA_PGN]; // Attention : la valeurs au-delà de 'lg_data' ne sont pas garanties...
|
||
};
|
||
struct Struct_entree_catalogue_pgn_nmea {
|
||
uint32_t pgn;
|
||
int8_t type; // -1: INCONNU, 0: SYSTEM_SINGLE_FRAME, 1: SYSTEM_FAST_PACKET, 2:DEFAULT_SINGLE_FRAME, 3: MANDATORY_FAST_PACKET, 4: DEFAULT_FAST_PACKET, 5: PROPRIETARY_FAST_PACKET
|
||
uint16_t periode_mini; // En x100ms
|
||
int8_t (*fonction_parse_pgn)(uint16_t rang, uint8_t mode); // Le 'rang' est l'indice dans 'nmea.annuaire[]' ; le 'mode' est l'une des valeurs définies dans 'nmea.h' (0: Création, 1: mise à jour, 2: suppression)
|
||
};
|
||
struct Struct_nmea
|
||
{
|
||
struct Struct_pgn_nmea annuaire[NMEA_MAX_NOMBRE_PGN]; // Stocke tous les PGN tels qu'envoyés par le Compagnon. C'est ensuite le rôle de nmea.c de traiter une nouvelle valeur d'un PGN pour mettre à jour TB_Nmea2000 avec tous les champs que contient ce PGN.
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de plus haut niveau
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Reseaux.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_wifi_sta
|
||
{
|
||
int8_t cde; // Indique si le mode STA est actif (1) ou pas (0). La valeur -1 est utilisée au moment de l'init pour forcer une mise à jour.
|
||
char ssid[MAX_RESEAUX_WIFI_STA_TAILLE_SSID]; // Le nom du réseau Wifi auquel se connecter.
|
||
char bssid[MAX_RESEAUX_WIFI_STA_TAILLE_BSSID]; // L'adresse MAC du réseau Wifi auquel se connecter
|
||
char psk[MAX_RESEAUX_WIFI_STA_TAILLE_PSK]; // Mot de passe (Pres-Shared Key) du réseau Wifi auquel se connecter
|
||
char adresse_ip[TAILLE_ADRESSE_IP]; // Adresse IP de la liaison Wifi en mode STA sur le réseau du bord.
|
||
bool flag_dde_scan; // Positionné à vrai dès que TB_Configuration.Wifi_new_config == 2
|
||
};
|
||
struct Struct_wifi_ap
|
||
{
|
||
int8_t cde; // Indique si le mode AP est actif (1) ou pas (0). La valeur -1 est utilisée au moment de l'init pour forcer une mise à jour.
|
||
char ssid[MAX_RESEAUX_WIFI_AP_TAILLE_SSID]; // Le nom du réseau Wifi généré. Entre 0 et 32 caractères.
|
||
char pwd[MAX_RESEAUX_WIFI_AP_TAILLE_PWD]; // Mot de passe (Passphrase). Entre 8 et 63 caractères ASCII.
|
||
uint8_t canal; // Le numero de canal à utiliser. Valeur de 1 à 140 voire plus selon la version de ShipBase
|
||
char adresse_ip[TAILLE_ADRESSE_IP]; // Adresse IP de ShipBase sur le réseau Wifi ShipHeart
|
||
};
|
||
struct Struct_wifi
|
||
{
|
||
bool flag_new_config; // Positionné à vrai dès que TB_Configuration.Wifi_new_config == 1
|
||
struct Struct_wifi_sta sta;
|
||
struct Struct_wifi_ap ap;
|
||
};
|
||
struct Struct_ethernet
|
||
{
|
||
char adresse_ip[TAILLE_ADRESSE_IP]; // Adresse IP de la liaison ethernet sur le réseau du bord.
|
||
};
|
||
struct Struct_webgl
|
||
{
|
||
uint8_t validite; // 0: l'accès webGL est dévalidé, 1: l'accès est validé
|
||
char parametres[MAX_LONGUEUR_PARAMETRES_WEBGL]; // Chaine de caractères correspondant au lacement du process WebGL à faire (exemple : "-platform webgl:port=8081:wsserverport=8082")
|
||
};
|
||
struct Struct_reseaux
|
||
{
|
||
uint32_t compteur_check_adresses_ip;
|
||
uint32_t periode_check_adresses_ip; // Copie de TB_Configuration.Periode_check_adresses_ip
|
||
uint32_t compteur_connexion_ship2net;
|
||
uint32_t periode_connexion_ship2net; // Copie de TB_Configuration.Periode_connexion_ship2net
|
||
uint32_t compteur_scan_sta;
|
||
uint32_t periode_scan_sta; // Copie de TB_Configuration.Periode_scan_wifi_sta
|
||
uint16_t time_out_scan_sta; // Compteur décrémenté chaque TEMPO_ATTENTE_BOUCLE_SCAN_WIFI_STA (a priori,1s) qui permet de gérer le time-out de relecture du fichier de résultat du scan
|
||
struct Struct_wifi wifi_new; // Utilisé pour stocker temporairement les valeurs reçues via la BDD
|
||
struct Struct_wifi wifi;
|
||
struct Struct_ethernet ethernet;
|
||
uint32_t compteur_check_webgl;
|
||
struct Struct_webgl webgl_new[MAX_NOMBRE_PROCESS_WEBGL];
|
||
struct Struct_webgl webgl[MAX_NOMBRE_PROCESS_WEBGL];
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Réservoirs.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_reservoir
|
||
{
|
||
uint16_t cle_primaire; // Valeur de Clé Primaire dans TB_Reservoirs
|
||
bool flag_validite;
|
||
int8_t etat_systeme; // 0: fonctionnement normal, -1: incohérence dans la config, -2: module physique affecté non disponible (absent ou type incompatible)
|
||
|
||
uint8_t adresse_module; // Indique l'adresse du module sur laquelle sont positionnées les entrées du réservoir (entre 0 et MAX_NOMBRE_MODULES-1).
|
||
uint8_t type_entrees; // '0=Non défini, 1=Entrée Auxiliaire, 2=Entrée Level Sensor, 3= Voltage Input, 4=entrée OW, 5=Prédéfni, 7=Nmea, 8=Can (ou J1939), 20=Booléen calculé, 21=numérique calculé. Les autres valeurs sont invalides.
|
||
uint16_t no_entrees[MAX_NOMBRE_ENTREES_PAR_RESERVOIR]; // Stocke les numéros de 'entrees.aux/level_sensor.entrees[]' selon Type_entrée.
|
||
uint8_t nb_entrees; // Précise le nombre de valeurs utiles dans 'no_entrees[]'
|
||
|
||
float valeur_brute; // Contient la valeur brute du ou des capteurs du réservoir. SDIR #288
|
||
uint8_t etat_entrees; // 0=Ok, 1=Electrodes plongées dans le désordre
|
||
uint8_t niveau_coeff_filtrage; // Image du champs 'Niveau_coeff_filtrage' dans TB_Reservoirs
|
||
float niveau_seuil_haut; // Exprimé en centième de pourcentage, entre 0.00 et 100.00%. Ce seuil est utilisé pour l'affichage, pour l'historique et les alertes.
|
||
float niveau_seuil_bas; // Exprimé en centième de pourcentage, entre 0.00 et 100.00%. Ce seuil est utilisé pour l'affichage, pour l'historique et les alertes.
|
||
struct Struct_valeur_niveau liste_valeurs_niveaux[MAX_NOMBRE_VALEURS_NIVEAUX_RESERVOIRS]; // Contient des couples '[valeur]/[niveau]'. Le 'Niveau' du réservoir est calculé par extrapolation linéaire entre les deux points dont la 'valeur' est la plus proche de la Valeur actuelle du réservoir.
|
||
int8_t logique; // Par défaut, les alertes sont déclenchées lors du dépassement des seuils du haut vers le bas (Logique=-1). En passant à Logique=1, le principe est inversé ; les alertes sont alors déclenchées lors du dépassement du bas vers le haut. Si Logique=0, la zone normale est située entre le seuil bas et le seuil haut. Ce sont les dépassements au-dessous du seuil bas ou au-dessus du seuil haut qui déclenchent une alerte.
|
||
uint8_t mode_enregistrement_mesures; // 0:aucun enregistrement de mesures pour ce capteur, 1: enregistrement de la valeur du capteur lors de ses changements d'état, 2: enregistrement périodique de la valeur du capteur indépendamment de ses changements d'état, 3: enregistrement périodique ET sur changement d'état
|
||
uint8_t mode_enregistrement_historique; // 0:l'enregistrement dans l'historique des changements d'état du capteur ne sont pas réalisées, 1: les changements d'état du capteur sont enregistrées dans l'historique
|
||
|
||
struct Struct_variables variables[MAX_NOMBRE_VARIABLES_RESERVOIRS]; // Différentes valeurs de chaque variable du réservoir
|
||
uint16_t cumuls_nb_val; // Nombre d'échantillons stockés sur la période (identique pour toutes les variables qui sont cumulés dans des cumuls séparés mais en même temps)
|
||
|
||
bool flag_dde_maj_bdd; // Est utilisé pour signaler qu'un UPDATE de l'état de la BDD est nécessaire (RAZ dans Gestion_bdd.c)
|
||
struct Struct_sequenceur sequenceur; // Séquenceur de gestion du capteur.
|
||
};
|
||
|
||
struct Struct_reservoirs
|
||
{
|
||
struct Struct_variable variables[MAX_NOMBRE_VARIABLES_RESERVOIRS];
|
||
struct Struct_reservoir reservoirs[MAX_NOMBRE_RESERVOIRS];
|
||
uint16_t nb; // Nb de réservoirs détectés dans 'bdd_init()'. Permet de réduite les boucles en exploitation à ce nombre plutôt que jusqu'à MAX_NOMBRE_RESERVOIRS. Attention : tous les réservoirs dont le rang est < nb ne sont pas forcément valides.
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Serial.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_config_serial
|
||
{
|
||
int8_t validite; // -1=l'UART n'est pas modifié, 0=l'UART est arrêté, 1=l'UART est activé (avec les paramètres de config suivants)
|
||
int32_t vitesse; // Contient la vitesse, en b/s
|
||
int8_t longueur; // Longueur des mots (8, 7, 6 ou 5)
|
||
int8_t parite; // 0=aucune, 1=impaire, 2=paire
|
||
int8_t stops; // 1=1 bit, 2=2 bits
|
||
int16_t filestream; // Contient le n° de port après ouvertue
|
||
};
|
||
|
||
struct Struct_serial
|
||
{
|
||
uint8_t buffer_rx[MAX_TAILLE_RX_BUFFER_UART]; // Buffer tournant de réception des caractères reçus sur le port UART
|
||
uint16_t ptr_debut_buffer_rx; // Indique la position du prochain octet à lire
|
||
uint16_t ptr_fin_buffer_rx; // Indique la position du dernier octet à lire
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Sorties.c :
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_sortie_gpio
|
||
{
|
||
bool flag_validite; // FALSE=Non valide, TRUE=Valide
|
||
uint8_t no; // Indique le N° de l'E/S GPIO affectée (0 à 53)
|
||
int8_t logique; // 1:logique normale; -1:logique inverséee
|
||
uint8_t pull; // 0=Aucune, 1=PULL_DOWN, 2=PULL_UP
|
||
uint8_t valeur; // Etat de la sortie (ON/OFF)
|
||
};
|
||
struct Struct_sorties_gpio
|
||
{
|
||
struct Struct_sortie_gpio sorties[MAX_NOMBRE_SORTIES_GPIO];
|
||
};
|
||
struct Struct_sorties
|
||
{
|
||
struct Struct_sorties_gpio gpio;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Systeme.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_module_config
|
||
{
|
||
// Un module est identifiée par son 'adresse_module' dans la plupart des fonctions et dans les échanges avec le Compagnon.
|
||
// Ce numéro est l'adresse du module sur K_Bus (il n'y a donc pas de champs spécifique correspondant à cette adresse_k_bus).
|
||
// Ce numéro est compris entre 0 (ShipBase) et (MAX_NOMBRE_MODULES - 1).
|
||
// L'essentiel des champs ci-dessous correspondent à la table TB_Modules_config. La table TB_Modules_physiques sert essentiellement au démarrage pour vérifier la cohérence physique/config.
|
||
|
||
// Paramètres de configuration lus dans la BDD :
|
||
int8_t type; // Type de carte (0=Compagnon, 1=Sp812, 2=SBS, 3=SP4AC, 4=SP8DC).
|
||
float alim_tension_seuil_bas; // Indique, en V, la tension en-dessous de laquelle un défaut de type UNDER_VOLTAGE sera déclenché.
|
||
uint16_t id_batterie; // Contient la clé primaire de la batterie à laquelle la carte est connectée (utilisée pour ShipBase et les ShipPower8xx notamment). 0 si aucune batterie n'est définie.
|
||
float courant_maxi; // Valeur (en A) de courant maxi pour la carte (notamment SP8XX). Si =0, la fonction est dévalidée.
|
||
uint16_t courant_maxi_tempo; // Tempo à appliquer avant de délester un circuit de la carte pour cause de courant maxi. En secondes.
|
||
|
||
// Paramètres mis à jour par la fonction annuaire au démarrage :
|
||
bool flag_validite; // Indique si cette carte est valide (1) ou pas (0). Ce flag est mis à jour au démarrage : tous les modules présents dans TB_Modules_config ont ce flag à VRAI et tous les autres à FALSE.
|
||
bool flag_presence; // Indique si la carte est physiquement présente (1) ou pas (0)
|
||
bool flag_affecte; // Indique si le module est affecté à au moins un circuit, une batterie, un réservoir ou un capteur.
|
||
|
||
// Variables d'état reçues des cartes et mis à jour toutes les secondes dans la BDD (notamment via 'c_bus_up_commande_etat_carte()' ) :
|
||
uint8_t origine_reset; // Contient l'origine du dernier reset de la carte
|
||
uint8_t alim_cde; // Etat de la commande de l'alim (5V2 sur SBS)
|
||
uint8_t alim_etat; // Etat de l'alimentation (0=Normal, 1=Under-Voltage). Attention : concerne soit l'alimentation 12-24V (ShipBase, SP8DC) ou 5V (SBS).
|
||
float alim_valeur; // Valeur, en V, de la tension d'alimentation. Attention : concerne soit l'alimentation 12-24V (ShipBase, SP8DC) ou 5V (SBS).
|
||
uint8_t mode_test; // Indique la position actuelle du switch de mode test de la carte (0=Off, 1=On)
|
||
uint8_t etat_commande_carte; // Etat de la commande des circuits mis à jour par le logiciel à partir des informations d'état de la carte. 0=Normal, 1=Undervoltage, 2=Test
|
||
uint16_t courant_maxi_compteur; // Permet de mesurer le temps de défaut de courant maxi par carte. En secondes
|
||
float courant_masses; // Valeur (en A) de courant de masse actuel sur la carte (notamment SP8DC). SDIR #318
|
||
};
|
||
|
||
struct Struct_module_physique
|
||
{
|
||
// L'essentiel des champs ci-dessous correspondent à la table TB_Modules_physique et sont mise à jour au démarrage par l'appli en fonction des infos reçues depuis le Compagnon
|
||
int8_t type; // Type de carte (0=Compagnon, 1=Sp812, 2=SBS, 3=SP4AC, 4=SP8DC).
|
||
bool flag_presence; // Indique si la carte est physiquement présente (1) ou pas (0)
|
||
uint8_t hardware_unique_id[MAX_TAILLE_UNIQUE_ID]; // Contient l'ID unique du µC de la carte
|
||
uint16_t hardware_flash_size; // Contient la taille de la flash du µC (en ko)
|
||
uint8_t hardware_package; // Contient le type de boitier du µC (cf doc ST)
|
||
uint8_t hardware_version; // Contient la configuration matérielle de la carte (état des switches de config sur la carte)
|
||
char soft_type[MAX_TAILLE_TYPE_SOFT]; // Contient le type de logiciel de la carte
|
||
char soft_version[MAX_TAILLE_VERSION_SOFT]; // Contient la version de soft actuelle de la carte
|
||
uint32_t soft_crc; // Contient le CRC du soft actuellement exécuté
|
||
uint8_t adresse_mac[TAILLE_ADRESSE_MAC]; // Contient l'adresse MAC de la carte (provenant du boitier dédié soudé)
|
||
uint8_t eeprom[MAX_TAILLE_EEPROM]; // Contient une image (probablement partielle) de l'EEPROM de la carte. Chaque octet du tableau correspond à l'octet en EEPROM (le codage sur 2 caractères hexa est fait au moment du stockage dans la BDD). Permet d'échanger des paramètres de config stockées dans la carte avec QT (via Compagnon et l'appli).
|
||
uint8_t resistance_terminaison; // Indique si la résistance de terminaison est activée sur la carte (1) ou pas (0)
|
||
uint8_t maj_soft_disponible; // Indique si une mise à jour de logiciel a été chargée dans la carte et est disponible pour être activée. Utilisée dans le séquenceur 'gestion_chargement_carte()' (auparavant était stocké en BDD mais retiré en 02/2022)
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
struct Struct_fichier_download
|
||
{
|
||
char nom[MAX_LONGUEUR_NOM_FICHIER];
|
||
uint32_t taille_locale;
|
||
uint32_t taille_serveur;
|
||
bool flag_a_telecharger;
|
||
bool flag_a_supprimer;
|
||
};
|
||
struct Struct_download
|
||
{
|
||
char nom_repertoire_destination[MAX_LONGUEUR_NOM_REPERTOIRE_LOCAL]; // Nom du répertoire sur lequel le fichier sera uploadé
|
||
char nom_fichier_destination[MAX_LONGUEUR_NOM_FICHIER]; // Nom du fichier qui sera créé à destination
|
||
char nom_repertoire_source[MAX_LONGUEUR_NOM_REPERTOIRE_LOCAL]; // Nom du répertoire duquel le fichier sera uploadé
|
||
char nom_fichier_source[MAX_LONGUEUR_NOM_FICHIER]; // Nom du fichier à transférer
|
||
FILE *ptr_fichier_destination; // Stocke le pointeur de fichier correspondant au fichier downloadé
|
||
uint32_t no_paquet; // Permet de suivre le n° du paquet en cours de transmission (0=premier paquet du fichier)
|
||
uint32_t taille_fichier_local; // Contient le nombre d'octets lus dans le fichier local une fois l'upload effectué
|
||
uint32_t taille_fichier_serveur; // Contient le nombre d'octets du fichier présent sur le serveir FTP distant avant le download
|
||
uint8_t buffer[MAX_TAILLE_BUFFER_DOWNLOAD]; // Stocke le buffer en cours de réception
|
||
uint32_t lg_buffer; // Indique la longueur utile du buffer
|
||
uint64_t secondes_debut; // Contient le timestamp (secondes) du début du download. Est utilisé pour calculer le temps total de chargement
|
||
uint64_t secondes_fin; // Contient le timestamp (secondes) du fin du download. Est utilisé pour calculer le temps total de chargement
|
||
|
||
struct Struct_fichier_download liste_fichiers[MAX_NOMBRE_FICHIERS_DOWNLOAD]; // Contient la liste des fichiers à charger après la ecture du répertoire distant et comparaison avec le répertoire local
|
||
uint16_t nb_fichiers_liste; // Contient le nombre d'entrées valides dans la liste des fichiers
|
||
int16_t fichier_en_cours; // Contient le pointeur du fichier en cours de download dans 'liste_fichiers' (ou -1 si aucun n'est en cours)
|
||
|
||
int32_t status_get; // Contient le dernier status retourné par les fonctions de download (en général, '1' est la valeur sans erreur)
|
||
uint32_t taille_buffer_tx; // Contient la taille du buffer demandée en lecture
|
||
uint32_t taille_buffer_rx; // Contient la taille du buffer tel que renvoyée par le modem
|
||
};
|
||
|
||
struct Struct_json_version
|
||
{
|
||
char no_version[MAX_TAILLE_VERSION_SOFT]; // Contient la version du package. Par exemple : "1.0.7"
|
||
char updater[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier d'updater à utiliser. Par exemple : "updater_210722_171424.php"
|
||
char application[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier d'application à utiliser. Par exemple : "shipheart_appli_210719_180758"
|
||
char qt[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier d'application QT à utiliser. Par exemple : "shipheart_qt_210722_154703"
|
||
char compagnon[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier binaire du Compagnon à utiliser. Par exemple : "shipheart_compagnon_210716_191905.bin"
|
||
char sp812[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier binaire des SP812 à utiliser. Par exemple : "shipheart_sp812_210630_115719.bin"
|
||
char sbs[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier binaire des SBS à utiliser. Par exemple : "shipheart_sbs_210630_115719.bin"
|
||
char sp4ac[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier binaire des SP4AC à utiliser. Par exemple : "shipheart_sp4ac_210630_115719.bin"
|
||
char sp8dc[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier binaire des SP8DC à utiliser. Par exemple : "shipheart_sp8dc_230130_115719.bin"
|
||
char sql[MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier SQL à utiliser. Par exemple : "shipheart_sql_new.sql"
|
||
char force; // Contient l'état du flag Force du package.
|
||
char description[MAX_TAILLE_DESCRIPTION_PACKAGE]; // Contient la description du package. Exemple : "Version de test générée à la main"
|
||
};
|
||
|
||
|
||
struct Struct_chargement_code
|
||
{
|
||
char nom_fichier[MAX_NOMBRE_MODULES][MAX_LONGUEUR_NOM_FICHIER]; // Contient le nom du fichier à utiliser pour le prochain chargementsur cette carte (par exemple, 'ShipHeart_Compagnon.bin'). Si NULL, pas de chargement demandé pour cette carte.
|
||
uint32_t taille_fichier; // Contient le nombre d'octets du fichier
|
||
uint32_t crc_fichier; // Valeur de CRC indiquée en fin de fichier (mis là par le linker, juste après la création)
|
||
uint8_t adresse_module; // Adresse K-Bus du module concerné par le chargement. 0=Compagnon, >0 pour les cartes extensions
|
||
uint16_t no_bloc; // N° de bloc en cours de transfert
|
||
uint16_t taille_bloc; // Contient la taille du bloc en cours de transfert
|
||
uint32_t nb_transmis; // Indique le nombre d'octets transmis
|
||
bool flag_reponse; // Indique qu'une réponse à la dernière commande adressée au Compagnon a été reçue
|
||
uint8_t status_reponse; // Contient le code d'erreur retourné par le Compagnon à la dernière commande d'upload
|
||
uint8_t nb_repetitions; // Contient le nombre de répétitions en cours
|
||
uint32_t id_message_user; // Contient la clé primaire du message user en cours d'affichage et dont l'état est maintenu à jour lors du chargement...
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
struct Struct_upload
|
||
{
|
||
char nom_repertoire_destination[MAX_LONGUEUR_NOM_REPERTOIRE_LOCAL]; // Nom du répertoire sur lequel le fichier sera uploadé
|
||
char nom_fichier_destination[MAX_LONGUEUR_NOM_FICHIER]; // Nom du fichier qui sera créé à destination
|
||
char nom_repertoire_source[MAX_LONGUEUR_NOM_REPERTOIRE_LOCAL]; // Nom du répertoire duquel le fichier sera uploadé
|
||
char nom_fichier_source[MAX_LONGUEUR_NOM_FICHIER]; // Nom du fichier à transférer
|
||
FILE *ptr_fichier_source; // Stocke le pointeur de fichier correspondant au fichier à uploader
|
||
uint32_t ptr_debut; // Stocke la première position dans le fichier correspondant au début du buffer en cours d'émission
|
||
uint32_t ptr_fin; // Stocke la dernière position dans le fichier correspondant au début du buffer en cours d'émission
|
||
uint32_t no_paquet; // Permet de suivre le n° du paquet en cours de transmission (0=premier paquet du fichier)
|
||
uint32_t taille_theorique_fichier; // Taille lue du fichier à uploader
|
||
uint32_t taille_fichier_local; // Contient le nombre d'octets transmis depuis le début du transfert du fichier
|
||
uint32_t taille_fichier_serveur; // Contient le nombre d'octets du fichier présent sur le serveir FTP distant après l'upload
|
||
uint8_t buffer[MAX_TAILLE_BUFFER_UPLOAD]; // Stocke le buffer qui va être émis
|
||
uint32_t lg_buffer; // Indique la longueur utile du buffer
|
||
int32_t status_get_size; // Contient le statut de retour de la commande FTPSIZE (0 = OK, sinon code entre 61 et 80)
|
||
int8_t code_erreur_ftpput_data; // Contient le code d'erreur retourné après l'envoi des data dans une séquence FTPPUT (a priori, soit OK=0, soit ERROR=4)
|
||
uint8_t nb_repetitions; // Contient le nombre de répétitions en cours (utilisé lorsque'une erreur est détectée sur un bloc pour ne pas répéter ce bloc indéfiniement)
|
||
uint16_t nb_repetitions_total; // Contient le nb de répétitions de blocs effectuée sur l'ensemble de l'Upload du fichier (utilisé pour info en fin d'upload pour donner une idée de la qualité du transfert)
|
||
uint64_t secondes_debut; // Contient le timestamp (secondes) du début de l'upload. Est utilisé pour calculer le temps total de chargement
|
||
uint64_t secondes_fin; // Contient le timestamp (secondes) du fin de l'upload. Est utilisé pour calculer le temps total de chargement
|
||
};
|
||
|
||
struct Struct_faucheuse
|
||
{
|
||
int32_t signal_recu; // Stocke la valeur reçue par le handler de signaux
|
||
bool flag_demande_reinit; // Positionné lorsqu'une réinit a été décidé pour informer que ça ne va pas tarder... (équivalent à 'signal_reçu' mais interne)
|
||
uint32_t id_message_user; // Contient l'ID du message user utilisé pendant la phase d'arrêt du système
|
||
uint16_t compteur; // Est utilisé pour temporiser l'arrêt
|
||
};
|
||
struct Struct_compute_module
|
||
{
|
||
uint8_t overvoltage_allowed;
|
||
uint8_t otp_programming_allowed;
|
||
uint8_t otp_reading_allowed;
|
||
uint8_t warranty_bit;
|
||
uint8_t new_style_revision;
|
||
uint8_t memory_size;
|
||
uint8_t manufacturer;
|
||
uint8_t processor;
|
||
uint8_t type;
|
||
uint8_t revision;
|
||
char chaine_version[MAX_LONGUEUR_CHAINE_VERSION_CM]; // Contient la chaine de caractère qui est remontée après init dans TB_Systeme.Version_cm
|
||
};
|
||
struct Struct_systeme
|
||
{
|
||
char nom_bateau[MAX_LONGUEUR_NOM_BATEAU]; // Valeur image de TB_Configuration.Nom_du_bateau
|
||
float courant_masses_maxi_sp8dc; // Valeur image de TB_Configuration.Courant_masses_maxi_sp8dc. SDIR #318
|
||
|
||
int8_t fuseau_horaire; // Fuseau horaire, exprimé en heures par rapport à UTC. De -12.00 à +14.00
|
||
uint8_t heure_ete; // Offset sur le fuseau horaire. soit 0, soit +1
|
||
struct Struct_heure heures_speciales[MAX_HEURES_SPECIALES]; // Contient les heures spéciales du jour. Récupérées via la BDD des calculs faits par Qt. Cf liste dans 'events.h'.
|
||
|
||
uint8_t veille; // Indique si le système est en veille légère (1), profonde (2) ou pas en veille du tout (0)
|
||
struct Struct_module_config modules_config[MAX_NOMBRE_MODULES]; // Structure contenant, pour chaque module utilisé en config toutes les informations de configuration et d'état
|
||
struct Struct_module_physique modules_physiques[MAX_NOMBRE_MODULES]; // Structure contenant les informations de chaque module physiquement présent sur K-Bus
|
||
uint8_t mode_validation_maj; // Valeur de 'Mode_validation_maj' dans TB_COnfiguration. Indique comment les fichiers de mises à jour reçus du serveur doivent être traités. 0=aucune mise à jour (les fichiers reçus sont détruits), 1=validation manuelle de chaque mise à jour, 2= validation automatique des mises à jour.
|
||
uint8_t mode_maj_firmwares; //Indique comment les mise à jour du firmware des modules présents sur K-Bus doit être effectuée. 0=Normal : mise à jour si la version installée est antérieure à la version en cours. 1=Forçage si la version installée est différente de la version en cours (donc mise à jour même si la version installée est plus récente que la version en cours). 2=Forçage dans tous les cas (y compris si les deux versions sont identiques).
|
||
uint32_t periode_sauvegarde_bdd; // Valeur provenant de la BDD et indiquant la période (en secondes) à laquelle la BDD est sauvegardée (et donc uploadée vers le serveur)
|
||
bool flag_compagnon_ready; // Positionné à FALSE au démarrage, il est positionné à TRUE dès que le Compagnon est déclaré prêt à passer en opération normale
|
||
bool flag_cm3p_ready; // Positionné à FALSE au démarrage, il est positionné à TRUE dès que le CM3P est déclaré prêt à passer en opération normale
|
||
bool flag_new_download; // Positionné à TRUE (par 'modem.c') quand de nouveaux fichiers ont été downloadés du serveur. Permet à 'systeme.c' de lancer l'analyse de ces fichiers.
|
||
uint16_t compteur_sauvegarde_bdd; // En secondes
|
||
uint16_t compteur_check_new_download; // En secondes
|
||
uint32_t no_paquet; // N° du paquet en cours de constitution mais pas encore envoyé (issu de TB_Système au démarrage puis mis à jour à chaque envoi de paquet)
|
||
char cm3p_soft_version[MAX_TAILLE_VERSION_SOFT]; // Contient la version de soft de l'application
|
||
char package_version[MAX_TAILLE_VERSION_SOFT]; // Contient la version de package sous la forme 'AAMMJJ_HHMMSS'
|
||
char package_no_version[MAX_TAILLE_VERSION_SOFT]; // Contient le numéro de la version du package. Par exemple : "1.0.7"
|
||
uint8_t flag_r_term_etat_carte; // Si Vrai, considère que les flags de présence R_Term sont remontés dans les commandes 'etat_carte()' (compatibilité < 2.0.0). Si Faux (défaut), l'état des R_Term est remonté dans le retour d'annuaire K-Bus et pas dans etat_carte().
|
||
struct Struct_compute_module cm; // Contient les informations relatives au Compute Module
|
||
uint8_t generation_shipbase; // Mis à jour au démarrage en recherchant le type de CM installé => 0 = inconnue, 1=CM3+, 2=CM4
|
||
uint16_t entree_gpio_cm_di_from_uc; // Prend la valeur de CM3P_DI_FROM_UC ou CM4_DI_FROM_UC selon la génération de ShipBase
|
||
uint16_t sortie_gpio_cm_do_to_uc; // Prend la valeur de CM3P_DO_TO_UC ou CM4_DO_TO_UC selon la génération de ShipBase
|
||
struct Struct_sequenceur sequenceur;
|
||
struct Struct_faucheuse faucheuse; // Structure permettant la surveillance des signaux externes et la tempo en cas de demande de reset.
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------
|
||
// Usb.c
|
||
//---------------------------------------------------------------------------------------------
|
||
struct Struct_port_usb
|
||
{
|
||
bool flag_validite; // Indique si le port est valide (1) ou pas (0)
|
||
uint8_t no_entree_defaut; // Contient le n° d'entrée GPIO recevant le défaut du contrôleur
|
||
uint8_t defaut; // Indique si le port est Ok (0) ou en défaut (1)
|
||
};
|
||
struct Struct_usb
|
||
{
|
||
int16_t no_circuit_usb_avant; // Contient le n° du circuit utilisé pour piloter les ports USB de la face avant ou -1 si aucun circuit n'est associé.
|
||
int16_t no_circuit_usb_arriere; // Contient le n° du circuit utilisé pour piloter le port USB arrière ou -1 si aucun circuit n'est associé.
|
||
// uint8_t consigne_usb; // Indique si les ports doivent être alimentés (1) ou pas (0)
|
||
// uint8_t consigne_usb_arriere; // Indique si le port USB arriere doit être alimenté (1) ou pas (0)
|
||
uint16_t sortie_gpio_cm_do_usb_avant_pwr_en; // Prend la valeur de CM3P_DO_USBPWR_EN ou CM4_DO_USBPWR_EN selon la génération de ShipBase
|
||
uint16_t sortie_gpio_cm_do_usb_arriere_pwr_en; // Prend la valeur de CM4_DO_USB_ARRIERE_PWR_EN selon la génération de ShipBase (uniquement sur V2)
|
||
struct Struct_port_usb ports[USB_MAX_NOMBRE_PORTS];
|
||
struct Struct_sequenceur sequenceur;
|
||
};
|
||
|
||
|
||
// **********************************************************************************************************************************************************************************
|
||
// Prototypages :
|
||
// **********************************************************************************************************************************************************************************
|
||
|
||
// Audio.c :
|
||
extern void gestion_audio(void);
|
||
extern int8_t init_audio(void);
|
||
extern int8_t emission_bip(char * nom_fichier, uint16_t nb_repetitions, uint16_t periode_boucles, uint16_t nb_boucles);
|
||
extern int8_t set_volume(float volume, bool echo);
|
||
extern int8_t lecture_mp3(char * nom_fichier, uint16_t nb_repetitions);
|
||
|
||
// Batteries.c
|
||
extern int8_t init_batteries(void);
|
||
extern void gestion_batteries(void);
|
||
extern int16_t batterie_cle_primaire(uint16_t cle_primaire);
|
||
extern int16_t variable_batterie_cle_primaire(uint16_t cle_primaire);
|
||
|
||
// Bdd_admin.c :
|
||
extern int32_t sauvegarde_bdd(void);
|
||
extern int8_t archivage_bdd(char * chaine_date_fin, uint8_t type);
|
||
|
||
// Bdd_fonctions.c :
|
||
extern int8_t init_annuaire_nmea(void);
|
||
extern int8_t enregistrement_date_pgn_nmea(uint16_t rang);
|
||
extern int8_t creation_pgn_field_nmea(uint16_t rang, uint8_t field, char * code_unite, uint8_t precision_accueil, uint8_t precision_mesures, char * nom);
|
||
extern int8_t enregistrement_pgn_field_nmea(uint16_t rang, uint8_t field, float val);
|
||
extern int8_t suppression_pgn_nmea(uint16_t rang);
|
||
extern void maj_etat_cm3p(uint8_t etat);
|
||
extern int8_t enregistrement_annuaire_k_bus(void);
|
||
extern int8_t enregistrement_annuaire_ow(uint8_t nb_devices);
|
||
extern void enregistrement_eeprom(uint8_t adresse_module, uint16_t longueur);
|
||
extern void enregistrement_historique(uint8_t type_source, uint8_t type, uint16_t id_source, float valeur, char * complement);
|
||
extern void enregistrement_mesures(uint8_t mode);
|
||
extern void enregistrement_mesure(uint8_t type, uint16_t no, uint16_t no_variable, char str_date[MAX_LONGUEUR_DATE_COURANTE], uint8_t mode);
|
||
extern int32_t enregistrement_message_users(int32_t code, char * parametres, int8_t etat_demande);
|
||
extern int8_t maj_message_users(uint32_t id, char * parametres, int8_t etat_demande);
|
||
extern int8_t clear_scan_wifi_sta(void);
|
||
extern int8_t enregistrement_scan_wifi_sta(char * bssid, char * nom, uint8_t canal, uint8_t qualite);
|
||
extern int8_t nom_capteur_cle_primaire(uint16_t id, char * nom);
|
||
extern int8_t nom_circuit_cle_primaire(uint16_t id, char * nom);
|
||
|
||
// Bdd_init.c :
|
||
extern int8_t init_bdd(uint8_t mode_init);
|
||
|
||
// Bdd_synchro.c :
|
||
extern void synchro_bdd(void);
|
||
|
||
// C_bus.c
|
||
extern void gestion_c_bus(void);
|
||
extern void gestion_protocole_c_bus_down(void);
|
||
extern int8_t init_c_bus(void);
|
||
extern int8_t c_bus_next_write_buffer_cdes(uint8_t priorite);
|
||
|
||
// C_commandes.c
|
||
|
||
// Commandes Down :
|
||
extern int8_t c_bus_down_commande_config_date_heure(void);
|
||
extern int8_t c_bus_down_commande_config_carte(uint8_t adresse_module, uint8_t mode);
|
||
extern int8_t c_bus_down_commande_config_circuits(uint8_t adresse_module);
|
||
extern int8_t c_bus_down_commande_config_level_sensors(void);
|
||
extern int8_t c_bus_down_commande_config_ow(void);
|
||
extern int8_t c_bus_down_commande_config_batteries(uint8_t adresse_module);
|
||
extern int8_t c_bus_down_commande_config_pgn_nmea(uint16_t rang);
|
||
|
||
extern int8_t c_bus_down_commande_reset(void);
|
||
extern int8_t c_bus_down_commande_cde_backlight(float consigne_ecran, float consigne_leds);
|
||
extern int8_t c_bus_down_commande_cde_circuits(uint8_t adresse_module);
|
||
extern int8_t c_bus_down_commande_cde_carte(uint8_t adresse_module, uint8_t cde, uint8_t consigne);
|
||
|
||
extern int8_t c_bus_down_commande_lecture_date_heure(void);
|
||
extern int8_t c_bus_down_commande_lecture_id_carte(uint8_t adresse_module);
|
||
|
||
extern int8_t c_bus_down_commande_annuaire_k_bus(void);
|
||
extern int8_t c_bus_down_commande_chargement_code(uint8_t mode, uint8_t adresse_module);
|
||
extern int8_t c_bus_down_commande_annuaire_ow(void);
|
||
|
||
|
||
// Réponses Down :
|
||
extern int8_t c_bus_down_reponse_config_date_heure(void);
|
||
|
||
extern int8_t c_bus_down_reponse_cde_backlight(void);
|
||
|
||
extern int8_t c_bus_down_reponse_lecture_date_heure(void);
|
||
extern int8_t c_bus_down_reponse_lecture_id_carte(void);
|
||
|
||
extern int8_t c_bus_down_reponse_annuaire_k_bus(void);
|
||
extern int8_t c_bus_down_reponse_chargement_code(void);
|
||
extern int8_t c_bus_down_reponse_annuaire_ow(void);
|
||
|
||
extern int8_t c_bus_down_recherche_reponse(void);
|
||
|
||
|
||
// Commandes UP :
|
||
extern uint8_t c_bus_up_commande_etat_carte(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_circuits(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_entrees_aux(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_level_sensors(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_entrees_volt(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_entrees_ow(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_entrees_batteries(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_commande_etat_pgn_nmea(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
|
||
extern uint8_t c_bus_up_commande_inconnue(struct Struct_commande_c_bus * commande, struct Struct_reponse_c_bus * reponse);
|
||
extern uint8_t c_bus_up_recherche_commande(void);
|
||
|
||
// Capteurs.c
|
||
extern void gestion_capteurs(void);
|
||
extern int8_t init_capteurs(void);
|
||
extern int16_t capteur_cle_primaire(uint16_t cle_primaire);
|
||
extern int16_t variable_capteur_cle_primaire(uint16_t cle_primaire);
|
||
|
||
// Circuits :
|
||
extern void gestion_circuits(void);
|
||
extern void gestion_circuit(uint16_t no_circuit);
|
||
extern int8_t changement_consigne_circuit(uint16_t no_circuit, uint8_t consigne, uint8_t origine_consigne, uint16_t id_origine_consigne);
|
||
extern int8_t init_circuits(void);
|
||
extern int16_t circuit_cle_primaire(uint16_t cle_primaire);
|
||
extern int16_t variable_circuit_cle_primaire(uint16_t cle_primaire);
|
||
|
||
// Debug.c :
|
||
extern void clrscr(void);
|
||
extern void affichage_debug_bus(uint8_t bus, char * sens, char *commande, uint8_t output);
|
||
extern void affichage_debug(char *fichier, int ligne, char *message, char type);
|
||
extern void affichage_debug_creation_ligne(char * chaine, char *fichier, int ligne, char *message, char type);
|
||
extern int8_t init_affichage_debug(void);
|
||
extern void append_chaine_fichier(char * chaine, char * fichier);
|
||
extern char * nom_type_carte(uint8_t type);
|
||
|
||
// Ecran.c
|
||
extern int8_t set_luminosite_ecran(uint16_t luminosite);
|
||
extern void gestion_ecran(void);
|
||
extern int8_t init_ecran(void);
|
||
|
||
// Entrees.c
|
||
extern int16_t entree_cle_primaire(uint8_t type, uint16_t cle_primaire);
|
||
extern void gestion_entrees(void);
|
||
extern void gestion_entrees_gpio(void);
|
||
extern void gestion_entrees_core(void);
|
||
extern int8_t init_entrees(void);
|
||
extern int8_t init_entrees_gpio(void);
|
||
extern int8_t init_entrees_core(void);
|
||
extern float lecture_entree(uint8_t type, uint8_t module, uint8_t no, bool flag_immediat);
|
||
extern int16_t entree_no(uint8_t type, uint8_t module, uint8_t no);
|
||
extern uint8_t lecture_entree_gpio(uint8_t no, int8_t logique);
|
||
|
||
// Events.c
|
||
extern int8_t init_events(void);
|
||
extern void gestion_events(void);
|
||
|
||
// Fonctions.c
|
||
extern void date_courante(char* chaine, bool flag_ns, int format);
|
||
extern int8_t set_date_heure(struct Struct_date date, struct Struct_heure heure);
|
||
extern void delai_dixieme_sec(uint16_t tempo);
|
||
extern void delai_nano_sec(unsigned int tempo);
|
||
extern uint64_t timestamp_secondes(void);
|
||
extern int8_t tri_liste_valeurs_niveaux(struct Struct_valeur_niveau * liste, uint16_t taille_liste);
|
||
extern float calcul_niveau(struct Struct_valeur_niveau * liste, uint16_t taille_liste, float valeur);
|
||
extern float moyenne_mobile(float old_val, float new_val, uint16_t coefficient);
|
||
extern char * conversion_adresse_mac_chaine(uint8_t * adresse_mac, char * chaine, char separateur);
|
||
extern uint8_t * conversion_chaine_adresse_mac(char * chaine, uint8_t * adresse_mac);
|
||
extern char * conversion_rom_code_chaine(uint8_t * rom_code, char * chaine, char separateur);
|
||
extern char * conversion_unique_id_chaine(uint8_t * unique_id, char * chaine);
|
||
extern int32_t recherche_caractere_dans_chaine(char * chaine, char car, uint16_t debut);
|
||
extern char * chaine_minuscules(char * chaine);
|
||
|
||
// G_Bus.c :
|
||
extern int8_t init_g_bus(void);
|
||
extern void gestion_g_bus(void);
|
||
extern int8_t gestion_protocole_rx_g_bus(void);
|
||
extern void gestion_protocole_tx_g_bus(void);
|
||
extern int8_t g_bus_next_write_buffer_cdes(uint8_t priorite);
|
||
|
||
// G_commandes.c :
|
||
int8_t g_bus_down_commande_libre(uint8_t classe, uint8_t id, uint8_t * ptr_cde, uint16_t lg_cde, uint8_t mode_protocole, uint16_t time_out, int8_t max_repetitions);
|
||
extern int8_t g_bus_down_analyse_reponse_commande(void);
|
||
|
||
// Gnss.c :
|
||
extern int8_t init_gnss(void);
|
||
extern void gestion_gnss(void);
|
||
|
||
// Hardware.c :
|
||
extern void timer(void);
|
||
extern int init_timer(void);
|
||
extern int init_memory_map(void);
|
||
|
||
// M_Bus :
|
||
extern int8_t init_m_bus(void);
|
||
extern void gestion_m_bus(void);
|
||
extern int8_t gestion_protocole_rx_m_bus(void);
|
||
extern void gestion_protocole_tx_m_bus(void);
|
||
extern int8_t m_bus_next_write_buffer_cdes(uint8_t priorite);
|
||
|
||
// M_commandes :
|
||
extern int8_t m_bus_down_commande_libre(char * ptr_cde, uint8_t mode_protocole, uint16_t time_out, int8_t max_repetitions);
|
||
extern int8_t m_bus_down_commande_libre_binaire(uint16_t code, char * ptr_cde, uint32_t lg_cde, uint8_t mode_protocole, uint16_t time_out, int8_t max_repetitions);
|
||
extern int8_t m_bus_down_analyse_reponse_commande(void);
|
||
extern int8_t m_bus_down_recherche_code_erreur(void);
|
||
|
||
// Modem.c :
|
||
extern int8_t init_modem(void);
|
||
extern void gestion_modem(void);
|
||
|
||
// Main.c :
|
||
extern int8_t init(void);
|
||
extern void lancement_reinit(uint16_t tempo);
|
||
extern void sigintHandler(int dummy);
|
||
|
||
// Nmea.c
|
||
extern int8_t init_nmea(void);
|
||
extern void gestion_nmea(void);
|
||
extern int8_t traitement_pgn_compagnon(struct Struct_pgn_nmea pgn);
|
||
|
||
// Reseaux.c :
|
||
extern void gestion_reseaux(void);
|
||
extern int8_t init_reseaux(void);
|
||
extern int8_t get_ip_address(void);
|
||
|
||
// Reservoirs.c
|
||
extern int8_t init_reservoirs(void);
|
||
extern void gestion_reservoirs(void);
|
||
extern int16_t reservoir_cle_primaire(uint16_t cle_primaire);
|
||
extern int16_t variable_reservoir_cle_primaire(uint16_t cle_primaire);
|
||
|
||
// Serial.c
|
||
extern void gestion_rx_serial0(void);
|
||
extern void gestion_rx_serial1(void);
|
||
extern int init_serial0(void);
|
||
extern int init_serial1(void);
|
||
|
||
// Sorties.c
|
||
extern void ecriture_sortie(uint8_t type, uint8_t module, uint8_t no, uint8_t valeur);
|
||
extern int8_t init_sorties(void);
|
||
|
||
// Systeme.c
|
||
extern int8_t init_systeme(void);
|
||
extern void gestion_systeme(void);
|
||
extern void arret_programme(void);
|
||
extern void supervision(void);
|
||
extern int8_t re_configuration_systeme(void);
|
||
extern int32_t commande_shell(char * commande);
|
||
extern struct Struct_json_version parse_json_version(char * nom_fichier, bool verbose);
|
||
extern int8_t send_signal (int32_t pid, int32_t signal);
|
||
extern int32_t get_pid_from_name (char * nom, char * parametres);
|
||
extern int32_t get_pid_numbers_from_name (char * nom, char * parametres);
|
||
|
||
// Usb.c
|
||
extern int8_t init_usb(void);
|
||
extern void gestion_usb(void);
|
||
|
||
// Version.c
|
||
extern char * maj_version_logiciel(void);
|
||
|
||
|
||
// **********************************************************************************************************************************************************************************
|
||
// Variables globales externes :
|
||
// **********************************************************************************************************************************************************************************
|
||
|
||
// Audio.c
|
||
extern struct Struct_audio audio;
|
||
|
||
// Batteries.c
|
||
extern struct Struct_batteries batteries;
|
||
|
||
// Circuits.c
|
||
extern struct Struct_circuits circuits;
|
||
|
||
// Capteurs.c
|
||
extern struct Struct_capteurs capteurs;
|
||
|
||
// C_bus.c
|
||
extern struct Struct_c_bus c_bus;
|
||
|
||
// Circuits.c
|
||
extern struct Struct_circuits circuits;
|
||
|
||
// Debug.c :
|
||
extern struct Struct_debug debug;
|
||
|
||
// Ecran.c
|
||
extern struct Struct_ecran ecran;
|
||
|
||
// Entrees.c :
|
||
extern struct Struct_entrees entrees;
|
||
|
||
// Events.c
|
||
extern struct Struct_events events;
|
||
|
||
// Fonctions.c :
|
||
extern volatile uint16_t tempo_delai_dixieme_sec;
|
||
|
||
// G_bus.c :
|
||
extern struct Struct_g_bus g_bus;
|
||
|
||
// Gestion_bdd.c :
|
||
extern struct Struct_bdd bdd;
|
||
|
||
// Gnss.c
|
||
extern struct Struct_gnss gnss;
|
||
|
||
// Hardware.c :
|
||
//extern volatile uint32_t *gpio;
|
||
extern struct Struct_hardware hardware;
|
||
|
||
// M_Bus :
|
||
extern struct Struct_m_bus m_bus;
|
||
|
||
// Main.c :
|
||
|
||
|
||
// Modem.c
|
||
extern struct Struct_modem modem;
|
||
|
||
// Nmea.c
|
||
extern struct Struct_nmea nmea;
|
||
extern const struct Struct_entree_catalogue_pgn_nmea catalogue_pgns[NMEA_MAX_NOMBRE_PGN + 1];
|
||
|
||
// Reseaux.c :
|
||
extern struct Struct_reseaux reseaux;
|
||
|
||
// Reservoirs.c
|
||
extern struct Struct_reservoirs reservoirs;
|
||
|
||
// Serial.c :
|
||
extern struct Struct_config_serial config_serial0;
|
||
extern struct Struct_config_serial config_serial1;
|
||
extern struct Struct_serial serial0;
|
||
extern struct Struct_serial serial1;
|
||
|
||
// Sorties :
|
||
extern struct Struct_sorties sorties;
|
||
|
||
// Systeme.c
|
||
extern struct Struct_download download;
|
||
extern struct Struct_systeme systeme;
|
||
extern struct Struct_chargement_code chargement_code;
|
||
extern struct Struct_upload upload;
|
||
extern struct Struct_supervision_boucle_principale supervision_boucle_principale;
|
||
extern int8_t version_compute_module(void);
|
||
|
||
// Usb.c
|
||
extern struct Struct_usb usb;
|