Protocole Modbus RTU halfduplex RS485

Bonjour,
J’essaie d’intégrer une carte arduino Uno avec son capteur GPS et son accéléromètre 6 axes et son shield Joy-it-Shield à un système automate Maitre qui peux cibler les registre qu’il veut lire.

Malheureusement je ne trouve pas comment faire ce protocole j’ai essayer plein de méthode et de librairie afin de pouvoir communiquer d’abord avec mon pc pour vérifier la bonne lecture mais vu que je suis encore novice dans ce domaine je n’y arrive pas du tout.
Quand je branche ma carte arduino (shield RS485) à mon PC en passant par un adaptateur RS485=>USB je n’arrive même pas à établir une connexion entre les 2 même avec les exemples de programmes tout fait avec les librairies.

#include <SimpleModbusSlave.h>


// Using the enum instruction allows for an easy method for adding and
// removing registers. Doing it this way saves you #defining the size
// of your slaves register array each time you want to add more registers
// and at a glimpse informs you of your slaves register layout.

//////////////// registers of your slave ///////////////////
enum
{
  // just add or remove registers and your good to go...
  // The first register starts at address 0
  ADC0,
  ADC1,
  ADC2,
  ADC3,
  ADC4,
  TOTAL_ERRORS,
  // leave this one
  TOTAL_REGS_SIZE
  // total number of registers for function 3 and 16 share the same register array
};

unsigned int holdingRegs[TOTAL_REGS_SIZE]; // function 3 and 16 register array
////////////////////////////////////////////////////////////


#include <ModbusRtu.h>

#include <TinyGPS++.h>
#include <SoftwareSerial.h>
#include <LSM303D.h>

#include <Wire.h>
#include <SPI.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>

static const int RXPin = 2, TXPin = 3;
static const uint32_t GPSBaud = 9600;
int accel[3];          // stockage ici les valeurs d'accélération brutes
int mag[3];           // valeurs brutes du magnétomètre stockées ici
float realAccel[3];  // valeurs d'accélération calculées ici
float titleHeading;
bool t[35];
uint32_t n;
int j;
int h = 0;
double g;
uint32_t k;
bool NL[16];
bool NH[16];
word Latlow;
word Lathight;

bool lngt[35];
uint32_t lngn;
int lngj;
int lngh = 0;
double lngg;
uint32_t lngk;
bool EL[16];
bool EH[16];
word Lnglow;
word Lnghight;
float anglef;
uint16_t angle;

float anglecompf;
uint16_t anglecompe;






// The TinyGPS++ object
TinyGPSPlus gps;
double lng;
double  lat;
// The serial connection to the GPS device
SoftwareSerial ss(RXPin, TXPin);

//************************************************

void setup()
{

  Serial.begin(9600);                  // Serie ustilisé pour le débuggage
  ss.begin(GPSBaud);
}
void loop()
{


  GPSfonction();

  ACCELfonction();

}

//**********************************************

void GPSfonction()
{
  while (ss.available() > 0)
    if (gps.encode(ss.read()))
    {

    }
  if (millis() > 5000 && gps.charsProcessed() < 10)
  {
    Serial.println(F("No GPS detected: check wiring."));
    while (true);
  }
}

//**********************************************

void ACCELfonction()
{
  char rtn = 0;


  Serial.println("\r\npower on");
  rtn = Lsm303d.initI2C();       // si en SPI et non en I2C mettre rtn = Lsm303d.initSPI (SPI_CS);
  if (rtn != 0)                 // Initialise le LSM303 en utilisant une gamme complète SCALE
  {
    Serial.println("\r\nLSM303D is not found");  //Capteur non trouvé
    while (1);
  }
  else
  {
    Serial.println("\r\nLSM303D is found"); //Capteur  trouvé

  }

  Lsm303d.getAccel(accel);         // récupère les valeurs d'accélération et les stocke dans le tableau accel
  while (!Lsm303d.isMagReady());  // attend que les lectures du magnétomètre soient prêtes
  Lsm303d.getMag(mag);           // récupère les valeurs du magnétomètre, enregistre-les dans mag

  for (int i = 0; i < 3; i++)
  {
    realAccel[i] = accel[i] / pow(2, 15) * ACCELE_SCALE;  // calcule les valeurs d'accélération réelles, en unités de g
  }
  titleHeading = Lsm303d.getTiltHeading(mag, realAccel);

  displayInfo();
  printValues();
  sendautomate();

  delay(2000);  // délai de lecture pour le, port Serie
}

//***********************************************

void displayInfo()
{
  Serial.print(F("Localisation: "));
  if (gps.location.isValid())
  {
    /*   lat = gps.location.lat(), 6;
       g = lat;
       k = g * 100000.0;
       h = 0;
       n = k;
       Serial.println(n);
       do
       { t[h] = n % 2;
         n = n / 2;
         h++;
       } while (n != 0);
       for (j = h ; j > -1; j--)
       {
         if (j >= 16)
         {
           NH[j - 16] = t[j];
         }
         else
           NL[j] = t[j];
         Serial.print(t[j]);
       }
       Serial.println();*/
       Latlow = (32768 * NL[15] + 16384 * NL[14] + 8192 * NL[13] + 4096 * NL[12] + 2048 * NL[11] + 1024 * NL[10] + 512 * NL[9] + 256  * NL[8] + 128 * NL[7] + 64 * NL[6] + 32 * NL[5] + 16 * NL[4] + 8 * NL[3] + 4 * NL[2] + 2 * NL[1] + 1 * NL[0]);
       Lathight = (32768 * NH[15] + 16384 * NH[14] + 8192 * NH[13] + 4096 * NH[12] + 2048 * NH[11] + 1024 * NH[10] + 512 * NH[9] + 256  * NH[8] + 128 * NH[7] + 64 * NH[6] + 32 * NH[5] + 16 * NH[4] + 8 * NH[3] + 4 * NH[2] + 2 * NH[1] + 1 * NH[0]);
      //   Serial.print("Mot bas lat:   ");
      // Serial.println(Latlow);
       //Serial.print("Mot haut lat:   ");
      // Serial.println(Lathight);

       Serial.println();
       for (j = h ; j != 0; j--)
       {
         t[j] = NULL;
       }
      /* lng = gps.location.lng(), 6;
       lngg = lng;
       lngk = lngg * 100000.0;
       lngh = 0;
       lngn = lngk;
       Serial.println(lngn);
       do
       { lngt[lngh] = lngn % 2;
         lngn = lngn / 2;
         lngh++;
       } while (lngn != 0);
       for (lngj = lngh ; lngj > -1; lngj--)
       {
         if (lngj >= 16)
         {
           EH[lngj - 16] = lngt[lngj];
         }
         else
           EL[lngj] = lngt[lngj];
         Serial.print(lngt[lngj]);
       }
       Serial.println();*/
     Lnglow = (32768 * EL[15] + 16384 * EL[14] + 8192 * EL[13] + 4096 * EL[12] + 2048 * EL[11] + 1024 * EL[10] + 512 * EL[9] + 256  * EL[8] + 128 * EL[7] + 64 * EL[6] + 32 * EL[5] + 16 * EL[4] + 8 * EL[3] + 4 * EL[2] + 2 * EL[1] + 1 * EL[0]);
   Lnghight = (32768 * EH[15] + 16384 * EH[14] + 8192 * EH[13] + 4096 * EH[12] + 2048 * EH[11] + 1024 * EH[10] + 512 * EH[9] + 256  * EH[8] + 128 * EH[7] + 64 * EH[6] + 32 * EH[5] + 16 * EH[4] + 8 * EH[3] + 4 * EH[2] + 2 * EH[1] + 1 * EH[0]);
    // Serial.print("Mot bas lng:   ");
    // Serial.println(Lnglow);
    // Serial.print("Mot haut lng:   ");
    //  Serial.println(Lnghight);

    Serial.println();
    for (lngj = lngh ; lngj != 0; lngj--)
    {
      lngt[lngj] = NULL;
    }
    /*Serial.println(lngk);
      Serial.print("%0x");
      Serial.println(lngk);
      Serial.println(lngk);*/
    Serial.print(gps.location.lat(), 6);
    Serial.print(" N");
    Serial.print(F(","));
    Serial.print(gps.location.lng(), 6);
    Serial.print(" E");
    Serial.println("");

  }
  else
  {
    Serial.print(F("INVALID"));
  }
  Serial.println();
}


//****************************************

void printValues()
{
  Serial.println("L'accélération de X, Y, Z est");
  for (int i = 0; i < 3; i++)
  {
    Serial.print(realAccel[i]);
    Serial.println("g");
  }
  // affiche le niveau et les titres en bas compensés ci-dessous pour comparer
  Serial.print("Angle entre le nord magnétique et la projection de l'axe des x positif dans le plan horizontal:");
  Serial.print(titleHeading, 3);  // Compensation de l'inclinaison
  Serial.println(" degrés");
  anglecompf = titleHeading;
  anglecompe = (anglecompf * 100);

}

//***********************************

void  sendautomate()
{ 
  modbus_configure(9600, 1, 3, TOTAL_REGS_SIZE, 2);       // Baud,ID,Broche activation non signé,Registre,pin utilisé )

  holdingRegs[TOTAL_ERRORS] = modbus_update(holdingRegs);

  // assign the  value to the holding register
  holdingRegs[ADC0] = Lathight;
  holdingRegs[ADC1] = Latlow;
  holdingRegs[ADC2] = Lnghight;
  holdingRegs[ADC3] = Lnglow;
  holdingRegs[ADC4] = anglecompe;
  // read the LED_STATE register value and set the onboard LED high or low with function 16




}