Código de comunicacion MODBUS Master-Slave

Hola que tal:

He estado realizando un programa con comunicación MODBUS Maestro-esclavo. Siguiendo varios ejemplos y leyendo documentos que me he encontrado por el Internet, he llegado a hacer el siguiente código en los cuales utilizo las librerías SimpleModbusMaster y SimpleModbusSlave.

Lo que trato de hacer es leer entradas por el Arduino esclavo, y quiero que el Arduino Maestro active salidas digitales salidas digitales por cada entrada del slave.

Les dejo mi código para ver si me podrían ayudar a corregir mi código.

Este es el código para el Maestro.

#include <SimpleModbusMaster.h>


//////////////////// Información del puerto de comunicación ///////////////////
#define baud 9600
#define timeout 1000
#define polling 200 // scan rate
#define retry_count 10

// receive/transmit pin
#define TxEnablePin 2 

//Defino los Pines que usare para las salidas

#define LED14 22
#define LED15 23
#define LED16 24
#define LED17 25
#define LED18 26


// The total amount of available memory on the master to store data
#define TOTAL_NO_OF_REGISTERS 1

// This is the easiest way to create new packets
// Add as many as you want. TOTAL_NO_OF_PACKETS
// is automatically updated.
enum
{
 Salida22,
 Salida23,
 Salida24,
 Salida25,
 Salida26,
  PACKET1,
  PACKET2,
  TOTAL_NO_OF_PACKETS // leave this last entry
};

// Create an array of Packets to be configured
Packet packets[TOTAL_NO_OF_PACKETS];

// Masters register array
unsigned int regs[TOTAL_NO_OF_REGISTERS];

void setup()
{
  // Initialize each packet
  // El construct 1 lo utilizo para leer los registros desde el 0x0000 hasta el 0x0015
  modbus_construct(&packets[PACKET1], 1, READ_INPUT_STATUS, 0, 15, 0);
  //modbus_construct(&packets[PACKET2], 1, PRESET_MULTIPLE_REGISTERS, 1, 1, 0);
  
  // Initialize the Modbus Finite State Machine
  modbus_configure(&Serial, baud, SERIAL_8N2, timeout, polling, retry_count, TxEnablePin, packets, TOTAL_NO_OF_PACKETS, regs);


  //Inicializo los pines 1, 2, 3.... 36 en Salidas

  pinMode(LED22, OUTPUT);
  pinMode(LED23, OUTPUT);
  pinMode(LED24, OUTPUT);
  pinMode(LED25, OUTPUT);
  pinMode(LED26, OUTPUT);
  
}

void loop()
{
  modbus_update();

//**********************************************************************************************
//Empiezo a leer registros y comparandolos con el valor de la salida para asignarlo un nuevo valor.
//**********************************************************************************************


  byte ledState22 = regs[Salida22];

  if (ledState22)
  digitalWrite(LED22, HIGH);
  if (ledState22 == 0)
  {
    digitalWrite(LED22, LOW);
    regs[Salida22];
  }

  byte ledState23 = regs[Salida23];

  if (ledState23)
  digitalWrite(LED23, HIGH);
  if (ledState23 == 0)
  {
    digitalWrite(LED23, LOW);
    regs[Salida23];
  }

  byte ledState24 = regs[Salida24];

  if (ledState24)
  digitalWrite(LED24, HIGH);
  if (ledState24 == 0)
  {
    digitalWrite(LED24, LOW);
    regs[Salida24];
  }

  byte ledState25 = regs[Salida25];

  if (ledState25)
  digitalWrite(LED25, HIGH);
  if (ledState25 == 0)
  {
    digitalWrite(LED25, LOW);
    regs[Salida25];
  }

  byte ledState26 = regs[Salida26];

  if (ledState26)
  digitalWrite(LED26, HIGH);
  if (ledState26 == 0)
  {
    digitalWrite(LED26, LOW);
    regs[Salida26];
  }

}

Este es el código para el esclavo.

#include <SimpleModbusSlave.h>

#define LED1 22
#define LED2 23
#define LED3 24
#define LED4 25
#define LED5 26
 

// 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
  //ADC_VAL,     
  //PWM_VAL,

 INP22,
 INP23,
 INP24,
 INP25,
 INP26,
      
  HOLDING_REGS_SIZE // leave this one
  // total number of registers for function 3 and 16 share the same register array
  // i.e. the same address space
};

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

void setup()
{
  /* parameters(HardwareSerial* SerialPort,
                long baudrate, 
    unsigned char byteFormat,
                unsigned char ID, 
                unsigned char transmit enable pin, 
                unsigned int holding registers size,
                unsigned int* holding register array)
  */
  
  /* Valid modbus byte formats are:
     SERIAL_8N2: 1 start bit, 8 data bits, 2 stop bits
     SERIAL_8E1: 1 start bit, 8 data bits, 1 Even parity bit, 1 stop bit
     SERIAL_8O1: 1 start bit, 8 data bits, 1 Odd parity bit, 1 stop bit
     
     You can obviously use SERIAL_8N1 but this does not adhere to the
     Modbus specifications. That said, I have tested the SERIAL_8N1 option 
     on various commercial masters and slaves that were suppose to adhere
     to this specification and was always able to communicate... Go figure.
     
     These byte formats are already defined in the Arduino global name space. 
  */
  
  modbus_configure(&Serial, 9600, SERIAL_8N2, 1, 2, HOLDING_REGS_SIZE, holdingRegs);

  // modbus_update_comms(baud, byteFormat, id) is not needed but allows for easy update of the
  // port variables and slave id dynamically in any function.
  modbus_update_comms(9600, SERIAL_8N2, 1);
  

  pinMode(LED22, INPUT);
  pinMode(LED23, INPUT);
  pinMode(LED24, INPUT);
  pinMode(LED25, INPUT);
  pinMode(LED26, INPUT);

}

void loop()
{
  // modbus_update() is the only method used in loop(). It returns the total error
  // count since the slave started. You don't have to use it but it's useful
  // for fault finding by the modbus master.
  
  modbus_update();


  holdingRegs[INP22] = digitalRead(LED22);
  holdingRegs[INP23] = digitalRead(LED23);
  holdingRegs[INP24] = digitalRead(LED24);
  holdingRegs[INP25] = digitalRead(LED25);
  holdingRegs[INP26] = digitalRead(LED26);

  

  
  /* Note:
     The use of the enum instruction is not needed. You could set a maximum allowable
     size for holdinRegs[] by defining HOLDING_REGS_SIZE using a constant and then access 
     holdingRegs[] by "Index" addressing. 
     I.e.
     holdingRegs[0] = analogRead(A0);
     analogWrite(LED, holdingRegs[1]/4);
  */
  
}

Creo que mi problema es al tratar de guardar las entradas en los registros en el slave y al tratar de leer los registros.

Pero si me podrían asesorar, se los agradecería mucho.

Gracias.

Dejo una imagen del esquema electrónico que utilizo un MAX487.

Slave.png

Master.png

hola pudiste avanzar con la comunicacion Modbus con el Mega, yo estoy recien empezando

Porfavor lee las normas del foro,este post tiene mas de un año.Crea un nuevo post de acuerdo a dichas normas.