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

#include "Process.h"


void Dep_AttenteDCY(void)
{
sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                       // Commande fermeture vanne vidange
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)))
{
    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_PoidsCumul = 0;
    EXP.Dep_PoidsDebut = EXP.PoidsMoyen;
    EXP.Dep_PoidsFin = 0;
    EXP.Dep_FinCycle = 0;

    sortiesTOR(DO_CycleEnCours, 1);                                             // Cycle en cours

    EXP.Dep_PosCycle = 2;
}
}


void Dep_AttenteStabilite1(void)                                                // EXP.Dep_PosCycle = 2
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

if (EXP.PoidsStable)
    EXP.Dep_PosCycle = 3;
}


void Dep_AttenteAutoriseVidange(void)                                           // EXP.Dep_PosCycle = 3
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

if (ValEntTOR(DI_ChoixProduit1, 1))
{
    sortiesTOR(DO_BdC_CommVidange, 1);                                          // Commande organe de vidange du vide bigbag

    if ((PAR.Dep_Options & 0x0004) == 0x0004)                                   // Si présence vis vidange
    {
        T100[timer_Dep_TempoDemVidangeVanne] = PAR.Dep_TempoDemVidangeVanne;
        EXP.Dep_PosCycle = 5;
    }
    else
    {
        T100[timer_Dep_TempoDemVidangeVanne] = 0;
        EXP.Dep_PosCycle = 5;
    }
}
}


void Dep_AttAvantOuvertureVanne(void)                                           // EXP.Dep_PosCycle = 5
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

if (!T100[timer_Dep_TempoDemVidangeVanne])
{
    sortiesTOR(DO_BdC_OuvVanneInferieure, 1);                                   // Commande ouverture vanne vidange
    T100[timer_BdC_VanneInf] = PAR.Dep_TpsMaxOuvFermVannes;
    T100[timer_Dep_PauseVibrant] = PAR.Dep_TempsPauseVibrant;
    T100[timer_Dep_VerifEvolutionPoids] = PAR.Dep_TempsVariationPoidsBigBagVide;
    EXP.Dep_PoidsMemEvolutionPoids = EXP.PoidsMoyen;
            
    EXP.Dep_PosCycle = 10;
}
}


void Dep_Chargement(void)                                                       // EXP.Dep_PosCycle = 10
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

//Vérification variation de poids
if ((EXP.PoidsMoyen >= EXP.Dep_PoidsMemEvolutionPoids - PAR.Dep_VariationPoidsBigBagVide)
        && (!T100[timer_Dep_VerifEvolutionPoids]))
{
    EXP.Defaut2 = EXP.Defaut2 | 0x0100;                                         // Pas d'évolution de poids
}
if (EXP.PoidsMoyen < EXP.Dep_PoidsMemEvolutionPoids - PAR.Dep_VariationPoidsBigBagVide)
{
    EXP.Dep_PoidsMemEvolutionPoids = EXP.PoidsMoyen;
    T100[timer_Dep_VerifEvolutionPoids] = PAR.Dep_TempsVariationPoidsBigBagVide;
}

// Gestion du vibrant
if ((PAR.Dep_Options & 0x0008) == 0x0008)                                       // Si présence vibrant
{
    if ((etatSortieTOR(DO_BdC_CommVibrant))
            && (!T100[timer_Dep_MarcheVibrant]))
    {
        sortiesTOR(DO_BdC_CommVibrant, 0);                                      // Commande ouverture vanne vidange
        T100[timer_Dep_PauseVibrant] = PAR.Dep_TempsPauseVibrant;
    }

    if ((!etatSortieTOR(DO_BdC_CommVibrant))
            && (!T100[timer_Dep_PauseVibrant]))
    {
        sortiesTOR(DO_BdC_CommVibrant, 1);                                      // Commande ouverture vanne vidange
        T100[timer_Dep_MarcheVibrant] = PAR.Dep_TempsMarcheVibrant;
    }
}

// Vérification ouverture vanne
if ((PAR.Dep_Options & 0x0001)                                                  // Si presence fin de course vanne ouverte
        && (!T100[timer_BdC_VanneInf])
        && (!ValEntTOR(DI_BdC_FdcVanneInfOuverte, 0)))
{
//  sortiesTOR(DO_OuvVanneInferieure, 0);                                       // Commande fermeture vanne vidange
//  T100[timer_BdC_Vannes] = PAR.Dep_TpsMaxOuvFermVannes;
    EXP.Defaut2 = EXP.Defaut2 | 0x0020;                                         // Défaut ouverture vanne
    
//  EXP.Dep_PosCycle = 50;                                                      // Attente fermeture vanne
}

// Suspension
if ((EXP.Command1 & 0x0002)                                                     // Suspension
        || (EXP.Profibus_Command & 0x0002)                                      // Suspension
        || (ValEntTOR(DI_SuspensionCycle, 0)))
{
    EXP.Command1 = EXP.Command1 & 0xFFFD;                                       // Suspension
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFD;                       // Suspension Profibus

    sortiesTOR(DO_BdC_CommVibrant, 0);                                          // Commande marche vibrant
    sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                   // Commande fermeture vanne vidange
    T100[timer_BdC_VanneInf] = PAR.Dep_TpsMaxOuvFermVannes;

    EXP.Dep_PosCycle = 50;                                                      // Attente fermeture vanne
}

// Consigne atteinte
if (EXP.Dep_PoidsEnCours + PAR.Dep_ErreurJetee >= EXP.Dep_Consigne)
{
    sortiesTOR(DO_BdC_CommVibrant, 0);                                          // Commande marche vibrant
    sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                                   // Commande fermeture vanne vidange
    EXP.Dep_FinCycle = 1;
    T100[timer_BdC_VanneInf] = PAR.Dep_TpsMaxOuvFermVannes;

    EXP.Dep_PosCycle = 50;                                                      // Attente fermeture vanne
}
}


void Dep_AttenteFermVanne(void)                                                 // EXP.Dep_PosCycle = 50
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

if (((PAR.Dep_Options & 0x0002)                                                 // Si presence fin de course vanne fermée
        && (ValEntTOR(DI_BdC_FdcVanneInfFermee))), 0
    || ((!(PAR.Dep_Options & 0x0002))                                           // Si pas presence fin de course et fin tempo
        && (!T100[timer_BdC_VanneInf])))
{
    if ((PAR.Dep_Options & 0x0004) == 0x0004)                                   // Si présence vis vidange
        T100[timer_Dep_TempoArretVidangeVanne] = PAR.Dep_TempoArretVidangeVanne;
    else
        T100[timer_Dep_TempoArretVidangeVanne] = 0;
    EXP.Dep_PosCycle = 55;                                                      // Attente arrêt vidange
}   

// Vérification fermeture vanne
if ((PAR.Dep_Options & 0x0002)                                                  // Si presence fin de course vanne fermée
        && (!T100[timer_BdC_VanneInf])
        && (!ValEntTOR(DI_BdC_FdcVanneInfFermee, 0)))
    EXP.Defaut2 = EXP.Defaut2 | 0x0040;                                         // Défaut fermeture vanne
}


void Dep_AttenteFinVidange(void)                                                // EXP.Dep_PosCycle = 55
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

if (!T100[timer_Dep_TempoArretVidangeVanne])
{
    sortiesTOR(DO_BdC_CommVidange, 0);                                          // Commande organe de vidange du vide bigbag
    EXP.Dep_PosCycle = 57;                                                      // Attente arrêt vidange
}
}


void Dep_AttenteStabilite2(void)                                                // EXP.Dep_PosCycle = 57
{
EXP.Dep_PoidsEnCours = EXP.Dep_PoidsCumul + EXP.Dep_PoidsDebut - EXP.PoidsMoyen;

if (EXP.PoidsStable)
{
    EXP.Dep_PoidsCumul = EXP.Dep_PoidsEnCours;
    if (!EXP.Dep_FinCycle)
    {
        EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                         // Bit installation en marche
        EXP.Etat1 = EXP.Etat1 | 0x0004;                                         // Bit installation en suspension
    
        sortiesTOR(DO_CycleEnCours, 0);                                         // Cycle suspendu
        sortiesTOR(DO_CycleSuspendu, 1);                                        // Cycle suspendu

        EXP.Dep_PosCycle = 60;                                                  // Suspension / Changement Bigbag
    }
    else
    {
        EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                         // Bit installation en marche
        EXP.Etat1 = EXP.Etat1 | 0x0001;                                         // Bit installation à l'arrêt

        if (PAR.Dep_CalculErreurJeteeAuto & 0x0001)
        {
            PAR.Dep_ErreurJetee = PAR.Dep_ErreurJetee + (EXP.Dep_PoidsEnCours - EXP.Dep_Consigne) / 2;
            if (PAR.Dep_ErreurJetee < 0)
                PAR.Dep_ErreurJetee = 0;
        }
        EXP.Dep_PosCycle = 0;
    }
}
}


void Dep_Suspension(void)                                                       // EXP.Dep_PosCycle = 60
{
// Gestion DCY
if ((EXP.Command1 & 0x0001)                                                     // DCY
        || (EXP.Profibus_Command & 0x0001)                                      // DCY
        || (ValEntTOR(DI_DCY, 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_PoidsDebut = EXP.PoidsMoyen;
    EXP.Dep_PoidsFin = 0;
    
    sortiesTOR(DO_CycleEnCours, 1);                                             // Cycle en cours
    sortiesTOR(DO_CycleSuspendu, 0);                                            // Cycle suspendu

    EXP.Dep_PosCycle = 2;
}

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

    sortiesTOR(DO_CycleSuspendu, 0);                                            // Cycle suspendu

    EXP.Dep_PosCycle = 0;
}
}


void gestion_cycle_Depeseur(void)
{
GestionCyclePesage();

switch (EXP.Dep_PosCycle)
{
    case   0 : Dep_AttenteDCY();
               break;
    case   2 : Dep_AttenteStabilite1();
               break;
    case   3 : Dep_AttenteAutoriseVidange();
               break;
    case   5 : Dep_AttAvantOuvertureVanne();
               break;
    case  10 : Dep_Chargement();
               break;
    case  50 : Dep_AttenteFermVanne();
               break;
    case  55 : Dep_AttenteFinVidange();
               break;
    case  57 : Dep_AttenteStabilite2();
               break;
    case  60 : Dep_Suspension();
               break;
}

// Gestion des seuils pesage bigbag
sortiesTOR(DO_BdC_SeuilHaut, (EXP.PoidsMoyen > PAR.Dep_SeuilHaut));             // Poids supérieur au seuil haut
sortiesTOR(DO_BdC_SeuilBas, (EXP.PoidsMoyen < PAR.Dep_SeuilBas));               // Poids inférieur au seuil bas

// Test du retour marche vis vidange
//if ((PAR.Dep_Options & 0xFFFB) == 0x0040)                                       // Présence vis vidange
{
    switch (EXP.Dep_PosCycle)
    {
//        case   5 :                                                              // Attente avant ouverture vanne
        case  10 :                                                              // Chargement
            if (!ValEntTOR(DI_ChoixProduit2, 1))
            {
                sortiesTOR(DO_CycleEnCours, 0);                                 // Cycle en cours
                sortiesTOR(DO_CycleSuspendu, 1);                                // Cycle suspendu
                sortiesTOR(DO_BdC_CommVidange, 0);                              // Commande organe de vidange du vide bigbag
                sortiesTOR(DO_BdC_CommVibrant, 0);                              // Commande ouverture vanne vidange
                sortiesTOR(DO_BdC_OuvVanneInferieure, 0);                       // Commande fermeture vanne vidange

                EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                 // Bit installation en marche
                EXP.Etat1 = EXP.Etat1 | 0x0004;                                 // Bit installation en suspension
            
                EXP.Defaut2 = EXP.Defaut2 | 0x0080;                             // Défaut retour marche vis vidange

                EXP.Dep_PosCycle = 57;                                          // Attente stabilite2
            }
    }

EXP.PosCycle = EXP.Dep_PosCycle;
}

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

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

    T100[timer_Dep_VerifEvolutionPoids] = PAR.Dep_TempsVariationPoidsBigBagVide;
}
}

void gestion_defauts_Depeseur(void)
{
unsigned long   interL;
int             defautGeneral;

interL = EXP.PoidsMoyen*1000;
if ((interL > (PAR.PoidsMax/10))                                                // Défaut Poids > Poids Max
        && (PAR.ActivationDefaut1 & 0x0100))
{
    if (!T100[timer_DefautPoidsMax])
        EXP.Defaut1 = EXP.Defaut1 | 0x0100;
}
else
{
    if (PAR.AcqAutoDefauts)
    {
        T100[timer_DefautPoidsMax] = PAR.TempoDefaut*10*((PAR.AffectTempoDefaut1&0x0100) == 0x0100);
        EXP.Defaut1 = EXP.Defaut1 & 0xFEFF;
    }
}

if (((EXP.PoidsPoints < PAR.DefautCapteurMoins) || (EXP.PoidsPoints > PAR.DefautCapteurPlus))  // Défaut Capteur
        && (PAR.ActivationDefaut1 & 0x1000))
{
    if (!T100[timer_DefautCapteur])
        EXP.Defaut1 = EXP.Defaut1 | 0x1000;
}
else
{
    if (PAR.AcqAutoDefauts)
    {
        T100[timer_DefautCapteur] = PAR.TempoDefaut*10*((PAR.AffectTempoDefaut1&0x1000) == 0x1000);
        EXP.Defaut1 = EXP.Defaut1 & 0xEFFF;
    }
}

defautGeneral = calculDefautGeneral();
if (defautGeneral > 0)                                                          
{
    EXP.Defaut1 = EXP.Defaut1 | 0x0004;                                         // Défaut général
    sortiesTOR(DO_DefGeneral, 1);
} else
{
    EXP.Defaut1 = EXP.Defaut1 & 0xFFFB;                                         // Défaut général
    sortiesTOR(DO_DefGeneral, 0);
}
}


