/******************************************************************************/
/* Files to Include                                                           */
/******************************************************************************/

#include "Process.h"

char BdC_VerifEtatVanne(int position, int vanne)
{
char            presenceFdc;
char            numEntreeTor;
char            numTimer;
unsigned int    numDefaut;

if (vanne == vanne_Sup)                                                         // Vanne supérieure
{
    numTimer = timer_BdC_VanneSup;
    if (position == 0)
    {
        presenceFdc = EXP.BdC_FdcVanneSupFermee;
        numEntreeTor = DI_BdC_FdcVanneSupFermee;
        numDefaut = 0x0010;
    }
    else
    {
        presenceFdc = EXP.BdC_FdcVanneSupOuverte;
        numEntreeTor = DI_BdC_FdcVanneSupOuverte;
        numDefaut = 0x0008;
    }
}
if (vanne == vanne_Inf)                                                         // Vanne supérieure
{
    numTimer = timer_BdC_VanneInf;
    if (position == 0)
    {
        presenceFdc = EXP.BdC_FdcVanneInfFermee;
        numEntreeTor = DI_BdC_FdcVanneInfFermee;
        numDefaut = 0x0040;
    }
    else
    {
        presenceFdc = EXP.BdC_FdcVanneInfOuverte;
        numEntreeTor = DI_BdC_FdcVanneInfOuverte;
        numDefaut = 0x0020;
    }
}

if (presenceFdc)                                                                // Si presence fin de course vanne sup fermée
{
    if (ValEntTOR(numEntreeTor, 0))
        return(1);
    else
    {
        if (!T100[numTimer])
            EXP.Defaut2 = EXP.Defaut2 | numDefaut;                              // Défaut fermeture vanne sup
            return(0);
    }
}
else
    return(!T100[timer_BdC_VanneSup]);
}


void BdC_VerifContacts(void)
{
switch (EXP.BdC_pos_cycle)
{
    case   0 :                                                                  // BdC_AttenteDCY
    case  10 :                                                                  // BdC_InitChargement
    case  25 :                                                                  // BdC_AttenteVanneSupFermee
    case  30 :                                                                  // BdC_AttenteStabilite
    case  35 :                                                                  // BdC_AttenteAutoriseVidange
    case  45 :                                                                  // BdC_AttenteVanneInfFermee
    case  50 :                                                                  // BdC_AttenteStabilite2
    case  60 :                                                                  // BdC_ImpressionTicket
    case 100 :                                                                  // BdC_Suspension
               BdC_VerifEtatVanne(0, vanne_Sup);                                // Vérif si vanne sup fermée
               BdC_VerifEtatVanne(0, vanne_Inf);                                // Vérif si vanne inf fermée
               break;
    case  15 :                                                                  // BdC_AttenteVanneSupOuverte
    case  20 :                                                                  // BdC_ChargementGV
    case  22 :                                                                  // BdC_ChargementPV
               BdC_VerifEtatVanne(1, vanne_Sup);                                // Vérif si vanne sup ouverte
               BdC_VerifEtatVanne(0, vanne_Inf);                                // Vérif si vanne inf fermée
               break;
    case  37 :                                                                  // BdC_AttenteVanneInfOuverte
    case  40 :                                                                  // BdC_Vidange
               BdC_VerifEtatVanne(0, vanne_Sup);                                // Vérif si vanne sup ouverte
               BdC_VerifEtatVanne(1, vanne_Inf);                                // Vérif si vanne inf fermée
               break;
}

//    case   0 : BdC_AttenteDCY();
//    case  10 : BdC_InitChargement();
//    case  15 : BdC_AttenteVanneSupOuverte();
//    case  20 : BdC_ChargementGV();
//    case  22 : BdC_ChargementPV();
//    case  25 : BdC_AttenteVanneSupFermee();
//    case  30 : BdC_AttenteStabilite();
//    case  35 : BdC_AttenteAutoriseVidange();
//    case  37 : BdC_AttenteVanneInfOuverte();
//    case  40 : BdC_Vidange();
//    case  45 : BdC_AttenteVanneInfFermee();
//    case  50 : BdC_AttenteStabilite2();
//    case  60 : BdC_ImpressionTicket();
//    case 100 : BdC_Suspension();


// Si défaut vanne mise en suspension
if ((EXP.Defaut2 & 0xFF87) && (EXP.BdC_pos_cycle > 0) && (EXP.BdC_pos_cycle < 100))
{
    EXP.BdC_pos_cycleMem = EXP.BdC_pos_cycle;
    EXP.BdC_pos_cycle = 100;
}
}


void BdC_AttenteDCY(void)                                                       // EXP.BdC_pos_cycle = 0
{
float               interf;
    
sortiesTOR(DO_BdC_OuvVanneSuperieure, 0);                                       // Commande fermeture vanne supérieure
sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                       // Commande fermeture vanne inférieure
sortiesTOR(DO_CycleEnCours, 0);                                                 // Cycle en cours
sortiesTOR(DO_CycleSuspendu, 0);                                                // Cycle suspendu

// Gestion DCY
if ((EXP.Command1 & 0x0001)                                                     // DCY
        || (EXP.Profibus_Command & 0x0001)                                      // DCY
        || (ValEntTOR(DI_DCY, 0)))                                              // DCY       
{
    interf = (float)PAR.BdC_TotalisationMin / 1000.0;
    if (EXP.Dep_Consigne < interf)
        EXP.Defaut2 = EXP.Defaut2 | 0x0004;                                     // Consigne hors tolérance
    
    if (EXP.Defaut2 == 0)
    {
        EXP.Command1 = EXP.Command1 & 0xFFFE;                                   // DCY
        EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFE;                   // DCY Profibus
        EXP.Etat1 = EXP.Etat1 & 0xFFFE;                                         // Bit installation à l'arrêt
        EXP.Etat1 = EXP.Etat1 & 0xFFFB;                                         // Bit installation suspendu
        EXP.Etat1 = EXP.Etat1 | 0x0002;                                         // Bit installation en marche

        EXP.Dep_PoidsEnCours = 0;
        EXP.BdC_NbBatchProduit = 0;
        
        Impression_BdC_Debut();
        
        EXP.BdC_pos_cycle = 10;
    }
}
}


void BdC_InitChargement(void)                                                   // EXP.BdC_pos_cycle = 10
{
EXP.BdC_derniere_pesee=0;
if (((EXP.Dep_Consigne - EXP.Dep_PoidsEnCours) >= 1.8*(float)PAR.BdC_CptTremiePesee/1000.0))
//		||(code_chargem==2))
	EXP.BdC_poids_cons = (float)PAR.BdC_CptTremiePesee;
else
{
	if ((EXP.Dep_Consigne - EXP.Dep_PoidsEnCours) <= (float)PAR.BdC_CptTremiePesee/1000.0)
	{
		EXP.BdC_poids_cons = (EXP.Dep_Consigne - EXP.Dep_PoidsEnCours)*1000;
		EXP.BdC_derniere_pesee = 1;
	}
	else
		EXP.BdC_poids_cons=(EXP.Dep_Consigne - EXP.Dep_PoidsEnCours)*1000/2;
}

sortiesTOR(DO_BdC_OuvVanneSuperieure, 1);                                       // Commande ouverture vanne supérieure
T100[timer_BdC_VanneSup] = PAR.BdC_TpsMaxOuvFermVannes;

EXP.BdC_pos_cycle = 15;
}


void BdC_AttenteVanneSupOuverte(void)                                           // EXP.BdC_pos_cycle = 15
{
sortiesTOR(DO_BdC_OuvVanneSuperieure, 1);                                       // Commande ouverture vanne supérieure

if (BdC_VerifEtatVanne(1, vanne_Sup))
    EXP.BdC_pos_cycle = 20;

if (EXP.PoidsMoyen > PAR.BdC_CptTremiePesee/1000)                               // Vérification trop plein trémie pesée
{
//    EXP.Defaut1 = EXP.Defaut1 | 0x0008;                                       // Défaut Poids > poids max
    sortiesTOR(DO_BdC_OuvVanneSuperieure, 0);                                   // Commande fermeture vanne supérieure

//    EXP.BdC_pos_cycleMem = 15;
//    EXP.BdC_pos_cycle = 100;                                                  // Suspension
}
}


void BdC_ChargementGV(void)                                                     // EXP.BdC_pos_cycle=20
{
// TEST
EXP.PoidsMoyen = 516;

sortiesTOR(DO_BdC_OuvVanneSuperieure, 1);                                       // Commande ouverture vanne supérieure

if (EXP.PoidsMoyen > EXP.BdC_poids_cons - EXP.BdC_ErreurJetee)
{
    sortiesTOR(DO_BdC_OuvVanneSuperieure, 0);                                   // Commande fermeture vanne supérieure
    T100[timer_BdC_VanneSup] = PAR.BdC_TpsMaxOuvFermVannes;

    EXP.BdC_pos_cycle = 25;                                                     // Attente vanne sup fermée
}
}


void BdC_ChargementPV(void)                                                     // EXP.BdC_pos_cycle = 22
{
// TEST
EXP.PoidsMoyen = 516;

EXP.BdC_pos_cycle = 25;                                                         // Attente vanne sup fermée
}


void BdC_AttenteVanneSupFermee(void)                                            // EXP.BdC_pos_cycle=25
{
// TEST
EXP.PoidsMoyen = 516;

if (BdC_VerifEtatVanne(0, vanne_Sup))
    EXP.BdC_pos_cycle = 30;
}


void BdC_AttenteStabilite(void)                                                 // EXP.BdC_pos_cycle = 30
{
// TEST
EXP.PoidsMoyen = 516;

if (EXP.PoidsStable)
{
    EXP.BdC_PoidsPlein = EXP.PoidsMoyen;
    EXP.BdC_EnVidange = 0;
    EXP.BdC_EnFinVidange = 0;
        
    EXP.BdC_pos_cycle = 35;                                                     // Attente vanne inférieure ouverte
}
}


void BdC_AttenteAutoriseVidange(void)                                           // EXP.BdC_pos_cycle = 35
{
// TEST
EXP.PoidsMoyen = 516;

if (ValEntTOR(DI_BdC_AutorisationVidange, 1))
{
    sortiesTOR(DO_BdC_OuvVanneInferieure, 1);                                   // Commande ouverture vanne inférieure
    T100[timer_BdC_VanneInf] = PAR.BdC_TpsMaxOuvFermVannes;

    EXP.BdC_pos_cycle = 37;                                                     // Attente vanne inférieure ouverte
}
}


void BdC_AttenteVanneInfOuverte(void)                                           // EXP.BdC_pos_cycle = 37
{
// TEST
EXP.PoidsMoyen = 516;

sortiesTOR(DO_BdC_OuvVanneInferieure, 1);                                       // Commande ouverture vanne inférieure

if (BdC_VerifEtatVanne(1, vanne_Inf))
{
    T100[timer_BdC_PauseVibrant] = PAR.BdC_TempsPauseVibrant;
    EXP.BdC_EnVidange = 1;
    EXP.BdC_EnFinVidange = 0;
    EXP.BdC_pos_cycle = 40;
}
}


void BdC_Vidange(void)                                                          // EXP.BdC_pos_cycle = 40
{
// TEST
EXP.PoidsMoyen = 0;

if (!ValEntTOR(DI_BdC_AutorisationVidange, 0))                                  // Perte autorisation de vidange
{
    sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                   // Commande fermeture vanne inférieure
    T100[timer_BdC_VanneInf] = PAR.BdC_TpsMaxOuvFermVannes;
    EXP.BdC_EnVidange = 0;
    EXP.BdC_EnFinVidange = 0;

    EXP.BdC_pos_cycle = 35;
}

if ((EXP.PoidsMoyen < (((float)PAR.BdC_CptTremiePesee/1000) * ((float)PAR.BdC_PourcTremieVide/10/100)))
            && (!EXP.BdC_EnFinVidange))
{
    T100[timer_BdC_TempoFinVidangeTremie] = PAR.BdC_TempsVidangeTremieVide;
    EXP.BdC_EnFinVidange = 1;
}

if ((EXP.BdC_EnFinVidange) && (!T100[timer_BdC_TempoFinVidangeTremie]))
{
    sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                   // Commande fermeture vanne inférieure
    T100[timer_BdC_VanneInf] = PAR.BdC_TpsMaxOuvFermVannes;
    sortiesTOR(DO_BdC_CommVibrant, 0);                                          // Commande arrêt vibrant

    EXP.BdC_pos_cycle = 45;                                                     // Attente fermeture vanne inférieure
}

// Gestion du vibrant
if ((etatSortieTOR(DO_BdC_CommVibrant))
        && (!T100[timer_BdC_MarcheVibrant]))
{
    sortiesTOR(DO_BdC_CommVibrant, 0);                                          // Commande arrêt vibrant
    T100[timer_BdC_PauseVibrant] = PAR.BdC_TempsPauseVibrant;
}

if ((!etatSortieTOR(DO_BdC_CommVibrant))
        && (!T100[timer_BdC_PauseVibrant]))
{
    sortiesTOR(DO_BdC_CommVibrant, 1);                                          // Commande marche vibrant
    T100[timer_BdC_MarcheVibrant] = PAR.BdC_TempsMarcheVibrant;
}
}


void BdC_AttenteVanneInfFermee(void)                                            // EXP.BdC_pos_cycle = 45
{
// TEST
EXP.PoidsMoyen = 0;

sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                       // Commande fermeture vanne inférieure

if (BdC_VerifEtatVanne(0, vanne_Inf))
    EXP.BdC_pos_cycle = 50;                                                     // Attente stabilité
}


void BdC_AttenteStabilite2(void)                                                // EXP.BdC_pos_cycle = 50
{
// TEST
EXP.PoidsMoyen = 0;

if (EXP.PoidsStable)
{
    EXP.BdC_PoidsVide = EXP.PoidsMoyen;
    EXP.BdC_EnVidange = 0;
    EXP.BdC_EnFinVidange = 0;
    EXP.BdC_PoidsDernierBatch = EXP.BdC_PoidsPlein - EXP.BdC_PoidsVide;
    EXP.Dep_PoidsEnCours = EXP.Dep_PoidsEnCours + EXP.BdC_PoidsDernierBatch/1000;
    EXP.BdC_NbBatchProduit++;
        
    Impression_BdC_Batch();
       
    if (EXP.BdC_derniere_pesee)
        EXP.BdC_pos_cycle = 60;                                                 // Impression ticket
    else
        EXP.BdC_pos_cycle = 10;                                                 // Calcul nouvelle consigne
}   
}


void BdC_ImpressionTicket(void)                                                 // EXP.BdC_pos_cycle = 60
{
    Impression_BdC_Fin();
    EXP.BdC_pos_cycle = 0;                                                      // Attente DCY
}


void BdC_Suspension(void)                                                       // EXP.BdC_pos_cycle = 100
{
sortiesTOR(DO_BdC_OuvVanneSuperieure, 0);                                       // Commande fermeture vanne supérieure
sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                       // Commande fermeture vanne inférieure
sortiesTOR(DO_BdC_CommVibrant, 0);                                              // Commande arrêt vibrant
sortiesTOR(DO_CycleEnCours, 0);                                                 // Cycle en cours
sortiesTOR(DO_CycleSuspendu, 1);                                                // Cycle suspendu

EXP.Command1 = EXP.Command1 & 0xFFFD;                                           // Suspension
EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFD;                           // Suspension

EXP.Etat1 = EXP.Etat1 & 0xFFFE;                                                 // Bit installation à l'arrêt
EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                                 // Bit installation en marche
EXP.Etat1 = EXP.Etat1 | 0x0004;                                                 // Bit installation suspendu

// Gestion DCY
if (((EXP.Command1 & 0x0001)                                                    // DCY
        || (EXP.Profibus_Command & 0x0001)                                      // DCY
        || (ValEntTOR(DI_DCY, 0)))                                              // DCY       
        && (!EXP.Defaut2))
{
    EXP.Command1 = EXP.Command1 & 0xFFFE;                                       // DCY
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFE;                       // DCY Profibus
    EXP.Etat1 = EXP.Etat1 & 0xFFFE;                                             // Bit installation à l'arrêt
    EXP.Etat1 = EXP.Etat1 & 0xFFFB;                                             // Bit installation suspendu
    EXP.Etat1 = EXP.Etat1 | 0x0002;                                             // Bit installation en marche

    switch (EXP.BdC_pos_cycleMem)
    {
        case  10 : 
                    EXP.BdC_pos_cycle = 10;                                     // Init chargement
                    break;
        case  15 :                                                              // Attente ouverture vanne supérieure
        case  20 :                                                              // Chargement GV
                    T100[timer_BdC_VanneSup] = PAR.BdC_TpsMaxOuvFermVannes;
                    EXP.BdC_pos_cycle = 15;                                     // Init chargement
                    break;
        case  25 :                                                              // Attente vanne supérieure fermée
                    T100[timer_BdC_VanneSup] = PAR.BdC_TpsMaxOuvFermVannes;
                    EXP.BdC_pos_cycle = 25;                                     // Attente vanne supérieure fermée
                    break;
        case  30 :                                                              // Attente stabilité
                    EXP.BdC_pos_cycle = 30;                                     // Attente stabilité
                    break;
        case  35 :                                                              // Attente autorise vidange
        case  37 :                                                              // Attente ouverture vanne inférieure
        case  40 :                                                              // Vidange
                    T100[timer_BdC_VanneInf] = PAR.BdC_TpsMaxOuvFermVannes;
                    EXP.BdC_pos_cycle = 35;                                     // Attente autorise vidange
                    break;
        case  50 :  
                    EXP.BdC_pos_cycle = 50;                                     // Attente stabilité 2
                    break;
    }
}

// Gestion abandon
if ((EXP.Command1 & 0x0004)                                                     // Abandon
        || (EXP.Profibus_Command & 0x0004)                                      // Abandon
        || (ValEntTOR(DI_AbandonCycle, 0)))                                     // Abandon       
{
    EXP.Command1 = EXP.Command1 & 0xFFFB;                                       // Abandon
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFB;                       // Abandon Profibus
    EXP.Etat1 = EXP.Etat1 | 0x0001;                                             // Bit installation à l'arrêt
    EXP.Etat1 = EXP.Etat1 & 0xFFFB;                                             // Bit installation suspendu
    EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                             // Bit installation en marche

    EXP.BdC_pos_cycle = 0;
}
}


void gestion_cycle_BdC(void)
{
int         indice;

// Recherche si fins de course existent
EXP.BdC_FdcVanneSupFermee = 0;
EXP.BdC_FdcVanneSupOuverte = 0;
EXP.BdC_FdcVanneInfFermee = 0;
EXP.BdC_FdcVanneInfOuverte = 0;

for (indice=1; indice<=10; indice++)
{
    if (PAR.EntreeTOR[indice] == DI_BdC_FdcVanneSupFermee)
        EXP.BdC_FdcVanneSupFermee = indice;
    if (PAR.EntreeTOR[indice] == DI_BdC_FdcVanneSupOuverte)
        EXP.BdC_FdcVanneSupOuverte = indice;
    if (PAR.EntreeTOR[indice] == DI_BdC_FdcVanneInfFermee)
        EXP.BdC_FdcVanneInfFermee = indice;
    if (PAR.EntreeTOR[indice] == DI_BdC_FdcVanneInfOuverte)
        EXP.BdC_FdcVanneInfOuverte = indice;
}

GestionCyclePesage();

BdC_VerifContacts();

switch (EXP.BdC_pos_cycle)
{
    case   0 : BdC_AttenteDCY();
               break;
    case  10 : BdC_InitChargement();
               break;
    case  15 : BdC_AttenteVanneSupOuverte();
               break;
    case  20 : BdC_ChargementGV();
               break;
    case  22 : BdC_ChargementPV();
               break;
    case  25 : BdC_AttenteVanneSupFermee();
               break;
    case  30 : BdC_AttenteStabilite();
               break;
    case  35 : BdC_AttenteAutoriseVidange();
               break;
    case  37 : BdC_AttenteVanneInfOuverte();
               break;
    case  40 : BdC_Vidange();
               break;
    case  45 : BdC_AttenteVanneInfFermee();
               break;
    case  50 : BdC_AttenteStabilite2();
               break;
    case  60 : BdC_ImpressionTicket();
               break;
    case 100 : BdC_Suspension();
               break;
}

// Gestion suspension cycle
if (((EXP.Command1 & 0x0002)                                                    // Suspension cycle
        || (EXP.Profibus_Command & 0x0002)                                      // Suspension cycle
        || (ValEntTOR(DI_SuspensionCycle, 0)))                                  // Suspension cycle
        && ((EXP.BdC_pos_cycle > 0)
        && (EXP.BdC_pos_cycle < 100)))
{
    EXP.BdC_pos_cycleMem = EXP.BdC_pos_cycle;                                   // Mémorisation position cycle

    T100[timer_BdC_VanneSup] = PAR.BdC_TpsMaxOuvFermVannes;
    T100[timer_BdC_VanneInf] = PAR.BdC_TpsMaxOuvFermVannes;

    EXP.BdC_pos_cycle = 100;
}

// Acquittement défauts
if ((EXP.Command1 & 0x0008)                                                     // Acquittement défauts
        || (EXP.Profibus_Command & 0x0008)                                      // Acquittement défauts
        || (ValEntTOR(DI_AcqDefauts, 0)))                                       // Acquittement défauts
{
    EXP.Command1 = EXP.Command1 & 0xFFF7;
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFF7;

    EXP.Defaut1 = 0;
    EXP.Defaut2 = 0;
}

EXP.PosCycle = EXP.BdC_pos_cycle;
}