Electrical – ADM2587 using input uart

microcontrollerrs485uart

I have a design with the ADM2587 in half duplex mode:

If I want to receive something over RS485 I pull RE and DE low. This is tested and works good.
The same thing with sending: RE and DE high, sending works, everybody is happy.

Now, sometimes I want to work directly with the UART on the board (the RX and TX lines feeding into the ADM2587). This is where stuff gets tricky.
To use the UART, I have to do the opposite: for receiving I have to pull RE and DE high, for sending RE and DE low. If I do anything else the ADM seems to pull on it's RX and TX lines, and my microcontroller is not able to communicate properly.

Do I something wrong, or can ADM really not coexist with some other serial communication on it's input lines?? In my ideal dream world, I would have RE constantly low (enabling the receiver), and DE normally low to keep my uart communication on the board. Only if I want to send something out I would enable DE and send data over RS485.

But this results in chaos and mayhem. RS485 is not stable (many bit errors in communication due to wrong voltage levels) and UART doesn't work at all (I can see the received data on the lines, but the LOW voltage does only go to 3V, not all the way down to 0V).

Picture below: RX Signal on the microcontroller pin, RE LOW, DE LOW

Any ideas? how would one implement an "receive only" ADM25XX, where the lines are not held by the chip?

Best Answer

In my ideal dream world, I would have RE constantly low (enabling the receiver), and DE normally low to keep my uart communication on the board. Only if I want to send something out I would enable DE and send data over RS485.

It is perfectly acceptable to have RE constantly low (tied to ground) and turn on DE only when you want to send something. In this case ADM2587 Receiver Output (RO) will be constantly on and will constantly track A and B lines. Your MCU Rx pin will receive everything that is transmitted on the bus including your own messages (echo).

Sometimes it can be very useful but as I understand it's not what you really want: you want to connect your MCU Rx line in parallel to some other MCU Tx line. In this case you will have 2 drivers (ADM2587 RO and other MCU Tx pin) connected to your MCU Rx pin, which is not good.

This is what you are seeing on the picture. You have a conflict: one driver (assume other MCU) is trying to send a bit (pull the voltage to LOW level), but at the same time another driver (ADM2587 RO pin) is not sending anything, that means it is trying to preserve HIGH output level.

The main problem here is that you need to ensure that only 1 driver in on at a time. To achieve your goal you need to disable both driver and receiver of ADM2587 at times when you want to do a parallel UART communication with other MCU. On the other hand you need to disable other MCU driver (put Tx pin in Z state) when you want to receive data from ADM2587.

It might work, but you need to have a full control of situation otherwise collisions are very possible.

Related Solutions

How to get data from one micro controller to another using UART

I dont understand your confusion. You want to communicate between the two controllers with UART, then ofcourse both of them need UART capabilities and code for this. Your computer has drivers and software for dealing with this, so your microcontroller also needs a driver for it.

Your ATmega32 need UART TX functionality, while AT90USB1287 need UART RX functionality. Having already written both TX and RX for your ATmega32, writing the UART RX routine for AT90 should be a breese. You could add a bitvalue of some kind, identifying that the UART RX on AT90 is coming from your ATmega32, and directly pass it through to USB.

EDIT: Code from AVRFreaks that is written for at90usb1287

#include <avr/io.h> 
#include <util/delay.h> 

#define RXC      (RXC1) 
#define TXC      (RXC1) 
#define UCSRC    (UCSR1C) 
#define UCSRB    (UCSR1B) 
#define UCSRA    (UCSR1A) 
#define UDR      (UDR1) 
#define UBRRL    (UBRR1L) 
#define UBRRH    (UBRR1H) 
#define UBRR     (UBRR1) 
#define UDRE     (UDRE1) 
#define RXCIE    (RXCIE1) 
#define TXEN     (TXEN1) 
#define RXEN     (RXEN1) 
#define UCSZ0    (UCSZ10) 
#define UCSZ1    (UCSZ11) 
#define UMSEL0   (UMSEL10) 
#define UMSEL1   (UMSEL11) 

#define FRAMING_ERROR (1<<FE1) 
#define PARITY_ERROR (1<<UPE1) 
#define DATA_OVERRUN (1<<DOR1) 
#define DATA_REGISTER_EMPTY (1<<UDRE1) 
#define RX_COMPLETE (1<<RXC1) 

#define FOSC 16000000 

typedef unsigned char       Uchar; 
typedef unsigned long int   Uint32; 

#define Wait_USART_Ready() while (!(UCSR1A & (1<<UDRE1))) 

#define lowByte(w) ((uint8_t) ((w) & 0xff)) 
#define highByte(w) ((uint8_t) ((w) >> 8)) 

int main(void) 
{ 
/* Disable clock division */ 
clock_prescale_set(clock_div_1); 
   UBRRH = (Uchar)((((Uint32)FOSC)/((Uint32)USART_BAUDRATE*16)-1)>>8); 
   UBRRL = (Uchar)(((Uint32)FOSC)/((Uint32)USART_BAUDRATE*16)-1) & 0x0ff; 

   UCSRB |= (1 << RXEN) | (1 << TXEN); 
   UCSRC |= (1 << UCSZ1) | (1 << UCSZ0); 

   char ReceivedByte; 
   for (;;) // Loop forever 
   { 
      while ((UCSRA & (1 << RXC)) == 0) {}; // Do nothing until data have been received and is ready to be read from UDR 
      ReceivedByte = UDR; // Fetch the received byte value into the variable "ByteReceived" 

      while ((UCSRA & (1 << UDRE)) == 0) {}; // Do nothing until UDR is ready for more data to be written to it 
      UDR = ReceivedByte; // Echo back the received byte back to the computer 
   } 
}

Electronic – arduino – RS-422 distance sensor with arduino

In normal serial communications links, you actually need two wires - one is the signal and one is the ground. The ground stays at zero volts and the signal wire swings between 2 voltages that represent data bits 0 and 1 respectively (in RS232, the signal swings between +25 volt and -25 volts).

Using voltage to signal is not great for long wires going though noisy environments because the wires act like antennas and the voltage difference can get lost in the noise.

RS422 uses current direction rather than voltage to transmit bits. Current going one way is a 1, reversed the other way is a 0. This is much more resistant to noise.

The RX+ and RX- are the two wires that that current for received data. You can imaging sending data down this wire using a battery as a transmitter. Connect the battery one way to send a 1, or flip it the other way to send a 0. Two wires, but they carry one bit of data. You can connect this one bit of data to a single serial input (using the the correct drivers to turn the current direction on thew wires in a voltage to show the pin).

Same goes for the TX+ and TX- wires. They carry a single bit. The driver will take a single bit of data represented as a voltage on your sereial send pin, and convert it to a current flowing one way or the other on the two TX wires.

ADVICE: Unless you are making lots of these, don't mess around with driver chips (unless you want to!). You can cheaply get prepackaged current loop dongles that have screw terminals and are very easy to use. They use the same chips you are looking at, but do all save you the hassles of figuring it all out. If you get one that uses TTL level signals, you can connect it directly to your Ardunio and treat it as just a regular serial connection. Here is an example of one (I've never used this one but looks as good as any other)...

http://www.amazon.com/INBOARD-RS422-DRIVER-ET-MINI-SHIPPING/dp/B00EXUGRUK/ref=sr_1_1?ie=UTF8&qid=1392255264&sr=8-1&keywords=ttl+rs422

Best Answer

Related Solutions

How to get data from one micro controller to another using UART

Electronic – arduino – RS-422 distance sensor with arduino

Related Topic