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

#include "Process.h"
#include "Regul.h"


void PdP_AttenteDCY(void)                                                       // EXP.PdP_PosCycle = 0
{
sortiesTOR(DO_CycleEnCours, 0);                                                 // Cycle en cours
EXP.PosCycleRegulation = 0;

// DCY
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0001)                              // DCY
            || (EXP.Profibus_Command & 0x0001)))                                // DCY
        || (PAR.CommandeTOR) && (ValEntTOR(DI_DCY, 0)))
{
    if ((PAR.Consigne*1000 >= PAR.LimiteConsigneNulle)
            && (EXP.PosCycleRegulation == 0))
    {
        EXP.Command1 = EXP.Command1 & 0xFFFE;
        EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFE;
        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.PdP_PremierRemplissage = 1;
        if (EXP.PdP_NiveauB)
            EXP.PdP_PosCycle = 30;                                              // Remplissage
        else
        {
            EXP.PosCycleRegulation = 10;
            T100[timer_Volumetrique] = PAR.TempsFonctVolumetrique;

            EXP.PdP_PosCycle = 10;                                              // Dosage volumétrique
        }
    }
}
}

void PdP_DosageVolumetrique(void)                                               // EXP.PdP_PosCycle = 10
{
sortiesTOR(DO_CycleEnCours, 1);                                                 // Cycle en cours
sortiesTOR(DO_PdP_CommandeExtracteur, 1);                                       // Commande extracteur

if (EXP.PdP_NiveauB)
    EXP.PdP_PosCycle = 30;                                                      // Remplissage

if (!T100[timer_Volumetrique])
{
    EXP.PosCycleRegulation = 20;
    EXP.PdP_PosCycle = 20;                                                      // Dosage volumétrique
}

// Suspension
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0002)                              // Suspension
            || (EXP.Profibus_Command & 0x0002)))                                // Suspension
        || (PAR.CommandeTOR) && (ValEntTOR(DI_SuspensionCycle, 0)))
{
    EXP.Command1 = EXP.Command1 & 0xFFFD;
    EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                             // Bit installation en marche
    EXP.Etat1 = EXP.Etat1 | 0x0004;                                             // Bit installation en suspension

    sortiesTOR(DO_PdP_CommandeExtracteur, 0);                                   // Commande extracteur

    EXP.PdP_PosCycleMem = 10;
    EXP.PdP_PosCycle = 100;                                                     // Suspension
}
}


void PdP_DosageRegulation(void)                                                 // EXP.PdP_PosCycle = 20
{
sortiesTOR(DO_CycleEnCours, 1);                                                 // Cycle en cours
sortiesTOR(DO_PdP_CommandeExtracteur, 1);                                       // Commande extracteur

if (EXP.PdP_NiveauB)
    EXP.PdP_PosCycle = 30;                                                      // Remplissage

// Suspension
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0002)                              // Suspension
            || (EXP.Profibus_Command & 0x0002)))                                // Suspension
        || (PAR.CommandeTOR) && (ValEntTOR(DI_SuspensionCycle, 0)))
{
    EXP.Command1 = EXP.Command1 & 0xFFFD;
    EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                             // Bit installation en marche
    EXP.Etat1 = EXP.Etat1 | 0x0004;                                             // Bit installation en suspension

    sortiesTOR(DO_PdP_CommandeExtracteur, 0);                                   // Commande extracteur

    EXP.PdP_PosCycleMem = 20;
    EXP.PdP_PosCycle = 100;                                                     // Suspension
}
}


void PdP_Remplissage(void)                                                      // EXP.PdP_PosCycle = 30
{
sortiesTOR(DO_PdP_DemandeRemplissage, 1);                                       // Demande remplissage
EXP.Etat2 = EXP.Etat2 | 0x0002;                                                 // Bascule en remplissage

if (EXP.PdP_NiveauH)
{
    sortiesTOR(DO_PdP_DemandeRemplissage, 0);                                   // Demande remplissage
    EXP.PdP_PosCycle = 35;                                                      // Attente fin remplissage
}

// Suspension
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0002)                              // Suspension
            || (EXP.Profibus_Command & 0x0002)))                                // Suspension
        || (PAR.CommandeTOR) && (ValEntTOR(DI_SuspensionCycle, 0)))
{
    sortiesTOR(DO_PdP_DemandeRemplissage, 0);                                   // Demande remplissage

    EXP.Command1 = EXP.Command1 & 0xFFFD;
    EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                             // Bit installation en marche
    EXP.Etat1 = EXP.Etat1 | 0x0004;                                             // Bit installation en suspension
    EXP.Etat2 = EXP.Etat2 & 0xFFFD;                                             // Bascule en remplissage
    EXP.PdP_IndiceTabPoids = 0;

    T100[timer_PdP_TempoRepriseRegul] = PAR.Pdp_TempoRepriseRegulation*10;
    EXP.PdP_PosCycleMem = 30;
    EXP.PdP_PosCycle = 100;                                                     // En suspension
}
}


void PdP_FinRemplissage(void)                                                   // EXP.PdP_PosCycle = 35
{
sortiesTOR(DO_PdP_DemandeRemplissage, 1);                                       // Demande remplissage
EXP.Etat2 = EXP.Etat2 | 0x0002;                                                 // Bascule en remplissage

if (!T100[timer_PdP_TempoRepriseRegul])
{
    EXP.Etat2 = EXP.Etat2 & 0xFFFD;                                             // Bascule en remplissage

    if (EXP.PdP_PremierRemplissage)
    {
        T100[timer_Volumetrique] = PAR.TempsFonctVolumetrique;
        EXP.PosCycleRegulation = 10;
        EXP.PdP_PosCycle = 10;                                                  // Dosage en volumétrique
    }
    else
        EXP.PdP_PosCycle = 20;                                                  // Dosage en régulation
}

// Suspension
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0002)                              // Suspension
            || (EXP.Profibus_Command & 0x0002)))                                // Suspension
        || (PAR.CommandeTOR) && (ValEntTOR(DI_SuspensionCycle, 0)))
{
    EXP.Command1 = EXP.Command1 & 0xFFFD;
    EXP.Etat1 = EXP.Etat1 & 0xFFFD;                                             // Bit installation en marche
    EXP.Etat1 = EXP.Etat1 | 0x0004;                                             // Bit installation en suspension
    EXP.Etat2 = EXP.Etat2 & 0xFFFD;                                             // Bascule en remplissage

    sortiesTOR(DO_PdP_DemandeRemplissage, 1);                                   // Demande remplissage

    EXP.PdP_PosCycleMem = 35;
    EXP.PdP_PosCycle = 100;                                                     // En suspension
}
}


void PdP_Suspension(void)                                                       // EXP.PdP_PosCycle = 100
{
// DCY
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0001)                              // DCY
            || (EXP.Profibus_Command & 0x0001)))                                // DCY
        || (PAR.CommandeTOR) && (ValEntTOR(DI_DCY, 0)))
{
    EXP.Command1 = EXP.Command1 & 0xFFFE;
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFE;
    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.PdP_PosCycleMem)
    {
        case 10 : EXP.PdP_PosCycle = 10;                                        // Dosage volumétrique
                  break;
        case 20 : EXP.PdP_PosCycle = 20;                                        // Dosage régulation
                  break;
    }
}

// Abandon
if ((PAR.CommandeSerie && ((EXP.Command1 & 0x0004)                              // Abandon
            || (EXP.Profibus_Command & 0x0004)))                                // Abandon
        || (PAR.CommandeTOR) && (ValEntTOR(DI_AbandonCycle, 0)))
{
    EXP.Command1 = EXP.Command1 & 0xFFFB;
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFFB;
    EXP.Etat1 = EXP.Etat1 & 0xFFFB;                                             // Bit installation suspendu
    EXP.Etat1 = EXP.Etat1 | 0x0001;                                             // Bit installation à l'arrêt
    sortiesTOR(DO_CycleEnCours, 0);                                             // Cycle en cours
    
    EXP.PdP_PosCycle = 0;                                                       // Attente DCY
}
}


void gestion_cycle_PerteDePoids(void)
{
float               interf;
int                 indice;

// Gestion tarage, etalonnage
GestionCyclePesage();

if (!T10[timer_PdP_AcqPoids])
{
    T10[timer_PdP_AcqPoids] = 10;

    if (EXP.PdP_IndiceTabPoids < 95)
    {
        EXP.PdP_Tab_Poids[EXP.PdP_IndiceTabPoids] = EXP.PoidsMoyen;
        EXP.PdP_IndiceTabPoids++;
    }
    else
    {
        for (indice=0; indice<96; indice++)
            EXP.PdP_Tab_Poids[indice] = EXP.PdP_Tab_Poids[indice+1];
        EXP.PdP_Tab_Poids[96] = EXP.PoidsMoyen;
    }   
}
if (EXP.PdP_IndiceTabPoids > 10)
    EXP.DebitMoyen = ((EXP.PdP_Tab_Poids[0] - EXP.PdP_Tab_Poids[EXP.PdP_IndiceTabPoids-1])/(EXP.PdP_IndiceTabPoids-1))*10000;

RegulationPdP();

Test();

// Gestion des seuils
interf = PAR.Pdp_SeuilNiveauTH; interf = (interf/1000) * PAR.PoidsMax /10000;
EXP.PdP_NiveauTH = (EXP.PoidsMoyen >= interf);
sortiesTOR(DO_PdP_SeuilTH, EXP.PdP_NiveauTH);                                   // Niveau très haut

interf = PAR.Pdp_SeuilNiveauH; interf = (interf/1000) * PAR.PoidsMax /10000;
EXP.PdP_NiveauH = (EXP.PoidsMoyen >= interf);
sortiesTOR(DO_PdP_SeuilH, EXP.PdP_NiveauH);                                     // Niveau haut

interf = PAR.Pdp_SeuilNiveauB; interf = (interf/1000) * PAR.PoidsMax /10000;
EXP.PdP_NiveauB = (EXP.PoidsMoyen <= interf);
sortiesTOR(DO_PdP_SeuilB, EXP.PdP_NiveauB);                                     // Niveau bas

interf = PAR.Pdp_SeuilNiveauTB; interf = (interf/1000) * PAR.PoidsMax /10000;
EXP.PdP_NiveauTB = (EXP.PoidsMoyen <= interf);
sortiesTOR(DO_PdP_SeuilTB, EXP.PdP_NiveauTB);                                   // Niveau très bas

// Gestion cycle de chargement
switch (EXP.PdP_PosCycle)
{
    case   0 : PdP_AttenteDCY();
               break;
    case  10 : PdP_DosageVolumetrique();
               break;
    case  20 : PdP_DosageRegulation();
               break;
    case  30 : PdP_Remplissage();
               break;
    case  35 : PdP_FinRemplissage();
               break;
    case 100 : PdP_Suspension();
               break;
    default :  EXP.PdP_PosCycle = 0;
}

// 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;
}
}


void Test(void)
{
switch (EXP.PdP_PosCycle)
{
    case  10 :
    case  20 : EXP.PoidsMoyen = EXP.PoidsMoyen -0.0001;
               break;
    case  30 : EXP.PoidsMoyen = EXP.PoidsMoyen +0.01;
               break;
}
EXP.PoidsMoyenAff = EXP.PoidsMoyen;

}