UART RS485 Problem

[DrWright (Gast)]

Hallo, ich möchte eine bidirektionale Kommunikation von einem Mega328 
mit einem Mega 168 herstellen.
Als Treiber benutze ich einen SN75176, meine Sprache ist C.

Nun habe ich festgestellt, das ich zwischen den Umschalten von Senden 
auf Empfang einen Delay einfügen muss, da sonst Bytes abgeschnitten 
werden.
Der UART Code inclusive Delays ist auf beiden µC gleich.

Die Kommunikation beobachte ich über einen RS485 auf RS232 Wandler auf 
meinem Laptop mit HTERM. Dort sehe ich auch, das zuerst alles 
funktioniert, und nach einer kleinen Laufzeit (wärme?) überträgt er 
nurnoch Mist. Ich vermute das er nicht schnell genug auf Empfang 
wechselt, und deshalb Bits abgeschnitten werden.

Ich empfange über eine ISR in einen Ringpuffer, was auch ohne weiteres 
funktioniert.

#define BAUD 9600UL    // Baudrate 

#define DIRBIT_DDR DDRD
#define DIRBIT_PORT PORTD
#define DIRBIT_DDI PIND
#define DIRBIT_PIN PD2

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif 

#define buffersize 16

void SetTempHum(uint8_t tmp, uint8_t hum);
void SetWaterSim(uint8_t status, uint8_t pps);
void SendWaterStatus(void);
void SaveToEEPROM(void);

uint8_t txd_buffer[buffersize] = "",txd_buffer_cnt = 0,txd_do_cnt = 0;

void uart_init(void)
{
  UBRR0H = UBRR_VAL >> 8;
  UBRR0L = UBRR_VAL & 0xFF;
  UCSR0C = (1<<UCSZ01)|(1<<UCSZ00); // Asynchron 8N1 
  UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);  // UART RX, TX und RX Interrupt einschalten
  DIRBIT_DDR |= (1<<DIRBIT_PIN); // DIRBIT auf Ausgang
  DIRBIT_PORT &= ~(1<<DIRBIT_PIN); // Auf Empfang schalten
}

void uart_txd_Do(void)
{
  while (txd_do_cnt != txd_buffer_cnt)  // Daten zum Senden vorhanden?
  {
    if (UCSR0A & (1<<UDRE0)) // Sendepuffer bereit?
    {
      if (!(DIRBIT_DDI & (1<<DIRBIT_PIN)))
      {
        _delay_us(150);
        DIRBIT_PORT |= (1<<DIRBIT_PIN); // DIRBIT auf Senden
        _delay_us(100);        
      }      
      UDR0 = txd_buffer[txd_do_cnt];  
      while (!(UCSR0A & (1<<TXC0)));  //  Warte bis Zeichen gesendet ist  
      UCSR0A |= (1<<TXC0);  //  Gesendet Bit löschen      
      txd_do_cnt++;
      if (txd_do_cnt == buffersize){txd_do_cnt = 0;}
    }
  }
  
  if (DIRBIT_DDI & (1<<DIRBIT_PIN))  // Empfangsbit schon umgeschaltet?
  {  
    _delay_us(100);      
    DIRBIT_PORT &= ~(1<<DIRBIT_PIN); // Auf Empfang schalten
    _delay_us(150);
  }
}

uint8_t uart_SendByte(uint8_t in)
{  
  txd_buffer[txd_buffer_cnt] = in;  
  txd_buffer_cnt++;
  if (txd_buffer_cnt == buffersize){txd_buffer_cnt = 0;}
  return in;
}

[DrWright (Gast)]

Achso, ich verwende bei beiden µC denselben Quarz von 9830400 und die 
Fuses sind auch richtig gesetzt.

[uli (Gast)]

Nimm den txcoplete interrupt!

[(prx) A. K. (prx)]

Ob per Interrupt oder nicht - jedenfalls muss man auf TXC warten, bevor 
man die Richtung umschaltet. Nicht schon, wenn das letzte Byte im Puffer 
gelandet ist.

[DrWright (Gast)]

Es wartet ja schon bis der TXC gesetzt ist, bevor es weitergeht. Das ist 
das Bit was anzeigt das das Byze aus dem Schieberegister raus ist.

[(prx) A. K. (prx)]

Stimmt, allerdings wäre das an anderer Stelle besser untergebracht.

[DrWright (Gast)]

A. K. schrieb:
> Stimmt, allerdings wäre das an anderer Stelle besser
> untergebracht.

Ich bin den Ablauf schritt für schritt durchgegangen und sehe nicht, wo 
er vorzeitig auf Senden umschaltet. Wo meinst du denn wo es besser 
untergebracht wäre?

[(prx) A. K. (prx)]

DrWright schrieb:
> Wo meinst du denn wo es besser untergebracht wäre?

Üblich ist es nach der while-Schleife vor der Richtungsumschaltung. TXC 
wird erst gesetzt, wenn Puffer und Schieberegister leer sind.

[(prx) A. K. (prx)]

Wird der RX Ausgang des Transceivers mit abgeschaltet? Wenn ja: Ist 
sichergestellt, dass der RX Pin nicht floatet?

[(prx) A. K. (prx)]

Im gezeigten Code wird der Tx-Puffer Daten verlieren, wenn die Bytes 
schneller dort landen als sie übertragen werden. Wird das im nicht 
gezeigten Code irgendwie verhindert/vermieden?

[DrWright (Gast)]

Ich habe keine Pullups oder einen 120 Ohm Abschlusswiderstand eingebaut. 
Hab mitm Oszi nachgemessen, und der Ausgang ist stabil, es floatet also 
nichts. Der TX Buffer ist groß genug, ich schicke nur alle 2 sek 4 byte.

Habe den Code daraufhin so geändert.

void uart_txd_Do(void)
{
  while (txd_do_cnt != txd_buffer_cnt)  // Daten zum Senden vorhanden?
  {
    if (UCSR0A & (1<<UDRE0)) // Sendepuffer bereit?
    {
      if (!(DIRBIT_DDI & (1<<DIRBIT_PIN)))
      {
        _delay_ms(5);
        DIRBIT_PORT |= (1<<DIRBIT_PIN); // DIRBIT auf Senden
        _delay_us(100);        
      }      
      UDR0 = txd_buffer[txd_do_cnt];            
      txd_do_cnt++;
      if (txd_do_cnt == buffersize){txd_do_cnt = 0;}
    }
  }
  
  if (DIRBIT_DDI & (1<<DIRBIT_PIN))  // Empfangsbit schon umgeschaltet?
  {  
    while (!(UCSR0A & (1<<TXC0)));  //  Warte bis Zeichen gesendet ist  
    UCSR0A |= (1<<TXC0);  //  Gesendet Bit löschen
    
    _delay_us(150);      
    DIRBIT_PORT &= ~(1<<DIRBIT_PIN); // Auf Empfang schalten
    _delay_us(100);
  }
}

Das hat leider auch nichts gebracht. Das merkwürdige ist ja das es 
einige Zeit funktioniert und dann langsam falsche bytes geschickt 
werden.
Ich versuche trotzdem mal Pullup/Down widerstände Einzulöten. Mal sehen 
ob es was bringt.

[DrWright (Gast)]

Habe nun 2 kOhm Widerstände als Terminierung genommen. Leider hat sich 
das Problem damit nicht gelöst. Es scheint mir ein thermiches Problem zu 
sein. Beim ersten Test wenns noch kalt ist gehts ohne Probleme und nach 
einiger Zeit tritt der Fehler dann auf. Im HTERM kann ich beobachten das 
er bei manchen Bytes das erste Bit High setzt, obwohl es Low sein 
sollte.

[DrWright (Gast)]

So, ich habe das Problem beheben können indem ich erstmal alle Delays 
entfernte und getestet habe welche überhaupt notwendig sind.
Es reicht ein 5ms Delay vor dem ersten Umschalten auf Sendebetrieb.

void uart_txd_Do(void)
{
  while (txd_do_cnt != txd_buffer_cnt)  // Daten zum Senden vorhanden?
  {
    if (UCSR0A & (1<<UDRE0)) // Sendepuffer bereit?
    {
      if (!(DIRBIT_DDI & (1<<DIRBIT_PIN)))
      {
        _delay_ms(5);        
        DIRBIT_PORT |= (1<<DIRBIT_PIN); // DIRBIT auf Senden
      }  
      UCSR0A |= (1<<TXC0);  //  Gesendet Bit löschen      
      UDR0 = txd_buffer[txd_do_cnt];        
      txd_do_cnt++;
      if (txd_do_cnt == buffersize){txd_do_cnt = 0;}
    }
  }
  
  if (DIRBIT_DDI & (1<<DIRBIT_PIN))  // Empfangsbit schon umgeschaltet?
  {    
    while (!(UCSR0A & (1<<TXC0)));  //  Warte bis Zeichen gesendet ist  
    UCSR0A |= (1<<TXC0);  //  Gesendet Bit löschen    
    DIRBIT_PORT &= ~(1<<DIRBIT_PIN); // Auf Empfang schalten
  }
}

uint8_t uart_SendByte(uint8_t in)
{  
  txd_buffer[txd_buffer_cnt] = in;  
  txd_buffer_cnt++;
  if (txd_buffer_cnt == buffersize){txd_buffer_cnt = 0;}
  return in;
}

Ganz wichtig ist auch das TX Complete Bit.
Vielen Dank für die Hilfe

[DrWright (Gast)]

Ich melde mich nach einiger Zeit mal wieder, nachdem ich mit der letzen 
Version Probleme hatte, hier nun eine die läuft.

void uart_txd_Do(uint8_t overflow)
{
  while (txd_do_cnt != txd_buffer_cnt || overflow)  // Daten zum Senden vorhanden?
  {
    if (UCSR0A & (1<<UDRE0)) // Sendepuffer bereit?
    {
      if (!(DIRBIT_DDI & (1<<DIRBIT_PIN)))
      {        
        _delay_us(50);        
        DIRBIT_PORT |= (1<<DIRBIT_PIN); // DIRBIT auf Senden
      }  
      UCSR0A |= (1<<TXC0);  //  Gesendet Bit löschen        
      UDR0 = txd_buffer[txd_do_cnt++];
      if (txd_do_cnt == buffersize_rxd){txd_do_cnt = 0;}  
      overflow = 0;      
    }  
  
    if (DIRBIT_DDI & (1<<DIRBIT_PIN))  // Empfangsbit schon umgeschaltet?
    {    
      while (!(UCSR0A & (1<<TXC0)));  //  Warte bis Zeichen gesendet ist  
      DIRBIT_PORT &= ~(1<<DIRBIT_PIN); // Auf Empfang schalten
      UCSR0A |= (1<<TXC0);  //  Gesendet Bit löschen    
    }
  }
}

uint8_t uart_SendByte(uint8_t in)
{  
  txd_buffer[txd_buffer_cnt] = in;  
  txd_buffer_cnt++;
  if (txd_buffer_cnt == buffersize_rxd){txd_buffer_cnt = 0;}  
  if (txd_do_cnt == txd_buffer_cnt)  //Bei Puffer überlauf, leeren veranlassen
  {
    uart_txd_Do(1);
  }    
  return in;
}

Ich habe festgestellt, das ich nach jedem Byte ein Umschalten auf 
Empfang notwendig ist, da sonst ein Frame Error vom empfangenden Byte 
erzeugt wird.
(Ich kommuniziere mit einer Steuerung deren Code in Assembler 
geschrieben wurde, das ACK kommt sehr schnell).

[Frank K. (fchk)]

Beschalte doch den 485-Transceiver so, dass Du immer empfängst, auch 
Deine eigenen Daten. Erstens weißt Du somit genau, wenn das Byte 
gesendet worden ist, und Du weißt genau, dass das Byte korrekt gesendet 
worden ist und nicht irgendwer anders den Bus belegt hat.

fchk

[Stefan (Gast)]

Hallo,

DrWright schrieb:
> Ich habe festgestellt, das ich nach jedem Byte ein Umschalten auf
> Empfang notwendig ist, da sonst ein Frame Error vom empfangenden Byte
> erzeugt wird.

sollte dies wirklich der Fall sein dann hast du was Grundlegendes falsch 
gemacht!

Ich hab jetzt alle vorhergehenden Mails überflogen und ich denke dein 
Problm ist weniger ein Timing-Problem als vielmehr ein Problem der 
"Stabilität".

Kurz: Du hast keine stabilen Verhältnisse in deiner Schaltung.

Ob dies der Fall ist oder nicht kannst du ganz einfach testen. Ein 
reines Umschalten von Empfang auf Senden und umgekehrt darf keinen 
Zustandswechsel auf den Leitungen DI, DO, A und B verursachen.
Ein Zustandswechsel würde Dir unweigerlich ein Startbit (und damit ein 
Zeichen) vorgaukeln.
Der Ruhezustand für DI und DO muss high sein und für A/B muss gelten 
A-B>200mV.
Damit der Ruhezustand auf diesen Leitungen sicher ist schlage ich dir 
obige Schaltung vor die du auch in diversen Foren wiederfindest.

[DrWright (Gast)]

Das denke ich langsam auch, R1 und R3 habe ich bereits, auf die 
Terminierung habe ich verzictet, weil die Leitung grad mal 1 m lang ist. 
Den Pullup an RO habe ich noch nicht. Ich werde Testhalber mal die 
Richtung umschalten lassen im sekundentakt und dann einfach mal mitm 
Oszi Messen.

[DrWright (Gast)]

OK, da stimmt definitiv was nicht. Ich schalte nur um und der 
USART_RX_vect Interrupt löst sofort aus.

[DrWright (Gast)]

Ich denke das sollte es gewesen sein, vielen dank für die Info.

Ich hab jetz auf RXD den Pullup eingeschaltet, ohne Pullup ist der von 
0,8-4,6V beim Umschalten gefloatet, mit aktiven Pullup bleibt er starr 
bei 4,7V stehen.