Debugging UART <==> RS485 and related #110

bertmelis · 2021-10-19T15:04:04Z

bertmelis
Oct 19, 2021
Maintainer

In this discussion, I'm going to build a simple modbus RTU circuit on a breadboard.

While doing so, I try to give as much information about the steps and attention points so you can use them for your debugging.

bertmelis · 2021-10-19T15:09:41Z

bertmelis
Oct 19, 2021
Maintainer Author

Off we go!

Components are

an ESP32 (devkit)
max3485
TTL to rs485 adapter
TTL to usb adapter
120Ohms resistors
a logic analyzer
jumper wires
a computer running a modbus server

4 replies

Miq1 Oct 19, 2021
Maintainer

Excellent!

If you have an Arduino Nano lying around, I have a sturdy RTU test server sketch to be run on it. It supports FCs 0x03, 0x04, 0x06 and 0x0F. With the DEBUG_ON pin pulled to GND and when compiled with -DTESTING, you will be given the data in and out etc. on the Serial Monitor.

// Copyright 2020 Michael Harwerth
#include <Arduino.h>
#include <ALtSoftSerial.h>
#include "Logging.h"

// 3 bit switches connected to pins 3, 4 and 5
#define IDBIT1 3
#define IDBIT2 4
#define IDBIT4 5

// Debug switch connected to pin 6
#define DEBUG_ON 6

// Built-in LED
#define LED 13

// MODBUS memory 
#define MEMSIZE 256
uint8_t data[MEMSIZE];

// MODBUS request buffer
// normal size is 8 (ID, FC, address 16bit, words 16bit)
// but we may catch packets for other purposes in future
#define INPACKETSIZE 32
uint8_t inPacket[INPACKETSIZE];
uint16_t inPacketLen;

// MODBUS response buffer
// maximum size is 3 (ID,FC,Byte count) + 255 (payload bytes) + 2 (CRC) = 260
#define OUTPACKETSIZE 260
uint8_t outPacket[OUTPACKETSIZE];
uint16_t outPacketLen;

// Own MODBUS slave ID
uint8_t ownID;

// State machine states
enum STATES : uint8_t { INIT=0, IDLE, PAUSE, IN_PACKET, PROCESS };
STATES state = INIT;
const char *statenames[] = { "INIT", "IDLE", "PAUSE", "IN_PACKET", "PROCESS" };

// RS485 module connected to AltSoftSerial
AltSoftSerial MODBUS;
const uint32_t BAUDRATE(19200);

#ifdef TESTING
const uint16_t BUFLEN(64);
char buffer[BUFLEN];

// Helper function to generate a printable hexadecimal dump
// head: printed first
// sep:  separator char printed between each byte. Omitted, if ==0
// data: pointer to data to be dumped
// length: number of bytes in data
// buffer: target to be printed into
// max_buffer_length: obvious... ;)
uint16_t hexDump(const char *head, const char sep, uint8_t *data, uint16_t length, char *buffer, uint16_t max_buffer_length)
{
  uint16_t maxByte = 0;               // maximum byte to fit in buffer
  uint16_t outLen = 0;                // used length in buffer
  uint8_t byteLen = (sep?3:2);        // length of a single byte dumped
  uint16_t headLen = strlen(head);    // length of header
  const char *PRINTABLES = "0123456789ABCDEF";

  // if not even the header will fit into buffer, bail out.
  if (headLen>max_buffer_length) return 0;

  // if we have a header, print it.
  if (headLen) strcpy(buffer, head);
  outLen = headLen;

  // Calculate number of bytes fitting into remainder of buffer
  maxByte = (max_buffer_length - headLen) / byteLen;
  // If more than neede, reduce accordingly
  if (length<maxByte) maxByte = length;

  // May we print at least a single byte?
  if (maxByte>0)
  {
    // Yes. Start behind the header
    char *cp = buffer + headLen;
    // For each byte...
    for (uint16_t i=0; i<maxByte; ++i)
    {
      // ...print it, plus...
      *cp++ = PRINTABLES[(data[i]>>4)&0x0F];
      *cp++ = PRINTABLES[data[i]&0x0F];
      outLen += 2;
      // .. a separator, if it is defined and another byte is to follow
      if (sep && i<maxByte-1)
      {
        *cp++ = sep;
        outLen++;
      }
    }
    *cp = 0;
  } 
  return outLen;
}
#endif 

// CRC16 tables and calculation function
const uint8_t crcHiTable[] PROGMEM = {
  0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
  0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
  0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
  0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
  0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
  0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
  0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
  0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
  0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
  0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
  0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
  0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
  0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
  0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  0x40
};

const uint8_t crcLoTable[] PROGMEM = {
  0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
  0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
  0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
  0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
  0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
  0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
  0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
  0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
  0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
  0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
  0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
  0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
  0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
  0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
  0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
  0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
  0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
  0x40
};

inline uint16_t CRC16(uint8_t* msg, size_t len) 
{
  register uint8_t crcHi = 0xFF;
  register uint8_t crcLo = 0xFF;
  register uint8_t index;

  while (len--) {
    index = crcLo ^ *msg++;
    crcLo = crcHi ^ pgm_read_byte(&crcHiTable[index]);
    crcHi = pgm_read_byte(&crcLoTable[index]);
  }
  return (crcHi << 8 | crcLo);
}

// Return MODBUS error packet
void error(uint8_t code, uint8_t err)
{
  outPacketLen = 0;
  outPacket[outPacketLen++] = ownID;
  outPacket[outPacketLen++] = code|0x80;
  outPacket[outPacketLen++] = err;
  uint16_t crc = CRC16(outPacket, outPacketLen);
  outPacket[outPacketLen++] = crc&0xFF;
  outPacket[outPacketLen++] = (crc>>8)&0xFF;
#ifdef TESTING
  if (digitalRead(DEBUG_ON)==LOW)
  {
    hexDump("ERR: ", ' ', outPacket, outPacketLen, buffer, BUFLEN);
    Serial.println(buffer);
    Serial.flush();
  }
#endif

  MODBUS.write(outPacket, outPacketLen);
  MODBUS.flush();
}

void setup() 
{
  // Init LED
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);

  // Start MODBUS
  MODBUS.begin(BAUDRATE);

  // Set own slave ID
  // if pins are jumpered to GND, bits will be added to slave ID 1
  pinMode(IDBIT1, INPUT_PULLUP);
  pinMode(IDBIT2, INPUT_PULLUP);
  pinMode(IDBIT4, INPUT_PULLUP);

  ownID = 1;
  if (digitalRead(IDBIT1)==LOW) ownID++;
  if (digitalRead(IDBIT2)==LOW) ownID += 2;
  if (digitalRead(IDBIT4)==LOW) ownID += 4;

  Serial.begin(115200);
  Serial.println("");
  Serial.print("ownID=");
  Serial.println((int)ownID);
  Serial.flush();

  // Set up Debug line
  pinMode(DEBUG_ON, INPUT_PULLUP);

  // Fill memory with test data
  uint8_t c = 0x20;
  for (uint16_t i= 0; i<MEMSIZE; i++)
  {
    data[i] = c++;
    if (c>127) c = 0x20;
  }
#ifdef TESTING
  uint16_t offset = 0;
  while (offset<MEMSIZE)
  {
    hexDump("- ", ' ', data+offset, (MEMSIZE-offset)<16 ? (MEMSIZE-offset) : 16, buffer, BUFLEN);
    Serial.println(buffer);
    Serial.flush();
    offset += 16;
  }
#endif
}

void loop() 
{
  static uint8_t readByte = 0;
  // PAUSETIME gives the required silence time on the bus to detect a new packet.
  // With 19200/s, a byte takes about 0.52 ms, so we are waiting for a pause of
  // approx. 1822us here!
  // (The MODBUS standard is requiring >3.5)
  const uint32_t PAUSETIME = 35000000UL/BAUDRATE;
  static uint32_t starttime = micros();

#ifdef TESTING
  // Print out state changes in debug mode
  static STATES oldState = INIT;

  if (digitalRead(DEBUG_ON)==LOW)
  {
    if (oldState!=state)
    {
      Serial.print(state);
      Serial.print(' ');
      Serial.flush();
      oldState = state;
    }
  }
#endif

  switch (state)
  {
  case INIT: // Init means skip to pause, so next data will be a packet most probably
    // Read all available bytes into the bin
    while (MODBUS.available()) readByte = MODBUS.read();
    state = PAUSE;
    starttime = micros();
    // No break; - Fallthrough intended!
  case PAUSE:  // Discard all bytes, then wait for a PAUSETIME gap
    // PAUSETIME passed without a byte?
    if (micros()-starttime>=PAUSETIME)
    {
      // Yes. Rewind timer to open IÂ²C writing with a delay
      starttime = micros();
      // Go look for a packet
      state = IDLE;
    }
    // No, but is a byte available?
    else if (MODBUS.available())
    {
      // Yes, there is one. Pause was interrupted - skip to next pause
      state = INIT;
    }
    break;
  case IDLE: // Waiting for a packet after the pause
    // Do we have a byte? It will be the first of a packet = Slave ID
    if (MODBUS.available())
    {
      // Yes. Is it our own slave ID?
      readByte = MODBUS.read();
      if (readByte!=ownID)
      {
        // No. Skip packet and wait for the next
        state = INIT;
      }
      else
      {
        // This is for us - go collect the packet
        inPacketLen = 0;
        inPacket[inPacketLen++] = readByte;
        // Signal to D0 processor to stop sending data
        state = IN_PACKET;
        starttime = micros();
      }
    }
    break;
  case IN_PACKET:  // We caught a byte of a packet addressed to us
    // If a byte is available...
    if (MODBUS.available())
    {
      while (MODBUS.available())
      {
        // Catch it.
        readByte = MODBUS.read();
        if (inPacketLen<INPACKETSIZE) 
        {
          inPacket[inPacketLen++] = readByte;
        }
        else
        {
          // Overflow... Discard all data
          state = INIT;
          break;
        }
      }
      starttime = micros();
    }

    // Did we encounter a gap time again?
    if (micros() - starttime >= PAUSETIME)
    {
      // Yes. Process data
      state = PROCESS;
    }
    break;
  case PROCESS:  // we seem to have caught a packet.
    {
      digitalWrite(LED, HIGH);
#ifdef TESTING
      if (digitalRead(DEBUG_ON)==LOW)
      {
        hexDump("REQ: ", ' ', inPacket, inPacketLen, buffer, BUFLEN);
        Serial.println(buffer);
        Serial.flush();
      }
#endif

      uint8_t fc = inPacket[1];
      // Is the function code right?
      switch (fc) {
      case 0x03:
      case 0x04:
        // Sufficcient data for FC 0x03/0x04?
        if (inPacketLen==8)
        {
          // Yes, fc is okay, get address to read
          uint16_t addr = (inPacket[2]<<8)|inPacket[3];
          // Is it out of bounds?
          if (addr<1 || addr>(MEMSIZE/2))
          {
            // Yes, return error
            error(fc, 0x02);
          } else {
            // No, address is okay. get number of words requested
            uint16_t wrds = (inPacket[4]<<8)|inPacket[5];
            uint16_t byts = wrds * 2;
            // Words out of bounds?
            if (!wrds || byts>255 || byts>(OUTPACKETSIZE-5) || addr-1+wrds>(MEMSIZE/2))
            {
              // Yes, return error
              error(fc, 0x02);
            } else {
              // No, words will fit in memory. 
              // Check if packet is intact
              if (CRC16(inPacket, inPacketLen-2)!=(uint16_t)((inPacket[7]<<8)|inPacket[6]))
              {
                // No, seems to be corrupt
                error(fc, 0xE3);
              } else {
                // Packet is intact. Build response packet and return it
                outPacketLen = 0;
                outPacket[outPacketLen++] = ownID;
                outPacket[outPacketLen++] = fc;
                outPacket[outPacketLen++] = byts;
                
                // We should have the complete response now - move it to the response packet
                memcpy(outPacket+outPacketLen, data + (addr-1)*2, byts);
                outPacketLen += byts;
  
                // Calculate CRC for the response packet
                uint16_t crc = CRC16(outPacket, outPacketLen);
                outPacket[outPacketLen++] = crc&0xFF;
                outPacket[outPacketLen++] = (crc>>8)&0xFF;
#ifdef TESTING
                if (digitalRead(DEBUG_ON)==LOW)
                {
                  hexDump("RSP: ", ' ', outPacket, outPacketLen, buffer, BUFLEN);
                  Serial.println(buffer);
                  Serial.flush();
                }
#endif
                // Write response to MODBUS requester
                MODBUS.write(outPacket, outPacketLen);
                MODBUS.flush();
              }
            }
          }
        } else {
          // Return packet length mismatch
          error(fc, 0xE5);
        }
        break;
      case 0x06:
        // Sufficcient data for FC 0x06?
        if (inPacketLen==8)
        {
          // Yes, fc is okay, get address to read
          uint16_t addr = (inPacket[2]<<8)|inPacket[3];
          // Is it out of bounds?
          if (addr<1 || addr>(MEMSIZE/2))
          {
            // Yes, return error
            error(fc, 0x02);
          } else {
            // No, address is okay. get data to be written
            uint16_t dword = (inPacket[5]<<8)|inPacket[4];
            // Check if packet is intact
            if (CRC16(inPacket, inPacketLen-2)!=(uint16_t)((inPacket[7]<<8)|inPacket[6]))
            {
              // No, seems to be corrupt
              error(fc, 0xE3);
            } else {
              // Packet is intact. Write data, Build response packet and return it
              memcpy(data + (addr - 1) * 2, &dword, 2);
              outPacketLen = 8;
              memcpy(outPacket, inPacket, 8);
              // Write response to MODBUS requester
              MODBUS.write(outPacket, outPacketLen);
              MODBUS.flush();
            }
          }
        }
        break;
      case 0x10:
        // Sufficcient data for FC 0x10?
        if (inPacketLen>9 && inPacketLen==((uint8_t)9+inPacket[6]))
        {
          // Yes, fc is okay, get address to read
          uint16_t addr = (inPacket[2]<<8)|inPacket[3];
          // Is it out of bounds?
          if (addr<1 || addr>(MEMSIZE/2))
          {
            // Yes, return error
            error(fc, 0x02);
          } else {
            // No, address is okay. Get data count to be written
            uint8_t count = inPacket[6];
            // Check if packet is intact
            if (CRC16(inPacket, inPacketLen-2)!=(uint16_t)((inPacket[inPacketLen-1]<<8)|inPacket[inPacketLen-2]))
            {
              // No, seems to be corrupt
              error(fc, 0xE3);
            } else {
              // Packet is intact. Write data, Build response packet and return it
              memcpy(data + (addr - 1) * 2, inPacket+7, count);
              outPacketLen = inPacketLen;
              memcpy(outPacket, inPacket, inPacketLen);
              // Write response to MODBUS requester
              MODBUS.write(outPacket, outPacketLen);
              MODBUS.flush();
            }
          }
        }
        break;
      default:
        error(fc, 0x01);
        break;
      }
      
      digitalWrite(LED, LOW);
      state = INIT;
    }
    break;
  }
}

bertmelis Oct 19, 2021
Maintainer Author

I've only got a "regular" Arduino. But for now I'm focusing on just transmitting text: "hello world". If that is working, modbus should also work. Only issue then is the silent time in between messages.

bertmelis Oct 21, 2021
Maintainer Author

@Miq1 Scrolling through this code. There's nothing special about this code, right? I might as well flash it on an Arduino Uno. I just need a device that responds on Modbus.

Miq1 Oct 21, 2021
Maintainer

Yeah, most probably will work. You might need to adjust the GPIO numbers, though.

bertmelis · 2021-10-19T15:55:08Z

bertmelis
Oct 19, 2021
Maintainer Author

1. Connect ESP32 to max3485

UART0 (Serial) is connected to the USB output of the development board so we'll use UART1 (Serial1) and define the pins ourselves

D5  --> RO     (orange)
D18 --> DI     (green)
D19 --> /RE-DE (white)
3V3 --> Vcc    (yellow)
GND --> GND    (black)

I also added a 120Ohsm resistor between A and B at the max3485.

0 replies

bertmelis · 2021-10-19T17:40:34Z

bertmelis
Oct 19, 2021
Maintainer Author

2. Test

Flash this simple code to the ESP

#include <Arduino.h>

#define RX_PIN 5
#define TX_PIN 18
#define RE_DE  19

void setup() {
  Serial.begin(115200);
  Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);
  pinMode(RE_DE, OUTPUT);
  delay(5);
  Serial.print("Starting test\n");
}

void loop() {
  static uint32_t lastMillis = 0;
  if (millis() - lastMillis > 1000UL) {
    lastMillis = millis();
    Serial.print("writing to max485\n");
    digitalWrite(RE_DE, HIGH);
    Serial1.print("hello");
    Serial1.flush();
    digitalWrite(RE_DE, LOW);
  }
}

It does a simple task: every second it sets pin RE/DE high, prints "hello" on Serial1, waits until communication is done and sets RE/DE low again.

I connected a logic analyzer to RE/DE (probe D0) and the TX line (probe D1).

The image from the logic analyzer is this:

Mind that in the idle state, UART is high and communication starts by setting the "start bit" low (the yellow S). at the end of each character is the stop bit (green T).

0 replies

bertmelis · 2021-10-19T18:08:17Z

bertmelis
Oct 19, 2021
Maintainer Author

3. RS485

Next step: loopback over RS485. I connected terminal A of the max3485 to terminal A of a TTL-to-rs485 adapter. The TTL-side is connected to a laptop via a TTL-to-USB adapter. I also added a third probe of the logic analyzer to the RX-line on the computer side (between the rs-485 adapter and the USB-adapter)

Results

You would expect the computer reads "hello". But this is not the case! Instead I get some unreadable characters. A view on the logic analyzer reveals whats going on:

As you can see, the levels are switched at the computer side.

Swapping A and B (only on one side obviously) resolves this:

3 replies

Miq1 Oct 19, 2021
Maintainer

WHAT? 😱
This is against all I know. How is one supposed to connect any given device if you do not know which line is which? This is Roulette then...
Could it be the A and B marks are wrongly placed?

bertmelis Oct 19, 2021
Maintainer Author

Of course it can be. Especially on those cheap Chinese adapters (mine is).

bertmelis Oct 19, 2021
Maintainer Author

I believe my cheap TTL-toRS485 adapter is labeled wrong. Luckily, you have to or swap A and B or invert the UART signal. But I'm on to something on the receiving side (when sending something to ESP32)

bertmelis · 2021-10-19T18:18:53Z

bertmelis
Oct 19, 2021
Maintainer Author

Further testing

OK, we had to swap the rs485 lines. But what if we can't do this? There a trick in software to invert the UART levels:

// instead of this:
Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);

// we use this:
Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN, true);  // the last parameter tells Serial1 to invert the logical levels

0 replies

bertmelis · 2021-10-19T18:24:05Z

bertmelis
Oct 19, 2021
Maintainer Author

Further improvements

I undid inverting the UART signal again. A look on the logic analyzer reveals something strange:

Just before the start bit, a very short drop is noticeable on the receiving side.

A closer look tells us this is about the time when to output driver (ESP32 side) is active but UART isn't sending yet.

0 replies

bertmelis · 2021-10-19T19:03:02Z

bertmelis
Oct 19, 2021
Maintainer Author

From PC to ESP

Setup is as follows: A and B lines are swapped but UART signal is not inverted. We can communicate from the ESP to the PC. However, in the other direction something strange is happening.

During transmission, the RX line on the ESP32 is pulled high so the UART is preparing to receive.

Same situation when UART is inverted and A and B are not swapped:

6 replies

Miq1 Oct 19, 2021
Maintainer

You are my hero! 🤣

But how is that happening? And how to prevent it?

bertmelis Oct 19, 2021
Maintainer Author

I think I have to go to sleep now. I can't think straight anymore. I can't remember having this problem while working on my old lib. (I'm not saying it's the lib's fault, I just can't remember what I did different hardware-wise)

At least I can reproduce.

bertmelis Oct 19, 2021
Maintainer Author

Thing is, by tying /RE and DE together, the max3485 is always in receiving mode. So it just transmits whatever is on the bus and the state is defined by the bus where the terminating resistors keep noise down.
It is when the /RE goes high that RO goes into high impedance mode. Depending if the UART inverting or not, it sees an 0x00 at the start of high impedance mode or at the end. The UART is set as INPUT and not INPUT_PULLUP (in current Pio version, for latest I don't know) so it's state depends... I'll try tomorrow with some external biasing.

Miq1 Oct 20, 2021
Maintainer

<nervously scurring my feet>
@bertmelis Anything new? 😉

bertmelis Oct 20, 2021
Maintainer Author

<nervously scurring my feet> @bertmelis Anything new? 😉

Sorry, no work done today (yet).

bertmelis · 2021-10-20T16:57:00Z

bertmelis
Oct 20, 2021
Maintainer Author

Spurious 0x00???

As seen in the previous post, there is a spurious 0x00 on the RX of the esp32. This is unwanted and avoidable. First you have to understand that when configuring a pin as RX, Arduino sets it to INPUT.
When we drive the /RE-DE pin HIGH, the data output pin of the max3485 goes into high-impedance mode. This leaves the RX pin floating. In reality there are some weak pullups/pull-downs the make the pin go into a state -unfortunately- we don't want.

Adding a strong pull-up (non-inverting Serial) or pull-down (inverting Serial) makes the issue disappear.

Added a pull-down (470Ohms) on the RX-line to the esp32:

18 replies

bertmelis Oct 20, 2021
Maintainer Author

Nope, I think it is unsolvable. i'm wrong.

bertmelis Oct 20, 2021
Maintainer Author

Got it. It is only solveable when inverted, pulled down strongly and A and B swapped (because of UART is inverted).

Reasoning: you can invert the ESPs UART but not the max485 chip. Because of the way the chip works, you get a spurious 0x00 when the RE line switches. But not only that, because the 0x00 is not a real character the UART messes up and you get a framing error. This causes all subsequent characters to be messed up.

Miq1 Oct 20, 2021
Maintainer

No way. That is too special a case 😞

bertmelis Oct 20, 2021
Maintainer Author

I lost track of everything I did. My current test setup is quite a mess. I'll make a writeup with a proper modbus server in my Arduino Uno. For now my conclusions is my latest.

Miq1 Oct 20, 2021
Maintainer

Take your time now. We at least know what is happening thanks to your work.

One effectively would need some additional electronics that will pull down the RX line while the RE switch is done. I am a little sceptic if a 470 Ohms resistor will not damage weak signals if constantly connected.

I definitely will put some warning in the docs to avoid the adapters without automatic half duplex control.

Miq1 · 2021-10-20T17:05:48Z

Miq1
Oct 20, 2021
Maintainer

💯 points awarded!

Excellent you found that out. Unfortunately this seems to be nothing we can solve in software for our users.
My suggestion is to add the advice in the docs to add the 470 Ohms pulldown to the RX line in case one is using one of the MAXx485 adapters without automatic half duplex control.

2 replies

bertmelis Oct 20, 2021
Maintainer Author

I guess it's not only the MAXIM drivers.
When Platformio updates to the newest Arduino core, we have to try again. As I understand, IDF has an option to suppress the spurious bytes.

Miq1 Oct 20, 2021
Maintainer

So for the time being the advice would make sense without the restriction to the MAX chips?

bertmelis · 2021-10-22T08:07:28Z

bertmelis
Oct 22, 2021
Maintainer Author

I have given it some thoughts and I think it is solvable. Unfortunately I don't have time this week to test.

0 replies

bertmelis · 2021-10-26T14:39:15Z

bertmelis
Oct 26, 2021
Maintainer Author

So I made the circuit again, now but bus line biasing et voilà!

Got it running smoothly. Trick is to put the bus in a known state when idle. That is: voltage difference must be lower then 200mV.
Often, the biasing resistors that take care of this are included in the design of the various equipment and can be set by dipswitches.

See #112.

0 replies

Debugging UART <==> RS485 and related #110

bertmelis Oct 19, 2021 Maintainer

Replies: 11 comments · 33 replies

bertmelis Oct 19, 2021 Maintainer Author

Miq1 Oct 19, 2021 Maintainer

bertmelis Oct 19, 2021 Maintainer Author

bertmelis Oct 21, 2021 Maintainer Author

Miq1 Oct 21, 2021 Maintainer

bertmelis Oct 19, 2021 Maintainer Author

1. Connect ESP32 to max3485

bertmelis Oct 19, 2021 Maintainer Author

2. Test

bertmelis Oct 19, 2021 Maintainer Author

3. RS485

Results

Miq1 Oct 19, 2021 Maintainer

bertmelis Oct 19, 2021 Maintainer Author

bertmelis Oct 19, 2021 Maintainer Author

bertmelis Oct 19, 2021 Maintainer Author

Further testing

bertmelis Oct 19, 2021 Maintainer Author

Further improvements

bertmelis Oct 19, 2021 Maintainer Author

From PC to ESP

Miq1 Oct 19, 2021 Maintainer

bertmelis Oct 19, 2021 Maintainer Author

bertmelis Oct 19, 2021 Maintainer Author

Miq1 Oct 20, 2021 Maintainer

bertmelis Oct 20, 2021 Maintainer Author

bertmelis Oct 20, 2021 Maintainer Author

Spurious 0x00???

bertmelis Oct 20, 2021 Maintainer Author

bertmelis Oct 20, 2021 Maintainer Author

Miq1 Oct 20, 2021 Maintainer

bertmelis Oct 20, 2021 Maintainer Author

Miq1 Oct 20, 2021 Maintainer

Miq1 Oct 20, 2021 Maintainer

bertmelis Oct 20, 2021 Maintainer Author

Miq1 Oct 20, 2021 Maintainer

bertmelis Oct 22, 2021 Maintainer Author

bertmelis Oct 26, 2021 Maintainer Author

bertmelis
Oct 19, 2021
Maintainer

Replies: 11 comments 33 replies

bertmelis
Oct 19, 2021
Maintainer Author

Miq1 Oct 19, 2021
Maintainer

bertmelis Oct 19, 2021
Maintainer Author

bertmelis Oct 21, 2021
Maintainer Author

Miq1 Oct 21, 2021
Maintainer

bertmelis
Oct 19, 2021
Maintainer Author

bertmelis
Oct 19, 2021
Maintainer Author

bertmelis
Oct 19, 2021
Maintainer Author

Miq1 Oct 19, 2021
Maintainer

bertmelis Oct 19, 2021
Maintainer Author

bertmelis Oct 19, 2021
Maintainer Author

bertmelis
Oct 19, 2021
Maintainer Author

bertmelis
Oct 19, 2021
Maintainer Author

bertmelis
Oct 19, 2021
Maintainer Author

Miq1 Oct 19, 2021
Maintainer

bertmelis Oct 19, 2021
Maintainer Author

bertmelis Oct 19, 2021
Maintainer Author

Miq1 Oct 20, 2021
Maintainer

bertmelis Oct 20, 2021
Maintainer Author

bertmelis
Oct 20, 2021
Maintainer Author

bertmelis Oct 20, 2021
Maintainer Author

bertmelis Oct 20, 2021
Maintainer Author

Miq1 Oct 20, 2021
Maintainer

bertmelis Oct 20, 2021
Maintainer Author

Miq1 Oct 20, 2021
Maintainer

Miq1
Oct 20, 2021
Maintainer

bertmelis Oct 20, 2021
Maintainer Author

Miq1 Oct 20, 2021
Maintainer

bertmelis
Oct 22, 2021
Maintainer Author

bertmelis
Oct 26, 2021
Maintainer Author