STM8 UART blockiert

[Christoph R. (christoph_r463)]

Hallo Zusammen,
Ich habe hier ein kleines Testsystem mit zwei Slaves und einem Master. 
Die Kommunikation realisiere ich über UART. Der Master ist ein STM32 und 
die Slaves STM8Ss.
Die Slaves lauschen auf Daten vom Master, welche an den jeweiligen Slave 
adressiert sind (ID im Bytestream). Das ganze läuft für eine gewisse 
Zeit sehr gut (30Sek-2Min). Danach jedoch sehen die beiden(!) Slaves mit 
einem Mal keine eingehenden Daten mehr, als ob sich der UART an den 
STM8ern abgeschaltet hätte (Auf der Leitung sind die Daten aber 
vorhanden, - mit Oszilloskop gemessen).
Ich habe mit dem Interrupt getestet und bin nun beim pollen angelangt. 
Jede Variante zeigt dieses Verhalten.

Meine Empfangsroutine startet so:

 /* clear new data received flag */
  UART1_ClearFlag(UART1_FLAG_RXNE);
  UART1_ReceiveData8(); 
  
  /* wait here for first data byte */
  while (UART1_GetFlagStatus(UART1_FLAG_RXNE) == RESET);

  /* Read one byte from the receive data register */
 byValue = UART1_ReceiveData8();
  
  /* check for frame start */
  if(START_OF_FRAME == byValue)

....

Im Fehlerfall hängen die STMs immer beim „while 
(UART1_GetFlagStatus(UART1_FLAG_RXNE)“. Wenn ich das umgehe und einfach 
immer nur per UART1_ReceiveData8() ein Byte vom UART DR lese und auf 
mein Frame Start Byte warte, passiert nichts -> zum Beispiel:

  while (UART1_ReceiveData8() != START_OF_FRAME);

Wenn ich nur einen STM8 allein betreibe habe ich keine Probleme. Es kann 
hin und wieder vorkommen, dass beide STM8s zur selben Zeit etwas senden, 
was aber vom Master erkannt wird. Könnte das ein Problem für die STM8s 
darstellen? Suche ich an der falschen Stelle? Hat jemand einen Tipp?

Danke!
Grüße
Chris

[aSma>> (Gast)]

Servus,
mache das lieber per ISR und einen Protokoll. Pollen kann man schon aber 
nur wenn man DMA hat oder einen Sender mit Buffer...

Du bekommst mit Sicherheit ein Overflow, weil die Daten zu langsam 
abgearbeitet werden.

Programmiere also per ISR ein FIFO und werte die Daten per Protokoll 
aus. Erstelle eine ISR die Fehler abarbeitet.

mfg

[Christopher B. (chrimbo)]

Check mal ob du nen Error bekommst UART_SR:(FE|OR). Manche Controller 
empfange nicht mehr wenn ein Fehler aufgetreten ist.

[Christoph R. (christoph_r463)]

aSma>> schrieb:
> Servus,
> mache das lieber per ISR und einen Protokoll. Pollen kann man schon aber
> nur wenn man DMA hat oder einen Sender mit Buffer...
>
> Du bekommst mit Sicherheit ein Overflow, weil die Daten zu langsam
> abgearbeitet werden.
>
> Programmiere also per ISR ein FIFO und werte die Daten per Protokoll
> aus. Erstelle eine ISR die Fehler abarbeitet.
>
> mfg

Hallo aSma

Meine erste Version sah genau so aus, also ISR + FIFO + Protokoll. das 
einzige was ich da getestet habe, war das erste Byte des Frames -> 
Startbyte. Sowie das Zweite Frame -> Länge des kommenden Frames.

Was für Fehler meinst du, die ich in der ISR abarbeiten sollte? Gibt es 
da noch mehr Flags die man auswerten kann, bzw. zurücksetzen muss?

Ich hatte mal ausprobiert das OR Flag noch zurück zu setzen, aber da ist 
mir der STM auch immer eingefroren

UART1_ClearFlag(UART1_FLAG_OR);

Wenn ich nur einen Slave nutze, läuft meine Lösung wirklich gut bei 
250KBaud (sehr kurze Leitungen werden genutzt), ob ich nun Interrupt 
oder Polling nehme.

Danke und Grüße
Chris

[Christoph R. (christoph_r463)]

Christopher B. schrieb:
> Check mal ob du nen Error bekommst UART_SR:(FE|OR). Manche
> Controller
> empfange nicht mehr wenn ein Fehler aufgetreten ist.

Hi Christopher,

das ist ein guter Hinweis, dass bestimmte Controller nicht mehr 
empfangen. Was muss man dann im allgemeinen tun? Einfach die Fehler 
Register wieder zurücksetzen?

(Ich teste mich da mal durch!)

Danke und Grüße!
Chris

[Christoph R. (christoph_r463)]

Reagiert eine Lösung mit Polling nicht genauso schnell wie ein 
Interrupt?

sowas hier zum Beispiel:

while (UART1_GetFlagStatus(UART1_FLAG_RXNE) == RESET);

Also die reine Reaktionszeit, vom befüllten Buffer bis zum ersten Code 
in der ISR, bzw nach der while()-Schleife....

[aSma>> (Gast)]

Christoph R. schrieb:
> /* wait here for first data byte */
>   while (UART1_GetFlagStatus(UART1_FLAG_RXNE) == RESET);
Fehler Quelle 1
>
>   /* Read one byte from the receive data register */
>  byValue = UART1_ReceiveData8();
>
>   /* check for frame start */
>   if(START_OF_FRAME == byValue)
Fehler Quelle 2

Hier mein Beispiel für !stm32 aber:

//----------------------------------------------------------------------------
// USART1_IRQHandler: USART1 Tx,Rx interrupt request handler
//----------------------------------------------------------------------------
void USART1_IRQHandler(void)
{
  if((USART_GetITStatus(USART1, USART_IT_RXNE) == SET)) //only 1 byte
  {
    USART_ClearITPendingBit(USART1, USART_IT_RXNE);   //clear flag

    Usart_Rx_Buffer[Receive_W] = USART_ReceiveData(USART1);
    Receive_W++;
    Receive_C++;
  }


  if((USART_GetITStatus(USART1, USART_IT_TXE) == SET))
  {
      USART_ClearITPendingBit(USART1, USART_IT_TXE);//clear flag

      if(Usart_Tx_Buffer[Send_C] != '\0')
    {
      USART_SendData(USART1, Usart_Tx_Buffer[Send_C]);
      Send_C++;
    } else {
      Send_C = 0;
      USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
    }
  }

}

Alle Var in der ISR sind global und volatile!

Jetzt musst du nur noch eine Fkt. schreiben, in der du den Header, 
Daten, Terminator bearbeitest. Ein Header aus nur einen Char ist halt 
Fehler anfällig.

void UsartRead(void)
{
  if (Receive_C>0){
...
//header
//terminator
//data
Receive_C--;
}

mfg

[Christoph R. (christoph_r463)]

aSma, Christopher, ihr seids super :) Danke!

es ist eine Kombination aus beidem. Mit dem reinen Polling habe ich mich 
etwas verzettelt. Initial warte ich nun auf einen USART_IT_RXNE 
Interrupt, polle danach dann aber weiter (mit Timeout) - funktioniert 
wunderbar. Mein Protokoll besteht übrigens aus einigen mehr bytes + crc 
usw, - hatte es hier nur zur Vereinfachung weggelassen :)

In der ISR werte ich nun alle Flags aus, - und wie Christopher schon 
vermutet, poppt irgendwann ein OR Interrupt auf. Genau da hängt es dann.


So ungefähr:

INTERRUPT_HANDLER(UART1_RX_IRQHandler, 18)
{
  if(UART1_GetFlagStatus(UART1_FLAG_RXNE) == SET)
  {
    IRQHandler_Rx(); //-> Emfangsroutine
  }
  else
  {
    if(UART1_GetFlagStatus(UART1_FLAG_OR) == SET)
    {
      UART1_ReceiveData8();  // -> clear!
    }
    if(UART1_GetFlagStatus(UART1_FLAG_FE) == SET)
    {
      UART1_ReceiveData8();  
    }
  }
}

Interessant ist nur, warum immer beide Slaves gleichzeitig blockiert 
wurden. Das liegt sicher irgendwo an der Tatsache, dass beide manchmal 
zur selben Zeit senden.

Naja, so oder so, - es läuft jetzt erstmal :)
Danke nochmal für eure Zeit und euren Input!
Grüße
Chris