//**********************************************************************************************************************************************************************************
//	Fichier BATTERIES.C 
//
//	Contient toutes les fonctions liées aux batteries de ShipHeart
//**********************************************************************************************************************************************************************************/

//#define __DEBUG_BATTERIES


// Includes :
#include "main.h"

// Prototypes :
int8_t init_batteries(void);
void gestion_batteries(void);
int16_t batterie_cle_primaire(uint16_t cle_primaire);
int16_t variable_batterie_cle_primaire(uint16_t cle_primaire);


// Variables globales :
struct Struct_batteries batteries;


/**********************************************************************************************************************************************************************************
	Fonction 	: Initialise les différents paramètres des batteries au démarrage de l'application
	Reçoit : 	Rien
	Retour : 	-1 si erreur, 0 sinon.
**********************************************************************************************************************************************************************************/
int8_t init_batteries(void)
{
	//------------------------------------------------------------------------------------------------------
	// Init des variables générales :
	
	batteries.sequenceur.etat = ETAT_SEQUENCEUR_BATTERIES_INIT;
	batteries.sequenceur.compteur = BATTERIES_TEMPO_INIT;
	
	
	// Affichage du message de débug :
	affichage_debug(__FILE__, __LINE__, "Initialisation des batteries\t: OK", TYPE_MESSAGE_DEBUG_OK);
	return(0);
	
}


/**********************************************************************************************************************************************************************************
	Fonction : 	Fonction de plus haut niveau de gestion batteries
	Reçoit : 	Rien
	Retour : 	Rien
**********************************************************************************************************************************************************************************/
void gestion_batteries(void)
{
uint16_t i, j;
float soc;
float tension_a_vide;
float resistance_interne;
float efficacite;
float delta_energie;
float capacite_reelle;
float duree_decharge_corrigee;
float courant_differentiel_corrige;
bool flag_erreur;
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
	
	
	if (!systeme.flag_cm3p_ready) return;			// Evite que le traitement soit fait au milieu d'une reconfiguration...

	switch(batteries.sequenceur.etat)
	{
		//--------------------------------------------------------
		case ETAT_SEQUENCEUR_BATTERIES_INIT :
		{
			if ((systeme.flag_cm3p_ready) &&						// Permet de s'assurer que le cycle d'init système est terminé. En particulier, on est sûr que 'init_bdd()' puis 'annuaire_k_bus()' ont été traités.
				(batteries.sequenceur.compteur == 0))
			{	
		
affichage_debug(__FILE__, __LINE__, "------------------BATTEREIES INIT", TYPE_MESSAGE_DEBUG_WARNING);				
				batteries.sequenceur.etat = ETAT_SEQUENCEUR_BATTERIES_REPOS;
			}

			break;
		}
		
		//--------------------------------------------------------
		case ETAT_SEQUENCEUR_BATTERIES_REPOS :
		{
			if (batteries.sequenceur.compteur == 0)	
			{
				batteries.sequenceur.compteur = BATTERIES_PERIODE_MESURES;
#ifdef __DEBUG_BATTERIES
batteries.sequenceur.compteur = 10;
// Valeur passée de 300ms à 1s pour les tests (cf batteries.h)
#endif				
				for (i = 0; i < batteries.nb; i ++)
				{
					if (batteries.batteries[i].flag_validite == FALSE) continue;
					
					flag_erreur = FALSE;
					
					// Acquisition des dernières valeurs et mémorisation du nouveau niveau :
					switch(batteries.batteries[i].type_entrees)
					{
						//--------------------------------------------------------------------------
						case TYPE_ENTREES_VOLTAGE :
						{
							// Récupération de l'état de l'entrées Voltage configurée sur cette batterie et calcul de la nouvelle moyenne de tension à partir de l'ancienne et de la valeur lue :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante = (((batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante * (batteries.batteries[i].tension_coeff_filtrage - 1))) + entrees.volt.entrees[batteries.batteries[i].no_entrees].valeur) / batteries.batteries[i].tension_coeff_filtrage;
							
							break;
						}

						//--------------------------------------------------------------------------
						case TYPE_ENTREES_PREDEFINIES :
						{
							// Récupération de l'état de l'entrées Prédéfinie configurée sur cette batterie et calcul de la nouvelle moyenne de tension à partir de l'ancienne et de la valeur lue :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante = (((batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante * (batteries.batteries[i].tension_coeff_filtrage - 1))) + entrees.predefinies.entrees[batteries.batteries[i].no_entrees].valeur) / batteries.batteries[i].tension_coeff_filtrage;
							
							break;
						}
						
						//--------------------------------------------------------------------------
						case TYPE_ENTREES_IBS :
						{
							break;
						}
						
						default : 
						{
							sprintf(tmp, "Le 'Type_entrées' de la batterie #%i est invalide [%i]. La batterie est dévalidée", (i+1), batteries.batteries[i].type_entrees);
							affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
							batteries.batteries[i].flag_validite = FALSE;
							flag_erreur = TRUE;
							break;
						}
					}

					// Traitement :
					if (flag_erreur == FALSE)
					{
						
						//-------------------------------------
						// Tension :
						//-------------------------------------
						// Calcul de l'impact de Gain_tension sur la tension courante :
						batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante *= batteries.batteries[i].tension_gain;
						
						// Mise à jour du cumul :
						batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante;
						
						
						//-------------------------------------
						// Courant de décharge :
						//-------------------------------------
						batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante = 0;
						
						for (j = 0; j < circuits.nb; j ++)
						{
							if (! circuits.circuits[j].flag_validite) continue;
							if (circuits.circuits[j].id_batterie != batteries.batteries[i].cle_primaire) continue;
							
							batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante -= circuits.circuits[j].variables[CIRCUIT_VARIABLE_COURANT].valeur_courante;			// Cumul du courant dans chaque circuit. En négatif car le courant de chaque circuit est comptabilisé de façon positive alors que le courant de décharge est forcément négatif. 
						}
						
						// Mise à jour du cumul :
						batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante;
						

						//-------------------------------------
						// Puissance :
						//-------------------------------------
						// SDIR #199 : suppression du (-1) dans le produit (tension x courant) afin de laisser la puissance consommée toujours négative :
						batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante = batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante * batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante;

						// Mise à jour du cumul :
						batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante;			



						//================================================
						// Entrée de type Entrée Prédéfinie ou Voltage :
						//================================================
						if (batteries.batteries[i].type_entrees != TYPE_ENTREES_IBS)		
						{
							//-------------------------------------
							// SOC :
							//-------------------------------------
							// Calcul du SOC :
							soc = calcul_niveau(batteries.batteries[i].points_tension_soc, MAX_NOMBRE_POINTS_TENSION_SOC_BATTERIE, batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante);
							if (soc >= 0) batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = soc;
							else 
							{
								sprintf(tmp, "Erreur de calcul de SOC de la batterie #%i avec tension=%.3fV. La valeur lue n'est pas exploitée.\n", i, batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante);
								affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
							}
							
							// Mise à jour du cumul :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante;


							//-------------------------------------
							// Mise à jour BDD :
							//-------------------------------------
							// Mise à jour dans la BDD si les valeurs ont suffisemment évolué :
//							if ((fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_TENSION].marge)								||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_COURANT_DECHARGE].marge)		||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_SOC].marge)											||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_PUISSANCE].marge))
							if ((fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante) > 0)						||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante) > 0)		||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante) > 0)								||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante) > 0))
							{
								batteries.batteries[i].flag_dde_maj_bdd = TRUE;						// Flag pour mise à jour dans la BDD
							}
							
/*#ifdef __DEBUG_BATTERIES							
sprintf(tmp, "Batterie #%i : Tension = %.3fV, courant de décharge = %.3fA (donc puissance = %.3fW) et SOC = %.2f%% (coeff filtrage tension = %i)", 
			i, batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante, 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante, 
			(batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante * (-1) * batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante), 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante, 
			batteries.batteries[i].tension_coeff_filtrage);	
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
#endif
*/
						}
						
						//================================================
						// Entrée de type IBS :
						//================================================
						else 		
						{
							//-------------------------------------
							// Température :
							//-------------------------------------
							// Mise à jour du cumul :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante;

							//-------------------------------------
							// Courant différentiel :
							//-------------------------------------
							// Mise à jour du cumul :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante;
							
							//-------------------------------------
							// Calcul du courant de charge :
							//-------------------------------------
							batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante = batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante;
							if (batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante < 0) 						// Normalement, impossible car cela induirait un courantd e charge négatif...
							{
#ifdef __DEBUG_BATTERIES							
//								sprintf(tmp, "Batterie #%i : Le courant de charge est calculé avec une valeur négative [%.3f A], ce qui n'est pas possible. Il est ramené à 0 mA", i, batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante);	
//								affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
#endif							
								batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante = 0;							// Par défaut, on écrête...
							}	
							
							// Mise à jour du cumul :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante;
							


							//-------------------------------------
							// Calcul du SOC :
							//-------------------------------------		

							// Calcul de la résistance interne en fonction de la température :
							resistance_interne = calcul_niveau(batteries.batteries[i].points_temperature_resistance_interne, MAX_NOMBRE_POINTS_TEMPERATURE_RESISTANCE_INTERNE_BATTERIE, batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante);
							if (resistance_interne != -1) resistance_interne = resistance_interne * batteries.batteries[i].resistance_interne / 1000;			// Le '/1000' permet de passer de valeurs de résistance interne en mOhms à Ohms.
							else resistance_interne = batteries.batteries[i].resistance_interne / 1000;															// Le '/1000' permet de passer de valeurs de résistance interne en mOhms à Ohms.
#ifdef __DEBUG_BATTERIES							
// sprintf(tmp, "Valeur brute de résistance interne = %.2f mOhms, température batterie = %.2f °C, soit résistance interne corrigée = %.2f mOhms", batteries.batteries[i].resistance_interne, batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante, (resistance_interne * 1000));
// affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);							
#endif							
							// Estimation de la tension à vide (en tenant compte de la chute de tension due à la résistance interne de la batterie) :
							tension_a_vide = batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante - (batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante * resistance_interne);		

							if ((batteries.batteries[i].sequenceur.etat != ETAT_SEQUENCEUR_BATTERIE_CHARGE_NULLE)	&&		// Le calcul de l'EOD, et, in fine, du SOC n'est pas effectué tant qu'on est à l'état de charge nulle...
								(batteries.batteries[i].sequenceur.etat != ETAT_SEQUENCEUR_BATTERIE_PLEINE_CHARGE))			// ... ou de pleine charge.
							{			
								// Calcul de l'EOD :
									// Calculs fonction d'une charge ou d'une décharge :
								if (batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante < 0) 		// Il est important de ne PAS prendre la valeur 0 (sinon le calcul de 'duree_decharge_corrigee' va planter via division par 0)
								{
									efficacite = 1 / batteries.batteries[i].efficacite_decharge;
									
									// Effet Peukert :
									duree_decharge_corrigee = batteries.batteries[i].heures_capacite * powf(((batteries.batteries[i].capacite / batteries.batteries[i].heures_capacite) / (-batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante)), batteries.batteries[i].coeff_peukert);		// Le signe - devant le courant permet d'avoir une valeur positive (sinon POWF va générer une erreur)
									courant_differentiel_corrige = -(float)batteries.batteries[i].capacite / duree_decharge_corrigee;			// Le signe '-' permet de revenir à un courant négatif en cas de décharge
								}
								else 
								{
									efficacite = batteries.batteries[i].efficacite_charge;
									courant_differentiel_corrige = batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante;			// Pas de correction de Peukert en charge...
								}
							
									// Calculs intermédiaires (facilite la lecture et le debug) :
								delta_energie = courant_differentiel_corrige * efficacite * (BATTERIES_PERIODE_MESURES * 0.1 / 3600);								// La dernière () permet de passer en heures.
// SDIR #337 :					capacite_reelle = batteries.batteries[i].capacite * batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante / 100;	// Le '100' permet de tenir compte du fait que le SOH est en pourcents
								capacite_reelle = batteries.batteries[i].capacite;		// SDIR #337
								
									// Calcul de l'EOD proprement dit :
								batteries.batteries[i].eod += delta_energie;
								if (batteries.batteries[i].eod > 0) batteries.batteries[i].eod = 0;			// SDIR #337
//printf("Courant diff = %.3f, efficacité = %.3f, Delta T = %.6f secondes donc Delta Energie = %.6fAh => energie_dechargee = %.6fAh. Capacite_reelle = %.2fAh\n", batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante, efficacite, (BATTERIES_PERIODE_MESURES * 0.1 / 3600), delta_energie, batteries.batteries[i].eod, capacite_reelle);
									
								// Mise à jour du SOC à partir de l'EOD : 
								batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = (1 + (batteries.batteries[i].eod / capacite_reelle)) * 100;		// EOD est négative par nature. Le 'x100' permet de revenir d'une fraction en pourcents
							}
							else 
							{
								efficacite = 0;						// Permet d'éviter un warning losqu'il n'est pas calculé (état de pleine charge ou de charge nulle) mais utilisé par le message de debug
								courant_differentiel_corrige = 0;	// Idem
							}
							
							//--------------------------------
							// Mode repos :
							//--------------------------------
/*							if (fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante) < batteries.batteries[i].courant_repos)
							{
								soc = calcul_niveau(batteries.batteries[i].points_tension_soc, MAX_NOMBRE_POINTS_TENSION_SOC_BATTERIE, tension_a_vide);
								if (soc >= 0) 
								{
// batteries.batteries[i].soc_coeff_filtrage = 50;					
// float old = batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante;
// float new;				
// new = moyenne_mobile(old, soc, batteries.batteries[i].soc_coeff_filtrage);
// sprintf(tmp, "Old = %.3f%%, Add=%.3f%%, New = %.3f%% et le coeff %i. ", old, soc, new, batteries.batteries[i].soc_coeff_filtrage);
// affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);


									batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = moyenne_mobile(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante, soc, batteries.batteries[i].soc_coeff_filtrage);
sprintf(tmp, "La batterie #%i est en mode REPOS. Son nouveau SOC = %.1f%%, il a été mis à jour via moyenne mobile avec la nouvelle valeur %.1f%% et le coeff %i. ", i, batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante, soc, batteries.batteries[i].soc_coeff_filtrage);
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
								}
								// Sinon, on n'utilise pas la valeur calculée car il ne sert à rien de corriger avec une valeur erronée...
							}
*/							
							//--------------------------------
							// Mode Décharge :
							//--------------------------------
							if (batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante < 0) 
							{
								// Vérification du passage en "charge nulle" :
								switch(batteries.batteries[i].sequenceur.etat)
								{
									//......................................
									case ETAT_SEQUENCEUR_BATTERIE_NORMAL:
									{
										if (tension_a_vide <= batteries.batteries[i].tension_charge_nulle)
										{
											batteries.batteries[i].sequenceur.compteur = batteries.batteries[i].temporisation_charge_nulle;
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_ATTENTE_CONFIRMATION_CHARGE_NULLE;
										}
										break;
									}
									//......................................
									case ETAT_SEQUENCEUR_BATTERIE_ATTENTE_CONFIRMATION_CHARGE_NULLE:
									{
										if (tension_a_vide > batteries.batteries[i].tension_charge_nulle) 		// Cas où on n'a pas eu le temps d'attendre la tempo de confirmation avant remontée de la tension.
										{
											batteries.batteries[i].sequenceur.compteur = 0;
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_NORMAL;
											break;
										}
										
										if (batteries.batteries[i].sequenceur.compteur == 0)					// Cas où le passage à charge nulle est confirmé :
										{
											batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = 0;
											batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante = -(batteries.batteries[i].eod * 100) / batteries.batteries[i].capacite;									
											sprintf(tmp, "La Batterie [%i] est confirmée en CHARGE NULLE. EOD = %.3fAh et Capacité = %.2fAh donc SOH = %.3f%%", (i+1), batteries.batteries[i].eod, batteries.batteries[i].capacite, batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante);
											affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
											
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_CHARGE_NULLE;
										}
										break;
									}
									//......................................
									case ETAT_SEQUENCEUR_BATTERIE_CHARGE_NULLE:
									{
										if (tension_a_vide > (batteries.batteries[i].tension_charge_nulle + BATTERIES_HYSTERESIS_CHARGE_NULLE)) 		
										{
											batteries.batteries[i].sequenceur.compteur = 0;
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_NORMAL;
											break;
										}
										
										break;
									}
									//......................................
									default :
									{
#ifdef __DEBUG_BATTERIES										
										sprintf(tmp, "L'état du séquenceur de la Batterie [%i] est inconnu pour ce mode [%i]. Il est repositionné à NORMAL", (i+1), batteries.batteries[i].sequenceur.etat);
										affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
#endif										
										batteries.batteries[i].sequenceur.compteur = 0;
										batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_NORMAL;
										break;
									}
								}
							}
								
							//--------------------------------
							// Mode Charge :
							//--------------------------------
							if (batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante > 0) 
							{
								switch(batteries.batteries[i].sequenceur.etat)
								{
									//......................................
									case ETAT_SEQUENCEUR_BATTERIE_NORMAL:
									{
										// Détection d'un passage à l'état "Pleine charge" :
										if ((tension_a_vide >= batteries.batteries[i].tension_pleine_charge) &&
											(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante <= batteries.batteries[i].courant_pleine_charge))
										{
#ifdef __DEBUG_BATTERIES											
											sprintf(tmp, "Les conditions du mode PLEINE CHARGE ont été détectées sur la Batterie [%i]. La temporisation de vérification (%is) est lancée ", (i+1), batteries.batteries[i].temporisation_pleine_charge);
											affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
#endif											
											batteries.batteries[i].sequenceur.compteur = batteries.batteries[i].temporisation_pleine_charge;
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_ATTENTE_CONFIRMATION_PLEINE_CHARGE;
										}
										break;
									}
									//......................................
									case ETAT_SEQUENCEUR_BATTERIE_ATTENTE_CONFIRMATION_PLEINE_CHARGE:
									{
										// Détection de sortie de l'état "Pleine charge" avant d'avoir été confirmé :
										if ((tension_a_vide < batteries.batteries[i].tension_pleine_charge) ||																				// Si la tension est redescendue...
											(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante > batteries.batteries[i].courant_pleine_charge))		// ... ou le courant remonté avant l'expiration de la tempo :
										{
											sprintf(tmp, "Les conditions du mode PLEINE CHARGE ont disparu sur la Batterie [%i]. La batterie est repositionnée en mode NORMAL ", (i+1));
											affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
											batteries.batteries[i].sequenceur.compteur = 0;
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_NORMAL;
											break;
										}
										
										// Confirmation du passage à l'état "Pleine charge" :
										if (batteries.batteries[i].sequenceur.compteur == 0)					// Cas où le passage à pleine charge est confirmé :
										{
											sprintf(tmp, "La Batterie [%i] est confirmée en PLEINE CHARGE ", (i+1));
											affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
											batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = 100;
											batteries.batteries[i].eod = 0;
//	batteries.batteries[i].tension_pleine_charge = tension_a_vide - BATTERIES_DELTA_TENSION_PLEINE_CHARGE_AUTO;			// Ajustement auto de la tension pleine charge 
											
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_PLEINE_CHARGE;
										}
										break;
									}
									//......................................
									case ETAT_SEQUENCEUR_BATTERIE_PLEINE_CHARGE:
									{
										// Détection de sortie de l'état "Pleine charge" :
										if ((tension_a_vide < batteries.batteries[i].tension_pleine_charge) ||																				// Si la tension est redescendue...
											(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante > batteries.batteries[i].courant_pleine_charge))		// ... ou le courant remonté  :
										{
											batteries.batteries[i].sequenceur.compteur = 0;
											batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_NORMAL;
											break;
										}
										
// Etat "pleine charge" :
// batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = 100;
// batteries.batteries[i].eod = 0;
										
										break;
									}
									//......................................
									default :
									{
#ifdef __DEBUG_BATTERIES										
										sprintf(tmp, "L'état du séquenceur de la Batterie [%i] est inconnu pour ce mode [%i]. Il est repositionné à NORMAL", (i+1), batteries.batteries[i].sequenceur.etat);
										affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
#endif										
										batteries.batteries[i].sequenceur.compteur = 0;
										batteries.batteries[i].sequenceur.etat = ETAT_SEQUENCEUR_BATTERIE_NORMAL;
										break;
									}
								}
							}
							
							// Vérification du SOC : 
							if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante > 100) batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = 100;
							if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante < 0) batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante = 0;
							
							// Mise à jour du cumul :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante;


							//--------------------------------------------
							// Calcul des nombres de cycles :
							//--------------------------------------------
							if (batteries.batteries[i].flag_increment_cycles == 0)		// Le compteur est armé et n'a pas encore été incrémenté :
							{
								if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante <= BATTERIES_SEUIL_SOC_BAS_NOMBRE_CYCLES) 
								{
									batteries.batteries[i].flag_increment_cycles = 1;					// Blocage du flag jusqu'au prochain passage par 100%
									batteries.batteries[i].nombre_cycles ++;							// Incrémentation du compteur
									batteries.batteries[i].flag_dde_maj_bdd = TRUE;						// Flag pour mise à jour dans la BDD
								}
							}
							else														// Le compteur "Nombre_cylces" a été incrémenté, on attend maintenant de revenir à 100% pour le réarmer :
							{
								if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante == 100) 
								{
									batteries.batteries[i].flag_increment_cycles = 0;					// Réarmement du flag pour le prochain cycle
									batteries.batteries[i].flag_dde_maj_bdd = TRUE;						// Flag pour mise à jour dans la BDD
								}
							}
							
							//--------------------------------------------
							// Calcul du nombre de décharges complètes :
							//--------------------------------------------
							if (batteries.batteries[i].flag_increment_decharges_completes == 0)		// Le compteur est armé et n'a pas encore été incrémenté :
							{
								if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante == 0) 
								{
									batteries.batteries[i].flag_increment_decharges_completes = 1;		// Blocage du flag jusqu'au prochain passage par 100%
									batteries.batteries[i].nombre_decharges_completes ++;				// Incrémentation du compteur
									batteries.batteries[i].flag_dde_maj_bdd = TRUE;						// Flag pour mise à jour dans la BDD
								}
							}
							else																	// Le compteur "Nombre_cylces" a été incrémenté, on attend maintenant de revenir à 100% pour le réarmer :
							{
								if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante == 100) 
								{
									batteries.batteries[i].flag_increment_decharges_completes = 0;		// Réarmement du flag pour le prochain cycle
									batteries.batteries[i].flag_dde_maj_bdd = TRUE;						// Flag pour mise à jour dans la BDD
								}
							}
							
							

							//-------------------------------------
							// Calcul du SOH :
							//-------------------------------------
							// Vérification du SOH : 
	// if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante > 100) batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante = 100;
							if (batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante < BATTERIES_SEUIL_MINI_SOH) batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante = BATTERIES_SEUIL_MINI_SOH;
							
							// Mise à jour du cumul :
							batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante;





//-------------------------------------
// Calcul de l'autonomie :
//-------------------------------------
							
// Mise à jour du cumul :
batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].cumul += batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_courante;
							
							
							
							//-------------------------------------
							// Mise à jour BDD :
							//-------------------------------------
							// Mise à jour dans la BDD si les valeurs ont suffisemment évolué :
//							if ((fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_TEMPERATURE].marge)								||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_TENSION].marge)											||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].marge)		||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_COURANT_CHARGE].marge)						||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_COURANT_DECHARGE].marge)					||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_SOH].marge)														||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_SOC].marge)														||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_AUTONOMIE].marge)										||
//								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante) >= batteries.variables[BATTERIE_VARIABLE_PUISSANCE].marge))
							if ((fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante) > 0)						||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante) > 0)								||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante) > 0)		||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante) > 0)					||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante) > 0)				||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante) > 0)										||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante) > 0)										||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_courante) > 0)							||
								(fabs(batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_bdd - batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante) > 0))
							{
								batteries.batteries[i].flag_dde_maj_bdd = TRUE;						// Flag pour mise à jour dans la BDD
							}
					
#ifdef __DEBUG_BATTERIES
char texte_etat[200];

if (++ batteries.compteur_affichage_debug == 6)			// Comme BATTERIES_PERIODE_MESURES = 300ms, cela donne un affichage toutes les 1.8s
{
	batteries.compteur_affichage_debug = 0;
	
	switch(batteries.batteries[i].sequenceur.etat)
	{
		case ETAT_SEQUENCEUR_BATTERIE_NORMAL: {	strcpy(texte_etat, "NORMAL"); break; }
		case ETAT_SEQUENCEUR_BATTERIE_ATTENTE_CONFIRMATION_CHARGE_NULLE: {	strcpy(texte_etat, "ATTENTE_CONFIRMATION_CHARGE_NULLE"); break; }
		case ETAT_SEQUENCEUR_BATTERIE_CHARGE_NULLE: {	strcpy(texte_etat, "CHARGE_NULLE"); break; }
		case ETAT_SEQUENCEUR_BATTERIE_ATTENTE_CONFIRMATION_PLEINE_CHARGE: {	strcpy(texte_etat, "ATTENTE_CONFIRMATION_PLEINE_CHARGE"); break; }
		case ETAT_SEQUENCEUR_BATTERIE_PLEINE_CHARGE: {	strcpy(texte_etat, "PLEINE_CHARGE"); break; }
		default: {	strcpy(texte_etat, "Inconnu"); break; }
	}
	
	sprintf(tmp, "Batterie #%i : Etat = %s, Température = %.2f°C, Tension = %.3fV, Courant diff = %.3fA, courant charge = %.3fA, Courant décharge = %.3fA, SOH = %.2f%%, SOC = %.2f%%, Autonomie = %.2fh et puissance = %.3fW. Tension à vide = %.3fV, résistance interne corrigée = %.2fmOhms, efficacité = %.3f, courant_differentiel_corrigé = %.3fA, capacité = %.2fAh, EOD (énergie déchargée depuis démarrage) = %.5fAh", i, 
			texte_etat,
			batteries.batteries[i].variables[BATTERIE_VARIABLE_TEMPERATURE].valeur_courante, 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante,
			batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante, 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_CHARGE].valeur_courante, 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DECHARGE].valeur_courante, 		
			batteries.batteries[i].variables[BATTERIE_VARIABLE_SOH].valeur_courante, 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_SOC].valeur_courante, 
			batteries.batteries[i].variables[BATTERIE_VARIABLE_AUTONOMIE].valeur_courante,
			batteries.batteries[i].variables[BATTERIE_VARIABLE_PUISSANCE].valeur_courante,
			tension_a_vide,
			(resistance_interne * 1000),			// Pour passer de Ohms à mOhms
			efficacite,
			courant_differentiel_corrige,
			batteries.batteries[i].capacite,
			batteries.batteries[i].eod
			);	
			
/*sprintf(tmp, "Batterie #%i : Etat = %s, Tension = %.3fV, Courant diff = %.3fA. Tension à vide = %.3fV, efficacité = %.3f, courant_differentiel_corrigé = %.3fA, capacité = %.2fAh, duree_decharge_corrigee = %.2fh, EOD = %.5fAh", i, 
		texte_etat,
		batteries.batteries[i].variables[BATTERIE_VARIABLE_TENSION].valeur_courante,
		batteries.batteries[i].variables[BATTERIE_VARIABLE_COURANT_DIFFERENTIEL].valeur_courante, 
		tension_a_vide,
		efficacite,
		courant_differentiel_corrige,
		batteries.batteries[i].capacite,
		duree_decharge_corrigee,
		batteries.batteries[i].eod
		);	
*/
		
	affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
}
#endif
						}	// Fin du traitement pour batterie sur IBS
						
						batteries.batteries[i].cumuls_nb_val ++;									// MàJ du nombre d'échantillons dans le cumul
						
						
						// Mise à jour des valeurs BDD des variables :
						if (batteries.batteries[i].flag_dde_maj_bdd)
						{
							for (j = 0; j < MAX_NOMBRE_VARIABLES_BATTERIES; j ++) batteries.batteries[i].variables[j].valeur_bdd = batteries.batteries[i].variables[j].valeur_courante;
						}
					}
					
				}
				
			}
			break;
		}
		
		//--------------------------------------------------------
		default :
		{
			sprintf(tmp, "L'état du séquenceur Batteries est inconnu [%i]. Il est repositionné au REPOS", batteries.sequenceur.etat);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			batteries.sequenceur.etat = ETAT_SEQUENCEUR_BATTERIES_REPOS;
			break;
		}
	}
}


//**********************************************************************************************************************************************************************************
//	Fonction	: Recherche la batterie dont la Clé_primaire est reçue en paramètre
//	Reçoit 		: La Cle_primaire de la batterie à rechercher
//	Retourne 	: le numéro de batterie correspondant (ou -1 si aucun circuit valide ne correspond). La numérotation allant de 0 à MAX_NOMBRE_BATTERIES - 1.
//**********************************************************************************************************************************************************************************
int16_t batterie_cle_primaire(uint16_t cle_primaire)
{
uint16_t i;
	

	if (cle_primaire == 0) return (-1);					// Inutile de chercher si le n° à chercher est nul...
	
	for (i = 0; i < batteries.nb; i ++)
	{
		if (batteries.batteries[i].flag_validite == FALSE) continue;
		if (batteries.batteries[i].cle_primaire == cle_primaire) return(i);
	}
	return (-1);	// Si on est arrivé au bout de la boucle, on renvoi le code de 'non trouvé'.
}


//**********************************************************************************************************************************************************************************
//	Fonction VARIABLE_BATTERIE_CLE_PRIMAIRE
//	Reçoit en paramètre : 
//		- La Cle_primaire de la variable à rechercher
//	Retourne :
//		- le numéro de variable correspondant (ou -1 si aucune variable valide ne correspond). La numérotation allant de 0 à MAX_NOMBRE_VARIABLES_BATTERIES-1.
//**********************************************************************************************************************************************************************************
int16_t variable_batterie_cle_primaire(uint16_t cle_primaire)
{
uint16_t i;
	
	for (i=0; i<MAX_NOMBRE_VARIABLES_BATTERIES; i++)
	{
		if (batteries.variables[i].cle_primaire == cle_primaire) return(i);
		
	}
	return (-1);	// Si on est arrivé au bout de la boucle, on renvoi le code de 'non trouvé'.
}