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

/* Device header file */
#if defined(__XC16__)
#include <xc.h>
#endif

#include <stdint.h>                                                             /* For uint16_t definition                       */
#include <stdbool.h>                                                            /* For true/false definition                     */
#include "Process.h"

void GestionCyclePesage(void)
{
float           PenteInter;
int             NbPulsesAtteindre;
int             interI;
float           interF;

//********** TARAGE STATIQUE **********//
// Tarage statique métrologie ou utilisateur
if ((((EXP.Command1 & 0x0100) && (ValEntTOR(DI_AutorisationReglage, 1)))        // Tarage statique utilisateur
        || (EXP.Command3 & 0x0001))                                             // Tarage statique métrologique
        && (EXP.Etat1 && 0x0001)                                                // Bascule à l'arrêt
        && (!EXP.ReglEnCours))
{
    sortiesTOR(DO_ReglageEnCours, 1);                                           // Réglage en cours

    EXP.ReglageMetrologique = (EXP.Command3 & 0x0001);
    EXP.Etat1 = EXP.Etat1 | 0x0020;                                             // Tarage en cours
    EXP.Etat1 = EXP.Etat1 & 0xFFBF;                                             // Tarage OK
    EXP.Command1 = EXP.Command1 & 0xFEFF;                                       // Tarage statique utilisateur
    EXP.Command3 = EXP.Command3 & 0xFFFE;                                       // Tarage statique métrologique
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFEF;                       // Tarage statique profibus
    EXP.ReglEnCours = 1;
    EXP.NbMesureReglage = 0;
    EXP.TotalReglageFloat = 0.0;
    EXP.TotIncReglageFloat = 0.0;
    EXP.posTarageStatique = 10;
    T100[timer_TarageStatique] = 20;
}

// Tarage statique métrologie ou utilisateur en cours
if (EXP.posTarageStatique == 10)                                                // Tarage en cours
{
    if (!T100[timer_TarageStatique])                                            // Fin du temps de tarage
    {
        if (EXP.NbMesureReglage > 0)
            EXP.TareNew = EXP.TotIncReglageFloat / EXP.NbMesureReglage;

        if (EXP.ReglageMetrologique == 0)
        {
            PenteInter = (PAR.TareMetrologie - EXP.TareNew);
            if (PenteInter < 0)
                PenteInter *= (-1);

            interF = PAR.PoidsMax; interF = interF * PAR.ToleranceTarage / 100 / 10000;
            interF = interF * 100000 / PAR.Pente[1];
            if ((EXP.TareNew <= PAR.TareMetrologie + interF)
                    && (EXP.TareNew >= PAR.TareMetrologie - interF))
            {
                PAR.TareInc = EXP.TareNew;
                EXP.Etat1 = EXP.Etat1 | 0x0040;                                 // Tarage OK
                EXP.Defaut1 = EXP.Defaut1 & 0xDFFF;                             // Tarage hors tolérance
            }
            else
                EXP.Defaut1 = EXP.Defaut1 | 0x2000;                             // Tarage hors tolérance
        }
        else
        {
            PAR.TareInc = EXP.TareNew;
            PAR.TareMetrologie =  EXP.TareNew;
            EXP.Etat1 = EXP.Etat1 | 0x0040;                                     // Tarage OK
            EXP.Defaut1 = EXP.Defaut1 & 0xDFFF;                                 // Tarage hors tolérance
        }

        EXP.Etat1 = EXP.Etat1 & 0xFFDF;                                         // Tarage en cours
        EXP.ReglEnCours = 0;
        EXP.ReglageMetrologique = 0;
        EXP.posTarageStatique = 20;

        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
    }

    if (EXP.Command1 & 0x0400)                                                  // Abandon
    {
        EXP.Command1 = EXP.Command1 & 0xFBFF;                                   // Abandon
        EXP.Etat1 = EXP.Etat1 & 0xFFDF;                                         // Tarage en cours
        EXP.ReglEnCours = 0;
        EXP.ReglageMetrologique = 0;
        EXP.posTarageStatique = 0;

        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
    }
}

if ((EXP.ReglageMetrologique == 0) && (!ValEntTOR(DI_AutorisationReglage, 1))   // Abandon tarage si perte autorisation réglage
        && (EXP.posTarageStatique >= 10))
{
    EXP.Etat1 = EXP.Etat1 & 0xFFDF;                                             // Tarage en cours
    EXP.ReglEnCours = 0;
    EXP.ReglageMetrologique = 0;
    EXP.posTarageStatique = 0;

    sortiesTOR(DO_ReglageEnCours, 0);                                           // Réglage en cours
}


//********** TARAGE DYNAMIQUE OU AUTOMATIQUE **********//
interF = PAR.DebitMax*PAR.LimZeroAuto/100;                                      // Calcul de la zone de tarage automatique
// Tarage automatique utilisateur
if ((EXP.Etat1 & 0x0002)                                                        // Bascule en marche
        && (!EXP.ReglEnCours)
        && (PAR.LimZeroAuto > 0)
        && (ValEntTOR(DI_AutorisationReglage))
        && (!T100[timer_FinTarageAuto])
        && (EXP.DebitMoyen <= interF))
{
    EXP.Etat1 = EXP.Etat1 | 0x0010;                                             // Attente début tarage
    EXP.Etat1 = EXP.Etat1 | 0x0020;                                             // Tarage en cours
    EXP.Etat1 = EXP.Etat1 & 0xFFBF;                                             // Tarage OK
    EXP.ReglEnCours = 1;
    EXP.ReglAutoEnCours = 1;
    EXP.TotPulseReglage = 0;
    EXP.NbMesureReglage = 0;
    EXP.TotalReglageFloat = 0.0;
    EXP.TotIncReglageFloat = 0.0;
    EXP.NbPulsesRestantReglage = PAR.NbPulsesAvantReglage;

    if (PAR.VitesseManu > 0.0)                                                  // Tarage avec vitesse fixe
        T100[timer_TarageDynamique] = 50;

    EXP.posTarageDynamique = 10;                                                // Attente démarrage bande
    sortiesTOR(DO_ReglageEnCours, 1);                                           // Réglage en cours
    sortiesTOR(DO_CommandeBande, 1);                                            // Commande marche bande
}

// Tarage dynamique métrologie ou utilisateur
if ((((EXP.Command1 & 0x0200) && (ValEntTOR(DI_AutorisationReglage, 1)))        // Tarage dynamique utilisateur
        || (EXP.Command3 & 0x0002)                                              // Tarage dynamique métrologique
        || ((EXP.Profibus_Command & 0x0010) && (ValEntTOR(DI_AutorisationReglage, 1)))  // Tarage dynamique utilisateur profibus
        || ((ValEntTOR(DI_Tarage, 0)) && (ValEntTOR(DI_AutorisationReglage, 1))))       // Tarage dynamique utilisateur entrée TOR
//      && (EXP.Etat1 && 0x0001)                                                // Bascule à l'arrêt
        && (!EXP.ReglEnCours))
{
    EXP.ReglageMetrologique = (EXP.Command3 & 0x0002);
    EXP.Command1 = EXP.Command1 & 0xFDFF;                                       // Tarage dynamique utilisateur
    EXP.Command3 = EXP.Command3 & 0xFFFD;                                       // Tarage dynamique métrologie
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFFEF;                       // Tarage dynamique utilisateur
    EXP.Etat1 = EXP.Etat1 | 0x0010;                                             // Attente début tarage
    EXP.Etat1 = EXP.Etat1 | 0x0020;                                             // Tarage en cours
    EXP.Etat1 = EXP.Etat1 & 0xFFBF;                                             // Tarage OK
    EXP.ReglEnCours = 1;
    EXP.TotPulseReglage = 0;
    EXP.NbMesureReglage = 0;
    EXP.TotalReglageFloat = 0.0;
    EXP.TotIncReglageFloat = 0.0;
    EXP.NbPulsesRestantReglage = PAR.NbPulsesAvantReglage;

    if (PAR.VitesseManu > 0.0)                                                  // Tarage avec vitesse fixe
        T100[timer_TarageDynamique] = 50;

    EXP.posTarageDynamique = 10;                                                // Attente démarrage bande
    sortiesTOR(DO_ReglageEnCours, 1);                                           // Réglage en cours
    sortiesTOR(DO_CommandeBande, 1);                                            // Commande marche bande
}

// Abandon tarage dynamique
if (((EXP.Command1 & 0x0400)
        || (EXP.Profibus_Command & 0x0400)
        || (EXP.posTarageDynamique == 25))                                      // Abandon tarage automatique
        && (EXP.posTarageDynamique >= 10))
{
    EXP.Command1 = EXP.Command1 & 0xFBFF;                                       // Abandon
    EXP.Profibus_Command = EXP.Profibus_Command & 0xFBFF;                       // Tarage dynamique utilisateur
    EXP.Etat1 = EXP.Etat1 & 0xFFDF;                                             // Tarage en cours
    EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                             // Attente début réglage
    EXP.Etat1 = EXP.Etat1 & 0xFFBF;                                             // Tarage OK
    EXP.ReglEnCours = 0;
    EXP.ReglAutoEnCours = 0;
    EXP.ReglageMetrologique = 0;
    EXP.posTarageDynamique = 0;

    sortiesTOR(DO_ReglageEnCours, 0);                                           // Réglage en cours
    if (!EXP.ReglAutoEnCours)
        sortiesTOR(DO_CommandeBande, 0);                                        // Commande marche bande
}

if ((EXP.ReglageMetrologique == 0) && (!ValEntTOR(DI_AutorisationReglage, 1))   // Abandon tarage si perte autorisation réglage
        && (EXP.posTarageDynamique >= 10))
    {
        EXP.ReglEnCours = 0;
        EXP.posTarageDynamique = 25;                                            // Abandon tarage
    }

if ((EXP.ReglAutoEnCours)
        && (EXP.posTarageDynamique >= 10))
{
    interF = PAR.PoidsMax; interF = (interF/1000)*PAR.LimZeroAuto/100;          // Poids = 0 si on est dans la zone de tarage
    if (!(EXP.Etat1 & 0x0002)                                                   // Bascule en marche
            || (EXP.PoidsMoyen > interF)
            || (EXP.PoidsMoyen < -interF))
    {
        EXP.ReglEnCours = 0;
        EXP.posTarageDynamique = 25;                                            // Abandon tarage
    }
}

// Attente début tarage dynamique
if (EXP.posTarageDynamique == 10)
{
    if ((PAR.VitesseManu > 0.0) && (!T100[timer_TarageDynamique]))              // Fin du temps de tarage
    {
        T100[timer_TarageDynamique] = (PAR.LongueurBande/PAR.VitesseManu)*10;
        EXP.posTarageDynamique = 20;                                            // Attente fin x tours de bande
        EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                         // Attente début tarage
        EXP.ReglEnCours = 1;
        EXP.TotPulseReglage = 0;
        EXP.NbMesureReglage = 0;
        EXP.TotalReglageFloat = 0.0;
        EXP.TotIncReglageFloat = 0.0;
    }
    
    if (PAR.VitesseManu > 0.0)
        EXP.NbPulsesRestantReglage = T100[timer_TarageDynamique]/10;
    else
        EXP.NbPulsesRestantReglage = PAR.NbPulsesAvantReglage - EXP.TotPulseReglage;

    if (EXP.TotPulseReglage >= PAR.NbPulsesAvantReglage)
    {
        EXP.posTarageDynamique = 20;                                            // Attente fin x tours de bande
        EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                         // Attente début tarage
        EXP.ReglEnCours = 1;
        EXP.TotPulseReglage = 0;
        EXP.NbMesureReglage = 0;
        EXP.TotalReglageFloat = 0.0;
        EXP.TotIncReglageFloat = 0.0;
        EXP.NbPulsesRestantReglage = PAR.NbTourBandesReglage * (PAR.ImpTambMene * PAR.LongueurBande / PAR.CirconfTambMene);
    }
}

// Tarage dynamique
if (EXP.posTarageDynamique == 20)
{
    if ((EXP.ReglEnCours)
            && (((PAR.VitesseManu > 0.0) && (!T100[timer_TarageDynamique]))     // Fin du temps de tarage
            || ((PAR.VitesseManu == 0.0)
                && (EXP.TotPulseReglage > PAR.NbTourBandesReglage *             // ou fin des tours de bande
                   (PAR.ImpTambMene * PAR.LongueurBande / PAR.CirconfTambMene)))))
    {
        if (EXP.NbMesureReglage > 0)
            EXP.TareNew = EXP.TotIncReglageFloat / EXP.NbMesureReglage;

        if (EXP.ReglageMetrologique == 0)
        {
            interF = PAR.PoidsMax; interF = interF * PAR.ToleranceTarage / 100 / 10000;
            interF = interF * 100000 / PAR.Pente[1];
            if ((EXP.TareNew <= PAR.TareMetrologie + interF)
                    && (EXP.TareNew >= PAR.TareMetrologie - interF))
            {
                PAR.TareInc = EXP.TareNew;
                EXP.Defaut1 = EXP.Defaut1 & 0xDFFF;                             // Tarage hors tolérance
                if (!EXP.ReglAutoEnCours)
                    EXP.Etat1 = EXP.Etat1 | 0x0040;                             // Tarage OK
            }
            else
                EXP.Defaut1 = EXP.Defaut1 | 0x2000;                             // Tarage hors tolérance

        } else
        {
            PAR.TareInc = EXP.TareNew;
            PAR.TareMetrologie =  EXP.TareNew;
            EXP.Etat1 = EXP.Etat1 | 0x0040;                                     // Tarage OK
            EXP.Defaut1 = EXP.Defaut1 & 0xDFFF;                                 // Tarage hors tolérance
        }
        EcrFRAM_Param();

        if (EXP.ReglAutoEnCours)
        {
            T100[timer_FinTarageAuto] = 600;
        }
        else
            sortiesTOR(DO_CommandeBande, 0);                                    // Commande marche bande
            
        EXP.Etat1 = EXP.Etat1 & 0xFFDF;                                         // Tarage en cours
        EXP.ReglEnCours = 0;
        EXP.ReglAutoEnCours = 0;
        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
        EXP.posTarageDynamique = 0;
    }

    if (PAR.VitesseManu > 0.0)
        EXP.NbPulsesRestantReglage = T100[timer_TarageDynamique]/10;
    else
        EXP.NbPulsesRestantReglage = PAR.NbTourBandesReglage
                * (PAR.ImpTambMene * PAR.LongueurBande / PAR.CirconfTambMene) - EXP.TotPulseReglage;
}


//********** TARAGE STATIQUE **********//
// Etalonnage statique métrologie
if ((EXP.Command3 & 0x0004)                                                     // Etalonnage statique
        && (EXP.Etat1 && 0x0001)                                                // Bascule à l'arrêt
        && (!EXP.ReglEnCours))
{
    sortiesTOR(DO_ReglageEnCours, 1);                                           // Réglage en cours

    EXP.Etat1 = EXP.Etat1 | 0x0080;                                             // Etalonnage en cours
    EXP.Etat1 = EXP.Etat1 & 0xFEFF;                                             // Etalonnage OK
    EXP.Command3 = EXP.Command3 & 0xFFFB;                                       // Etalonnage statique métrologique
    EXP.ReglEnCours = 1;
    EXP.NbMesureReglage = 0;
    EXP.TotalReglageFloat = 0.0;
    EXP.TotIncReglageFloat = 0.0;
    EXP.posEtalonnageStatique = 10;
    T100[timer_EtalonnageStatique] = 20;
}

// Etalonnage statique métrologie en cours
if (EXP.posEtalonnageStatique == 10)                                            // Etalonnage en cours
{
    if (!T100[timer_EtalonnageStatique])                                        // Fin du temps de tarage
    {
        if (EXP.NbMesureReglage > 0)
        {
            EXP.TareNew = EXP.TotIncReglageFloat / EXP.NbMesureReglage;
        }
        interF = PAR.RapportEtalonnage;
        interF = interF / 1000;

        PenteInter = (PAR.SeuilPente[PAR.NumPointEtalonnage] * interF * 100000) / (EXP.TareNew - PAR.TareInc);
        PAR.Pente[PAR.NumPointEtalonnage] = PenteInter;

        EXP.Etat1 = EXP.Etat1 | 0x0100;                                         // Etalonnage OK
        EXP.Etat1 = EXP.Etat1 & 0xFF7F;                                         // Etalonnage en cours
        EXP.ReglEnCours = 0;
        EXP.ReglageMetrologique = 0;
        EXP.posEtalonnageStatique = 20;

        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
    }

    if ((EXP.Command1 & 0x0400)                                                 // Abandon
        || (EXP.Profibus_Command & 0x0400))
    {
        EXP.Command1 = EXP.Command1 & 0xFBFF;                                   // Abandon
        EXP.Profibus_Command = EXP.Profibus_Command & 0xFBFF;
        EXP.Etat1 = EXP.Etat1 & 0xFF7F;                                         // Etalonnage en cours
        EXP.ReglEnCours = 0;
        EXP.ReglageMetrologique = 0;
        EXP.posEtalonnageStatique = 20;

        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
    }
}

// Etalonnage dynamique métrologie
if ((EXP.Command3 & 0x0008)                                                     // Etalonnage dynamique
        && (EXP.Etat1 && 0x0001)                                                // Bascule à l'arrêt
        && (!EXP.ReglEnCours))
{
    EXP.Command3 = EXP.Command3 & 0xFFF7;                                       // Etalonnage dynamique métrologie
    EXP.Etat1 = EXP.Etat1 | 0x0010;                                             // Attente début réglage
    EXP.Etat1 = EXP.Etat1 & 0xFEFF;                                             // Etalonnage OK
    EXP.ReglEnCours = 1;
    EXP.TotPulseReglage = 0;
    EXP.NbMesureReglage = 0;
    EXP.TotalReglageFloat = 0.0;
    EXP.TotIncReglageFloat = 0.0;
    EXP.NbPulsesRestantReglage = PAR.NbPulsesAvantReglage;

    if (PAR.VitesseManu > 0.0)                                                  // Fin du temps de tarage
    {
        T100[timer_TarageDynamique] = 50;
    }
    
    EXP.posEtalonnageDynamique = 10;                                            // Attente démarrage bande
    sortiesTOR(DO_ReglageEnCours, 1);                                           // Réglage en cours
    sortiesTOR(DO_CommandeBande, 1);                                            // Commande marche bande
}

// Abandon étalonnage dynamique
if ((EXP.Command1 & 0x0400) && (EXP.posEtalonnageDynamique >= 10))
{
    EXP.Command1 = EXP.Command1 & 0xFBFF;                                       // Abandon
    EXP.Etat1 = EXP.Etat1 & 0xFF7F;                                             // Etalonnage en cours
    EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                             // Attente début réglage
    EXP.Etat1 = EXP.Etat1 & 0xFEFF;                                             // Etalonnage OK
    EXP.ReglEnCours = 0;
    EXP.ReglageMetrologique = 0;
    EXP.posEtalonnageDynamique = 0;

    sortiesTOR(DO_ReglageEnCours, 0);                                           // Réglage en cours
    sortiesTOR(DO_CommandeBande, 0);                                            // Commande marche bande
}

// Attente début étalonnage dynamique
if (EXP.posEtalonnageDynamique == 10)
{
    if (PAR.VitesseManu > 0.0)
        EXP.NbPulsesRestantReglage = T100[timer_TarageDynamique]/10;
    else
        EXP.NbPulsesRestantReglage = PAR.NbPulsesAvantReglage - EXP.TotPulseReglage;

    if ((PAR.VitesseManu > 0.0) && (!T100[timer_TarageDynamique]))              // Fin du temps de tarage
    {
        T100[timer_TarageDynamique] = (PAR.LongueurBande/PAR.VitesseManu)*10;
        EXP.posEtalonnageDynamique = 20;                                        // Attente fin x tours de bande
        EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                         // Attente début réglage
        EXP.Etat1 = EXP.Etat1 | 0x0080;                                         // Etalonnage en cours
        EXP.ReglEnCours = 1;
        EXP.TotPulseReglage = 0;
        EXP.NbMesureReglage = 0;
        EXP.TotalReglageFloat = 0.0;
        EXP.TotIncReglageFloat = 0.0;
    }

    if (EXP.TotPulseReglage >= PAR.NbPulsesAvantReglage)
    {
        EXP.posEtalonnageDynamique = 20;                                        // Attente fin x tours de bande
        EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                         // Attente début réglage
        EXP.Etat1 = EXP.Etat1 | 0x0080;                                         // Etalonnage en cours
        EXP.ReglEnCours = 1;
        EXP.TotPulseReglage = 0;
        EXP.NbMesureReglage = 0;
        EXP.TotalReglageFloat = 0.0;
        EXP.TotIncReglageFloat = 0.0;
        EXP.NbPulsesRestantReglage = PAR.NbTourBandesReglage * (PAR.ImpTambMene * PAR.LongueurBande / PAR.CirconfTambMene);
    }
}

// Etalonnage dynamique
if (EXP.posEtalonnageDynamique == 20)
{
    interF = PAR.RapportEtalonnage;
    interF = interF / 1000;

    if (PAR.VitesseManu > 0.0)
        EXP.NbPulsesRestantReglage = T100[timer_TarageDynamique]/10;
    else
        EXP.NbPulsesRestantReglage = PAR.NbTourBandesReglage
                * (PAR.ImpTambMene * PAR.LongueurBande / PAR.CirconfTambMene) - EXP.TotPulseReglage;

    if ((PAR.VitesseManu > 0.0) && (!T100[timer_TarageDynamique]))              // Fin du temps de tarage
    {
        if (EXP.NbMesureReglage > 0)
            EXP.TareNew = EXP.TotIncReglageFloat / EXP.NbMesureReglage;

        PenteInter = (PAR.SeuilPente[PAR.NumPointEtalonnage] * interF * 100000) / (EXP.TareNew - PAR.TareInc);
        PAR.Pente[PAR.NumPointEtalonnage] = PenteInter;

        EXP.Etat1 = EXP.Etat1 | 0x0100;                                         // Etalonnage OK
        EXP.Etat1 = EXP.Etat1 & 0xFF7F;                                         // Etalonnage en cours
        EXP.ReglEnCours = 0;
        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
        sortiesTOR(DO_CommandeBande, 0);                                        // Commande marche bande
        EXP.posEtalonnageDynamique = 0;
    }

    if (EXP.TotPulseReglage > PAR.NbTourBandesReglage *
            (PAR.ImpTambMene * PAR.LongueurBande / PAR.CirconfTambMene))
    {
        if (EXP.NbMesureReglage > 0)
            EXP.TareNew = EXP.TotIncReglageFloat / EXP.NbMesureReglage;

        PenteInter = (PAR.SeuilPente[PAR.NumPointEtalonnage] * interF * 100000) / (EXP.TareNew - PAR.TareInc);
        PAR.Pente[PAR.NumPointEtalonnage] = PenteInter;

        EXP.Etat1 = EXP.Etat1 | 0x0100;                                         // Etalonnage OK
        EXP.Etat1 = EXP.Etat1 & 0xFF7F;                                         // Etalonnage en cours
        EXP.ReglEnCours = 0;
        sortiesTOR(DO_ReglageEnCours, 0);                                       // Réglage en cours
        sortiesTOR(DO_CommandeBande, 0);                                        // Commande marche bande
        EXP.posEtalonnageDynamique = 0;
    }
}

// Controle
if (((EXP.Command1 & 0x0800)                                                    // Controle avec arrêt sur nombre de pulses
        || (EXP.Command1 & 0x1000))                                             // Controle avec arrêt sur abandon
        && (!EXP.ReglEnCours))  
{
    EXP.ControlAvecAbandon = 0;
    if (EXP.Command1 & 0x1000)                                                  // Controle avec arrêt sur abandon
        EXP.ControlAvecAbandon = 1;
    EXP.Command1 = EXP.Command1 & 0xF7FF;                                       // Controle avec arrêt sur nombre de pulses
    EXP.Command1 = EXP.Command1 & 0xEFFF;                                       // Controle avec arrêt sur abandon
    EXP.posControleDynamique = 10;                                              // Attente démarrage bande
    sortiesTOR(DO_CommandeBande, 1);
    EXP.Etat1 = EXP.Etat1 | 0x0010;                                             // Attente début controle
    EXP.ReglEnCours = 1;
    EXP.TotPulseReglage = 0;
    EXP.NbMesureReglage = 0;
    EXP.TotalReglageFloat = 0.0;
    EXP.TotIncReglageFloat = 0.0;
    EXP.PulseTotal = 0;
    if (PAR.VitesseManu > 0.0)
        T100[timer_TarageDynamique] = PAR.NbPulsesAvantReglage;
}

if (EXP.posControleDynamique == 10)                                             // Attente début controle
{
    if (PAR.VitesseManu > 0.0)
        EXP.NbPulsesRestantReglage = T100[timer_TarageDynamique]/10;
    else
        EXP.NbPulsesRestantReglage = PAR.NbPulsesAvantReglage - EXP.TotPulseReglage;

    if (((PAR.VitesseManu == 0.0) && (EXP.TotPulseReglage > PAR.NbPulsesAvantReglage))
            || ((PAR.VitesseManu > 0.0) && (!T100[timer_TarageDynamique])))
    {
        EXP.posControleDynamique = 20;                                          // Attente fin x tours de bande
        sortiesTOR(DO_CommandeBande, 1);
        EXP.Etat1 = EXP.Etat1 & 0xFFEF;                                         // Attente début controle
        EXP.Etat1 = EXP.Etat1 | 0x0200;                                         // Controle en cours
        EXP.ReglEnCours = 1;
        EXP.ControlEnCours = 1;
        EXP.TotPulseReglage = 0;
        EXP.NbMesureReglage = 0;
        EXP.TotalReglageFloat = 0.0;
        EXP.TotIncReglageFloat = 0.0;
        EXP.PulseTotal = 0;
        if (PAR.VitesseManu > 0.0)
            T100[timer_TarageDynamique] = (PAR.LongueurBandeControle/PAR.VitesseManu);
    }
}

if (EXP.posControleDynamique == 20)
{
    NbPulsesAtteindre = (PAR.LongueurBandeControle * PAR.ImpTambMene) / PAR.CirconfTambMene /10;
    if (!EXP.ControlAvecAbandon)
    {
        if (PAR.VitesseManu > 0.0)
            EXP.LongueurBandeRestanteControle = T100[timer_TarageDynamique]*EXP.Vitesse;
        else
            EXP.LongueurBandeRestanteControle = ((NbPulsesAtteindre - EXP.TotPulseReglage) * PAR.CirconfTambMene)*10 / PAR.ImpTambMene;
    }
    else
            EXP.LongueurBandeRestanteControle = (EXP.TotPulseReglage * PAR.CirconfTambMene)*10 / PAR.ImpTambMene;
        
    if ((!EXP.ControlAvecAbandon)
        && (((PAR.VitesseManu == 0.0) && (EXP.TotPulseReglage > NbPulsesAtteindre))
            || ((PAR.VitesseManu > 0.0) && (!T100[timer_TarageDynamique]))))
    {
        EXP.ReglEnCours = 0;
        EXP.ControlEnCours = 0;
        EXP.Etat1 = EXP.Etat1 & 0xFDFF;                                         // Controle en cours
        sortiesTOR(DO_CommandeBande, 0);
        EXP.posControleDynamique = 0;
    }
}

if (((EXP.posControleDynamique == 10)
        || (EXP.posControleDynamique == 20))
        && (EXP.Command1 & 0x0400))                                             // Abandon controle
{
    EXP.ReglEnCours = 0;
    EXP.ControlEnCours = 0;
    EXP.Etat1 = EXP.Etat1 & 0xFDFF;                                             // Controle en cours
    sortiesTOR(DO_CommandeBande, 0);
    EXP.posControleDynamique = 0;
}

// Mesure temps d'un tour de bande
if ((EXP.Command1 & 0x2000)                                                     // Start mesure bande
        && (EXP.posMesureTempsTourBande == 0)
        && (!EXP.ReglEnCours))  
{
    EXP.Command1 = EXP.Command1 & 0xDFFF;                                       // Start mesure bande
    sortiesTOR(DO_CommandeBande, 1);                                            // Commande marche bande
    EXP.Etat1 = EXP.Etat1 | 0x0200;                                             // Controle en cours
    EXP.NbPulsesRestantReglage = 0;
    EXP.TotPulseReglage = 0;
    EXP.posMesureTempsTourBande = 10;
}

if (EXP.posMesureTempsTourBande == 10)                                          // Mesure temps bande
{
    EXP.NbPulsesRestantReglage = EXP.TotPulseReglage;
    
    if (EXP.Command1 & 0x0400)                                                  // Abandon
    {
        EXP.Command1 = EXP.Command1 & 0xFBFF;                                   // Abandon
        EXP.Etat1 = EXP.Etat1 & 0xFDFF;                                         // Controle en cours
        EXP.posMesureTempsTourBande = 0;

        sortiesTOR(DO_CommandeBande, 0);                                        // Commande marche bande
    }
}
}