Relaiskarte mit ATmega16 - Problem mit falschen Steuerbefehlen

[Andreas W. (a-w)]

Hallo,

ich habe frei programmierbare Relaiskarten mit ATmega16. Die Relais 
werden über die serielle Schnittstelle RS-232 vom PC aus geschalten.
Die Befehle bestehen aus 9 Zeichen, wobei das erste Zeichen als 
Adressierung einer bestimmten Karte dient, da mehrere davon 
aneinandergereiht werden können. Die restlichen 8 Zeichen sind immer die 
gleichen Befehle zum Steuern der Relais. Zu der Karte gab es eine 
Demosoftware, die ich etwas angepasst habe. (Code gekürzt)

/*commands
 *  1) cc<0x01>e  - TURN ON relay 1
 *  2) cc<0x02>e  - TURN ON relay 2
 *  3) cc<0x03>e  - TURN ON relay 3
 *  4) cc<0x04>e  - TURN ON relay 4
 *  5) cc<0x05>e  - TURN OFF relay 1
 *  6) cc<0x06>e  - TURN OFF relay 2
 *  7) cc<0x07>e  - TURN OFF relay 3
 *  8) cc<0x08>e  - TURN OFF relay 4
 *  9) cc<0x09>e  - READ AIN2-2 
 *  10) cc<0x1A>e  - READ AIN2-1
 *  11) cc<0x1B>e  - READ AIN1-3
 *  12) cc<0x1V>e  - READ AIN1-2
 *  13) cc<0x1D>e  - READ DIGITAL INPUTS
 * erste Stelle gibt Adresse der Platine an*/

#include <avr/eeprom.h> 
#include <ctype.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include "avr/io.h"
#include<string.h>
#include <avr/interrupt.h>
#include <util/delay.h>

//target//
const char target='c';

volatile char var;
volatile char flag_address=0;
 const unsigned char address=0x05;
volatile char buffer[8];
volatile unsigned char test;
volatile char string_analog[10]="0000000000";
unsigned char i=0;
#define command_on    flag_register = 0xFF
#define  command_off    flag_register = 0x00
int digital(void);
int action (void);
void Print(char Text[80]);
void PrintLine();
void PORT_Init();
void USART_Init( unsigned int ubrr);
unsigned char UART_Receive();
void UART_Transmit(unsigned char Data);
void PrintLn(char Text[80]);
volatile unsigned char u=0;
volatile   unsigned char abba;
 volatile char result[10]="0000000000";
volatile long rezultat=0;
unsigned char i;
volatile char p,d; 
volatile char v[10];    

unsigned  char  flag_register=0;

#define  __AVR_ATmega16__  1

#define FOSC 8000000 /* in Hz */
#define BAUD 9600
#define MYUBRR ((FOSC/16/BAUD)-1)

char Txt[80];
unsigned char Action = 0;
volatile uint16_t adcval;
volatile struct status {

  unsigned command:1;
  unsigned end:1;
  unsigned addres:1;
  }status_bits;

  //
char *masiv[]={

    "C<0x01>E",
    "C<0x02>E",
    "C<0x03>E",
    "C<0x04>E",
    "C<0x05>E",
    "C<0x06>E",
    "C<0x07>E",
    "C<0x08>E",
    "C<0x09>E",
    "C<0x1A>E",
    "C<0x1B>E",
    "C<0x1V>E",
    "C<0x1D>E"
        };
        
/*  Print new line to the Hyper Terminal */  
void PrintLine()
{
  UART_Transmit(10);
  UART_Transmit(13);
}

/*  PORT_Init */  
void PORT_Init()
{
  PORTA = 0b00000000;
  DDRA = 0b00001111;

  PORTB = 0b00000000;
  DDRB = 0b11111000;    

  PORTC = 0b00000000;
  DDRC = 0b11111111;

  PORTD = 0b00000000;
  DDRD = 0b11100010;    
}

/*  USART_Init */      
void USART_Init( unsigned int ubrr)
{
  /* Set baud rate */
  UCSRA = 0x00;
  /* Enable receiver and transmitter */
  UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
  /* Set frame format: 8data, 1stop bit */
  UCSRC = 0b10000110;
  
  UBRRH = (unsigned char)(ubrr>>8);
  UBRRL = (unsigned char)ubrr;
}

/* Read ANALOG inputs */
void analog(unsigned char channel) {
//-- funktioniert--  
                  }

/* Read DIGITAL inputs */
int digital(void)  {
//-- funktioniert--  
          }

/* action finction */
 int action ()
{    
    char i=0;
    result[0]=0;
  
  for(i=0;i<10;i++) {result[i]=result[i+1];}
  result[8]='\0';

    for(unsigned char zar=0;zar<13;zar++)   {
        
            if(!(strcasecmp(result,masiv[zar])))
                {
                switch(zar)  {
                case 0:PORTA|=0b00001000;break;
                case 1:PORTA|=0b00000100;break;
                case 2:PORTA|=0b00000010;break;
                case 3:PORTA|=0b00000001;break;
                case 4:PORTA&=0b11110111;break;
                case 5:PORTA&=0b11111011;break;
                case 6:PORTA&=0b11111101;break; 
                case 7:PORTA&=0b11111110;break;
                case 8:analog(4);break;
                case 9:analog(5);break;
                case 10:analog(6);break;
                case 11:analog(7);break;
                case 12:digital();break;
                      }          
                }
                        }
    for(unsigned char per=0;per<10;per++)
      {result[per]='\0';}                                            
    SREG|=0b10000000;              
    test=0;
    return 0;        
}
  
/*  UART Recieve Interrupt */              
ISR(USART_RXC_vect)
{   
  result[u++]=UDR;
  
  if(u==9)       {

  result[9]='\0';
  u=0;
  SREG&=0b01111111;
  var = eeprom_read_byte ((const uint8_t *)(0x00));
  if(result[0]==var) 
    {
    PrintLine();
    test=1;
    UCSRA&=0b01111111;
    return;
    }
    
  SREG|=0b10000000;
            }    
  UCSRA&=0b01111111;
  return 0;
}

/*  UART Receive */  
unsigned char UART_Receive()
{
  if (UCSRA & 0b10000000)
    return UDR;
  else
    return 0;
}

/*  UART Transmit */
void UART_Transmit(unsigned char Data)
{
  
  /* Wait for empty transmit buffer */
  
  while ( !( UCSRA & (1<<UDRE)) ){}
  /* Put data into buffer, sends the data */
  UDR = Data;
}
/**************** M A I N ******************/
int main(void)
{
  eeprom_is_ready();
  eeprom_write_byte ((uint8_t *)(0x00), (uint8_t)(target));
  PORT_Init();
  USART_Init (MYUBRR);
  test=0;
  PrintLine();
  sei();
    
    while(1){
        if (test!=0)
          {
          action();
          test=0;
          }
        }
  return 0;        
}

Die Software funktioniert soweit eigentlich. Ansprechen bestimmter 
Teilnehmer und die Steuerbefehle funktionieren. Werden jedoch mehr oder 
weniger als 9 Zeichen gesendet, hängt sich der Controller komplett auf 
und nimmt keine Befehle mehr an. Es bleibt nur der Reset. Das Problem 
ist, dass der Fehlerfall auch eintritt, sobald die Leitung zum PC 
getrennt wird. Der offene Eingang (ca. 2cm Leiterbahn bis zum 
Controller) reicht aus um falsche Steuerbefehle zu erzeugen. Selbst 
Pulldown-Widerstände änderten daran nichts. Jetzt wollte ich 
software-seitig versuchen diese Fehler zu ignorieren, aber alle Versuche 
sind bis jetzt gescheitert. Nach meinem Verständnis sollte das Programm 
auf Befehle, die nicht genau 9 Zeichen haben, eigentlich nicht 
reagieren. Wo liegt der Fehler?

[STK500-Besitzer (Gast)]

Kommentier den Code einfach mal vernünftig - vielleicht kommst du dann 
selber auf den Fehler.

[STK500-Besitzer (Gast)]

Du solltest einfach noch ein Timeout einbauen.

[Otto (Gast)]

Die Schleife sollte auch verlassen werden:

a) wenn es mehr als 9 Zeichen sind (bisherige Botschaft wird verworfen)
b) durch einen Timeout (s.o.)

Otto

[Karl H. (kbuchegg)]

Und PS:

Kannst du mir mal erklären, was dieser Blödsinn
>   SREG&=0b01111111;
hier sein soll?

[Karl H. (kbuchegg)]

Andreas W. schrieb:

> Werden jedoch mehr oder
> weniger als 9 Zeichen gesendet, hängt sich der Controller komplett auf
> und nimmt keine Befehle mehr an. Es bleibt nur der Reset.

das verwundert nicht wirklich, wenn ...

ISR(USART_RXC_vect)
{   
  result[u++]=UDR;
  
  if(u==9)       {

  result[9]='\0';
  u=0;
  SREG&=0b01111111;
  var = eeprom_read_byte ((const uint8_t *)(0x00));
  if(result[0]==var) 
    {
    PrintLine();
    test=1;
    UCSRA&=0b01111111;
    return;
    }
    
  SREG|=0b10000000;
            }    
  UCSRA&=0b01111111;
  return 0;
}

... deine einzige Protokollvereinbarung darin besteht, dass jeweils 9 
Zeichen zu einem Befehl zusammengefasst werden. Das ist untauglich um 
auch nur den einfachsten Fehler abzufangen bzw. neu zu synchronisieren.


PS: Das hast du nicht besonders schlau gemacht, dass du im ersten 
Zeichen die 'Adressierung' der jeweiligen Karte untergebracht hast. 
Besser wäre es gewesen, wenn du als erstes Zeichen ein immer gleiches 
Zeichen benutzt hättest, welches in den restlichen Kommandos nicht 
vorkommt. Denn dann hättest du hier in der Empfangsroutine vereinbaren 
können, dass wenn immer dieses Zeichen hereinkommt, ein neues Kommando 
beginnt. Dann sammelst du solange Zeichen bis
* das allen Kommandos gemeinsame Abschlusszeichen 'E' eintrifft
* oder 9 Zeichen beisammen sind.

Und natürlich: Siehst du beim Empfänger dieses speziell vereinbarte 
Startzeichen, dann wird sofort alles bisher empfangene verworfen und die 
Sammlerei von Buchstaben zu einem Kommando beginnt wieder von vorne.

Kriterium für die Auswertung sind
* ist das erste Zeichen im String das von dir vereinbarte Sonderzeichen?
* ist das letzte Zeichen im String ein 'E'?
* Hat der String eine komplette Länge von 9 Zeichen?
nur dann, wenn all diese Kriterien erfüllt sind, dann kann es sich um 
ein gültiges Kommando handeln.
Du holst dir aus dem String von der 2. Position den Empfänger raus und 
vergleichst mit dem eigenen Empfänger
Und wenn auch das noch übereinstimmt, dann holst du dir aus dem String 
den Kommandoanteil raus und wertest ihn aus.

Und dann kannst du auch nach Belieben das Kabel abziehen und wieder 
anstecken, ohne dass etwas durcheinander kommt.

[Andreas W. (a-w)]

Zunächst mal Danke für die schnellen Antworten.
Das Programm war wie schon gesagt eine Demosoftware. Der Teil mit dem 
UART-Interrupt ist original. Ursprünglich streikte die Software schon, 
sobald das erste Zeichen für die Adresse nicht stimmte. Das konnte ich 
aber beheben. Es blieb nur der Fehler mit Befehlen größer/kleiner 9 
Zeichen.
Ich dachte im Abschnitt der UART-Interrupt muss dazu nur noch die 
Abfrage eingebaut werden, dass wenn weniger als 9 Zeichen kommen nichts 
gemacht wird außer das Resultat-Array zu leeren und u=0 zusetzen. Habe 
ich auch erfolglos probiert.

Prinzipiell ist die Auswertung doch nicht schlecht. Es wird als erstes 
geprüft, ob die Adresse stimmt und dann der Rest weitergeprüft. Ob ein 
Sonderzeichen oder ein beliebiges anders Zeichen als erstes geprüft wird 
ist egal.
Die Befehlslänge mit 9 Zeichen wird auch abgefragt.
Problematisch habe ich nur gesehen, dass der "Gegenfall" nicht 
abgesichert wird. Das bei weniger als 9 Zeichen das Resultat-Array 
geleert und u Null gesetzt wird, damit alles für das Empfangen neuer 
Zeichen vorbereitet ist.

> result[u++]=UDR;

 füllt sich ja mit jedem empfangen Zeichen. Bei 9 Zeichen mit richtiger 
Adresse wird der Befehl ausgewertet und das Array gelöscht. Besteht der 
Befehl nur aus 3 Zeichen, füllt sich das Array mit 3 Zeichen und es 
passiert nichts. Es wird auch nichts gelöscht. Damit bleiben 3 Zeichen 
im Array und u=2. Kommt jetzt ein richtiger Befehl mit 9 Zeichen, dann 
werden die ersten 6 Zeichen übernommen, damit ist u=9 und Befehl wird 
ausgewertet und das Resultat-Array gelöscht. Und es werden die 
restlichen 3 Zeichen des eigentlich richtigen Befehls gleich wieder 
eingelesen. Somit kommt kein richtiger Befehl mehr an.

Ich habe es probiert und nach zu kurzen Befehlen solange die Adresse als 
einzelne Zeichen gesendet, bis wieder eine Antwort (neue Zeile im 
Hyperterminal)kam, da die Adresse stimmte und genau 9 Zeichen vorhanden 
waren. result und u wurden gelöscht, sodass richtige Befehle wieder 
angenommen wurden.

Da bei 9 Zeichen alles wieder zum Empfangen zurückgesetzt wird, muss nur 
das Detektieren von zu wenige empfangenen Zeichen in einem bestimmten 
Zeitraum gemacht werden. Timeout ist da das richtige, aber ich weiß 
nicht, wie und wo ich das unterbringen muss. Timeout wäre ja ein 
Interrupt im UART-Interrupt.
Das geht schon nicht, weil mit

> SREG&=0b01111111;

 die Interrupts vorübergehend ausgeschalten werden. Wobei ich mich auch 
schon gefragt habe wozu das gut sein soll.

Ich werde mal nach Infos stöbern und versuchen den Timeout einzubauen. 
Wäre nett wenn mir jemand hier vielleicht direkt ein Tipp geben könnte, 
wie man das macht.
Im Prinzip muss ich einen Interrupt-Timer bauen, den ich aktiviere 
sobald etwas empfangen wird. Ist der Timer abgelaufen und noch kein 
neuntes Zeichen da, wird der Befehl verworfen. Umgekehrt muss der Timer 
zurückgesetzt werden, sobald das neunte Zeichen empfangen wurde.