Problema al leer con arduino un contador de tipo rs485

Buenas noches o día, según sea el caso, estoy trabajando en un proyecto de leer una "tijera" de pase de personas, esos que se colocan en algunos lugares para ver cuantas personas pasaron o salieron, en mi caso es un experimento para mi tesis, bien, el fabricante de la "tijera" me envia un solo codigo para lo que es entender el protocolo rs485, y que comando debo enviar para hacerle funcionar, funciona del tipo en que yo envio un comando en hexadecimal y el me responde en hexadecimal, como se esto? bueno compre unos conversores de rs485 a usb para a travez de un programa (sscom32e, que funciona como terminal serial) enviarle el comando y asegurarme que esto funcionara, bien... e leido bastante sobre el asunto de como se puede leer rs485 mediante arduino y entiendo que existen diversas maneras de hacerlo trabajar, compre 4 MAX485, por si acaso alguno estuviese defectuoso, primero los probe entre ellos con la conecxion full duplex y half duplex para verificar que los MAX485 estuvieran en correcto funcionamiento, la tijera en cuestion solo trae 2 cables "a rs485 y b rs485" (recalco que por conversor usb-rs485 me funciona correcto), no sabia como enviar el codigo hexadecimal y recibir en hexadecimal, por ende encontre un proyecto parecido en esta web, y no pido que me hagan las cosas, deseo aprender y solo hize unos cambios en el mismo codigo que usaron en ese proyecto, porque mis codigos creo que ni siquiera envian hex ya que uso serial print, y me encuentro ya en una pared sin poder avanzar desde hace unos dias.

el codigo que se usa para que la "tijera" nos de respuesta es este "63 00 01 28 d7 0d"

como dije anteriormente, el proyecto que encontre parecido es este: https://forum.arduino.cc/index.php?topic=476611.15

tome el codigo final que colocan como solucion y le hice unas pequeñas adaptaciones solo para ver si, de por casualidad enviaba algo, y pues obviamente no fue asi, en foros en ingles tampoco e encontrado mucha informacion util.

estoy usando un arduino mega, tengo conectado las masas, la "tijera" funciona con 12v

las conexiones de los cables las hice igual al proyecto que menciono anteriormente en el link

const byte ledPin   =  13;  // Led integrado
const byte ReDePin  =  2;  // HIGH = Driver / LOW = Receptor
char incomingByte   =  0;

const unsigned char  interruptor[]= {0xFE, 0x44, 0x12, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFD};
unsigned char ser_sw[32];
unsigned char ser_buf[32];
//unsigned char temp_ser_buf[32];

unsigned char rep_rate    = 0;
unsigned char ping_ctr    = 0;
unsigned char last_nBytes   = 0;

unsigned char head_id   = 0x12; //0x11, 0x12, 0x13, 0x14, 0x15 or 0x1D
unsigned char range   = 5;
unsigned char gain    = 3;
int intento           = 0;

void envioTrama();
void reciboTrama();
unsigned long timeOut;

void setup()
{
  Serial1.begin(9600);      // Puerto serie 1 usado para comunicar con el sensor (18TX, 19RX)
  Serial.begin(9600);         // Puerto serie para ver los datos que estoy escribiendo en el serie1
  //Serial.setTimeout(100);     // establecemos un tiempo de espera de 100ms
 
 //inicializamos los pines
  pinMode(ledPin, OUTPUT);
  pinMode(ReDePin, OUTPUT);
  SetSwitches();
}

void loop() {

  
  envioTrama();
  //Serial.flush();  //Limpio el buffer de salida
  delayMicroseconds(300); //retardo para leer respuesta

  reciboTrama();
  //delay(20);
  delay(20);

 }

 void envioTrama() {
  //RS485 en modo transmisor, el activador del sensor
  digitalWrite(ReDePin, HIGH); //Pongo el pin 2 en modo alto para que el RS485 sea transmisor
  digitalWrite(ledPin, HIGH); 
  char buffer[30];
  sprintf(buffer, "Peticion = %d ",intento++);
  Serial.println(buffer);

  for (byte i=0; i<11; i++) {
    Serial1.write(ser_sw[i]); //Escribo el comando por el puerto 1
    // Serial.print(ser_sw[i],HEX); //Veo los datos que estoy escribiendo en el puerto 1 mediante el monitor serie
    delay(1); //Dejo un pequeño retraso sacado de un programa que tiene el fabricante
  }
  // Serial.println();
  
  Serial1.flush();
 }

 void reciboTrama() {
  bool data_found = false;
  char buffer[30];

  //RS485 como receptor
  digitalWrite(ReDePin, LOW); //Pongo el pin 2 en estado bajo para activar el RS485 como receptor
  digitalWrite(ledPin, LOW); 


  byte ch_ctr = 0;
  int bytes_read = 12;
  bytes_read = Serial1.available();
  //  sprintf(buffer,"Bytes leidos: %d",bytes_read);
  //  Serial.println(buffer);
  ClearTimeOut();
  //Serial.println();
  while(data_found == false && CheckTimeOut() == false) {
    
    
   //while (Serial.available() >0) { //< 12) {
       while (Serial1.available() >1) { //< 12) {
        incomingByte = Serial1.read();

        //Serial.println(incomingByte, HEX);
        if (bytes_read >=1) {
            for (byte i=0;i<bytes_read;i++) 
                ser_buf[ch_ctr++] = incomingByte;
            
            if (ser_buf[ch_ctr-1]==0xFC) {
                data_found = true;
                ClearTimeOut();

                //Serial.println();

                Serial.println("Datos recibidos");

                sprintf(buffer,"Header     : %c%c%c",ser_buf[2],ser_buf[3],ser_buf[4]);
                Serial.println(buffer);
                sprintf(buffer,"Head ID    : 0x%02X",ser_buf[5]);
                Serial.println(buffer);
                sprintf(buffer,"Status      : 0x%02X",ser_buf[6]);
                Serial.println(buffer);
                sprintf(buffer,"Rango      : %d M",ser_buf[9]);
                Serial.println(buffer);
                sprintf(buffer,"Profundidad: %-3d",((ser_buf[11]&0x7F)<<7) | (ser_buf[10]&0x7F));
                Serial.println(buffer);
                //sprintf(buffer,"ser_buf[%d]:  0x%02X - Termination Byte",ch_ctr-1,ser_buf[ch_ctr-1]);
                //Serial.println(buffer);
              
            }
        }        
        
      }
      Serial1.flush();        
    }

}

void ClearTimeOut() {
   timeOut = millis();
}

bool CheckTimeOut(){
  if (millis() - timeOut >= 10000)
      return true;
  else 
      return false;

}

void SetSwitches(void)
{

  ser_sw[0]  = 6;   
  ser_sw[1]  = 3; 
  ser_sw[2]  = 0;
  ser_sw[3]  = 0; 
  ser_sw[4]  = 0;
  ser_sw[5]  = 1;
  ser_sw[6]  = 2;
  ser_sw[7]  = 8;
  ser_sw[8]  = 0xD7;   
  ser_sw[9]  = 0x0D;
}

// 63 00 01 28 d7 0d

lo unico que me dejo el fabricante es lo adjunto, tambien dejo el esquema de como tenian conectado en el proyecto anterior (que tambien lo tengo igual)

de antemano, alguna sugerencia que me pueda ayudar a traspasar esta pared sera bienvenida, muchas gracias de antemano

RS485Protocols.pdf (667 KB)

Mal armada latrama de datos

void SetSwitches(void)  {

  ser_sw[0]  = 0x63;   
  ser_sw[1]  = 0x00; 
  ser_sw[2]  = 0x01;
  ser_sw[3]  = 0x28; 
  ser_sw[4]  = 0xD7;     
  ser_sw[5]  = 0x0D;
}

O puede ser asi

void SetSwitches(void)  {
  ser_sw[0]  = 0x63;   
  ser_sw[1]  = 0x00; 
  ser_sw[2]  = 0x01;
  ser_sw[3]  = 0x28; 
  ser_sw[4]  = check();     
  ser_sw[5]  = 0x0D;
}

// 63 00 01 28 d7 0d
unsigned char check() {
  int checksum;
  unsigned char str[64];
  for (i = 1; i < 4; i++) {
      checksum += str[i];
  }
  checksum = ~checksum + 1;  

  return checksum;
}

prueba a ver si funcionan?

Hola surbyte, gracias por responder, si mal no recuerdo esa manera los había probado, pero de igual manera lo hize, en ambos casos la respuesta que me sale por consola es el siguiente:

Peticion = 0 
6301283D00000 == esto es lo que envio
Bytes leidos: 0
Peticion = 1 
6301283D00000 == esto es lo que envio
Bytes leidos: 0

si utilizo:

  ser_sw[0]  = 6;
  ser_sw[1]  = 3;
  ser_sw[2]  = 0;
  ser_sw[3]  = 0; 
  ser_sw[4]  = 0;
  ser_sw[5]  = 1;
  ser_sw[6]  = 2;
  ser_sw[7]  = 8;
  ser_sw[8]  = 0xD7; 
  ser_sw[9]  = 0x0D;

aunque sea ahi me aparece el envio parecido al codigo que supuestamente activa la tijera

Peticion = 0 
63000128D7D0 == esto es lo que envio
Bytes leidos: 0

pero seguimos sin obtener respuesta de la tijera

Bien, realize unos cambios en el codigo entero, y con la ayuda de surbyte e recibo respuesta, pero lo que me responde es algo que no se como decodificarlo, o no se si es un valor aleatorio

recordando que el el codigo que se usa para que la "tijera" nos de respuesta es este "63 00 01 28 d7 0d", con la codificacion de la trama que nos brindo surbyte, la respuesta que recibo es la siguiente:

con Serial.print(incomingByte, HEX);

Envio::: 630128D7D00000
Respuesta::: FFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFF94000000000000000FFFFFFC7

en uno que otro momento aleatorio recibo esta respuesta

Envio::: 630128D7D00000
Respuesta::: 28000000000000000FFFFFFC7

y tan solo una sola vez a la primera envio esto!

Envio::: 630128D7D00000
Respuesta::: 63011280000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFFA10000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFFA10000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFFA10000000000000000FFFFFFC7
Envio::: 630128D7D00000
Respuesta::: DFFFFFFA10000000000000000FFFFFFC7

en donde se puede ver que solo la primera respuesta se parece a lo que buscamos

con Serial.print(incomingByte, DEC);

Envio::: 630128D7D00000
Respuesta::: -108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13-108000000000000000-57
Envio::: 630128D7D00000
Respuesta::: 13400000000000000000-57

la respuesta correcta deberia ser:

63 00 11 28 82 00 00 00 10 00 00 00 16 14 00 00 00 7A 00 00 00 00

si le cambio el valor de lectura de "HEX" a otro tipo, envia caracteres extraños, entonces la codificacion de los bytes que se reciben deberia ser correcta, sin embargo la trama que recibo como la convierto.

alguna idea?

Me respondo a mi mismo, cambiando variables, se ha logrado que envie lo siguiente por consola:

Envio::: 630128D7D
Respuesta::: 63011282000200000000000FFFFFFC3
Envio::: 630128D7D
Respuesta::: D63011282000200000000000FFFFFFC3
Envio::: 630128D7D
Respuesta::: D63011282000200000000000FFFFFFC3
Envio::: 630128D7D
Respuesta::: D63011282000200000000000FFFFFFC3
Envio::: 630128D7D
Respuesta::: D63011282000200000000000FFFFFFC3
Envio::: 630128D7D
Respuesta::: D63011282000200000000000FFFFFFC3
Envio::: 630128D7D
Respuesta::: D63011282000200000000000FFFFFFC3
Envio::: 630128D7D

creo que esto se asemeja a lo que buscamos

63 00 11 28 82 00 00 00 10 00 00 00 16 14 00 00 00 7A 00 00 00 00

ahora la pregunta es, como decodificamos la parte final “FFFFFFC3” ?

Puedes poner un enlace del dispositivo, algo que nos de los tiempos de espera entre trama y trama, porque esta faltando algo.

El producto lo adquiri mediante un fabricante chino de un contacto que me lo paso, le escribi por whatsapp y se ha hecho el negocio todo por whatsapp lastimosamente no tengo un link ni especificaciones que nos puedan guiar, estuve hablando con el ayer y solo decia que intentara con otro conversor rs485, que si el usb me funcionaba el producto estaba bien entonces, lo unico que me dejo para guiarme fue el adjunto, no me dice valores, solo que funciona a 12v, comentaste lo de los tiempos de respuesta, efectivamente en el post que me respondí a mi mismo se me habia ocurrido lo mismo, osea el anterior al tuyo surbyte, le elimine todos los delay y tiempos de espera, y me envia la trama correcta, o la forma, ya que hay números en las posiciones 4-16 que van a variar.

se ha logrado bastante hasta el momento, muchas gracias por la ayuda surbyte

esto es lo que ya recibo

Envio::: 630128D7D
Respuesta::: D63011283000200000000000FFFFFFC2
Envio::: 630128D7D
Respuesta::: D63011283000200000000000FFFFFFC2
Envio::: 630128D7D
Respuesta::: D63011283000300000000000FFFFFFC1
Envio::: 630128D7D
Respuesta::: D63011284000300000000000FFFFFFC0
Envio::: 630128D7D
Respuesta::: D63011284000500000000000FFFFFFBE
Envio::: 630128D7D
Respuesta::: D63011284000500000000000FFFFFFBE

y tiene la forma o trama esperada

63 00 11 28 82 00 00 00 10 00 00 00 16 14 00 00 00 7A 00 00 00 00

como mencione lo valores entre “D6301128” y “FFFFFFBE” pueden variar porque son los pases del aparato, que confirmado varian.

ahorita el detalle esta en la ultima parte “FFFFFFBE” que no se como decodificarla

RS485Protocols.pdf (667 KB)

Bueno si funciona bien con el 485 USB entonces no estas respetando los tiempos.
Algo que se puede hacer es, usar al Arduino como USB to 485, de modo que sea transparente a la PC e intentar leer entonces esos tiempos entre envio y respuestas.
Tal vez estes dejando pasar algo por alto o sea un simple delay a tener en cuenta entre trama y trama.

Intentare ello que aconsejas, vuelvo cuando tenga información nueva