Duda libreria Simplemodbusmaster

International Español Software
1

Hola amigos, vengo a consultar una duda casi trivial pero que no he podido resolver... He encontrado mucha información pero por mas que la leo no me queda 100% resuelta mi duda y es por esto que vengo a consultar acá (Disculpas de antemano).

Les cuento mi problema:
Pretendo utilizar la libreria Simplemodbusmaster para leer un registro de un equipo.

Datos previos:

direccion de registro que se quiere leer: 0303
id del slave: 2
*El registro a leer varia entre 0-80.000 aproximadamente

Segun leo en el manual el orden de datos a ingresar es:

modbus_construct(direccion de packete, "quien dirige el mensaje"(0 para broadcasting), funcion, direccion hacia donde va el mensaje, desconozco, local_start_address;

[/code]

De modo que segun lo que he logrado captar... para lograr la funcion que yo deseo deberia escribir lo siguiente:

modbus_construct(&packets[PACKET1], 0, READ_HOLDING_REGISTERS, 0303, ????, 0;

Adjunto lo que dice el manual de la libreria:

The fifth parameter is the index of the masters register map. More on this later...
The address, data and local_start_address parameter needs some further clarification.
The address parameter for function 1, 2, 5 and 15 is the number of boolean points. The address
parameter for functions 3, 4, 6 and 16 is an unsigned int index from 0 – 65535. It must be noted
however that some slaves accept the function as explicit or implicit which affects the address range. I.e.
using function 3 as an example, READ_HOLDING_REGISTERS starts at address 40000 which is within the
limits of an unsigned int so referring to address 40000 implicitly refers to function 3 and an address
range of 0 – 9999, but when a slave refers to the function explicitly than the address can range from 0 –
65535.
The data parameter differs when using different functions namely:
For functions 1 & 2 data is the number of points. Points are stored in the masters unsigned int register
map using shifting and padding.
For function 5 data is either ON (0xFF00) or OFF (0x0000)
For function 6 data is exactly that, one register's data
For functions 3, 4 & 16 data is the number of registers
For function 15 data is the number of coils

Mi nivel de ingles y mi poca comprensión lectora me imposibilitan de entender como funcionan a pesar de que el manual es bastante explicativo...

Como se puede apreciar no me queda claro que poner en el 5 parámetro y me surgen dudas sobre el 6 parámetro.... Ojala alguien pueda aclararme las dudas u.u
Necesito que alguien me pueda explicar con peras y manzanas para lograr entender u.u...

De antemano gracias !

2

Hola kabal331. No conozco la librería, por lo tanto no te puedo ayudar con las sintaxis, pero te puedo aclarar algunas cosas.
El protocolo modbus utiliza registros de 16 bits (0~ 65535), pero en tu caso necesitas un registro de 32 bits, esto se logra utilizando dos registros de 16 bits consecutivos. Deberías investigar si la librería implementa la transferencia de registro de 32 bits.
Saludos

3

A ver si esto te ayuda:

// Un paquete es una petición de modbus.
// Creamos un enum, sirve para ver los paquetesnos lo podiamos ahorrar creando 
// una variable entera con el valor que queremos.
enum
{
   PACKET1,
   TOTAL_NO_OF_PACKETS
};

// Una array con todas las peticiones de modbus.
Packet packets[TOTAL_NO_OF_PACKETS];

// Creamos un array para guardar los registros a leer.
unsigned int regs[2];

void setup() {

// Hay que crear todas las peticiones... según las que queramos hacer.
modbus_construct(
    packet1, // Es el paquete definido anteriormente.
    2,       // ID-dirección modbus del esclavo.
    READ_HOLDING_REGISTERS, // Tipo de registro a leer. 
    0, // Direccion de inicio. 
    2, // Cantidad de registros a leer.
    regs // Donde se va a guardar la información.
);


// Configuramos el puerto de comunicaciones.
modbus_configure(
    &Serial, // Puerto serie a utilizar, en este caso para un UNO.
    baud, // Velocidad del puerto en baudios.
    SERIAL_8N2, // Configuración: 8 bits de datos, sin paridad, 2 bits parada.
    timeout, // Es una variable que estable el tiempo para considerar que una
             // petición ha dado un error de timeout. Un valor entre 1000 ms y
             // 5000 ms está bien.
    polling, // Tiempo entre peticiones. Se hace la petición de datos, se recibe
             // (o hay un error de timeout) y se espera para hacer la siguiente.
             // Lo suyo está entre 100 y 200 ms.
    retry_count, // Número de intentos si falla la petición. 
    TxEnablePin, // Es el pin del arduino que habilita la recepción/envío de 
                 // datos del MAX.
    packets, // El array de paquetes creado anteriormente.
    TOTAL_NO_OF_PACKETS // El nnúmero de paquets.
);

// Otro código de inicialización
//
// ...
//

}

unsigned long dato;

void loop() {

    modbus_update(); // rutina de modbus, hace las peticiones y guarda datos.

    // Si todo ha ido bien en regs, tenemos el dato que queremos.
    // de 0..800000, significa que tenemos dos bytes de datos.
    // en regs[0] tendremos la parte alta de 16 bits y en regs[1] la parte
    // baja, así que los únimos.
    dato = regs[0]<<16 | regs[1];


    // Otro código.
}

No es un código compilado ni nada por el estilo, así que hay fallos seguro, pero es orientativo.

4

Sugiero una lectura a esta otra librería Modbus Master RTU

5

Victorjam, me parece que no funcionaria, deberías trabajar con los registros hexadecimales para reconstruir el numero. Ademas se debería saber si el esclavo utiliza bigendian o lowendian.
Saludos
Edit sorry no había visto el seteo de base

6

Has cometido otro error, en contra de las normas del foro.
Has generado dos hilos similares!
Eso no es correcto y te voy a cerrar el anterior, el que me hiciste mover desde la zona prohibida.

7

Pido perdón. Lapsus mio. Cuando respondí esta mañana creo que estaba en software y al mediodia no vi mi respuesta y pensé que había sido un error que no cargué bien la página y por eso he vuelto a responder. Vuelvo a pedir mil perdones.

Y como bien dice PeterKantTropus, posiblemente no funcionará del todo, es una orientación. Aunque el leer variables de 32 bits por modbus, es lo mismo que leer variables de 16, solo que hay que conocer al esclavo. Yo leo variables de 32 bits como si fueran de 16, luego, por software, arreglo el array para poder
leerlos como float, double, signed int, unsigned int, etc.

8

Buenos dias chicos, de antemano gracias por sus respuestas. Vuelvo a acudir al foro porque a pesar de su ayuda, aun no consigo establecer la comunicación :frowning: ...

Siguiendo los pasos que me recomendaron este fue el codigo que estoy utilizando:

#include <SimpleModbusMaster_DUE.h>


unsigned long dato=2;
long previousMillis = 0;
long interval = 1000;

//////////////////// Port information ///////////////////
#define baud 9600
#define timeout 1000
#define polling 200 // the scan rate
#define retry_count 10

// used to toggle the receive/transmit pin on the driver
#define TxEnablePin 1 


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

// This is the easiest way to create new packets
// Add as many as you want. TOTAL_NO_OF_PACKETS
// is automatically updated.
enum
{
  PACKET1,
  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
 modbus_construct(&packets[PACKET1], 2, READ_HOLDING_REGISTERS, 300, 2, regs[TOTAL_NO_OF_REGISTERS]);
  //modbus_construct(&packets[PACKET2], 1, PRESET_MULTIPLE_REGISTERS, 1, 1, 0);
  
  // modbus_construct(&packets[PACKET1], 1, READ_INPUT_STATUS, 0, 1, 0);
  //   modbus_construct(&packets[PACKET2], 1, FORCE_SINGLE_COIL, 5, 1, 1);
  //modbus_construct(&packets[PACKET3], 1, FORCE_SINGLE_COIL, 5, 1, 1);
  
  // Initialize the Modbus Finite State Machine
  modbus_configure(&Serial, baud, timeout, polling, retry_count, TxEnablePin, packets, TOTAL_NO_OF_PACKETS, regs);
  

}

void loop()
{
  modbus_update();

   dato = regs[0]<<16 | regs[1];
   Serial.println(dato);
  
  //regs[0] = analogRead(0); // update data to be written to arduino slave


}

Luego de usar ese codigo tengo a salida "0" de manera constante :(, lo he revisado un par de veces y no tengo certeza de que pueda estar mal.
Quiero agregar antecedentes para ver si la ayuda es mas certera... Quiero leer el registro 300 de un equipo, este registro lleva un conteo del tiempo interno por lo que me imagino que el puerto serial deberia ver un contador ascendente... pero solo veo 0.

9

Respecto al uso de la libreria Modbus Master, tambien hice el intento y dejo aqui mis resultados:
Realice 2 pruebas. (En base al ejemplo que entrega la libreria):
Prueba 1:

/*

  Basic.pde - example using ModbusMaster library
  
  This file is part of ModbusMaster.
  
  ModbusMaster is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
  
  ModbusMaster is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with ModbusMaster.  If not, see <http://www.gnu.org/licenses/>.
  
  Written by Doc Walker (Rx)
  Copyright © 2009-2013 Doc Walker <4-20ma at wvfans dot net>
  
*/

#include <ModbusMaster.h>


// instantiate ModbusMaster object as slave ID 2
// defaults to serial port 0 since no port was specified
ModbusMaster node(2);


void setup()
{
  // initialize Modbus communication baud rate
  node.begin(19200);
  Serial.begin(19200);
}


void loop()
{
  static uint32_t i;
  uint8_t j, result;
  uint16_t data[6];
  
  i++;
  
  // set word 0 of TX buffer to least-significant word of counter (bits 15..0)
  node.setTransmitBuffer(0, lowWord(i));
  
  // set word 1 of TX buffer to most-significant word of counter (bits 31..16)
  node.setTransmitBuffer(1, highWord(i));
  
  // slave: write TX buffer to (2) 16-bit registers starting at register 0
  result = node.writeMultipleRegisters(0, 2);
  
  // slave: read (6) 16-bit registers starting at register 2 to RX buffer
  result = node.readHoldingRegisters(2, 6);
  
  // do something with data if read is successful
  if (result == node.ku8MBSuccess)
  {
    for (j = 0; j < 6; j++)
    {
      data[j] = node.getResponseBuffer(j);
      Serial.println(data[j]);
    }
  }
}

Donde solo obtengo signos raros en la serial. Asumo que esto es así ya que no he solicitado ningun request...

Prueba 2:

#include <ModbusMaster.h>

// discrete coils
#define NANO_DO(n)   (0x0000 + n) ///< returns nanoLC discrete output address
#define NANO_FLAG(n) (0x1000 + n) ///< returns nanoLC flag address

// discrete inputs
#define NANO_DI(n)   (0x0000 + n) ///< returns nanoLC discrete input address

// analog holding registers
#define NANO_REG(n)  (0x0000 + 2 * n) ///< returns nanoLC holding register address
#define NANO_AO(n)   (0x1000 + 2 * n) ///< returns nanoLC analog output address
#define NANO_TCP(n)  (0x2000 + 2 * n) ///< returns nanoLC timer/counter preset address
#define NANO_OTP(n)  (0x3000 + 2 * n) ///< returns nanoLC discrete output preset address
#define NANO_HSP(n)  (0x4000 + 2 * n) ///< returns nanoLC high-speed counter preset address
#define NANO_TCA(n)  (0x5000 + 2 * n) ///< returns nanoLC timer/counter accumulator address
#define NANO_OTA(n)  (0x6000 + 2 * n) ///< returns nanoLC discrete output accumulator address
#define NANO_HSA(n)  (0x7000 + 2 * n) ///< returns nanoLC high-speed counter accumulator address

// analog input registers
#define NANO_AI(n)   (0x0000 + 2 * n) ///< returns nanoLC analog input address


// instantiate ModbusMaster object, serial port 0, Modbus slave ID 2
ModbusMaster nanoLC(0, 2);


void setup()
{
  // initialize Modbus communication baud rate
  nanoLC.begin(19200);
  Serial.begin(9600);
}


void loop()
{
  static uint32_t u32ShiftRegister;
  static uint32_t i;
  uint8_t u8Status;
  
  u32ShiftRegister = ((u32ShiftRegister < 0x01000000) ? (u32ShiftRegister << 4) : 1);
  if (u32ShiftRegister == 0) u32ShiftRegister = 1;
  i++;
  
  // set word 0 of TX buffer to least-significant word of u32ShiftRegister (bits 15..0)
  nanoLC.setTransmitBuffer(0, lowWord(u32ShiftRegister));
  
  // set word 1 of TX buffer to most-significant word of u32ShiftRegister (bits 31..16)
  nanoLC.setTransmitBuffer(1, highWord(u32ShiftRegister));
  
  // set word 2 of TX buffer to least-significant word of i (bits 15..0)
  nanoLC.setTransmitBuffer(2, lowWord(i));
  
  // set word 3 of TX buffer to most-significant word of i (bits 31..16)
  nanoLC.setTransmitBuffer(3, highWord(i));
  
  // write TX buffer to (4) 16-bit registers starting at NANO_REG(1)
  // read (4) 16-bit registers starting at NANO_REG(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..3)
  nanoLC.readWriteMultipleRegisters(NANO_REG(0), 4, NANO_REG(1), 4);
  
  // write lowWord(u32ShiftRegister) to single 16-bit register starting at NANO_REG(3)
  nanoLC.writeSingleRegister(NANO_REG(3), lowWord(u32ShiftRegister));
  
  // write highWord(u32ShiftRegister) to single 16-bit register starting at NANO_REG(3) + 1
  nanoLC.writeSingleRegister(NANO_REG(3) + 1, highWord(u32ShiftRegister));
  
  // set word 0 of TX buffer to nanoLC.getResponseBuffer(0) (bits 15..0)
  nanoLC.setTransmitBuffer(0, nanoLC.getResponseBuffer(0));
  
  // set word 1 of TX buffer to nanoLC.getResponseBuffer(1) (bits 31..16)
  nanoLC.setTransmitBuffer(1, nanoLC.getResponseBuffer(1));
  
  // write TX buffer to (2) 16-bit registers starting at NANO_REG(4)
  nanoLC.writeMultipleRegisters(NANO_REG(4), 2);
  
  // read 17 coils starting at NANO_FLAG(0) to RX buffer
  // bits 15..0 are available via nanoLC.getResponseBuffer(0)
  // bit 16 is available via zero-padded nanoLC.getResponseBuffer(1)
  nanoLC.readCoils(NANO_FLAG(0), 17);
  
  // read (66) 16-bit registers starting at NANO_REG(0) to RX buffer
  // generates Modbus exception ku8MBIllegalDataAddress (0x02)
  u8Status = nanoLC.readHoldingRegisters(NANO_REG(0), 66);
  if (u8Status == nanoLC.ku8MBIllegalDataAddress)
  {
    // read (64) 16-bit registers starting at NANO_REG(0) to RX buffer
    // data is available via nanoLC.getResponseBuffer(0..63)
    u8Status = nanoLC.readHoldingRegisters(NANO_REG(0), 64);
  }
  
  // read (8) 16-bit registers starting at NANO_AO(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..7)
  nanoLC.readHoldingRegisters(NANO_AO(0), 8);
  
  // read (64) 16-bit registers starting at NANO_TCP(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..63)
  nanoLC.readHoldingRegisters(NANO_TCP(0), 64);
  
  // read (64) 16-bit registers starting at NANO_OTP(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..63)
  nanoLC.readHoldingRegisters(NANO_OTP(0), 64);
  
  // read (64) 16-bit registers starting at NANO_TCA(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..63)
  nanoLC.readHoldingRegisters(NANO_TCA(0), 64);
  
  // read (64) 16-bit registers starting at NANO_OTA(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..63)
  nanoLC.readHoldingRegisters(NANO_OTA(0), 64);
  
  // read (8) 16-bit registers starting at NANO_AI(0) to RX buffer
  // data is available via nanoLC.getResponseBuffer(0..7)
  nanoLC.readInputRegisters(NANO_AI(0), 8);
}

Aqui tengo la duda de como asignarle a la libreria que solo me lea el registro 300, o 303 que son de mi interes y como hacer para visualizar el resultado en el puerto serial... Aqui al igual que en la prueba 1 solo visualizo numeros y signos aleatorios que me sirven :(...

Ayuda porfavor :frowning:

10

A ver como funciona esto

#include <ModbusMaster.h>
#define SLAVE 2
// instantiate ModbusMaster object as slave ID 2
// defaults to serial port 0 since no port was specified
ModbusMaster node(SLAVE);

void setup() {
  // initialize Modbus communication baud rate
  node.begin(19200);
  Serial.begin(19200);
}


void loop() {
  static uint32_t i;
  uint8_t j, result;
  uint16_t data[2];  // Almaceno datos leídos
  
    // slave: read (2) 16-bit registers starting at register 2 to RX buffer
  result = node.readHoldingRegisters(0x303, 2);
  
  // do something with data if read is successful
  if (result == node.ku8MBSuccess)  {
    for (j = 0; j < 6; j++)   {
      data[j] = node.getResponseBuffer(j);
      Serial.println(data[j]);
    }
  }
}
11

Hola surbyte, muchas gracias por la respuesta y la rapidez de esta.
A continuacion expongo los resultados obtenidos:

Realice 2 pruebas, la primera con el registro 300 que deberia ser un contador ascendente y otra con el registro 303, ambos resultados estan expuestos en la imagen.
Como se aprecia no puedo obtener un valor numerico claro y desde mi ignorancia se me ocurre que puede ser un problema de los baud rate. Tambien realice las pruebas cambiando los baud rate a 9600 pero se obtuvo resultados similares

Adiciono informacion que podria ser de utilidad para establecer una correcta comunicacion:

En esta ultima imagen se aprecia informacion del equipo y el detalle de los registros que me interesa leer (300 y 303)

12

En lo que se refiere a la libreria SimpleModbus veo un fallo:

#define TxEnablePin 1

Usas el pin 1 para establecer cuando el circuito va a transmitir/recibir. Pero eso no lo puedes hacer ya que el pin 1 también es el pin de transmitir información serie. Deberías usar otro. Además no sé como has montado el hardware y eso es importante.

13

creo que victorjam dio con el problema!!!

14

Hola victor, adjuntare una imagen que representa como tengo conectado todo el hardware:


Fig.1: Como YO tengo conectado el sistema

Ademas adjuntare lo extraido de la hoja de datos de los hardware para dar mas claridad al asunto:

Espero que eso de claridad al asunto, y decidi definir Tx en 1 pues segun mi diagrama, ese es el pin de transmision, porfavor hazme saber si estoy equivocado en este aspecto.

Reitero mi infinita gratitud para ti y todos los que me han ayudado en este post.
Saludos !

15

No sé como es el conversor que estas usando. No se puede apreciar por el diagrama. Si es un conversor TTL a rs485 y solo tiene los pines TX y RX (transmitir y recibir) significa que tiene detección de envio automatico de emision/recepcion. Puede ser que sea basado en un MAX485 o equivalente, y sin detección automatica, con lo que debe tener los pines TX, RX, y un tercero llamado TXE, Enable, o algo similar.

En el caso de la libreria SimpleModbus, se asume que estas usando simplemente el chip MAX485 conectado al arduino, con un par de resistencias y poco mas. Por lo tanto utiliza tres pines. Cuando llamas a la funcion modbusconfigure, se asume que RX y TX son los pines 0 y 1 del arduino (usando Serial y utilizas otro tercer pin que es TxEnablePin que puede asignar libremente de los otros que hay disponibles, por comodidad y por costumbre yo utilizo el 2.

Si utilizas el pin 1 también para habilitar el modulo mira la que pasa. Envias un byte por ejemplo 01001000
estas diciendole al conversor: recibe, envia, recibe, recibe, envia, recibe, recibe, recibe, recibe... Con lo cual no estas estableciendo una comunicación real y lo que tendras seras cosas raras.

En la página del autor de la libreria (no me acuerdo cual es la dirección ahora), además de la libreria hay un documento .pdf que te explica como usar la libreria y como conectar el hardware al arduino. Si la encuentro lo posteo.

Conclusión: usa una configuración hardware buena, con los pines bien asignados. Ambas librerias tienen que funcionar igual.

16

Te dejo la conexión de como se hace con el chip max485

y el enlace a la pagina del documento .pdf

ModbusMaster manual

17

muchas gracias por la ayuda, he mandado a comrpar el max485 y lo implementare, cuando lo haga dejare mis resultados por aca :slight_smile:

Muchas gracias !

18

Hola denuevo chicos, vengo aqui nuevamente con mis problemas..
He adquirido el modulo MAX485 para evitar los errores pero aun así no llego a los resultados esperados
El modulo que estoy usando es el siguiente:

Y realice la conexion que subiste arriba y tengo resultados similares :/...

Leyendo el manual me di cuenta de un detalle, el equipo con el trabajo trabaja con:
Interface: RS-485 (half duplex);

  • Baud Rate: 2400, 4800, 9600 (default value), 19200, 38400, 57600 or 115200bps;
  • Start bit: 1;
  • Stop bit: 1;
  • Parity: No parity;
  • Data bits: 8;

Por lo que hice una pequeña modificacion en el codigo, adaptandome al equipo que me deseo comunicar...
El codigo que estoy utilizando es el siguiente:

#include <SimpleModbusMaster.h>

/*
   The example will use packet1 to read a register from address 0 (the adc ch0 value)
   from the arduino slave (id=1). It will then use this value to adjust the brightness
   of an led on pin 9 using PWM.
   It will then use packet2 to write a register (its own adc ch0 value) to address 1 
   on the arduino slave (id=1) adjusting the brightness of an led on pin 9 using PWM.
*/
float dato=2;
//////////////////// Port information ///////////////////
#define baud 9600
#define timeout 1000
#define polling 200 // the scan rate
#define retry_count 20

// used to toggle the receive/transmit pin on the driver
#define TxEnablePin 2 

#define LED 9

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

// This is the easiest way to create new packets
// Add as many as you want. TOTAL_NO_OF_PACKETS
// is automatically updated.
enum
{
  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
   modbus_construct(&packets[PACKET1], 2, READ_HOLDING_REGISTERS, 300, 1, regs[TOTAL_NO_OF_REGISTERS]);
 
 // modbus_construct(&packets[PACKET2], 2, PRESET_MULTIPLE_REGISTERS, 1, 1, 0);
  
  // Initialize the Modbus Finite State Machine
  modbus_configure(&Serial, baud, SERIAL_8N1, timeout, polling, retry_count, TxEnablePin, packets, TOTAL_NO_OF_PACKETS, regs);
  
  pinMode(LED, OUTPUT);
}

void loop()
{
  modbus_update();

    dato = regs[0];
   
    if(dato >= 2){
   Serial.println(dato);
    }

}

La verdad esque ya me estoy empezando a desesperar y no se que mas hacer.
PD: la modificacion del codigo que realice (lo testie con y sin la modificacion) fue la siguiente:

modbus_configure(&Serial, baud, [b]SERIAL_8N1[/b], timeout, polling, retry_count, TxEnablePin, packets, TOTAL_NO_OF_PACKETS, regs);

Me apoye en el manual y no hay problema con ese cambio... creo xD

Espero sus comentarios para que me puedan orientar !

PD2: Probe ambas librerias y en ninguna tenia resultados satisfactorios

19

El problema sigue siendo el mismo: la conexión. El cacharro que has comprado veo que tiene acceso a los pines DI, RO, DE, RE, y seguro los has conectado bien. Ahora bien, por el otro lado has conectado los pines VCC, GND, A, B al dispositivo que estás leyendo porque tiene los pines accesibles... pero ¿y la masa de arduino?

Ahora me tengo que ir a trabajar y no voy a poder mirarlo bien. Mientras tanto puedes ponerme algún dato mas del modulo que has comprado, a ver si encuentro el esquema y te digo como habría que conectarlo para que funcione.

20

Mira esto:

El modulo que has comprado no me gusta mucho, tiene varias resistencias de pull-up en la parte conectada al arduino y los valores de las resistencias de "bias" me parecen exageradamente altos. Además lleva incorporada la resistencia terminadora puesta.

Las conexiones que te pongo con arduino son asi:

  • RX a RO
  • TX a DI
  • D2 a DE/RE
  • +5v a VCC
  • GND a GND
    .

Luego unes los A's y los B's, también los GND del modulo y del aparato que quieres conectar. Además dado que el modulo posee resistencia terminadora, hay que poner una resistencia de 120 ohms justo donde acaba el cable, en tu aparato, en la misma regleta.

El uso de la resistencia terminadora es opcional; según el número de dispositivos del bus y de la longitud del cable, para dos aparatos cercanos no es necesaria. Pero en este caso un extremo ya la tiene por lo tanto hay que ponerla.

El cable, si tiene mas de 20 cm, tiene que ser trenzado: SI o SI.

En cuanto a tu aparato, en las imagenes que pusiste, indica en una de ellas que GND está referenciado con una resistencia de 100 ohms pull-down. A lo mejor conviene que el GND del arduino al salir hacia tu aparato tenga una resistencia de 100 ohms, como te puse en la imagen de posts anteriores.

Prueba a ver que me cuentas...