/*********************************************************************
 *
 *	MODBUS TCP Server Example Application
 *      Module for Microchip TCP/IP Stack
 *      -Implements an MODBUS Server over TCP on port 502
 *
 *********************************************************************
 * FileName:        ModbusUartServer.c
 * Dependencies:    UART
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
 * Compiler:        Microchip C32 v1.05 or higher
 *					Microchip C30 v3.12 or higher
 *					Microchip C18 v3.30 or higher
 *
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright (C) 2002-2009 Microchip Technology Inc.  All rights
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and
 * distribute:
 * (i)  the Software when embedded on a Microchip microcontroller or
 *      digital signal controller product ("Device") which is
 *      integrated into Licensee's product; or
 * (ii) ONLY the Software driver source files ENC28J60.c, ENC28J60.h,
 *		ENCX24J600.c and ENCX24J600.h ported to a non-Microchip device
 *		used in conjunction with a Microchip ethernet controller for
 *		the sole purpose of interfacing with the ethernet controller.
 *
 * You should refer to the license agreement accompanying this
 * Software for additional information regarding your rights and
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date    	Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Parthiv Pandya     10/1/13           Original
 *
 *
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *
 *
 ********************************************************************/
#define __MODBUSUARTSERVER_C

#include <stdlib.h>
#include "Process.h"
#include "MODBUSTCPServer.h"
#include "UARTsComm.h"

//_MODBUS_COMMAND MODBUS_COMMAND;

//char ReadByteReverse = 1;                                                       //If a modbus client requires to reverse the byte order for HOLDING REGISTER
//char InputByteReverse = 1;
//char WriteByteReverse = 0;

static BYTE Erreur_fonction;
//BYTE MODBUS_RX[MODBUS_RX_BUFFER_SIZE];                                          //MODBUS UART buffer
//BYTE MODBUS_TX[MODBUS_TX_BUFFER_SIZE];                                          //Buffer to transfer MODBUS response
//WORD_VAL1 COIL;
//BYTE COIL_REG[COIL_SIZE];                                                       //Saves addresses and value for coils

//WORD HOLDING_REG[HOLDING_REG_SIZE];
//WORD    INPUT_REG[INPUT_REG_SIZE];

void envoieReelPF(float valeur, int adresse);
void envoieReelPf(float valeur, int adresse);
void envoieLongPF(unsigned long valeur, int adresse);
void envoieLongPf(unsigned long valeur, int adresse);
void LectureModbus(int type, int adrModbus, int val1, int val2, long val4, float val3, unsigned int val5, int inversionPFPf);
void ModifParamMetro(int indice, int valeur1, float valeur2, long valeur3, int adrModbus1);
void ValidationCodeMetrologie(void);
void ModifieVitesseComm(int numPort);
int AffectationIO(int type, int numero, int adrModbus);
int Random (int _iMin, int _iMax);

extern void US_SetSwitch1( UINT8 bSw1 );

    
/*****************************************************************************
  Function:
	void MODBUSTCPServer(void)

  Summary:
	Implements a MODBUS_RX TCP Server.

  Precondition:
	TCP is initialized.

 *   Parameters:
	None

  Returns:
  	None
  ***************************************************************************/
WORD ModbusUartServer(int numPort)
{
int w;

ProcessMessageRecu();

switch (MODBUS_COMMAND.FunctionCode)
{
    case ReadHoldingRegister:
    case ReadInputRegister:
        if (MODBUS_COMMAND.NumberOfRegister.Val > 127)
            MODBUS_TX[MODBUS_FunctionCode] = 0x83;

        //Assemble the data
        LectureMots(numPort, 0);

        //Test if server sends Exception error to the client
        if (!(MODBUS_TX[MODBUS_FunctionCode] == 0X83))
            w = 0x09 + MODBUS_TX[8];
        else w = 9;

        return(w);
        break;

    case WriteMultipleRegister:
//        if (MODBUS_COMMAND.NumberOfRegister.Val > MODBUS_RX[12])
            //Assemble the data
            EcritureMots(numPort);

        //Test if server sends Exception error to the client
        if (!(MODBUS_TX[MODBUS_FunctionCode] == 0X90))
            w = 12;
        else w = 9;

        return(w);
        break;

    case WriteSingleCoil:
        //Test if server sends Exception error to the client
        if (!(MODBUS_TX[MODBUS_FunctionCode] == 0X85))
           w = 0x09 + MODBUS_TX[8];
        else w = 12;

        return(w);
        break;
}
return(0);
}


/*****************************************************************************
  Function:
	void ProcessReceivedMessage(void)

  Summary:
        Decodes Modbus commands.
        Also, tests if this server supports the requested Modbus command

 *   Parameters:
	None

  Returns:
  	None
  ***************************************************************************/

//Function Definition
void ProcessMessageRecu(void)
{
//Transaction Identifier
MODBUS_COMMAND.TransactionID.v[1] = MODBUS_RX[0];
MODBUS_COMMAND.TransactionID.v[0] = MODBUS_RX[1];
//Protocol Identifier
MODBUS_COMMAND.ProtocolID.v[1] = MODBUS_RX[2];
MODBUS_COMMAND.ProtocolID.v[0] = MODBUS_RX[3];
//Number of bytes to receive
MODBUS_COMMAND.Length = MODBUS_RX[5];
//Unit Identifier
MODBUS_COMMAND.UnitID = MODBUS_RX[6];
//Function code
MODBUS_COMMAND.FunctionCode = MODBUS_RX[7];
//Address
MODBUS_COMMAND.StartAddress.v[1] = MODBUS_RX[8];
MODBUS_COMMAND.StartAddress.v[0] = MODBUS_RX[9];
//Number of Register or Quantity
MODBUS_COMMAND.NumberOfRegister.v[1] = MODBUS_RX[10];
MODBUS_COMMAND.NumberOfRegister.v[0] = MODBUS_RX[11];
MODBUS_COMMAND.NumberOfRegister.Val = MODBUS_RX[10]*256 + MODBUS_RX[11];

//Verify the function code
if (!((MODBUS_COMMAND.FunctionCode == ReadHoldingRegister)      ||
        (MODBUS_COMMAND.FunctionCode == WriteMultipleRegister) ||
        (MODBUS_COMMAND.FunctionCode == ReadInputRegister)     ||
        (MODBUS_COMMAND.FunctionCode == WriteSingleCoil)))
{
    ModbusError(Illegal_Function_Code);
    memcpy(MODBUS_TX, MODBUS_RX, 9);
    Erreur_fonction = 1;
    return;
}
}


/*****************************************************************************
  Function:
	void readHoldingRegister(void

  Summary:
        Implements read holding registers command.

 *   Parameters:
	None

  Returns:
  	None
  ***************************************************************************/
void LectureMots(int numPort, int inversionPFPf)
{
int             debut;
int             longueur;
int             a;
int             adrModbus;
unsigned int    interUI;
unsigned long   interul;
float           interf;

//Assemble the data to be sent
// Début trame
MODBUS_TX[0] = MODBUS_RX[0];
MODBUS_TX[1] = MODBUS_RX[1];
MODBUS_TX[2] = MODBUS_RX[2];
MODBUS_TX[3] = MODBUS_RX[3];
MODBUS_TX[4] = MODBUS_RX[4];
MODBUS_TX[5] = MODBUS_RX[11]*2+3;

// Numéro esclave
MODBUS_TX[6] = MODBUS_RX[6];

//Function code
MODBUS_TX[7] = MODBUS_RX[7];

//Length
MODBUS_TX[8] = MODBUS_RX[11]*2;

if (MODBUS_TX[MODBUS_FunctionCode] == 0x83)                                     // Erreur donc pas d'envoie de données
    return;

// Données
adrModbus = 9;
debut = (int)MODBUS_COMMAND.StartAddress.Val;
longueur = ((int)MODBUS_COMMAND.NumberOfRegister.Val)*2;
if (longueur > 0xFF) longueur = 0xFF;

for (a=debut; a<debut+longueur; a++)
{
    MODBUS_TX[adrModbus]   = 0;
    MODBUS_TX[adrModbus+1] = 0;

//    if ((a >= 0x010F) && (a <= 0x010F+3))
//        LectureModbus(1, adrModbus, EXP.Date[(a-0x010F)*2], EXP.Date[(a-0x010F)*2+1], 0, 0, 0);
//    if ((a >= 0x0113) && (a <= 0x0113+2))
//        LectureModbus(1, adrModbus, EXP.Heure[(a-0x0113)*2], EXP.Heure[(a-0x0113)*2+1], 0, 0, 0);

    if ((a >= 0x018A) && (a <= 0x018A+7))
        LectureModbus(1, adrModbus, PAR.DateDerniereRAZ[(a-0x018A)*2], PAR.DateDerniereRAZ[(a-0x018A)*2+1], 0, 0, 0, 0);
    if ((a >= 0x0200) && (a <= 0x0200+49))
        LectureModbus(1, adrModbus, PAR.InfosClient[(a-0x0200)*2], PAR.InfosClient[(a-0x0200)*2+1], 0, 0, 0, 0);
    if (a >= 0x0232 && a <= 0x0232+9)
        LectureModbus(1, adrModbus, PAR.TechnicienPLCD[(a-0x0232)*2], PAR.TechnicienPLCD[(a-0x0232)*2+1], 0, 0, 0, 0);
    if (a >= 0x023C && a <= 0x023C+9)
        LectureModbus(1, adrModbus, PAR.TechnicienClient[(a-0x023C)*2], PAR.TechnicienClient[(a-0x023C)*2+1], 0, 0, 0, 0);
    if (a >= 0x0246 && a <= 0x0246+24)
        LectureModbus(1, adrModbus, PAR.TypeCapteurs[(a-0x0246)*2], PAR.TypeCapteurs[(a-0x0246)*2+1], 0, 0, 0, 0);
    if (a >= 0x025F && a <= 0x025F+19)
        LectureModbus(1, adrModbus, PAR.ProduitPese[(a-0x025F)*2], PAR.ProduitPese[(a-0x025F)*2+1], 0, 0, 0, 0);
    if (a >= 0x0273 && a <= 0x0273+3)
        LectureModbus(1, adrModbus, PAR.DateMiseEnService[(a-0x0273)*2], PAR.DateMiseEnService[(a-0x0273)*2+1], 0, 0, 0, 0);
    if (a >= 0x0277 && a <= 0x0277+3)
        LectureModbus(1, adrModbus, PAR.DateVerification[(a-0x0277)*2], PAR.DateVerification[(a-0x0277)*2+1], 0, 0, 0, 0);

    if ((a >= 0x102A) && (a <= 0x102A +19))
        LectureModbus(1, adrModbus, PAR.Impr_EnteteLigne1[(a-0x102A)*2], PAR.Impr_EnteteLigne1[(a-0x102A)*2+1], 0, 0, 0, 0);
    if ((a >= 0x1052) && (a <= 0x1052 +19))
        LectureModbus(1, adrModbus, PAR.Impr_EnteteLigne2[(a-0x1052)*2], PAR.Impr_EnteteLigne2[(a-0x1052)*2+1], 0, 0, 0, 0);
    if ((a >= 0x107A) && (a <= 0x107A +19))
        LectureModbus(1, adrModbus, PAR.Impr_EnteteLigne3[(a-0x107A)*2], PAR.Impr_EnteteLigne3[(a-0x107A)*2+1], 0, 0, 0, 0);
    if ((a >= 0x10A2) && (a <= 0x10A2 +19))
        LectureModbus(1, adrModbus, PAR.Impr_PiedPageLigne1[(a-0x10A2)*2], PAR.Impr_PiedPageLigne1[(a-0x10A2)*2+1], 0, 0, 0, 0);
    if ((a >= 0x10CA) && (a <= 0x10CA +19))
        LectureModbus(1, adrModbus, PAR.Impr_PiedPageLigne2[(a-0x10CA)*2], PAR.Impr_PiedPageLigne2[(a-0x10CA)*2+1], 0, 0, 0, 0);
    if ((a >= 0x10F2) && (a <= 0x10F2 +19))
        LectureModbus(1, adrModbus, PAR.Impr_PiedPageLigne3[(a-0x10F2)*2], PAR.Impr_PiedPageLigne3[(a-0x10F2)*2+1], 0, 0, 0, 0);
    if ((a >= 0x111E) && (a <= 0x111E +9))
        LectureModbus(1, adrModbus, PAR.Impr_Produit[(a-0x111E)*2], PAR.Impr_Produit[(a-0x111E)*2+1], 0, 0, 0, 0);
    if ((a >= 0x1128) && (a <= 0x1128 +9))
        LectureModbus(1, adrModbus, PAR.Impr_Client[(a-0x1128)*2], PAR.Impr_Client[(a-0x1128)*2+1], 0, 0, 0, 0);
    if ((a >= 0x1132) && (a <= 0x1132 +9))
        LectureModbus(1, adrModbus, PAR.Impr_Destination[(a-0x1132)*2], PAR.Impr_Destination[(a-0x1132)*2+1], 0, 0, 0, 0);
    if ((a >= 0x113C) && (a <= 0x113C +9))
        LectureModbus(1, adrModbus, PAR.Impr_Camion[(a-0x113C)*2], PAR.Impr_Camion[(a-0x113C)*2+1], 0, 0, 0, 0);

    // Lecture du tableau de 100 essieux
    if ((a >= 0x2320) && (a < 0x2500))
    {
        interf = a-0x2310; interf = interf/0x10;
        if ((a-0x2310)/0x10 == interf)
        {
            interUI = interf;
            MODBUS_TX[adrModbus]   = EXP.PEs_NumeroEssieu[interUI]/256;
            MODBUS_TX[adrModbus+1] = EXP.PEs_NumeroEssieu[interUI] - MODBUS_TX[adrModbus]*256;
        }
        interf = a-0x2311; interf = interf/0x10;
        if ((a-0x2311)/0x10 == interf)
        {
            interUI = interf;
            LectureModbus(4, adrModbus, 0, 0, EXP.PEs_PoidsEssieu[interUI], 0.0, 0, inversionPFPf);
        }
        interf = a-0x2312; interf = interf/0x10;
        if ((a-0x2312)/0x10 == interf)
        {
            interUI = interf;
            LectureModbus(5, adrModbus, 0, 0, EXP.PEs_PoidsEssieu[interUI], 0.0, 0, inversionPFPf);
        }
    }
    
    switch (a)
    {
        case 0x0100 : LectureModbus(1, adrModbus, PAR.TypeProgramme[0], PAR.TypeProgramme[1], 0, 0, 0, 0); break;
        case 0x0101 : LectureModbus(1, adrModbus, PAR.TypeProgramme[2], PAR.TypeProgramme[3], 0, 0, 0, 0); break;
        case 0x0102 : LectureModbus(1, adrModbus, PAR.Version[0], PAR.Version[1], 0, 0, 0, 0); break;
        case 0x0103 : LectureModbus(1, adrModbus, 0x30, PAR.Metrologie, 0, 0, 0, 0); break;
        case 0x0104 : LectureModbus(1, adrModbus, PAR.NumSerie[0], PAR.NumSerie[1], 0, 0, 0, 0); break;
        case 0x0105 : LectureModbus(1, adrModbus, PAR.NumSerie[2], PAR.NumSerie[3], 0, 0, 0, 0); break;
        case 0x0106 : LectureModbus(1, adrModbus, PAR.NumSerie[4], PAR.NumSerie[5], 0, 0, 0, 0); break;
        case 0x0107 : LectureModbus(1, adrModbus, PAR.CodeBalancier[0], PAR.CodeBalancier[1], 0, 0, 0, 0); break;
        case 0x0108 : LectureModbus(1, adrModbus, PAR.CodeBalancier[2], PAR.CodeBalancier[3], 0, 0, 0, 0); break;
        case 0x0109 : sprintf(PAR.CodeAleatoire,"%04d",Random(0,999));
                      LectureModbus(1, adrModbus, PAR.CodeAleatoire[0], PAR.CodeAleatoire[1], 0, 0, 0, 0); break;
        case 0x010A : LectureModbus(1, adrModbus, PAR.CodeAleatoire[2], PAR.CodeAleatoire[3], 0, 0, 0, 0); break;
//      case 0x010B : MODBUS_TX[adrModbus]   = PAR.CodeValidation[0];
//                    MODBUS_TX[adrModbus+1] = PAR.CodeValidation[1]; break;
//      case 0x010C : MODBUS_TX[adrModbus]   = PAR.CodeValidation[2];
//                    MODBUS_TX[adrModbus+1] = PAR.CodeValidation[3]; break;
        case 0x010D : LectureModbus(1, adrModbus, 0x30, 0x30+PAR.CodeMetrologiqueOK, 0, 0, 0, 0); break;
        case 0x010E : MODBUS_TX[adrModbus] = PAR.Options/256; MODBUS_TX[adrModbus+1] = PAR.Options - MODBUS_TX[adrModbus]*256; break;
        case 0x010F : LectureModbus(4, adrModbus, 0, 0, EXP.DateNum, 0.0, 0, inversionPFPf); break;
        case 0x0110 : LectureModbus(5, adrModbus, 0, 0, EXP.DateNum, 0.0, 0, inversionPFPf); break;
        case 0x0111 : LectureModbus(4, adrModbus, 0, 0, EXP.HeureNum, 0.0, 0, inversionPFPf); break;
        case 0x0112 : LectureModbus(5, adrModbus, 0, 0, EXP.HeureNum, 0.0, 0, inversionPFPf); break;
        case 0x0113 : MODBUS_TX[adrModbus] = EXP.ChargCPUafficheur/256;
                      MODBUS_TX[adrModbus+1] = EXP.ChargCPUafficheur - MODBUS_TX[adrModbus]*256; break;
                
        case 0x0150 : LectureModbus(2, adrModbus, 0, 0, 0, EXP.PoidsMoyen * 10000, 0, inversionPFPf); break;
        case 0x0151 : LectureModbus(3, adrModbus, 0, 0, 0, EXP.PoidsMoyen * 10000, 0, inversionPFPf); break;
        case 0x0152 : LectureModbus(2, adrModbus, 0, 0, 0, EXP.PoidsMoyenAff * 1000, 0, inversionPFPf); break;
        case 0x0153 : LectureModbus(3, adrModbus, 0, 0, 0, EXP.PoidsMoyenAff * 1000, 0, inversionPFPf); break;
        case 0x0154 : LectureModbus(2, adrModbus, 0, 0, 0, EXP.PoidsMetre * 10000, 0, inversionPFPf); break;
        case 0x0155 : LectureModbus(3, adrModbus, 0, 0, 0, EXP.PoidsMetre * 10000, 0, inversionPFPf); break;
        case 0x0156 : LectureModbus(4, adrModbus, 0, 0, EXP.PoidsPoints, 0.0, 0, inversionPFPf); break;
        case 0x0157 : LectureModbus(5, adrModbus, 0, 0, EXP.PoidsPoints, 0.0, 0, inversionPFPf); break;
        case 0x0158 : LectureModbus(2, adrModbus, 0, 0, 0, EXP.DebitTR * 10000, 0, inversionPFPf); break;
        case 0x0159 : LectureModbus(3, adrModbus, 0, 0, 0, EXP.DebitTR * 10000, 0, inversionPFPf); break;
        case 0x015A : LectureModbus(2, adrModbus, 0, 0, 0, EXP.DebitMoyen * 10000, 0, inversionPFPf); break;
        case 0x015B : LectureModbus(3, adrModbus, 0, 0, 0, EXP.DebitMoyen * 10000, 0, inversionPFPf); break;
        case 0x015C : LectureModbus(2, adrModbus, 0, 0, 0, EXP.Vitesse * 1000, 0, inversionPFPf); break;
        case 0x015D : LectureModbus(3, adrModbus, 0, 0, 0, EXP.Vitesse * 1000, 0, inversionPFPf); break;
        case 0x015E : interul = EXP.TotalPartiel2; interul *= 10000; interul += EXP.TotalPartiel1 * 1000;
                      LectureModbus(4, adrModbus, 0, 0, interul, 0.0, 0, inversionPFPf); break;
        case 0x015F : interul = EXP.TotalPartiel2; interul *= 10000; interul += EXP.TotalPartiel1 * 1000;
                      LectureModbus(5, adrModbus, 0, 0, interul, 0.0, 0, inversionPFPf); break;
        case 0x0160 : interul = EXP.TotalGlobal2; interul *= 10000; interul += EXP.TotalGlobal1 * 1000;
                      LectureModbus(4, adrModbus, 0, 0, interul, 0.0, 0, inversionPFPf); break;
        case 0x0161 : interul = EXP.TotalGlobal2; interul *= 10000; interul += EXP.TotalGlobal1 * 1000;
                      LectureModbus(5, adrModbus, 0, 0, interul, 0.0, 0, inversionPFPf); break;
        case 0x0162 : MODBUS_TX[adrModbus] = EXP.Etat1/256; MODBUS_TX[adrModbus+1] = EXP.Etat1 - MODBUS_TX[adrModbus]*256; break;
        case 0x0163 : MODBUS_TX[adrModbus] = EXP.Etat2/256; MODBUS_TX[adrModbus+1] = EXP.Etat2 - MODBUS_TX[adrModbus]*256; break;
        case 0x0164 : MODBUS_TX[adrModbus] = EXP.Etat3/256; MODBUS_TX[adrModbus+1] = EXP.Etat3 - MODBUS_TX[adrModbus]*256; break;
        case 0x0165 : MODBUS_TX[adrModbus] = EXP.Etat4/256; MODBUS_TX[adrModbus+1] = EXP.Etat4 - MODBUS_TX[adrModbus]*256; break;
        case 0x0166 : MODBUS_TX[adrModbus] = EXP.Defaut1/256; MODBUS_TX[adrModbus+1] = EXP.Defaut1 - MODBUS_TX[adrModbus]*256; break;
        case 0x0167 : MODBUS_TX[adrModbus] = EXP.Defaut2/256; MODBUS_TX[adrModbus+1] = EXP.Defaut2 - MODBUS_TX[adrModbus]*256; break;
        case 0x0168 : MODBUS_TX[adrModbus] = EXP.Defaut3/256; MODBUS_TX[adrModbus+1] = EXP.Defaut3 - MODBUS_TX[adrModbus]*256; break;
        case 0x0169 : MODBUS_TX[adrModbus] = EXP.Defaut4/256; MODBUS_TX[adrModbus+1] = EXP.Defaut4 - MODBUS_TX[adrModbus]*256; break;
        case 0x016A : MODBUS_TX[adrModbus] = EXP.Command1/256; MODBUS_TX[adrModbus+1] = EXP.Command1 - MODBUS_TX[adrModbus]*256; break;
        case 0x016B : MODBUS_TX[adrModbus] = EXP.Command2/256; MODBUS_TX[adrModbus+1] = EXP.Command2 - MODBUS_TX[adrModbus]*256; break;
        case 0x016C : MODBUS_TX[adrModbus] = EXP.Command3/256; MODBUS_TX[adrModbus+1] = EXP.Command3 - MODBUS_TX[adrModbus]*256; break;
        case 0x016D : MODBUS_TX[adrModbus] = EXP.Command4/256; MODBUS_TX[adrModbus+1] = EXP.Command4 - MODBUS_TX[adrModbus]*256; break;
        case 0x016E : MODBUS_TX[adrModbus] = EXP.NbPulsesRestantReglage/256; MODBUS_TX[adrModbus+1] = EXP.NbPulsesRestantReglage - MODBUS_TX[adrModbus]*256; break;
        case 0x016F : LectureModbus(4, adrModbus, 0, 0, EXP.TotalReglage, 0.0, 0, inversionPFPf); break;
        case 0x0170 : LectureModbus(5, adrModbus, 0, 0, EXP.TotalReglage, 0.0, 0, inversionPFPf); break;
        case 0x0171 : MODBUS_TX[adrModbus]   = EXP.PourcSortieAna[1]/256;
                      MODBUS_TX[adrModbus+1] = EXP.PourcSortieAna[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0172 : MODBUS_TX[adrModbus]   = EXP.PourcSortieAna[2]/256;
                      MODBUS_TX[adrModbus+1] = EXP.PourcSortieAna[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x0173 : MODBUS_TX[adrModbus]   = 0;
                      MODBUS_TX[adrModbus+1] = entTOR[0] + entTOR[1]*2 + entTOR[2]*4 + entTOR[3]*8 + entTOR[4]*16
                            + entTOR[5]*32 + entTOR[6]*64 + entTOR[7]*128; break;
        case 0x0174 : MODBUS_TX[adrModbus]   = 0;
                      MODBUS_TX[adrModbus+1] = sorTOR[1] + sorTOR[2]*2 + sorTOR[3]*4 + sorTOR[4]*8 + sorTOR[5]*16
                            + sorTOR[6]*32 + sorTOR[7]*64 + sorTOR[8]*128; break;
        case 0x0175 : MODBUS_TX[adrModbus]   = EXP.LongueurBandeRestanteControle/256;
                      MODBUS_TX[adrModbus+1] = EXP.LongueurBandeRestanteControle - MODBUS_TX[adrModbus]*256; break;
        case 0x0176 : LectureModbus(2, adrModbus, 0, 0, 0, EXP.Dep_Consigne * 10.0, 0, inversionPFPf); break;
        case 0x0177 : LectureModbus(3, adrModbus, 0, 0, 0, EXP.Dep_Consigne * 10.0, 0, inversionPFPf); break;
        case 0x0178 : LectureModbus(2, adrModbus, 0, 0, 0, (EXP.Dep_PoidsEnCours+0.05) * 10.0, 0, inversionPFPf); break;
        case 0x0179 : LectureModbus(3, adrModbus, 0, 0, 0, (EXP.Dep_PoidsEnCours+0.05) * 10.0, 0, inversionPFPf); break;
        case 0x017A : MODBUS_TX[adrModbus]   = EXP.PosCycle/256;
                      MODBUS_TX[adrModbus+1] = EXP.PosCycle - MODBUS_TX[adrModbus]*256; break;
        case 0x017B : LectureModbus(2, adrModbus, 0, 0, 0, EXP.DebitBascule2 * 10000, 0, inversionPFPf); break;
        case 0x017C : LectureModbus(3, adrModbus, 0, 0, 0, EXP.DebitBascule2 * 10000, 0, inversionPFPf); break;
        case 0x017D : LectureModbus(4, adrModbus, 0, 0, EXP.TotalPartielB, 0.0, 0, inversionPFPf); break;
        case 0x017E : LectureModbus(5, adrModbus, 0, 0, EXP.TotalPartielB, 0.0, 0, inversionPFPf); break;
        case 0x017F : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, EXP.BdC_NbBatchProduit, inversionPFPf); break;
        case 0x0180 : interUI = PAR.TempsMarcheVide /3600;
                      LectureModbus(6, adrModbus, 0, 0, 0, 0.0, interUI, inversionPFPf); break;
        case 0x0181 : interUI = PAR.TempsMarcheVide /3600; interUI = (PAR.TempsMarcheVide - interUI*3600)/60;
                      LectureModbus(6, adrModbus, 0, 0, 0, 0.0, interUI, inversionPFPf); break;
        case 0x0182 : interUI = PAR.TempsMarcheTotalisation /3600;
                      LectureModbus(6, adrModbus, 0, 0, 0, 0.0, interUI, inversionPFPf); break;
        case 0x0183 : interUI = PAR.TempsMarcheTotalisation /3600; interUI = (PAR.TempsMarcheTotalisation - interUI*3600)/60;
                      LectureModbus(6, adrModbus, 0, 0, 0, 0.0, interUI, inversionPFPf); break;
        case 0x0184 : interUI = PAR.TempsArret /3600;
                      LectureModbus(6, adrModbus, 0, 0, 0, 0.0, interUI, inversionPFPf); break;
        case 0x0185 : interUI = PAR.TempsArret /3600; interUI = (PAR.TempsArret - interUI*3600)/60;
                      LectureModbus(6, adrModbus, 0, 0, 0, 0.0, interUI, inversionPFPf); break;
        case 0x0186 : LectureModbus(4, adrModbus, 0, 0, EXP.DebitMoyenLot, 0.0, 0, inversionPFPf); break;
        case 0x0187 : LectureModbus(5, adrModbus, 0, 0, EXP.DebitMoyenLot, 0.0, 0, inversionPFPf); break;
        case 0x0188 : LectureModbus(4, adrModbus, 0, 0, PAR.DebitMaxLot, 0.0, 0, inversionPFPf); break;
        case 0x0189 : LectureModbus(5, adrModbus, 0, 0, PAR.DebitMaxLot, 0.0, 0, inversionPFPf); break;
        case 0x0199 : LectureModbus(4, adrModbus, 0, 0, EXP.PoidsMetreCarre, 0.0, 0, inversionPFPf); break;
        case 0x019A : LectureModbus(5, adrModbus, 0, 0, EXP.PoidsMetreCarre, 0.0, 0, inversionPFPf); break;

        case 0x027B : LectureModbus(5, adrModbus, 0, 0, PAR.AdresseIP[0], 0.0, 0, inversionPFPf); break;
        case 0x027C : LectureModbus(5, adrModbus, 0, 0, PAR.AdresseIP[1], 0.0, 0, inversionPFPf); break;
        case 0x027D : LectureModbus(5, adrModbus, 0, 0, PAR.AdresseIP[2], 0.0, 0, inversionPFPf); break;
        case 0x027E : LectureModbus(5, adrModbus, 0, 0, PAR.AdresseIP[3], 0.0, 0, inversionPFPf); break;
        case 0x027F : LectureModbus(5, adrModbus, 0, 0, PAR.MasqueIP[0], 0.0, 0, inversionPFPf); break;
        case 0x0280 : LectureModbus(5, adrModbus, 0, 0, PAR.MasqueIP[1], 0.0, 0, inversionPFPf); break;
        case 0x0281 : LectureModbus(5, adrModbus, 0, 0, PAR.MasqueIP[2], 0.0, 0, inversionPFPf); break;
        case 0x0282 : LectureModbus(5, adrModbus, 0, 0, PAR.MasqueIP[3], 0.0, 0, inversionPFPf); break;
        case 0x0283 : MODBUS_TX[adrModbus]   = PAR.PortIP/256;
                      MODBUS_TX[adrModbus+1] = PAR.PortIP - MODBUS_TX[adrModbus]*256; break;
                
        case 0x0400 : MODBUS_TX[adrModbus]   = 0x00;
                      MODBUS_TX[adrModbus+1] = PAR.UnitePoids; break;
        case 0x0401 : LectureModbus(4, adrModbus, 0, 0, PAR.PoidsMax, 0.0, 0, inversionPFPf); break;
        case 0x0402 : LectureModbus(5, adrModbus, 0, 0, PAR.PoidsMax, 0.0, 0, inversionPFPf); break;
        case 0x0403 : MODBUS_TX[adrModbus]   = 0x00;
                      MODBUS_TX[adrModbus+1] = PAR.NbChiffreVirgPoids; break;
        case 0x0404 : MODBUS_TX[adrModbus]   = 0x00;
                      MODBUS_TX[adrModbus+1] = PAR.EchelonPoids; break;
        case 0x0405 : MODBUS_TX[adrModbus]   = 0x00;
                      MODBUS_TX[adrModbus+1] = PAR.FiltrePoids; break;
        case 0x0406 : MODBUS_TX[adrModbus]   = 0x00;
                      MODBUS_TX[adrModbus+1] = PAR.FrequencePoids; break;
        case 0x0407 : LectureModbus(4, adrModbus, 0, 0, PAR.TareMetrologie, 0.0, 0, inversionPFPf); break;
        case 0x0408 : LectureModbus(5, adrModbus, 0, 0, PAR.TareMetrologie, 0.0, 0, inversionPFPf); break;
        case 0x0409 : LectureModbus(4, adrModbus, 0, 0, PAR.TareInc, 0.0, 0, inversionPFPf); break;
        case 0x040A : LectureModbus(5, adrModbus, 0, 0, PAR.TareInc, 0.0, 0, inversionPFPf); break;
        case 0x040B : MODBUS_TX[adrModbus]   = PAR.ToleranceTarage/256;
                      MODBUS_TX[adrModbus+1] = PAR.ToleranceTarage - MODBUS_TX[adrModbus]*256; break;
        case 0x040C : MODBUS_TX[adrModbus]   = PAR.NbPointsEtalonnage/256;
                      MODBUS_TX[adrModbus+1] = PAR.NbPointsEtalonnage - MODBUS_TX[adrModbus]*256; break;
        case 0x040D : MODBUS_TX[adrModbus]   = PAR.NumPointEtalonnage/256;
                      MODBUS_TX[adrModbus+1] = PAR.NumPointEtalonnage - MODBUS_TX[adrModbus]*256; break;
        case 0x040E : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Pente[1] * 1000.0, 0, inversionPFPf); break;
        case 0x040F : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Pente[1] * 1000.0, 0, inversionPFPf); break;
        case 0x0410 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.SeuilPente[1] * 1000.0, 0, inversionPFPf); break;
        case 0x0411 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.SeuilPente[1] * 1000.0, 0, inversionPFPf); break;
        case 0x0412 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Pente[2] * 1000.0, 0, inversionPFPf); break;
        case 0x0413 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Pente[2] * 1000.0, 0, inversionPFPf); break;
        case 0x0414 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.SeuilPente[2] * 1000.0, 0, inversionPFPf); break;
        case 0x0415 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.SeuilPente[2] * 1000.0, 0, inversionPFPf); break;
        case 0x0416 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Pente[3] * 1000.0, 0, inversionPFPf); break;
        case 0x0417 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Pente[3] * 1000.0, 0, inversionPFPf); break;
        case 0x0418 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.SeuilPente[3] * 1000.0, 0, inversionPFPf); break;
        case 0x0419 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.SeuilPente[3] * 1000.0, 0, inversionPFPf); break;
        case 0x041A : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Pente[4] * 1000.0, 0, inversionPFPf); break;
        case 0x041B : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Pente[4] * 1000.0, 0, inversionPFPf); break;
        case 0x041C : LectureModbus(2, adrModbus, 0, 0, 0, PAR.SeuilPente[4] * 1000.0, 0, inversionPFPf); break;
        case 0x041D : LectureModbus(3, adrModbus, 0, 0, 0, PAR.SeuilPente[4] * 1000.0, 0, inversionPFPf); break;
        case 0x041E : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Pente[5] * 1000.0, 0, inversionPFPf); break;
        case 0x041F : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Pente[5] * 1000.0, 0, inversionPFPf); break;
        case 0x0420 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.SeuilPente[5] * 1000.0, 0, inversionPFPf); break;
        case 0x0421 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.SeuilPente[5] * 1000.0, 0, inversionPFPf); break;
        case 0x0422 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteMoyCapteurs, 0.0, 0, inversionPFPf); break;
        case 0x0423 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteMoyCapteurs, 0.0, 0, inversionPFPf); break;
        case 0x0424 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[1], 0.0, 0, inversionPFPf); break;
        case 0x0425 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[1], 0.0, 0, inversionPFPf); break;
        case 0x0426 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[2], 0.0, 0, inversionPFPf); break;
        case 0x0427 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[2], 0.0, 0, inversionPFPf); break;
        case 0x0428 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[3], 0.0, 0, inversionPFPf); break;
        case 0x0429 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[3], 0.0, 0, inversionPFPf); break;
        case 0x042A : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[4], 0.0, 0, inversionPFPf); break;
        case 0x042B : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[4], 0.0, 0, inversionPFPf); break;
        case 0x042C : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[5], 0.0, 0, inversionPFPf); break;
        case 0x042D : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[5], 0.0, 0, inversionPFPf); break;
        case 0x042E : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[6], 0.0, 0, inversionPFPf); break;
        case 0x042F : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[6], 0.0, 0, inversionPFPf); break;
        case 0x0430 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[7], 0.0, 0, inversionPFPf); break;
        case 0x0431 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[7], 0.0, 0, inversionPFPf); break;
        case 0x0432 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[8], 0.0, 0, inversionPFPf); break;
        case 0x0433 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[8], 0.0, 0, inversionPFPf); break;
        case 0x0434 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[9], 0.0, 0, inversionPFPf); break;
        case 0x0435 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[9], 0.0, 0, inversionPFPf); break;
        case 0x0436 : LectureModbus(4, adrModbus, 0, 0, PAR.SensibiliteCapteur[10], 0.0, 0, inversionPFPf); break;
        case 0x0437 : LectureModbus(5, adrModbus, 0, 0, PAR.SensibiliteCapteur[10], 0.0, 0, inversionPFPf); break;
        case 0x0438 : LectureModbus(4, adrModbus, 0, 0, PAR.TarePoids, 0.0, 0, inversionPFPf); break;
        case 0x0439 : LectureModbus(5, adrModbus, 0, 0, PAR.TarePoids, 0.0, 0, inversionPFPf); break;
        case 0x043A : LectureModbus(4, adrModbus, 0, 0, PAR.DefautCapteurPlus, 0.0, 0, inversionPFPf); break;
        case 0x043B : LectureModbus(5, adrModbus, 0, 0, PAR.DefautCapteurPlus, 0.0, 0, inversionPFPf); break;
        case 0x043C : LectureModbus(4, adrModbus, 0, 0, PAR.DefautCapteurMoins, 0.0, 0, inversionPFPf); break;
        case 0x043D : LectureModbus(5, adrModbus, 0, 0, PAR.DefautCapteurMoins, 0.0, 0, inversionPFPf); break;
        case 0x043E : LectureModbus(4, adrModbus, 0, 0, PAR.BandeFiltrePoids, 0.0, 0, inversionPFPf); break;
        case 0x043F : LectureModbus(5, adrModbus, 0, 0, PAR.BandeFiltrePoids, 0.0, 0, inversionPFPf); break;
        case 0x0440 : MODBUS_TX[adrModbus]   = PAR.NbEchelonsStabilite/256;
                      MODBUS_TX[adrModbus+1] = PAR.NbEchelonsStabilite - MODBUS_TX[adrModbus]*256; break;
        case 0x0441 : MODBUS_TX[adrModbus]   = PAR.TempsStabilite/256;
                      MODBUS_TX[adrModbus+1] = PAR.TempsStabilite - MODBUS_TX[adrModbus]*256; break;
        case 0x0442 : LectureModbus(4, adrModbus, 0, 0, PAR.RapportEtalonnage, 0.0, 0, inversionPFPf); break;
        case 0x0443 : LectureModbus(5, adrModbus, 0, 0, PAR.RapportEtalonnage, 0.0, 0, inversionPFPf); break;
        case 0x0444 : MODBUS_TX[adrModbus]   = PAR.CorrectionTimer/256;
                      MODBUS_TX[adrModbus+1] = PAR.CorrectionTimer - MODBUS_TX[adrModbus]*256; break;
                              
        case 0x0500 : MODBUS_TX[adrModbus]   = PAR.EchelonTotalisation/256;
                      MODBUS_TX[adrModbus+1] = PAR.EchelonTotalisation - MODBUS_TX[adrModbus]*256; break;
        case 0x0501 : MODBUS_TX[adrModbus]   = PAR.EchelonSortieTot/256;
                      MODBUS_TX[adrModbus+1] = PAR.EchelonSortieTot - MODBUS_TX[adrModbus]*256; break;
        case 0x0502 : MODBUS_TX[adrModbus]   = PAR.UniteTotalisation/256;
                      MODBUS_TX[adrModbus+1] = PAR.UniteTotalisation - MODBUS_TX[adrModbus]*256; break;
        case 0x0503 : MODBUS_TX[adrModbus]   = PAR.NbChiffreDecimaleVitesse/256;
                      MODBUS_TX[adrModbus+1] = PAR.NbChiffreDecimaleVitesse - MODBUS_TX[adrModbus]*256; break;
        case 0x0504 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.VitesseMax * 1000, 0, inversionPFPf); break;
        case 0x0505 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.VitesseMax * 1000, 0, inversionPFPf); break;
        case 0x0506 : MODBUS_TX[adrModbus]   = PAR.NbChiffreDecimaleDebit/256;
                      MODBUS_TX[adrModbus+1] = PAR.NbChiffreDecimaleDebit - MODBUS_TX[adrModbus]*256; break;
        case 0x0507 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.DebitMax * 1000, 0, inversionPFPf); break;
        case 0x0508 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.DebitMax * 1000, 0, inversionPFPf); break;
        case 0x0509 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.DebitNominal * 1000, 0, inversionPFPf); break;
        case 0x050A : LectureModbus(3, adrModbus, 0, 0, 0, PAR.DebitNominal * 1000, 0, inversionPFPf); break;
        case 0x050B : envoieReelPf(PAR.Correction1*100, adrModbus); break;
        case 0x050C : envoieReelPf(PAR.Correction2*100, adrModbus); break;
        case 0x050D : envoieReelPf(PAR.Correction3*100, adrModbus); break;
        case 0x050E : envoieReelPf(PAR.Correction4*100, adrModbus); break;
        case 0x050F : LectureModbus(2, adrModbus, 0, 0, 0, PAR.LongueurBande * 1000, 0, inversionPFPf); break;
        case 0x0510 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.LongueurBande * 1000, 0, inversionPFPf); break;
        case 0x0511 : envoieReelPf(PAR.LongueurPesage*1000, adrModbus); break;
        case 0x0512 : envoieReelPf(PAR.CirconfTambMene*1000, adrModbus); break;
        case 0x0513 : envoieReelPf(PAR.CirconfTambMenant*1000, adrModbus); break;
        case 0x0514 : MODBUS_TX[adrModbus]   = PAR.ImpTambMene/256;
                      MODBUS_TX[adrModbus+1] = PAR.ImpTambMene - MODBUS_TX[adrModbus]*256; break;
        case 0x0515 : MODBUS_TX[adrModbus]   = PAR.ImpTambMenant/256;
                      MODBUS_TX[adrModbus+1] = PAR.ImpTambMenant - MODBUS_TX[adrModbus]*256; break;
        case 0x0516 : MODBUS_TX[adrModbus]   = PAR.NbPulsesAvantReglage/256;
                      MODBUS_TX[adrModbus+1] = PAR.NbPulsesAvantReglage - MODBUS_TX[adrModbus]*256; break;
        case 0x0517 : MODBUS_TX[adrModbus]   = PAR.NbTourBandesReglage/256;
                      MODBUS_TX[adrModbus+1] = PAR.NbTourBandesReglage - MODBUS_TX[adrModbus]*256; break;
        case 0x0518 : envoieReelPf(PAR.VitesseMin*1000, adrModbus); break;
        case 0x0519 : envoieReelPf(PAR.VitesseManu*1000, adrModbus); break;
        case 0x051A : LectureModbus(2, adrModbus, 0, 0, 0, PAR.DebitMin * 1000, 0, inversionPFPf); break;
        case 0x051B : LectureModbus(3, adrModbus, 0, 0, 0, PAR.DebitMin * 1000, 0, inversionPFPf); break;
        case 0x051C : envoieReelPf(PAR.ZoneMorte*10, adrModbus); break;
        case 0x051D : envoieReelPf(PAR.LimZeroAuto*10, adrModbus); break;
        case 0x051E : envoieReelPf(PAR.LimiteTotalisation*10, adrModbus); break;
        case 0x051F : envoieReelPf(PAR.VitesseNominale*1000, adrModbus); break;
        case 0x0520 : MODBUS_TX[adrModbus]   = PAR.TempsTourBande/256;
                      MODBUS_TX[adrModbus+1] = PAR.TempsTourBande - MODBUS_TX[adrModbus]*256; break;
        case 0x0521 : MODBUS_TX[adrModbus]   = PAR.LongueurBandeControle/256;
                      MODBUS_TX[adrModbus+1] = PAR.LongueurBandeControle - MODBUS_TX[adrModbus]*256; break;
        case 0x0522 : MODBUS_TX[adrModbus]   = PAR.FiltreDebit/256;
                      MODBUS_TX[adrModbus+1] = PAR.FiltreDebit - MODBUS_TX[adrModbus]*256; break;
        case 0x0523 : MODBUS_TX[adrModbus]   = PAR.LargeurBande/256;
                      MODBUS_TX[adrModbus+1] = PAR.LargeurBande - MODBUS_TX[adrModbus]*256; break;
                              
        case 0x0650 : envoieReelPF(PAR.Consigne*1000, adrModbus); break;
        case 0x0651 : envoieReelPf(PAR.Consigne*1000, adrModbus); break;
        case 0x0652 : MODBUS_TX[adrModbus]   = PAR.TolerancePlus/256;
                      MODBUS_TX[adrModbus+1] = PAR.TolerancePlus - MODBUS_TX[adrModbus]*256; break;
        case 0x0653 : MODBUS_TX[adrModbus]   = PAR.ToleranceMoins/256;
                      MODBUS_TX[adrModbus+1] = PAR.ToleranceMoins - MODBUS_TX[adrModbus]*256; break;
        case 0x0654 : envoieReelPF(PAR.PID_Kp*1000, adrModbus); break;
        case 0x0655 : envoieReelPF(PAR.PID_Ki*1000, adrModbus); break;
        case 0x0656 : MODBUS_TX[adrModbus]   = PAR.Calage10/256;
                      MODBUS_TX[adrModbus+1] = PAR.Calage10 - MODBUS_TX[adrModbus]*256; break;
        case 0x0657 : MODBUS_TX[adrModbus]   = PAR.Calage100/256;
                      MODBUS_TX[adrModbus+1] = PAR.Calage100 - MODBUS_TX[adrModbus]*256; break;
        case 0x0658 : MODBUS_TX[adrModbus]   = PAR.TempsFonctVolumetrique/256;
                      MODBUS_TX[adrModbus+1] = PAR.TempsFonctVolumetrique - MODBUS_TX[adrModbus]*256; break;
        case 0x0659 : MODBUS_TX[adrModbus]   = EXP.PourcSortieAna[1]/256;
                      MODBUS_TX[adrModbus+1] = EXP.PourcSortieAna[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x065A : MODBUS_TX[adrModbus]   = EXP.PourcSortieAna[2]/256;
                      MODBUS_TX[adrModbus+1] = EXP.PourcSortieAna[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x065B : LectureModbus(4, adrModbus, 0, 0, PAR.ConsigneAnaMax, 0.0, 0, inversionPFPf); break;
        case 0x065C : LectureModbus(5, adrModbus, 0, 0, PAR.ConsigneAnaMax, 0.0, 0, inversionPFPf); break;
        case 0x065D : MODBUS_TX[adrModbus]   = PAR.TypeConsigne/256;
                      MODBUS_TX[adrModbus+1] = PAR.TypeConsigne - MODBUS_TX[adrModbus]*256; break;
        case 0x065F : MODBUS_TX[adrModbus]   = PAR.MemorisationSortieAna/256;
                      MODBUS_TX[adrModbus+1] = PAR.MemorisationSortieAna - MODBUS_TX[adrModbus]*256; break;
        case 0x0660 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.SeuilHautRegul, inversionPFPf); break;
        case 0x0661 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.SeuilBasRegul, inversionPFPf); break;
        case 0x0662 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.ModeRegul, inversionPFPf); break;
        case 0x0663 : LectureModbus(4, adrModbus, 0, 0, PAR.ValeurMaxRegul, 0.0, 0, inversionPFPf); break;
        case 0x0664 : LectureModbus(5, adrModbus, 0, 0, PAR.ValeurMaxRegul, 0.0, 0, inversionPFPf); break;
        case 0x0665 : LectureModbus(4, adrModbus, 0, 0, PAR.LimiteConsigneNulle, 0.0, 0, inversionPFPf); break;
        case 0x0666 : LectureModbus(5, adrModbus, 0, 0, PAR.LimiteConsigneNulle, 0.0, 0, inversionPFPf); break;

        case 0x06A0 : MODBUS_TX[adrModbus]   = PAR.PdP_TempsRechargeMax/256;
                      MODBUS_TX[adrModbus+1] = PAR.PdP_TempsRechargeMax - MODBUS_TX[adrModbus]*256; break;
        case 0x06A1 : MODBUS_TX[adrModbus]   = PAR.Pdp_SeuilNiveauTH/256;
                      MODBUS_TX[adrModbus+1] = PAR.Pdp_SeuilNiveauTH - MODBUS_TX[adrModbus]*256; break;
        case 0x06A2 : MODBUS_TX[adrModbus]   = PAR.Pdp_SeuilNiveauH/256;
                      MODBUS_TX[adrModbus+1] = PAR.Pdp_SeuilNiveauH - MODBUS_TX[adrModbus]*256; break;
        case 0x06A3 : MODBUS_TX[adrModbus]   = PAR.Pdp_SeuilNiveauB/256;
                      MODBUS_TX[adrModbus+1] = PAR.Pdp_SeuilNiveauB - MODBUS_TX[adrModbus]*256; break;
        case 0x06A4 : MODBUS_TX[adrModbus]   = PAR.Pdp_SeuilNiveauTB/256;
                      MODBUS_TX[adrModbus+1] = PAR.Pdp_SeuilNiveauTB - MODBUS_TX[adrModbus]*256; break;
        case 0x06A5 : MODBUS_TX[adrModbus]   = PAR.Pdp_TempoRepriseRegulation/256;
                      MODBUS_TX[adrModbus+1] = PAR.Pdp_TempoRepriseRegulation - MODBUS_TX[adrModbus]*256; break;
        case 0x06A6 : MODBUS_TX[adrModbus]   = EXP.PdP_PosCycle/256;
                      MODBUS_TX[adrModbus+1] = EXP.PdP_PosCycle - MODBUS_TX[adrModbus]*256; break;

        case 0x0700 :
        case 0x0701 :
        case 0x0702 :
        case 0x0703 :
        case 0x0704 :
        case 0x0705 :
        case 0x0706 :
        case 0x0707 :
        case 0x0708 :
        case 0x0709 : MODBUS_TX[adrModbus]   = PAR.EntreeTOR[a-0x0700+1]/256;
                      MODBUS_TX[adrModbus+1] = PAR.EntreeTOR[a-0x0700+1] - MODBUS_TX[adrModbus]*256; break;
        case 0x070A :
        case 0x070B :
        case 0x070C :
        case 0x070D :
        case 0x070E :
        case 0x070F :
        case 0x0710 :
        case 0x0711 : MODBUS_TX[adrModbus]   = PAR.SortieTOR[a-0x070A+1]/256;
                      MODBUS_TX[adrModbus+1] = PAR.SortieTOR[a-0x070A+1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0712 : MODBUS_TX[adrModbus]   = PAR.EntreeANA[1]/256;
                      MODBUS_TX[adrModbus+1] = PAR.EntreeANA[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0713 : MODBUS_TX[adrModbus]   = PAR.EntreeANA[2]/256;
                      MODBUS_TX[adrModbus+1] = PAR.EntreeANA[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x0714 : MODBUS_TX[adrModbus]   = PAR.ValSortieANA[1]/256;
                      MODBUS_TX[adrModbus+1] = PAR.ValSortieANA[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0715 : MODBUS_TX[adrModbus]   = PAR.ValSortieANA[2]/256;
                      MODBUS_TX[adrModbus+1] = PAR.ValSortieANA[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x0716 : MODBUS_TX[adrModbus]   = PAR.TypeSortieANA[1]/256;
                      MODBUS_TX[adrModbus+1] = PAR.TypeSortieANA[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0717 : MODBUS_TX[adrModbus]   = PAR.TypeSortieANA[2]/256;
                      MODBUS_TX[adrModbus+1] = PAR.TypeSortieANA[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x0718 : interUI = PAR.OrigineSortieANA[1]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.OrigineSortieANA[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0719 : interUI = PAR.OrigineSortieANA[2]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.OrigineSortieANA[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x071A : interUI = PAR.CoeffSortieAna[1]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.CoeffSortieAna[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x071B : interUI = PAR.CoeffSortieAna[2]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.CoeffSortieAna[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x071C : interUI = PAR.InversionSortiesTOR; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.InversionSortiesTOR - MODBUS_TX[adrModbus]*256; break;
        case 0x071D : interUI = PAR.InversionEntreesTOR; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.InversionEntreesTOR - MODBUS_TX[adrModbus]*256; break;
        case 0x071E : interUI = EXP.Forcage0SortiesTOR; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = EXP.Forcage0SortiesTOR - MODBUS_TX[adrModbus]*256; break;
        case 0x071F : interUI = EXP.Forcage1SortiesTOR; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = EXP.Forcage1SortiesTOR - MODBUS_TX[adrModbus]*256; break;
        case 0x0720 : MODBUS_TX[adrModbus]   = 0;
                      MODBUS_TX[adrModbus+1] = OUT1_IO + OUT0_IO*2 + OUT2_IO*4 + OUT3_IO*8 + OUT4_IO*16
                            + OUT5_IO*32 + OUT6_IO*64 + OUT7_IO*128; break;
        case 0x0721 : MODBUS_TX[adrModbus]   = entTOR[8] + entTOR[9]*2;
                      MODBUS_TX[adrModbus+1] = entTOR[0] + entTOR[1]*2 + entTOR[2]*4 + entTOR[3]*8 + entTOR[4]*16
                            + entTOR[5]*32 + entTOR[6]*64 + entTOR[7]*128; break;
        case 0x0722 : interUI = PAR.OrigineEntreeANA[1]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.OrigineEntreeANA[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0723 : interUI = PAR.OrigineEntreeANA[2]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.OrigineEntreeANA[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x0724 : interUI = PAR.CoeffEntreeAna[1]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.CoeffEntreeAna[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0725 : interUI = PAR.CoeffEntreeAna[2]; interUI /= 256; MODBUS_TX[adrModbus] = interUI;
                      MODBUS_TX[adrModbus+1] = PAR.CoeffEntreeAna[2] - MODBUS_TX[adrModbus]*256; break;
        case 0x0726 : MODBUS_TX[adrModbus]   = PAR.TypeEntreeANA[1]/256;
                      MODBUS_TX[adrModbus+1] = PAR.TypeEntreeANA[1] - MODBUS_TX[adrModbus]*256; break;
        case 0x0727 : MODBUS_TX[adrModbus]   = PAR.TypeEntreeANA[2]/256;
                      MODBUS_TX[adrModbus+1] = PAR.TypeEntreeANA[2] - MODBUS_TX[adrModbus]*256; break;
                              
        case 0x0800 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommVitesse[0]; break;
        case 0x0801 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommParite[0]; break;
        case 0x0802 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbBits[0]; break;
        case 0x0803 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbbitsStop[0]; break;
        case 0x0804 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommCtrlFlux[0]; break;
        case 0x0805 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommMode[0]; break;
        case 0x0806 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNumEsclave[0]; break;
        case 0x0807 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommType[0]; break;
        case 0x0808 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommTypeImprimante[0]; break;
        case 0x0809 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommVitesse[1]; break;
        case 0x080A : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommParite[1]; break;
        case 0x080B : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbBits[1]; break;
        case 0x080C : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbbitsStop[1]; break;
        case 0x080D : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommCtrlFlux[1]; break;
        case 0x080E : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommMode[1]; break;
        case 0x080F : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNumEsclave[1]; break;
        case 0x0810 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommType[1]; break;
        case 0x0811 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommTypeImprimante[1]; break;
        case 0x0812 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommVitesse[2]; break;
        case 0x0813 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommParite[2]; break;
        case 0x0814 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbBits[2]; break;
        case 0x0815 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbbitsStop[2]; break;
        case 0x0816 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommCtrlFlux[2]; break;
        case 0x0817 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommMode[2]; break;
        case 0x0818 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNumEsclave[2]; break;
        case 0x0819 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommType[2]; break;
        case 0x081A : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommTypeImprimante[2]; break;
        case 0x081B : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommVitesse[3]; break;
        case 0x081C : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommParite[3]; break;
        case 0x081D : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbBits[3]; break;
        case 0x081E : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNbbitsStop[3]; break;
        case 0x081F : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommCtrlFlux[3]; break;
        case 0x0820 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommMode[3]; break;
        case 0x0821 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNumEsclave[3]; break;
        case 0x0822 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommType[3]; break;
        case 0x0823 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommTypeImprimante[3]; break;
        case 0x0824 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommVitesse[4]; break;
        case 0x0825 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNumEsclave[4]; break;
        case 0x0827 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommVitesse[5]; break;
        case 0x0828 : MODBUS_TX[adrModbus] = 0; MODBUS_TX[adrModbus+1] = PAR.CommNumEsclave[5]; break;

        case 0x0900 : MODBUS_TX[adrModbus]   = PAR.TempoDefaut/256;
                      MODBUS_TX[adrModbus+1] = PAR.TempoDefaut - MODBUS_TX[adrModbus]*256; break;
        case 0x0901 : MODBUS_TX[adrModbus]   = PAR.AffectTempoDefaut1/256;
                      MODBUS_TX[adrModbus+1] = PAR.AffectTempoDefaut1 - MODBUS_TX[adrModbus]*256; break;
        case 0x0902 : MODBUS_TX[adrModbus]   = PAR.AffectTempoDefaut2/256;
                      MODBUS_TX[adrModbus+1] = PAR.AffectTempoDefaut2 - MODBUS_TX[adrModbus]*256; break;
        case 0x0903 : MODBUS_TX[adrModbus]   = PAR.AffectDefautDefautGeneral1/256;
                      MODBUS_TX[adrModbus+1] = PAR.AffectDefautDefautGeneral1 - MODBUS_TX[adrModbus]*256; break;
        case 0x0904 : MODBUS_TX[adrModbus]   = PAR.AffectDefautDefautGeneral2/256;
                      MODBUS_TX[adrModbus+1] = PAR.AffectDefautDefautGeneral2 - MODBUS_TX[adrModbus]*256; break;
        case 0x0905 : MODBUS_TX[adrModbus]   = PAR.AcqAutoDefauts/256;
                      MODBUS_TX[adrModbus+1] = PAR.AcqAutoDefauts - MODBUS_TX[adrModbus]*256; break;
        case 0x0906 : MODBUS_TX[adrModbus]   = PAR.ActivationDefaut1/256;
                      MODBUS_TX[adrModbus+1] = PAR.ActivationDefaut1 - MODBUS_TX[adrModbus]*256; break;
        case 0x0907 : MODBUS_TX[adrModbus]   = PAR.ActivationDefaut2/256;
                      MODBUS_TX[adrModbus+1] = PAR.ActivationDefaut2 - MODBUS_TX[adrModbus]*256; break;
        
        case 0x1000 : MODBUS_TX[adrModbus]   = PAR.LongPulseSortie/256;
                      MODBUS_TX[adrModbus+1] = PAR.LongPulseSortie - MODBUS_TX[adrModbus]*256; break;
        case 0x1001 : MODBUS_TX[adrModbus]   = PAR.TypeCommande/256;
                      MODBUS_TX[adrModbus+1] = PAR.TypeCommande - MODBUS_TX[adrModbus]*256;
                      PAR.CommandeTOR = ((PAR.TypeCommande & 0x01) == 0x00);
                      PAR.CommandeSerie = ((PAR.TypeCommande & 0x01) == 0x01);
                      break;
        case 0x111A : MODBUS_TX[adrModbus]   = PAR.Impr_NbLignesVides/256;
                      MODBUS_TX[adrModbus+1] = PAR.Impr_NbLignesVides - MODBUS_TX[adrModbus]*256; break;
        case 0x111B : MODBUS_TX[adrModbus]   = PAR.Impr_MotCommande/256;
                      MODBUS_TX[adrModbus+1] = PAR.Impr_MotCommande - MODBUS_TX[adrModbus]*256; break;
        case 0x111C : MODBUS_TX[adrModbus]   = PAR.Impr_NumTicket/256;
                      MODBUS_TX[adrModbus+1] = PAR.Impr_NumTicket - MODBUS_TX[adrModbus]*256; break;
        case 0x111D : MODBUS_TX[adrModbus]   = PAR.Impr_TypeTicket/256;
                      MODBUS_TX[adrModbus+1] = PAR.Impr_TypeTicket - MODBUS_TX[adrModbus]*256; break;

        case 0x2000 : LectureModbus(4, adrModbus, 0, 0, PAR.BdC_PorteeMin, 0.0, 0, inversionPFPf); break;
        case 0x2001 : LectureModbus(5, adrModbus, 0, 0, PAR.BdC_PorteeMin, 0.0, 0, inversionPFPf); break;
        case 0x2002 : LectureModbus(4, adrModbus, 0, 0, PAR.BdC_TotalisationMin, 0.0, 0, inversionPFPf); break;
        case 0x2003 : LectureModbus(5, adrModbus, 0, 0, PAR.BdC_TotalisationMin, 0.0, 0, inversionPFPf); break;
        case 0x2006 : LectureModbus(4, adrModbus, 0, 0, PAR.BdC_CptTremiePesee, 0.0, 0, inversionPFPf); break;
        case 0x2007 : LectureModbus(5, adrModbus, 0, 0, PAR.BdC_CptTremiePesee, 0.0, 0, inversionPFPf); break;
        case 0x2008 : LectureModbus(4, adrModbus, 0, 0, PAR.BdC_SeuilPV, 0.0, 0, inversionPFPf); break;
        case 0x2009 : LectureModbus(5, adrModbus, 0, 0, PAR.BdC_SeuilPV, 0.0, 0, inversionPFPf); break;
        case 0x200A : LectureModbus(4, adrModbus, 0, 0, PAR.BdC_ErreurJeteeGV, 0.0, 0, inversionPFPf); break;
        case 0x200B : LectureModbus(5, adrModbus, 0, 0, PAR.BdC_ErreurJeteeGV, 0.0, 0, inversionPFPf); break;
        case 0x200C : LectureModbus(4, adrModbus, 0, 0, PAR.BdC_ErreurJeteePV, 0.0, 0, inversionPFPf); break;
        case 0x200D : LectureModbus(5, adrModbus, 0, 0, PAR.BdC_ErreurJeteePV, 0.0, 0, inversionPFPf); break;
        case 0x200E : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_ErreurJeteeAuto, inversionPFPf); break;
        case 0x200F : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_TempsCalculDebit, inversionPFPf); break;
        case 0x2010 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_TempsVidangeTremieVide, inversionPFPf); break;
        case 0x2011 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_TpsMaxOuvFermVannes, inversionPFPf); break;
        case 0x2012 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_PourcTremieVide, inversionPFPf); break;
        case 0x2015 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_ImpressionTousBatchs, inversionPFPf); break;
        case 0x2016 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_TempsPauseVibrant, inversionPFPf); break;
        case 0x2017 : LectureModbus(6, adrModbus, 0, 0, 0, 0.0, PAR.BdC_TempsMarcheVibrant, inversionPFPf); break;
                      
        case 0x2104 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Dep_ErreurJetee * 1000.0, 0, inversionPFPf); break;
        case 0x2105 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Dep_ErreurJetee * 1000.0, 0, inversionPFPf); break;
        case 0x2106 : MODBUS_TX[adrModbus]   = 0;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_CalculErreurJeteeAuto; break;
        case 0x2107 : MODBUS_TX[adrModbus]   = PAR.Dep_TpsMaxOuvFermVannes/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_TpsMaxOuvFermVannes - MODBUS_TX[adrModbus]*256; break;
        case 0x2108 : MODBUS_TX[adrModbus]   = PAR.Dep_Options/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_Options - MODBUS_TX[adrModbus]*256; break;
//        case 0x2109 : MODBUS_TX[adrModbus]   = EXP.Dep_PosCycle/256;
//                      MODBUS_TX[adrModbus+1] = EXP.Dep_PosCycle - MODBUS_TX[adrModbus]*256; break;
        case 0x210A : MODBUS_TX[adrModbus]   = PAR.Dep_TempoDemVidangeVanne/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_TempoDemVidangeVanne - MODBUS_TX[adrModbus]*256; break;
        case 0x210B : MODBUS_TX[adrModbus]   = PAR.Dep_TempoArretVidangeVanne/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_TempoArretVidangeVanne - MODBUS_TX[adrModbus]*256; break;
        case 0x210C : MODBUS_TX[adrModbus]   = PAR.Dep_TempsPauseVibrant/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_TempsPauseVibrant - MODBUS_TX[adrModbus]*256; break;
        case 0x210D : MODBUS_TX[adrModbus]   = PAR.Dep_TempsMarcheVibrant/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_TempsMarcheVibrant - MODBUS_TX[adrModbus]*256; break;
        case 0x210E : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Dep_VariationPoidsBigBagVide * 1000.0, 0, inversionPFPf); break;
        case 0x210F : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Dep_VariationPoidsBigBagVide * 1000.0, 0, inversionPFPf); break;
        case 0x2110 : MODBUS_TX[adrModbus]   = PAR.Dep_TempsVariationPoidsBigBagVide/256;
                      MODBUS_TX[adrModbus+1] = PAR.Dep_TempsVariationPoidsBigBagVide - MODBUS_TX[adrModbus]*256; break;
        case 0x2111 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Dep_SeuilHaut * 1000.0, 0, inversionPFPf); break;
        case 0x2112 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Dep_SeuilHaut * 1000.0, 0, inversionPFPf); break;
        case 0x2113 : LectureModbus(2, adrModbus, 0, 0, 0, PAR.Dep_SeuilBas * 1000.0, 0, inversionPFPf); break;
        case 0x2114 : LectureModbus(3, adrModbus, 0, 0, 0, PAR.Dep_SeuilBas * 1000.0, 0, inversionPFPf); break;

        case 0x2300 : LectureModbus(4, adrModbus, 0, 0, PAR.PEs_SeuilDeclenchement, 0.0, 0, inversionPFPf); break;
        case 0x2301 : LectureModbus(5, adrModbus, 0, 0, PAR.PEs_SeuilDeclenchement, 0.0, 0, inversionPFPf); break;
        case 0x2302 : MODBUS_TX[adrModbus]   = PAR.PEs_TempoHorsCycle/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_TempoHorsCycle - MODBUS_TX[adrModbus]*256; break;
        case 0x2303 : MODBUS_TX[adrModbus]   = PAR.PEs_TempoApresStabilite/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_TempoApresStabilite - MODBUS_TX[adrModbus]*256; break;
        case 0x2304 : MODBUS_TX[adrModbus]   = PAR.PEs_ModeStatique/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_ModeStatique - MODBUS_TX[adrModbus]*256; break;
        case 0x2305 : MODBUS_TX[adrModbus]   = PAR.PEs_LargeurPlateforme/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_LargeurPlateforme - MODBUS_TX[adrModbus]*256; break;
        case 0x2306 : MODBUS_TX[adrModbus]   = PAR.PEs_TolMaxVariationVitesse/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_TolMaxVariationVitesse - MODBUS_TX[adrModbus]*256; break;
        case 0x2307 : MODBUS_TX[adrModbus]   = PAR.PEs_VitesseMax/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_VitesseMax - MODBUS_TX[adrModbus]*256; break;
        case 0x2308 : MODBUS_TX[adrModbus]   = EXP.PEs_PosCycle/256;
                      MODBUS_TX[adrModbus+1] = EXP.PEs_PosCycle - MODBUS_TX[adrModbus]*256; break;
        case 0x2309 : MODBUS_TX[adrModbus]   = EXP.PEs_NbEssieuxPeses/256;
                      MODBUS_TX[adrModbus+1] = EXP.PEs_NbEssieuxPeses - MODBUS_TX[adrModbus]*256; break;
        case 0x230A : LectureModbus(4, adrModbus, 0, 0, EXP.PEs_PoidsTotalEssieux, 0.0, 0, inversionPFPf); break;
        case 0x230B : LectureModbus(5, adrModbus, 0, 0, EXP.PEs_PoidsTotalEssieux, 0.0, 0, inversionPFPf); break;
        case 0x230C : MODBUS_TX[adrModbus]   = PAR.PEs_TempsAcquisitionPoids/256;
                      MODBUS_TX[adrModbus+1] = PAR.PEs_TempsAcquisitionPoids - MODBUS_TX[adrModbus]*256; break;

        case 0x3000 : MODBUS_TX[adrModbus]   = 0; break;
    }
    adrModbus +=2;
}
}


void LectureModbus(int type, int adrModbus, int val1, int val2, long val4, float val3, unsigned int val5, int inversionPFPf)
{
if (type == 1)
{
    MODBUS_TX[adrModbus]   = val1;
    MODBUS_TX[adrModbus+1] = val2;
}
if (type == 2)
{
    if (inversionPFPf)
        envoieReelPf(val3, adrModbus);
    else
        envoieReelPF(val3, adrModbus);
}
if (type == 3)
{
    if (inversionPFPf)
        envoieReelPF(val3, adrModbus);
    else
        envoieReelPf(val3, adrModbus);
}
if (type == 4)
{
    if (inversionPFPf)
        envoieLongPf(val4, adrModbus);
    else
        envoieLongPF(val4, adrModbus);
}
if (type == 5)
{
    if (inversionPFPf)
        envoieLongPF(val4, adrModbus);
    else
        envoieLongPf(val4, adrModbus);
}
if (type == 6)
{
    MODBUS_TX[adrModbus]   = val5/256;
    MODBUS_TX[adrModbus+1] = val5 - MODBUS_TX[adrModbus]*256;
}
}


void envoieLongPF(unsigned long valeur, int adresse)
{
unsigned int    interI;
unsigned int    interI2;

valeur = valeur & 0xFFFF0000;
interI = valeur / 65536;

interI2 = interI & 0xFF00;
interI2 = interI2 / 256;
MODBUS_TX[adresse]   = interI2;
MODBUS_TX[adresse+1] = interI - MODBUS_TX[adresse] * 256;
}


void envoieLongPf(unsigned long valeur, int adresse)
{
unsigned int     interI;

interI = valeur & 0x0000FFFF;
MODBUS_TX[adresse]   = interI / 256;
MODBUS_TX[adresse+1] = interI - MODBUS_TX[adresse] * 256;
}


void envoieReelPF(float valeur, int adresse)
{
int             interI;
long            interI1;
unsigned int    interI2;
long            interI3;

interI1 = (long)valeur;
interI3 = interI1 & 0xFFFF0000;
interI3 = interI3 / 65536;
interI = (int)interI3;

//interF = valeur / 65536;
//interI = (int)interF;
if (valeur < 0)
{
    if (interI == 0)
        interI = 65535; // - interI;
}
interI2 = interI & 0xFF00;
interI2 = interI2 / 256;
MODBUS_TX[adresse]   = interI2;
MODBUS_TX[adresse+1] = interI - MODBUS_TX[adresse] * 256;
}


void envoieReelPf(float valeur, int adresse)
{
unsigned int    interI;
unsigned long   interL;
float           interF;

if (valeur >= 0)
    interL = (unsigned long)valeur;
else
{
    interF = (-1)*valeur;
    interL = (unsigned long)interF;
}

interL = interL & 0x0000FFFF;
interI = interL;

if (valeur < -0.0001)
    interI = 65535 - interI;

MODBUS_TX[adresse]   = interI / 256;
MODBUS_TX[adresse+1] = interI - MODBUS_TX[adresse] * 256;
}


void EcritureMots(int numPort)
{
int             a;
int             adrModbus;
int             adrTableau;
int             echelon;
float           interF;

//Verify that the data can be sent
//if ((MODBUS_COMMAND.StartAddress.Val > ((int)HOLDING_REG_SIZE - 1)) ||
//    ((MODBUS_COMMAND.StartAddress.Val - 1 + MODBUS_COMMAND.NumberOfRegister.Val) > (int)HOLDING_REG_SIZE))
//{
//    ModbusError(Illegal_Data_Address);
//    return;
//}

//Assemble the data to be sent
// Début trame
MODBUS_TX[0] = MODBUS_RX[0];
MODBUS_TX[1] = MODBUS_RX[1];
MODBUS_TX[2] = MODBUS_RX[2];
MODBUS_TX[3] = MODBUS_RX[3];
MODBUS_TX[4] = MODBUS_RX[4];
MODBUS_TX[5] = 0x06;

// Numéro esclave
MODBUS_TX[6] = MODBUS_RX[6];

//Function code
MODBUS_TX[7] = MODBUS_RX[7];

//Début
MODBUS_TX[8] = MODBUS_RX[8];
MODBUS_TX[9] = MODBUS_RX[9];

//Length
MODBUS_TX[10] = MODBUS_RX[10];
MODBUS_TX[11] = MODBUS_RX[11];

if (MODBUS_TX[7] == 0x10)
    adrModbus = 13;
else
{
    adrModbus = 12;
    MODBUS_COMMAND.NumberOfRegister.Val = 1;
}

for (a=MODBUS_COMMAND.StartAddress.Val; a<MODBUS_COMMAND.StartAddress.Val+MODBUS_COMMAND.NumberOfRegister.Val; a++)
{
    adrTableau = 0x015F;
    if ((a >= adrTableau) && (a <= adrTableau+3))
    {
        EXP.Date[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        EXP.Date[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x0163;
    if ((a >= adrTableau) && (a <= adrTableau+2))
    {
        EXP.Heure[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        EXP.Heure[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }

    adrTableau = 0x0200;
    if ((a >= adrTableau) && (a <= adrTableau+49))
    {
        PAR.InfosClient[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.InfosClient[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x232;
    if (a >= adrTableau && a <= adrTableau+9)
    {
        PAR.TechnicienPLCD[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.TechnicienPLCD[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x023C;
    if (a >= adrTableau && a <= adrTableau+9)
    {
        PAR.TechnicienClient[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.TechnicienClient[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x0246;
    if (a >= adrTableau && a <= adrTableau+24)
    {
        PAR.TypeCapteurs[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.TypeCapteurs[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x025F;
    if (a >= adrTableau && a <= adrTableau+19)
    {
        PAR.ProduitPese[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.ProduitPese[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x0273;
    if (a >= adrTableau && a <= adrTableau+3)
    {
        PAR.DateMiseEnService[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.DateMiseEnService[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x0277;
    if (a >= adrTableau && a <= adrTableau+3)
    {
        PAR.DateVerification[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.DateVerification[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x102A;
    if ((a >= adrTableau) && (a <= adrTableau+19))
    {
        PAR.Impr_EnteteLigne1[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_EnteteLigne1[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x1052;
    if ((a >= adrTableau) && (a <= adrTableau+19))
    {
        PAR.Impr_EnteteLigne2[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_EnteteLigne2[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x107A;
    if ((a >= adrTableau) && (a <= adrTableau+19))
    {
        PAR.Impr_EnteteLigne3[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_EnteteLigne3[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x10A2;
    if ((a >= adrTableau) && (a <= adrTableau+19))
    {
        PAR.Impr_PiedPageLigne1[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_PiedPageLigne1[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x10CA;
    if ((a >= adrTableau) && (a <= adrTableau+19))
    {
        PAR.Impr_PiedPageLigne2[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_PiedPageLigne2[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x10F2;
    if ((a >= adrTableau) && (a <= adrTableau+19))
    {
        PAR.Impr_PiedPageLigne3[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_PiedPageLigne3[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x111E;
    if ((a >= adrTableau) && (a <= adrTableau+9))
    {
        PAR.Impr_Produit[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_Produit[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x1128;
    if ((a >= adrTableau) && (a <= adrTableau+9))
    {
        PAR.Impr_Client[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_Client[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x1132;
    if ((a >= adrTableau) && (a <= adrTableau+9))
    {
        PAR.Impr_Destination[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_Destination[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }
    adrTableau = 0x113C;
    if ((a >= adrTableau) && (a <= adrTableau+9))
    {
        PAR.Impr_Camion[(a-adrTableau)*2]   = MODBUS_RX[adrModbus];
        PAR.Impr_Camion[(a-adrTableau)*2+1] = MODBUS_RX[adrModbus+1];
    }

    switch (a)
    {
        case 0x0100 : PAR.TypeProgramme[0] = MODBUS_RX[adrModbus]; PAR.TypeProgramme[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x0101 : PAR.TypeProgramme[2] = MODBUS_RX[adrModbus]; PAR.TypeProgramme[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x0102 : PAR.Version[0] = MODBUS_RX[adrModbus]; PAR.Version[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x0103 : ModifParamMetro(a, (int)PAR.Metrologie, 0.0, 0L, adrModbus); break;
        case 0x0104 : ModifParamMetro(a, PAR.NumSerie[0], 0.0, 0L, adrModbus); break;
        case 0x0105 : ModifParamMetro(a, PAR.NumSerie[2], 0.0, 0L, adrModbus); break;
        case 0x0106 : ModifParamMetro(a, PAR.NumSerie[4], 0.0, 0L, adrModbus); break;
        case 0x0107 : ModifParamMetro(a, PAR.CodeBalancier[0], 0.0, 0L, adrModbus); break;
        case 0x0108 : ModifParamMetro(a, PAR.CodeBalancier[2], 0.0, 0L, adrModbus); break;
        case 0x0109 : PAR.CodeAleatoire[0] = MODBUS_RX[adrModbus]; PAR.CodeAleatoire[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x010A : PAR.CodeAleatoire[2] = MODBUS_RX[adrModbus]; PAR.CodeAleatoire[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x010B : PAR.CodeValidation[0] = MODBUS_RX[adrModbus]; PAR.CodeValidation[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x010C : PAR.CodeValidation[2] = MODBUS_RX[adrModbus];
                      PAR.CodeValidation[3] = MODBUS_RX[adrModbus+1];
                      ValidationCodeMetrologie(); break;
        case 0x010E : PAR.Options = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                      PAR.OP_Doseur       = ((PAR.Options && 0x0001) == 0x0001);
                      break;
        case 0x010F :   EXP.DateNum = LectureLong(EXP.DateNum, adrModbus, 1); break;
        case 0x0110 :   EXP.DateNum = LectureLong(EXP.DateNum, adrModbus, 2);
                        if (EXP.DateNum != 20151218)
                            sprintf(EXP.Date,"%08lu", EXP.DateNum);
                        sprintf(EXP.Date,"%08lu", EXP.DateNum); break;
        case 0x0111 :   EXP.HeureNum = LectureLong(EXP.HeureNum, adrModbus, 1); break;
        case 0x0112 :   EXP.HeureNum = LectureLong(EXP.HeureNum, adrModbus, 2);
                        sprintf(EXP.Heure,"%06lu", EXP.HeureNum); break;
        case 0x0113 : EXP.ChargCPUafficheur = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;

        case 0x016A : EXP.Command1 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                      if (EXP.Command1 > 0)
                        EXP.Command1 = EXP.Command1;
                      break;
        case 0x016B : EXP.Command2 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                      if (EXP.Command2 > 0)
                        EXP.Command1 = EXP.Command1;
                      break;
        case 0x016C : EXP.Command3 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                      if (EXP.Command3 > 0)
                        EXP.Command1 = EXP.Command1;
                      break;
        case 0x016D : EXP.Command4 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                      if (EXP.Command4 > 0)
                        EXP.Command1 = EXP.Command1;
                      break;
        case 0x0176 : EXP.Dep_Consigne = LectureReel(EXP.Dep_Consigne, adrModbus, 1, 10.0); break;
        case 0x0177 : EXP.Dep_Consigne = LectureReel(EXP.Dep_Consigne, adrModbus, 2, 10.0); break;
        case 0x0178 : EXP.Dep_PoidsEnCours = LectureReel(EXP.Dep_PoidsEnCours, adrModbus, 1, 10.0); break;
        case 0x0179 : EXP.Dep_PoidsEnCours = LectureReel(EXP.Dep_PoidsEnCours, adrModbus, 2, 10.0); break;
        case 0x017B : EXP.DebitBascule2 = LectureReel(EXP.DebitBascule2, adrModbus, 1, 10.0); break;
        case 0x017C : EXP.DebitBascule2 = LectureReel(EXP.DebitBascule2, adrModbus, 2, 10.0); break;
        case 0x017D : EXP.TotalPartielB = LectureLong(EXP.TotalPartielB, adrModbus, 1); break;
        case 0x017E : EXP.TotalPartielB = LectureLong(EXP.TotalPartielB, adrModbus, 2); break;
        
        case 0x027B : PAR.AdresseIP[0] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyIPAddr.Val = PAR.AdresseIP[0] | PAR.AdresseIP[1]<<8ul | PAR.AdresseIP[2]<<16ul | PAR.AdresseIP[3]<<24ul;
                      break;
        case 0x027C : PAR.AdresseIP[1] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyIPAddr.Val = PAR.AdresseIP[0] | PAR.AdresseIP[1]<<8ul | PAR.AdresseIP[2]<<16ul | PAR.AdresseIP[3]<<24ul;
                      break;
        case 0x027D : PAR.AdresseIP[2] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyIPAddr.Val = PAR.AdresseIP[0] | PAR.AdresseIP[1]<<8ul | PAR.AdresseIP[2]<<16ul | PAR.AdresseIP[3]<<24ul;
                      break;
        case 0x027E : PAR.AdresseIP[3] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyIPAddr.Val = PAR.AdresseIP[0] | PAR.AdresseIP[1]<<8ul | PAR.AdresseIP[2]<<16ul | PAR.AdresseIP[3]<<24ul;
                      break;
        case 0x027F : PAR.MasqueIP[0] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyMask.Val = PAR.MasqueIP[0] | PAR.MasqueIP[1]<<8ul | PAR.MasqueIP[2]<<16ul | PAR.MasqueIP[3]<<24ul;
                      break;
        case 0x0280 : PAR.MasqueIP[1] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyMask.Val = PAR.MasqueIP[0] | PAR.MasqueIP[1]<<8ul | PAR.MasqueIP[2]<<16ul | PAR.MasqueIP[3]<<24ul;
                      break;
        case 0x0281 : PAR.MasqueIP[2] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyMask.Val = PAR.MasqueIP[0] | PAR.MasqueIP[1]<<8ul | PAR.MasqueIP[2]<<16ul | PAR.MasqueIP[3]<<24ul;
                      break;
        case 0x0282 : PAR.MasqueIP[3] = MODBUS_RX[adrModbus+1];
                      AppConfig.MyMask.Val = PAR.MasqueIP[0] | PAR.MasqueIP[1]<<8ul | PAR.MasqueIP[2]<<16ul | PAR.MasqueIP[3]<<24ul;
                      break;
        case 0x0283 : PAR.PortIP = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;

        case 0x0400 : ModifParamMetro(a, PAR.UnitePoids, 0.0, 0L, adrModbus); break;
        case 0x0401 : ModifParamMetro(a, 0, 0.0, PAR.PoidsMax, adrModbus); break;
        case 0x0402 : ModifParamMetro(a, 0, 0.0, PAR.PoidsMax, adrModbus); break;
        case 0x0403 : ModifParamMetro(a, PAR.NbChiffreVirgPoids, 0.0, 0L, adrModbus); break;
        case 0x0404 : ModifParamMetro(a, PAR.EchelonPoids, 0.0, 0L, adrModbus); break;
        case 0x0405 : ModifParamMetro(a, PAR.FiltrePoids, 0.0, 0L, adrModbus); break;
        case 0x0406 : ModifParamMetro(a, PAR.FrequencePoids, 0.0, 0L, adrModbus); break;
        case 0x0407 : ModifParamMetro(a, 0, 0.0, PAR.TareMetrologie, adrModbus); break;
        case 0x0408 : ModifParamMetro(a, 0, 0.0, PAR.TareMetrologie, adrModbus); break;
        case 0x0409 : ModifParamMetro(a, 0, 0.0, PAR.TareInc, adrModbus); break;
        case 0x040A : ModifParamMetro(a, 0, 0.0, PAR.TareInc, adrModbus); break;
        case 0x040B : ModifParamMetro(a, PAR.ToleranceTarage, 0.0, 0L, adrModbus); break;
        case 0x040C : ModifParamMetro(a, PAR.NbPointsEtalonnage, 0.0, 0L, adrModbus); break;
        case 0x040D : ModifParamMetro(a, PAR.NumPointEtalonnage, 0.0, 0L, adrModbus); break;
        case 0x040E : ModifParamMetro(a, 0, PAR.Pente[1], 0L, adrModbus); break;
        case 0x040F : ModifParamMetro(a, 0, PAR.Pente[1], 0L, adrModbus); break;
        case 0x0410 : ModifParamMetro(a, 0, PAR.SeuilPente[1], 0L, adrModbus); break;
        case 0x0411 : ModifParamMetro(a, 0, PAR.SeuilPente[1], 0L, adrModbus); break;
        case 0x0412 : ModifParamMetro(a, 0, PAR.Pente[2], 0L, adrModbus); break;
        case 0x0413 : ModifParamMetro(a, 0, PAR.Pente[2], 0L, adrModbus); break;
        case 0x0414 : ModifParamMetro(a, 0, PAR.SeuilPente[2], 0L, adrModbus); break;
        case 0x0415 : ModifParamMetro(a, 0, PAR.SeuilPente[2], 0L, adrModbus); break;
        case 0x0416 : ModifParamMetro(a, 0, PAR.Pente[3], 0L, adrModbus); break;
        case 0x0417 : ModifParamMetro(a, 0, PAR.Pente[3], 0L, adrModbus); break;
        case 0x0418 : ModifParamMetro(a, 0, PAR.SeuilPente[3], 0L, adrModbus); break;
        case 0x0419 : ModifParamMetro(a, 0, PAR.SeuilPente[3], 0L, adrModbus); break;
        case 0x041A : ModifParamMetro(a, 0, PAR.Pente[4], 0L, adrModbus); break;
        case 0x041B : ModifParamMetro(a, 0, PAR.Pente[4], 0L, adrModbus); break;
        case 0x041C : ModifParamMetro(a, 0, PAR.SeuilPente[4], 0L, adrModbus); break;
        case 0x041D : ModifParamMetro(a, 0, PAR.SeuilPente[4], 0L, adrModbus); break;
        case 0x041E : ModifParamMetro(a, 0, PAR.Pente[5], 0L, adrModbus); break;
        case 0x041F : ModifParamMetro(a, 0, PAR.Pente[5], 0L, adrModbus); break;
        case 0x0420 : ModifParamMetro(a, 0, PAR.SeuilPente[5], 0L, adrModbus); break;
        case 0x0421 : ModifParamMetro(a, 0, PAR.SeuilPente[5], 0L, adrModbus); break;
        case 0x0422 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteMoyCapteurs, adrModbus); break;
        case 0x0423 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteMoyCapteurs, adrModbus); break;
        case 0x0424 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[1], adrModbus); break;
        case 0x0425 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[1], adrModbus); break;
        case 0x0426 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[2], adrModbus); break;
        case 0x0427 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[2], adrModbus); break;
        case 0x0428 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[3], adrModbus); break;
        case 0x0429 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[3], adrModbus); break;
        case 0x042A : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[4], adrModbus); break;
        case 0x042B : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[4], adrModbus); break;
        case 0x042C : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[5], adrModbus); break;
        case 0x042D : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[5], adrModbus); break;
        case 0x042E : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[6], adrModbus); break;
        case 0x042F : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[6], adrModbus); break;
        case 0x0430 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[7], adrModbus); break;
        case 0x0431 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[7], adrModbus); break;
        case 0x0432 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[8], adrModbus); break;
        case 0x0433 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[8], adrModbus); break;
        case 0x0434 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[9], adrModbus); break;
        case 0x0435 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[9], adrModbus); break;
        case 0x0436 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[10], adrModbus); break;
        case 0x0437 : ModifParamMetro(a, 0, 0.0, PAR.SensibiliteCapteur[10], adrModbus); break;
        case 0x0438 : ModifParamMetro(a, 0, PAR.TarePoids, 0L, adrModbus); break;
        case 0x0439 : ModifParamMetro(a, 0, PAR.TarePoids, 0L, adrModbus);
                        interF = (PAR.TarePoids / PAR.Pente[1]) *1000 +0.001;
                        PAR.TareInc = interF;
                        PAR.TareMetrologie = PAR.TareInc; break;
        case 0x043A : PAR.DefautCapteurPlus = LectureLong(PAR.DefautCapteurPlus, adrModbus, 1); break;
        case 0x043B : PAR.DefautCapteurPlus = LectureLong(PAR.DefautCapteurPlus, adrModbus, 2); break;
        case 0x043C : PAR.DefautCapteurMoins = LectureLong(PAR.DefautCapteurMoins, adrModbus, 1); break;
        case 0x043D : PAR.DefautCapteurMoins = LectureLong(PAR.DefautCapteurMoins, adrModbus, 2); break;
        case 0x043E : PAR.BandeFiltrePoids = LectureLong(PAR.BandeFiltrePoids, adrModbus, 1); break;
        case 0x043F : PAR.BandeFiltrePoids = LectureLong(PAR.BandeFiltrePoids, adrModbus, 2); break;
        case 0x0440 : PAR.NbEchelonsStabilite = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0441 : PAR.TempsStabilite = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0442 : PAR.RapportEtalonnage = LectureLong(PAR.RapportEtalonnage, adrModbus, 1); break;
        case 0x0443 : PAR.RapportEtalonnage = LectureLong(PAR.RapportEtalonnage, adrModbus, 2); break;
        case 0x0444 : PAR.CorrectionTimer = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;

        case 0x0500 : ModifParamMetro(a, PAR.EchelonTotalisation, 0.0, 0L, adrModbus);
                        // Recopie du compteur de sortie sur le totalisateur partiel
                        echelon = 1000 / PAR.EchelonSortieTotVal;
                        EXP.CptTotalPartiel2 = EXP.TotalPartiel2;
                        while ((EXP.TotalPartiel1 * echelon) >= (EXP.CptTotalPartiel1 + 1))
                            EXP.CptTotalPartiel1++;
                        break;
        case 0x0501 : ModifParamMetro(a, PAR.EchelonSortieTot, 0.0, 0L, adrModbus);
                      switch (PAR.EchelonSortieTot)
                      {
                        case  1 : PAR.EchelonSortieTotVal =     1; break;
                        case  2 : PAR.EchelonSortieTotVal =     2; break;
                        case  3 : PAR.EchelonSortieTotVal =     5; break;
                        case  4 : PAR.EchelonSortieTotVal =    10; break;
                        case  5 : PAR.EchelonSortieTotVal =    20; break;
                        case  6 : PAR.EchelonSortieTotVal =    50; break;
                        case  7 : PAR.EchelonSortieTotVal =   100; break;
                        case  8 : PAR.EchelonSortieTotVal =   200; break;
                        case  9 : PAR.EchelonSortieTotVal =   500; break;
                        case 10 : PAR.EchelonSortieTotVal =  1000; break;
                        case 11 : PAR.EchelonSortieTotVal =  2000; break;
                        case 12 : PAR.EchelonSortieTotVal =  5000; break;
                        case 13 : PAR.EchelonSortieTotVal = 10000; break;
                        case 14 : PAR.EchelonSortieTotVal = 20000; break;
                        case 15 : PAR.EchelonSortieTotVal = 50000; break;
                      }
                      EXP.CptTotalPartiel = 0;
                      break;
        case 0x0502 : ModifParamMetro(a, PAR.UniteTotalisation, 0.0, 0L, adrModbus); break;
        case 0x0503 : ModifParamMetro(a, PAR.NbChiffreDecimaleVitesse, 0.0, 0L, adrModbus); break;
        case 0x0504 : ModifParamMetro(a, 0, PAR.VitesseMax, 0L, adrModbus); break;
        case 0x0505 : ModifParamMetro(a, 0, PAR.VitesseMax, 0L, adrModbus); break;
        case 0x0506 : ModifParamMetro(a, PAR.NbChiffreDecimaleDebit, 0.0, 0L, adrModbus); break;
        case 0x0507 : ModifParamMetro(a, 0, PAR.DebitMax, 0L, adrModbus); break;
        case 0x0508 : ModifParamMetro(a, 0, PAR.DebitMax, 0L, adrModbus); break;
        case 0x0509 : ModifParamMetro(a, 0, PAR.DebitNominal, 0L, adrModbus); break;
        case 0x050A : ModifParamMetro(a, 0, PAR.DebitNominal, 0L, adrModbus); break;
        case 0x050B : ModifParamMetro(a, 0, PAR.Correction1, 0L, adrModbus); break;
        case 0x050C : ModifParamMetro(a, 0, PAR.Correction2, 0L, adrModbus); break;
        case 0x050D : ModifParamMetro(a, 0, PAR.Correction3, 0L, adrModbus); break;
        case 0x050E : ModifParamMetro(a, 0, PAR.Correction4, 0L, adrModbus); break;
        case 0x050F : ModifParamMetro(a, 0, PAR.LongueurBande, 0L, adrModbus); break;
        case 0x0510 : ModifParamMetro(a, 0, PAR.LongueurBande, 0L, adrModbus); break;
        case 0x0511 : ModifParamMetro(a, 0, PAR.LongueurPesage, 0L, adrModbus); break;
        case 0x0512 : ModifParamMetro(a, 0, PAR.CirconfTambMene, 0L, adrModbus); break;
        case 0x0513 : ModifParamMetro(a, 0, PAR.CirconfTambMenant, 0L, adrModbus); break;
        case 0x0514 : ModifParamMetro(a, PAR.ImpTambMene, 0.0, 0L, adrModbus); break;
        case 0x0515 : ModifParamMetro(a, PAR.ImpTambMenant, 0.0, 0L, adrModbus); break;
        case 0x0516 : ModifParamMetro(a, PAR.NbPulsesAvantReglage, 0.0, 0L, adrModbus); break;
        case 0x0517 : ModifParamMetro(a, PAR.NbTourBandesReglage, 0.0, 0L, adrModbus); break;
        case 0x0518 : PAR.VitesseMin = 0.0; PAR.VitesseMin = LectureReel(PAR.VitesseMin, adrModbus, 2, 1000.0); break;
        case 0x0519 : PAR.VitesseManu = 0.0; PAR.VitesseManu = LectureReel(PAR.VitesseManu, adrModbus, 2, 1000.0); break;
        case 0x051A : ModifParamMetro(a, 0, PAR.DebitMin, 0L, adrModbus); break;
        case 0x051B : ModifParamMetro(a, 0, PAR.DebitMin, 0L, adrModbus); break;
        case 0x051C : ModifParamMetro(a, 0, PAR.ZoneMorte, 0L, adrModbus); break;
        case 0x051D : ModifParamMetro(a, 0, PAR.LimZeroAuto, 0L, adrModbus); break;
        case 0x051E : ModifParamMetro(a, 0, PAR.LimiteTotalisation, 0L, adrModbus); break;
        case 0x051F : PAR.VitesseNominale = 0.0; PAR.VitesseNominale = LectureReel(PAR.VitesseNominale, adrModbus, 2, 1000.0); break;
        case 0x0520 : PAR.TempsTourBande = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0521 : PAR.LongueurBandeControle = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0522 : PAR.FiltreDebit = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0523 : PAR.LargeurBande = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        
        case 0x0650 : PAR.ConsigneAff = LectureLong(PAR.ConsigneAff, adrModbus, 1); break;
        case 0x0651 : PAR.ConsigneAff = LectureLong(PAR.ConsigneAff, adrModbus, 2); break;
        case 0x0652 : PAR.TolerancePlus = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0653 : PAR.ToleranceMoins = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0654 : PAR.PID_Kp = LectureReel(PAR.PID_Kp, adrModbus, 1, 1000.0); break;
        case 0x0655 : PAR.PID_Ki = LectureReel(PAR.PID_Ki, adrModbus, 1, 1000.0); break;
        case 0x0656 : PAR.Calage10 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0657 : PAR.Calage100 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0658 : PAR.TempsFonctVolumetrique = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x065B : PAR.ConsigneAnaMax = LectureReel(PAR.ConsigneAnaMax, adrModbus, 1, 1.0); break;
        case 0x065C : PAR.ConsigneAnaMax = LectureReel(PAR.ConsigneAnaMax, adrModbus, 2, 1.0); break;
        case 0x065D : PAR.TypeConsigne = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x065F : PAR.MemorisationSortieAna = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0660 : PAR.SeuilHautRegul = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0661 : PAR.SeuilBasRegul = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0662 : PAR.ModeRegul = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0663 : PAR.ValeurMaxRegul = LectureLong(PAR.ValeurMaxRegul, adrModbus, 1); break;
        case 0x0664 : PAR.ValeurMaxRegul = LectureLong(PAR.ValeurMaxRegul, adrModbus, 2); break;
        case 0x0665 : PAR.LimiteConsigneNulle = LectureLong(PAR.LimiteConsigneNulle, adrModbus, 1); break;
        case 0x0666 : PAR.LimiteConsigneNulle = LectureLong(PAR.LimiteConsigneNulle, adrModbus, 2); break;

        case 0x06A0 : PAR.PdP_TempsRechargeMax = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x06A1 : PAR.Pdp_SeuilNiveauTH = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x06A2 : PAR.Pdp_SeuilNiveauH = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x06A3 : PAR.Pdp_SeuilNiveauB = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x06A4 : PAR.Pdp_SeuilNiveauTB = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x06A5 : PAR.Pdp_TempoRepriseRegulation = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        
        case 0x0700 : PAR.EntreeTOR[ 1] = AffectationIO(1,  1, adrModbus); break;
        case 0x0701 : PAR.EntreeTOR[ 2] = AffectationIO(1,  2, adrModbus); break;
        case 0x0702 : PAR.EntreeTOR[ 3] = AffectationIO(1,  3, adrModbus); break;
        case 0x0703 : PAR.EntreeTOR[ 4] = AffectationIO(1,  4, adrModbus); break;
        case 0x0704 : PAR.EntreeTOR[ 5] = AffectationIO(1,  5, adrModbus); break;
        case 0x0705 : PAR.EntreeTOR[ 6] = AffectationIO(1,  6, adrModbus); break;
        case 0x0706 : PAR.EntreeTOR[ 7] = AffectationIO(1,  7, adrModbus); break;
        case 0x0707 : PAR.EntreeTOR[ 8] = AffectationIO(1,  8, adrModbus); break;
        case 0x0708 : PAR.EntreeTOR[ 9] = AffectationIO(1,  9, adrModbus); break;
        case 0x0709 : PAR.EntreeTOR[10] = AffectationIO(1, 10, adrModbus); break;
        case 0x070A : PAR.SortieTOR[ 1] = AffectationIO(2,  1, adrModbus); break;
        case 0x070B : PAR.SortieTOR[ 2] = AffectationIO(2,  2, adrModbus); break;
        case 0x070C : PAR.SortieTOR[ 3] = AffectationIO(2,  3, adrModbus); break;
        case 0x070D : PAR.SortieTOR[ 4] = AffectationIO(2,  4, adrModbus); break;
        case 0x070E : PAR.SortieTOR[ 5] = AffectationIO(2,  5, adrModbus); break;
        case 0x070F : PAR.SortieTOR[ 6] = AffectationIO(2,  6, adrModbus); break;
        case 0x0710 : PAR.SortieTOR[ 7] = AffectationIO(2,  7, adrModbus); break;
        case 0x0711 : PAR.SortieTOR[ 8] = AffectationIO(2,  8, adrModbus); break;
        case 0x0712 : PAR.EntreeANA[ 1] = AffectationIO(3,  1, adrModbus); break;
        case 0x0713 : PAR.EntreeANA[ 2] = AffectationIO(3,  2, adrModbus); break;
        case 0x0714 : PAR.ValSortieANA[ 1] = AffectationIO(4,  1, adrModbus); break;
        case 0x0715 : PAR.ValSortieANA[ 2] = AffectationIO(4,  2, adrModbus); break;
        case 0x0716 : PAR.TypeSortieANA[ 1] = AffectationIO(4,  1, adrModbus); break;
        case 0x0717 : PAR.TypeSortieANA[ 2] = AffectationIO(4,  2, adrModbus); break;
        case 0x0718 : PAR.OrigineSortieANA[ 1] = AffectationIO(4,  1, adrModbus); break;
        case 0x0719 : PAR.OrigineSortieANA[ 2] = AffectationIO(4,  2, adrModbus); break;
        case 0x071A : PAR.CoeffSortieAna[1] = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x071B : PAR.CoeffSortieAna[2] = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x071C : PAR.InversionSortiesTOR = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                        PAR.InversionSortieTOR[1]  = (PAR.InversionSortiesTOR & 0x0001) == 0x0001;
                        PAR.InversionSortieTOR[2]  = (PAR.InversionSortiesTOR & 0x0002) == 0x0002;
                        PAR.InversionSortieTOR[3]  = (PAR.InversionSortiesTOR & 0x0004) == 0x0004;
                        PAR.InversionSortieTOR[4]  = (PAR.InversionSortiesTOR & 0x0008) == 0x0008;
                        PAR.InversionSortieTOR[5]  = (PAR.InversionSortiesTOR & 0x0010) == 0x0010;
                        PAR.InversionSortieTOR[6]  = (PAR.InversionSortiesTOR & 0x0020) == 0x0020;
                        PAR.InversionSortieTOR[7]  = (PAR.InversionSortiesTOR & 0x0040) == 0x0040;
                        PAR.InversionSortieTOR[8]  = (PAR.InversionSortiesTOR & 0x0080) == 0x0080;
                        PAR.InversionSortieTOR[9]  = (PAR.InversionSortiesTOR & 0x0100) == 0x0100;
                        PAR.InversionSortieTOR[10] = (PAR.InversionSortiesTOR & 0x0200) == 0x0200;
                        break;
        case 0x071D : PAR.InversionEntreesTOR = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                        PAR.InversionEntreeTOR[1]  = (PAR.InversionEntreesTOR & 0x0001) == 0x0001;
                        PAR.InversionEntreeTOR[2]  = (PAR.InversionEntreesTOR & 0x0002) == 0x0002;
                        PAR.InversionEntreeTOR[3]  = (PAR.InversionEntreesTOR & 0x0004) == 0x0004;
                        PAR.InversionEntreeTOR[4]  = (PAR.InversionEntreesTOR & 0x0008) == 0x0008;
                        PAR.InversionEntreeTOR[5]  = (PAR.InversionEntreesTOR & 0x0010) == 0x0010;
                        PAR.InversionEntreeTOR[6]  = (PAR.InversionEntreesTOR & 0x0020) == 0x0020;
                        PAR.InversionEntreeTOR[7]  = (PAR.InversionEntreesTOR & 0x0040) == 0x0040;
                        PAR.InversionEntreeTOR[8]  = (PAR.InversionEntreesTOR & 0x0080) == 0x0080;
                        PAR.InversionEntreeTOR[9]  = (PAR.InversionEntreesTOR & 0x0100) == 0x0100;
                        PAR.InversionEntreeTOR[10] = (PAR.InversionEntreesTOR & 0x0200) == 0x0200;
                        break;
        case 0x071E : EXP.Forcage0SortiesTOR = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                        EXP.Forcage0SortieTOR[1]  = (EXP.Forcage0SortiesTOR & 0x0001) == 0x0001;
                        EXP.Forcage0SortieTOR[2]  = (EXP.Forcage0SortiesTOR & 0x0002) == 0x0002;
                        EXP.Forcage0SortieTOR[3]  = (EXP.Forcage0SortiesTOR & 0x0004) == 0x0004;
                        EXP.Forcage0SortieTOR[4]  = (EXP.Forcage0SortiesTOR & 0x0008) == 0x0008;
                        EXP.Forcage0SortieTOR[5]  = (EXP.Forcage0SortiesTOR & 0x0010) == 0x0010;
                        EXP.Forcage0SortieTOR[6]  = (EXP.Forcage0SortiesTOR & 0x0020) == 0x0020;
                        EXP.Forcage0SortieTOR[7]  = (EXP.Forcage0SortiesTOR & 0x0040) == 0x0040;
                        EXP.Forcage0SortieTOR[8]  = (EXP.Forcage0SortiesTOR & 0x0080) == 0x0080;
                        EXP.Forcage0SortieTOR[9]  = (EXP.Forcage0SortiesTOR & 0x0100) == 0x0100;
                        EXP.Forcage0SortieTOR[10] = (EXP.Forcage0SortiesTOR & 0x0200) == 0x0200;
                        break;
        case 0x071F : EXP.Forcage1SortiesTOR = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
                        EXP.Forcage1SortieTOR[1]  = (EXP.Forcage1SortiesTOR & 0x0001) == 0x0001;
                        EXP.Forcage1SortieTOR[2]  = (EXP.Forcage1SortiesTOR & 0x0002) == 0x0002;
                        EXP.Forcage1SortieTOR[3]  = (EXP.Forcage1SortiesTOR & 0x0004) == 0x0004;
                        EXP.Forcage1SortieTOR[4]  = (EXP.Forcage1SortiesTOR & 0x0008) == 0x0008;
                        EXP.Forcage1SortieTOR[5]  = (EXP.Forcage1SortiesTOR & 0x0010) == 0x0010;
                        EXP.Forcage1SortieTOR[6]  = (EXP.Forcage1SortiesTOR & 0x0020) == 0x0020;
                        EXP.Forcage1SortieTOR[7]  = (EXP.Forcage1SortiesTOR & 0x0040) == 0x0040;
                        EXP.Forcage1SortieTOR[8]  = (EXP.Forcage1SortiesTOR & 0x0080) == 0x0080;
                        EXP.Forcage1SortieTOR[9]  = (EXP.Forcage1SortiesTOR & 0x0100) == 0x0100;
                        EXP.Forcage1SortieTOR[10] = (EXP.Forcage1SortiesTOR & 0x0200) == 0x0200;
                        break;
        case 0x0722 : PAR.OrigineEntreeANA[ 1] = AffectationIO(4,  1, adrModbus); break;
        case 0x0723 : PAR.OrigineEntreeANA[ 2] = AffectationIO(4,  2, adrModbus); break;
        case 0x0724 : PAR.CoeffEntreeAna[1] = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0725 : PAR.CoeffEntreeAna[2] = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0726 : PAR.TypeEntreeANA[ 1] = AffectationIO(4,  1, adrModbus); break;
        case 0x0727 : PAR.TypeEntreeANA[ 2] = AffectationIO(4,  2, adrModbus); break;

        case 0x0800 : PAR.CommVitesse[0] = MODBUS_RX[adrModbus+1]; ModifieVitesseComm(0); break;
        case 0x0801 : PAR.CommParite[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0802 : PAR.CommNbBits[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0803 : PAR.CommNbbitsStop[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0804 : PAR.CommCtrlFlux[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0805 : PAR.CommMode[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0806 : PAR.CommNumEsclave[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0807 : PAR.CommType[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0808 : PAR.CommTypeImprimante[0] = MODBUS_RX[adrModbus+1]; break;
        case 0x0809 : PAR.CommVitesse[1] = MODBUS_RX[adrModbus+1]; ModifieVitesseComm(1); break;
        case 0x080A : PAR.CommParite[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x080B : PAR.CommNbBits[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x080C : PAR.CommNbbitsStop[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x080D : PAR.CommCtrlFlux[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x080E : PAR.CommMode[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x080F : PAR.CommNumEsclave[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x0810 : PAR.CommType[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x0811 : PAR.CommTypeImprimante[1] = MODBUS_RX[adrModbus+1]; break;
        case 0x0812 : PAR.CommVitesse[2] = MODBUS_RX[adrModbus+1]; ModifieVitesseComm(2); break;
        case 0x0813 : PAR.CommParite[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x0814 : PAR.CommNbBits[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x0815 : PAR.CommNbbitsStop[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x0816 : PAR.CommCtrlFlux[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x0817 : PAR.CommMode[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x0818 : PAR.CommNumEsclave[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x0819 : PAR.CommType[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x081A : PAR.CommTypeImprimante[2] = MODBUS_RX[adrModbus+1]; break;
        case 0x081B : PAR.CommVitesse[3] = MODBUS_RX[adrModbus+1]; ModifieVitesseComm(3); break;
        case 0x081C : PAR.CommParite[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x081D : PAR.CommNbBits[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x081E : PAR.CommNbbitsStop[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x081F : PAR.CommCtrlFlux[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x0820 : PAR.CommMode[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x0821 : PAR.CommNumEsclave[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x0822 : PAR.CommType[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x0823 : PAR.CommTypeImprimante[3] = MODBUS_RX[adrModbus+1]; break;
        case 0x0824 : PAR.CommVitesse[4] = MODBUS_RX[adrModbus+1]; break;
        case 0x0825 : PAR.CommNumEsclave[4] = MODBUS_RX[adrModbus+1];
                      // Définit le numéro de l'esclave pour le PROFIBUS
                      US_SetSwitch1(PAR.CommNumEsclave[4]); break;
        case 0x0827 : PAR.CommVitesse[5] = MODBUS_RX[adrModbus+1]; break;
        case 0x0828 : PAR.CommNumEsclave[5] = MODBUS_RX[adrModbus+1]; break;

        case 0x0900 : PAR.TempoDefaut = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0901 : PAR.AffectTempoDefaut1 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0902 : PAR.AffectTempoDefaut2 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0903 : PAR.AffectDefautDefautGeneral1 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0904 : PAR.AffectDefautDefautGeneral2 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0905 : PAR.AcqAutoDefauts = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0906 : PAR.ActivationDefaut1 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x0907 : PAR.ActivationDefaut2 = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
                
        case 0x1000 : PAR.LongPulseSortie = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x1001 : PAR.TypeCommande = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x111A : PAR.Impr_NbLignesVides = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x111B : PAR.Impr_MotCommande = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x111C : PAR.Impr_NumTicket = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x111D : PAR.Impr_TypeTicket = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;

        case 0x2000 : PAR.BdC_PorteeMin = LectureLong(PAR.BdC_PorteeMin, adrModbus, 1); break;
        case 0x2001 : PAR.BdC_PorteeMin = LectureLong(PAR.BdC_PorteeMin, adrModbus, 2); break;
        case 0x2002 : PAR.BdC_TotalisationMin = LectureLong(PAR.BdC_TotalisationMin, adrModbus, 1); break;
        case 0x2003 : PAR.BdC_TotalisationMin = LectureLong(PAR.BdC_TotalisationMin, adrModbus, 2); break;
        case 0x2006 : PAR.BdC_CptTremiePesee = LectureLong(PAR.BdC_CptTremiePesee, adrModbus, 1); break;
        case 0x2007 : PAR.BdC_CptTremiePesee = LectureLong(PAR.BdC_CptTremiePesee, adrModbus, 2); break;
        case 0x2008 : PAR.BdC_SeuilPV = LectureLong(PAR.BdC_SeuilPV, adrModbus, 1); break;
        case 0x2009 : PAR.BdC_SeuilPV = LectureLong(PAR.BdC_SeuilPV, adrModbus, 2); break;
        case 0x200A : PAR.BdC_ErreurJeteeGV = LectureLong(PAR.BdC_ErreurJeteeGV, adrModbus, 1); break;
        case 0x200B : PAR.BdC_ErreurJeteeGV = LectureLong(PAR.BdC_ErreurJeteeGV, adrModbus, 2); break;
        case 0x200C : PAR.BdC_ErreurJeteePV = LectureLong(PAR.BdC_ErreurJeteePV, adrModbus, 1); break;
        case 0x200D : PAR.BdC_ErreurJeteePV = LectureLong(PAR.BdC_ErreurJeteePV, adrModbus, 2); break;
        case 0x200E : PAR.BdC_ErreurJeteeAuto = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x200F : PAR.BdC_TempsCalculDebit = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2010 : PAR.BdC_TempsVidangeTremieVide = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2011 : PAR.BdC_TpsMaxOuvFermVannes = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2012 : PAR.BdC_PourcTremieVide = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2015 : PAR.BdC_ImpressionTousBatchs = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2016 : PAR.BdC_TempsPauseVibrant = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2017 : PAR.BdC_TempsMarcheVibrant = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;

        case 0x2104 : PAR.Dep_ErreurJetee = LectureReel(PAR.Dep_ErreurJetee, adrModbus, 1, 1000.0); break;
        case 0x2105 : PAR.Dep_ErreurJetee = LectureReel(PAR.Dep_ErreurJetee, adrModbus, 2, 1000.0); break;
        case 0x2106 : PAR.Dep_CalculErreurJeteeAuto = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2107 : PAR.Dep_TpsMaxOuvFermVannes = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2108 : PAR.Dep_Options = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x210A : PAR.Dep_TempoDemVidangeVanne = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x210B : PAR.Dep_TempoArretVidangeVanne = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x210C : PAR.Dep_TempsPauseVibrant = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x210D : PAR.Dep_TempsMarcheVibrant = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x210E : PAR.Dep_VariationPoidsBigBagVide = LectureReel(PAR.Dep_VariationPoidsBigBagVide, adrModbus, 1, 1000.0); break;
        case 0x210F : PAR.Dep_VariationPoidsBigBagVide = LectureReel(PAR.Dep_VariationPoidsBigBagVide, adrModbus, 2, 1000.0); break;
        case 0x2110 : PAR.Dep_TempsVariationPoidsBigBagVide = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2111 : PAR.Dep_SeuilHaut = LectureReel(PAR.Dep_SeuilHaut, adrModbus, 1, 1000.0); break;
        case 0x2112 : PAR.Dep_SeuilHaut = LectureReel(PAR.Dep_SeuilHaut, adrModbus, 2, 1000.0); break;
        case 0x2113 : PAR.Dep_SeuilBas = LectureReel(PAR.Dep_SeuilBas, adrModbus, 1, 1000.0); break;
        case 0x2114 : PAR.Dep_SeuilBas = LectureReel(PAR.Dep_SeuilBas, adrModbus, 2, 1000.0); break;

        case 0x2300 : PAR.PEs_SeuilDeclenchement = LectureLong(PAR.PEs_SeuilDeclenchement, adrModbus, 1); break;
        case 0x2301 : PAR.PEs_SeuilDeclenchement = LectureLong(PAR.PEs_SeuilDeclenchement, adrModbus, 2); break;
        case 0x2302 : PAR.PEs_TempoHorsCycle = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2303 : PAR.PEs_TempoApresStabilite = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2304 : PAR.PEs_ModeStatique = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2305 : PAR.PEs_LargeurPlateforme = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2306 : PAR.PEs_TolMaxVariationVitesse = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2307 : PAR.PEs_VitesseMax = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2308 : EXP.PEs_PosCycle = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x2309 : EXP.PEs_NbEssieuxPeses = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
        case 0x230A : EXP.PEs_PoidsTotalEssieux = LectureLong(EXP.PEs_PoidsTotalEssieux, adrModbus, 1); break;
        case 0x230B : EXP.PEs_PoidsTotalEssieux = LectureLong(EXP.PEs_PoidsTotalEssieux, adrModbus, 2); break;
        case 0x230C : PAR.PEs_TempsAcquisitionPoids = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1]; break;
    }
    adrModbus +=2;
}
//EcrFRAM_Param();
}


int AffectationIO(int type, int numero, int adrModbus)
{
int     valeur;
int     indice;

valeur = MODBUS_RX[adrModbus]*256 + MODBUS_RX[adrModbus+1];
//    if (type == 1)                                                            // Affectation entrées TOR
//        cIO_Entree[valeur] = numero;

    if (type == 2)                                                              // Affectation sorties TOR
        PAR.SortieTOR[indice] = numero;
return valeur;
}


void ModifParamMetro(int indice, int valeur1, float valeur2, long valeur3, int adrModbus1)
{
// David - Autorisation permanente des modifications des paramètres métrologiques
PAR.CodeMetrologiqueOK = 1;

if (PAR.CodeMetrologiqueOK == 1)
{
    switch (indice)
    {
        case 0x0103 :   PAR.Metrologie = MODBUS_RX[adrModbus1+1]; break;
        case 0x0104 :   PAR.NumSerie[0] = MODBUS_RX[adrModbus1];
                        PAR.NumSerie[1] = MODBUS_RX[adrModbus1+1]; break;
        case 0x0105 :   PAR.NumSerie[2] = MODBUS_RX[adrModbus1];
                        PAR.NumSerie[3] = MODBUS_RX[adrModbus1+1]; break;
        case 0x0106 :   PAR.NumSerie[4] = MODBUS_RX[adrModbus1];
                        PAR.NumSerie[5] = MODBUS_RX[adrModbus1+1]; break;
        case 0x0107 :   PAR.CodeBalancier[0] = MODBUS_RX[adrModbus1];
                        PAR.CodeBalancier[1] = MODBUS_RX[adrModbus1+1]; break;
        case 0x0108 :   PAR.CodeBalancier[2] = MODBUS_RX[adrModbus1];
                        PAR.CodeBalancier[3] = MODBUS_RX[adrModbus1+1]; break;

        case 0x0400 :   PAR.UnitePoids = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0401 :   PAR.PoidsMax = LectureLong(PAR.PoidsMax, adrModbus1, 1); break;
        case 0x0402 :   PAR.PoidsMax = LectureLong(PAR.PoidsMax, adrModbus1, 2); break;
        case 0x0403 :   PAR.NbChiffreVirgPoids = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0404 :   PAR.EchelonPoids = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1];
                        switch (PAR.EchelonPoids)
                        {
                            case  1 : PAR.EchelonPoidsVal =   0.001; break;
                            case  2 : PAR.EchelonPoidsVal =   0.002; break;
                            case  3 : PAR.EchelonPoidsVal =   0.005; break;
                            case  4 : PAR.EchelonPoidsVal =   0.010; break;
                            case  5 : PAR.EchelonPoidsVal =   0.020; break;
                            case  6 : PAR.EchelonPoidsVal =   0.050; break;
                            case  7 : PAR.EchelonPoidsVal =   0.100; break;
                            case  8 : PAR.EchelonPoidsVal =   0.200; break;
                            case  9 : PAR.EchelonPoidsVal =   0.500; break;
                            case 10 : PAR.EchelonPoidsVal =   1.00; break;
                            case 11 : PAR.EchelonPoidsVal =   2.000; break;
                            case 12 : PAR.EchelonPoidsVal =   5.000; break;
                            case 13 : PAR.EchelonPoidsVal =  10.000; break;
                            case 14 : PAR.EchelonPoidsVal =  20.000; break;
                            case 15 : PAR.EchelonPoidsVal =  50.000; break;
                            case 16 : PAR.EchelonPoidsVal = 100.000; break;
                            case 17 : PAR.EchelonPoidsVal = 200.000; break;
                            case 18 : PAR.EchelonPoidsVal = 500.000; break;
                        }
                        break;
        case 0x0405 :   PAR.FiltrePoids = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0406 :   PAR.FrequencePoids = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0407 :   PAR.TareMetrologie = LectureLong(PAR.TareMetrologie, adrModbus1, 1); break;
        case 0x0408 :   PAR.TareMetrologie = LectureLong(PAR.TareMetrologie, adrModbus1, 2); break;
        case 0x0409 :   PAR.TareInc = LectureLong(PAR.TareInc, adrModbus1, 1); break;
        case 0x040A :   PAR.TareInc = LectureLong(PAR.TareInc, adrModbus1, 2); break;
        case 0x040B :   PAR.ToleranceTarage =MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x040C :   PAR.NbPointsEtalonnage = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x040D :   PAR.NumPointEtalonnage = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x040E :   PAR.Pente[1] = LectureReel(PAR.Pente[1], adrModbus1, 1, 1000.0); break;
        case 0x040F :   PAR.Pente[1] = LectureReel(PAR.Pente[1], adrModbus1, 2, 1000.0); break;
        case 0x0410 :   PAR.SeuilPente[1] = LectureReel(PAR.SeuilPente[1], adrModbus1, 1, 1000.0); break;
        case 0x0411 :   PAR.SeuilPente[1] = LectureReel(PAR.SeuilPente[1], adrModbus1, 2, 1000.0); break;
        case 0x0412 :   PAR.Pente[2] = LectureReel(PAR.Pente[2], adrModbus1, 1, 1000.0); break;
        case 0x0413 :   PAR.Pente[2] = LectureReel(PAR.Pente[2], adrModbus1, 2, 1000.0); break;
        case 0x0414 :   PAR.SeuilPente[2] = LectureReel(PAR.SeuilPente[2], adrModbus1, 1, 1000.0); break;
        case 0x0415 :   PAR.SeuilPente[2] = LectureReel(PAR.SeuilPente[2], adrModbus1, 2, 1000.0); break;
        case 0x0416 :   PAR.Pente[3] = LectureReel(PAR.Pente[3], adrModbus1, 1, 1000.0); break;
        case 0x0417 :   PAR.Pente[3] = LectureReel(PAR.Pente[3], adrModbus1, 2, 1000.0); break;
        case 0x0418 :   PAR.SeuilPente[3] = LectureReel(PAR.SeuilPente[3], adrModbus1, 1, 1000.0); break;
        case 0x0419 :   PAR.SeuilPente[3] = LectureReel(PAR.SeuilPente[3], adrModbus1, 2, 1000.0); break;
        case 0x041A :   PAR.Pente[4] = LectureReel(PAR.Pente[4], adrModbus1, 1, 1000.0); break;
        case 0x041B :   PAR.Pente[4] = LectureReel(PAR.Pente[4], adrModbus1, 2, 1000.0); break;
        case 0x041C :   PAR.SeuilPente[4] = LectureReel(PAR.SeuilPente[4], adrModbus1, 1, 1000.0); break;
        case 0x041D :   PAR.SeuilPente[4] = LectureReel(PAR.SeuilPente[4], adrModbus1, 2, 1000.0); break;
        case 0x041E :   PAR.Pente[5] = LectureReel(PAR.Pente[5], adrModbus1, 1, 1000.0); break;
        case 0x041F :   PAR.Pente[5] = LectureReel(PAR.Pente[5], adrModbus1, 2, 1000.0); break;
        case 0x0420 :   PAR.SeuilPente[5] = LectureReel(PAR.SeuilPente[5], adrModbus1, 1, 1000.0); break;
        case 0x0421 :   PAR.SeuilPente[5] = LectureReel(PAR.SeuilPente[5], adrModbus1, 2, 1000.0); break;
        case 0x0422 :   PAR.SensibiliteMoyCapteurs = LectureLong(PAR.SensibiliteMoyCapteurs, adrModbus1, 1); break;
        case 0x0423 :   PAR.SensibiliteMoyCapteurs = LectureLong(PAR.SensibiliteMoyCapteurs, adrModbus1, 2); break;
        case 0x0424 :   PAR.SensibiliteCapteur[1]  = LectureLong(PAR.SensibiliteCapteur[1], adrModbus1, 1); break;
        case 0x0425 :   PAR.SensibiliteCapteur[1]  = LectureLong(PAR.SensibiliteCapteur[1], adrModbus1, 2); break;
        case 0x0426 :   PAR.SensibiliteCapteur[2]  = LectureLong(PAR.SensibiliteCapteur[2], adrModbus1, 1); break;
        case 0x0427 :   PAR.SensibiliteCapteur[2]  = LectureLong(PAR.SensibiliteCapteur[2], adrModbus1, 2); break;
        case 0x0428 :   PAR.SensibiliteCapteur[3]  = LectureLong(PAR.SensibiliteCapteur[3], adrModbus1, 1); break;
        case 0x0429 :   PAR.SensibiliteCapteur[3]  = LectureLong(PAR.SensibiliteCapteur[3], adrModbus1, 2); break;
        case 0x042A :   PAR.SensibiliteCapteur[4]  = LectureLong(PAR.SensibiliteCapteur[4], adrModbus1, 1); break;
        case 0x042B :   PAR.SensibiliteCapteur[4]  = LectureLong(PAR.SensibiliteCapteur[4], adrModbus1, 2); break;
        case 0x042C :   PAR.SensibiliteCapteur[5]  = LectureLong(PAR.SensibiliteCapteur[5], adrModbus1, 1); break;
        case 0x042D :   PAR.SensibiliteCapteur[5]  = LectureLong(PAR.SensibiliteCapteur[5], adrModbus1, 2); break;
        case 0x042E :   PAR.SensibiliteCapteur[6]  = LectureLong(PAR.SensibiliteCapteur[6], adrModbus1, 1); break;
        case 0x042F :   PAR.SensibiliteCapteur[6]  = LectureLong(PAR.SensibiliteCapteur[6], adrModbus1, 2); break;
        case 0x0430 :   PAR.SensibiliteCapteur[7]  = LectureLong(PAR.SensibiliteCapteur[7], adrModbus1, 1); break;
        case 0x0431 :   PAR.SensibiliteCapteur[7]  = LectureLong(PAR.SensibiliteCapteur[7], adrModbus1, 2); break;
        case 0x0432 :   PAR.SensibiliteCapteur[8]  = LectureLong(PAR.SensibiliteCapteur[8], adrModbus1, 1); break;
        case 0x0433 :   PAR.SensibiliteCapteur[8]  = LectureLong(PAR.SensibiliteCapteur[8], adrModbus1, 2); break;
        case 0x0434 :   PAR.SensibiliteCapteur[9]  = LectureLong(PAR.SensibiliteCapteur[9], adrModbus1, 1); break;
        case 0x0435 :   PAR.SensibiliteCapteur[9]  = LectureLong(PAR.SensibiliteCapteur[9], adrModbus1, 2); break;
        case 0x0436 :   PAR.SensibiliteCapteur[10] = LectureLong(PAR.SensibiliteCapteur[10], adrModbus1, 1); break;
        case 0x0437 :   PAR.SensibiliteCapteur[10] = LectureLong(PAR.SensibiliteCapteur[10], adrModbus1, 2); break;
        case 0x0438 :   PAR.TarePoids = LectureReel(PAR.TarePoids, adrModbus1, 1, 10.0); break;
        case 0x0439 :   PAR.TarePoids = LectureReel(PAR.TarePoids, adrModbus1, 2, 10.0); break;
        case 0x0440 :   PAR.NbEchelonsStabilite = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0441 :   PAR.TempsStabilite = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;

        case 0x0500 :   PAR.EchelonTotalisation = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0501 :   PAR.EchelonSortieTot = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0502 :   PAR.UniteTotalisation = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0503 :   PAR.NbChiffreDecimaleVitesse = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0504 :   PAR.VitesseMax = LectureReel(PAR.VitesseMax, adrModbus1, 1, 1000.0); break;
        case 0x0505 :   PAR.VitesseMax = LectureReel(PAR.VitesseMax, adrModbus1, 2, 1000.0); break;
        case 0x0506 :   PAR.NbChiffreDecimaleDebit = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0507 :   PAR.DebitMax = LectureReel(PAR.DebitMax, adrModbus1, 1, 1000.0); break;
        case 0x0508 :   PAR.DebitMax = LectureReel(PAR.DebitMax, adrModbus1, 2, 1000.0); break;
        case 0x0509 :   PAR.DebitNominal = LectureReel(PAR.DebitNominal, adrModbus1, 1, 1000.0); break;
        case 0x050A :   PAR.DebitNominal = LectureReel(PAR.DebitNominal, adrModbus1, 2, 1000.0); break;
        case 0x050B :   PAR.Correction1 = LectureReel(PAR.Correction1, adrModbus1, 2, 100.0); break;
        case 0x050C :   PAR.Correction2 = LectureReel(PAR.Correction2, adrModbus1, 2, 100.0); break;
        case 0x050D :   PAR.Correction3 = LectureReel(PAR.Correction3, adrModbus1, 2, 100.0); break;
        case 0x050E :   PAR.Correction4 = LectureReel(PAR.Correction4, adrModbus1, 2, 100.0); break;
        case 0x050F :   PAR.LongueurBande = LectureReel(PAR.LongueurBande, adrModbus1, 1, 1000.0); break;
        case 0x0510 :   PAR.LongueurBande = LectureReel(PAR.LongueurBande, adrModbus1, 2, 1000.0); break;
        case 0x0511 :   PAR.LongueurPesage = LectureReel(PAR.LongueurPesage, adrModbus1, 2, 1000.0); break;
        case 0x0512 :   PAR.CirconfTambMene = LectureReel(PAR.CirconfTambMene, adrModbus1, 2, 1000.0); break;
        case 0x0513 :   PAR.CirconfTambMenant = LectureReel(PAR.CirconfTambMenant, adrModbus1, 2, 1000.0); break;
        case 0x0514 :   PAR.ImpTambMene = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0515 :   PAR.ImpTambMenant = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0516 :   PAR.NbPulsesAvantReglage = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0517 :   PAR.NbTourBandesReglage = MODBUS_RX[adrModbus1]*256 + MODBUS_RX[adrModbus1+1]; break;
        case 0x0518 :   PAR.NbChiffreVirgPoids = PAR.NbChiffreVirgPoids; break;
        case 0x051A :   PAR.DebitMin = LectureReel(PAR.DebitMin, adrModbus1, 1, 1000.0); break;
        case 0x051B :   PAR.DebitMin = LectureReel(PAR.DebitMin, adrModbus1, 2, 1000.0); break;
        case 0x051C :   PAR.ZoneMorte = LectureReel(PAR.ZoneMorte, adrModbus1, 2, 10.0); break;
        case 0x051D :   PAR.LimZeroAuto = LectureReel(PAR.LimZeroAuto, adrModbus1, 2, 10.0); break;
        case 0x051E :   PAR.LimiteTotalisation = LectureReel(PAR.LimiteTotalisation, adrModbus1, 2, 10.0); break;
    }
PAR.CodeMetrologiqueOK = 0;
}
}


long LectureLong(long valeur, int adrModbus, int poids)
{
unsigned long   interUL;
unsigned long   interUL1;
unsigned long   interUL2;

if (poids == 1)
{
    interUL = valeur & 0x0000FFFF;
    interUL1 = MODBUS_RX[adrModbus];
    interUL1 = interUL1 * 65536*256;
    interUL2 = MODBUS_RX[adrModbus+1];
    interUL2 = interUL2 * 65536;
}
else
{
    interUL = valeur & 0xFFFF0000;
    interUL1 = MODBUS_RX[adrModbus];
    interUL1 = interUL1 *256;
    interUL2 = MODBUS_RX[adrModbus+1];
    interUL2 = interUL2;
}

interUL = interUL + interUL1 + interUL2;
valeur = interUL;

return valeur;
}


float LectureReel(float valeur, int adrModbus, int poids, float multi)
{
long        interUL;
long        interUL1;
long        interUL2;
char        buf[10];

valeur = valeur*multi;
interUL = valeur;

if (poids == 1)
{
    interUL = interUL & 0x0000FFFF;
    interUL1 = MODBUS_RX[adrModbus];
    interUL1 = interUL1 * 65536*256;
    interUL2 = MODBUS_RX[adrModbus+1];
    interUL2 = interUL2 * 65536;
}
else
{
    interUL = interUL & 0xFFFF0000;
    interUL1 = MODBUS_RX[adrModbus];
    interUL1 = interUL1 *256;
    interUL2 = MODBUS_RX[adrModbus+1];
    interUL2 = interUL2;
}

interUL = interUL + interUL1 + interUL2;
ltoa(buf, interUL, 10);
valeur = atof(buf);
valeur = valeur/multi;

return valeur;
}



void ValidationCodeMetrologie(void)
{
unsigned int    codeAleatoire;
unsigned int    codeBalancier;
unsigned int    codeValidation;
unsigned long   codeValidationCalcule;
int             codeI;

PAR.CodeMetrologiqueOK = 0;

codeAleatoire = (PAR.CodeAleatoire[0]-0x30)*1000+(PAR.CodeAleatoire[1]-0x30)*100
        +(PAR.CodeAleatoire[2]-0x30)*10+(PAR.CodeAleatoire[3]-0x30);
codeBalancier = (PAR.CodeBalancier[0]-0x30)*1000+(PAR.CodeBalancier[1]-0x30)*100
        +(PAR.CodeBalancier[2]-0x30)*10+(PAR.CodeBalancier[3]-0x30);
codeValidation = (PAR.CodeValidation[0]-0x30)*1000+(PAR.CodeValidation[1]-0x30)*100
        +(PAR.CodeValidation[2]-0x30)*10+(PAR.CodeValidation[3]-0x30);

codeValidationCalcule = ((((long)codeAleatoire+1123) *54) + (((long)codeBalancier+1234) *32));

codeValidationCalcule = codeValidationCalcule - (codeValidationCalcule/10000)*10000;

codeI = codeValidationCalcule;

if (codeValidationCalcule == codeValidation)
    PAR.CodeMetrologiqueOK = 1;
}


//Modbus Error
void ModbusErreur(unsigned char ExceptionCode)
{
MODBUS_RX[4]=0X00;
MODBUS_RX[5]=0X03;
MODBUS_RX[MODBUS_FunctionCode]+=0X80;
MODBUS_RX[MODBUS_ExceptionCode]=ExceptionCode;

//Copy MODBUS_RX into MODBUS_TX and send MODBUS_TX as response
memcpy(MODBUS_TX, MODBUS_RX, 9);
}


int Random (int _iMin, int _iMax)
{
int         resultat;

srand(Compteur);
resultat = (_iMin + (rand () % (_iMax-_iMin+1)));
return(resultat);
}


void ModifieVitesseComm(int numPort)
{
unsigned long           Vitesse;

switch (PAR.CommVitesse[numPort])
{
    case  1 : Vitesse = BR300; break;
    case  2 : Vitesse = BR1200; break;
    case  3 : Vitesse = BR2400; break;
    case  4 : Vitesse = BR4800; break;
    case  5 : Vitesse = BR9600; break;
    case  6 : Vitesse = BR14400; break;
    case  7 : Vitesse = BR19200; break;
    case  8 : Vitesse = BR28800; break;
    case  9 : Vitesse = BR38400; break;
    case 10 : Vitesse = BR57600; break;
    case 11 : Vitesse = BR115200; break;
    case 12 : Vitesse = BR256000; break;
    case 13 : Vitesse = BR460800; break;
    case 14 : Vitesse = BR937500; break;
    case 15 : Vitesse = BR1875000; break;
    case 16 : Vitesse = BR3750000; break;
}

switch (numPort)
{
    case 0 : UART1_SetBaudrate(Vitesse); break;
    case 1 : UART2_SetBaudrate(Vitesse); break;
    case 2 : UART3_SetBaudrate(Vitesse); break;
    case 3 : UART4_SetBaudrate(Vitesse); break;
}
}



