UART AT90CAN128-16AU von ALVIDI

[Jens (Gast)]

Hallo,

ich habe ein Problem mit dem UART des ALVIDI AT90CAN128-16AU Board.
Ich kann Daten an den Controller richtig versenden, aber keine vom
Controller zum PC. Manchmal kommt etwas an, aber nur falsche Zeichen.
Ich kann zwar mit dem Oszilloskop auf der Senseleitung Signale sehen,
die sind jedoch sehr kurz. Ich hab mich im Datenblatt und anderen Foren
bei ähnlichen Problemen eingelesen und bin der Meinung, dass der UART 
richtig
eingestellt ist.
Das ist der gesamte Code für den UART. Wenn ich ein Zeichen senden 
möchte,
rufe ich nur die Funktion send_char('c'); auf.
Da das empfangen richtig funktioniert, müsste die Baudrate eigentlich 
richtig sein.
Ich bin mit meinem Latein am Ende. Mit den LED's auf dem Board konnte 
ich sehen, dass die Funktion send_char(); vollständig abgearbeitet wird.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include "uart.h"
#include "value.h"



/***** ISR USART RECEIVE ****************************************************/
ISR(USART0_RX_vect){
  *write = UDR0;        // Copy UDR0 to the ringbuffer 
  write++;          // Increment the write pointer for the next receive
  if(write == buffer+max){  // To start over if the end of the buffer is arrive
    write = buffer;      // Set the pointer
  }
}
/****************************************************************************/



/***** FUNKTION UART_INIT ***************************************************/    
void uart_init( void ){
  UBRR0H = 0x00;//(unsigned char)(BAUDRATE>>8);     //Set baud rate
  UBRR0L = 0x33;//(unsigned char)BAUDRATE;
  UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);  //Enable receiver and transmitter
  UCSR0C |= (1<<UCSZ01)|(1<<UCSZ00);      //Set frame format: 8data, 1stop bit

  read = buffer;      //Initialization of the pointer
  write = buffer;
}  
/****************************************************************************/



/***** FUNKTION UART_BYTE_AVAILABLE *****************************************/ 
uint8_t uart_byte_available(void){
  if(write != read)        
    return 1;    //Return True, if the two pointer aren't equal and
  else         //a byte is available
    return 0;    //Return false, if the two pointer are equal
}
/****************************************************************************/



/***** FUNKTION UART_GET_BYTE ***********************************************/   
uint8_t uart_get_byte(void){
  uint8_t databyte = 0;
  if(write != read){        //If a byte is available
    databyte = *read;       //Readout the Ringbuffers 
    read++;            //Increment the read pointer                 
    if(read == buffer+max){    //To start over if the end of the buffer is arrive  
      read = buffer;
    }
  }
  return databyte;
}
/****************************************************************************/



/***** FUNKTION SEND_CAHR ***************************************************/ 
void send_char(unsigned char i){
  while(!(UCSR0A & (1<<UDRE0)));//Wait for empty transmit buffer
  UDR0 = i;            //Put data into buffer -> sends the data
}
/****************************************************************************/



/***** FUNKTION SEND_STRING *************************************************/ 
void send_string(char *string){
    while(*string != 0){        //display the string up to the endlabel
        send_char(*string);      //give the several character to the send_char function
    string++;          //increment the string Pointer
    }
}
/****************************************************************************/



/***** FUNKTION SEND_INT ****************************************************/ 
void send_int(unsigned int zahl){
  char string[10];      //declaration of char array to save the string
  itoa(zahl, string, 10);    //convert integar -> string
  send_string(string);    //send the string
}
/****************************************************************************/

[cskulkw (Gast)]

Hallo Jens,

auf den ersten Blick sehe ich auch keinen Fehler.

Aber alternativ zum

Jens schrieb:
> while(!(UCSR0A & (1<<UDRE0)));//Wait for empty transmit buffer


kannst Du mal
while(!(UCSR0A & (1<<TXC0)); ausprobieren.

// wenn 1 dann zurücksetzen.
    USCR0A |= (1<<TXC0); // Datenblatt unter UART-Discriptionregister.

Dieses Flag muss bewußt mit 1 beschrieben werden, um es zu löschen.

Hier solltest Du Deine LED toggeln lassen, damit Du auf dem Scope etwas 
sehen kannst, dass die Bytes alle gesendet worden sind. Oder Du zählst 
einen PORT hoch (inkrementieren) und gibst ihn LEDs aus. Anhand derer 
kannst Du dann nachzählen (binär natürlich) wie viele Bytes tatsächlich 
gesendet worden sind.

Ansonsten empfehle ich Dir die Anschaffung eines Debuggers. So ein 
Dragon kostet nur 50-60 Euro. Die Dinger sind eine große Hilfe.

Wie Du festgestellt hast, dass Du korrekt vom PC empfängst?

Mit welcher Baudrate und Quarzfreguenz arbeitest Du?

[MWS (Gast)]

So ein Verhalten wäre erklärlich, wenn nach dem send_char() ein sleep 
käme. Und im Falle daß ein Bootlader installiert ist, wäre es sicher 
besser die Register beim Init nicht zu verodern. 19.2kB@16MHz ? Fuses 
richtig gesetzt ?

[Jens (Gast)]

Danke für die Antworten.

Ich arbeite mit einer Baufrate von 19200 bei einer Frequenz von 16MHz. 
Im Hauptprogramm wird permanent abgefragt, ob ein Byte angekommen ist. 
Ich frage dann nach den übertragenen Befehlen ab und setze bei Erfolg 
eine LED. Ausserdem wird dann ein Pulsbreitenmuster an einem Ausgang 
geändert. So weit
funktioniert alles. Bei einem Befehl soll allerdings eine Antwort 
gesendet werden, die jedoch nicht ankommt.
Die Fuse-Bits hab ich im Anhang als Bild engehängt. Ich glaube bei dem 
Board wird ein Bootloader verwendet, allerdings weiß ich nicht gut 
darüber bescheid. Welche Register sollte ich denn nicht ändern?

@cskulkw: Ich habe es so ausprobiert:

while(!(UCSR0A & (1<<TXC0)));
UDR0 = i;
UCSR0A |= (1<<TXC0);

hat allerdings nicht geholfen. Das Programm läuft nicht weiter. Es 
scheint als wäre das eine Endlosschleife.

[cskulkw (Gast)]

Hallo Jens,

wenn Du meinen Vorschlag benutzt, dann mußt Du erst die Daten in das 
UDR0 laden und dann auf das Gesendet-Bit prüfen.

UDR0 = i;
while(!(UCSR0A & (1<<TXC0)));
UCSR0A |= (1<<TXC0);

Ich gebe zu, daß ich daran nicht gedacht hatte. Wenn nach der 
Initialisierung noch nichts gesendet worden ist, dann wird das Flag noch 
nicht gesetzt sein. Insofern erklärt sich mir die Endlosschleife.

Bei jedem erfolgreichen Durchlauf würde ich eine Variable mitzählen 
lassen und auf einem Port ausgeben, wenn Du das umsetzen kannst.

...

[MWS (Gast)]

Jens schrieb:
> Welche Register sollte ich denn nicht ändern?

Ändern schon, ich wollte nur darauf hinweisen, daß das hier:

  UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);
  UCSR0C |= (1<<UCSZ01)|(1<<UCSZ00);

bei einem Bootlader gefährlich ist, denn es bleiben vom BL ggf. gesetzte 
Registerinhalte in UCSR0B/0C durch das "oder" erhalten.

Wenn man die Inhalte genau bestimmen möchte, dann würde man nur "=" ohne 
"|" schreiben.

[Jens (Gast)]

Die Endlosschleife ist mit der Änderung weg, aber es kommt auch so 
nichts an. Das Mitzählen ist nur sehr begrenzt möglich. Ich hab nur vier 
LED's zur Verfügung.

[Jens (Gast)]

@MWS:
Ach das hast du damit gemeint. Ich war mir da nicht ganz sicher. Ich hab 
die Variante ohne | auch schon ausprobiert. Es blieb aber bei dem selben 
Ergebnis.

[MWS (Gast)]

Jens schrieb:
> Ich kann Daten an den Controller richtig versenden

Das impliziert zwar, daß die Registereinstellungen passen, nur wenn ein 
Bootlader drauf ist, dann würde ich schon sichergehen wollen, daß jedes 
der beteiligten Register neu initialisiert wurde, da gehört auch UCSR0A 
und darin U2X0 und MPCM0 dazu.

Wie umfangreich ist denn der gesamte Code ? Meist ist der Fehler im 
nicht geposteten Teil.

[Jens (Gast)]

Da geb ich dir Recht. Ich poste dann mal das komplette Hauptprogramm.
Ich werd die Register mal setzen und poste dann das Ergebnis.

Der Controller soll bei den Befehl "con" alle Variablen über die UART 
senden. Der Rest des Codes funktioniert. Der Controller gelangt auch zu 
den Aufrufen der send_char() Funktionen.

/***** MAIN ******************************************************************/
int main(void){ 

  /***** The first initalization *****************************/
  DDRB = 0xFF;  //Port B is configured as an output port
  DDRE = 0xFF;  //Port E is configured as an output port
  DDRF = 0xFF;  //Port D is configured as an output port

  //open initalization funktions
  initialize_Values();
  uart_init();
  dac_init();
  timer1_init();  
  timer2_init();
  timer3_init();

  sei(); //enable - globel interrupts

  //set DA output voltage  
  dac_write((uint16_t)((((uint32_t)vlevel)*4095)/10000),DA_HIGH_VOLTAGE);
  dac_write((uint16_t)((((uint32_t)plevel)*4095)/100),DA_LINKAGE_POSITION);

  //uart acknowledgement disabled
  flag.uart_ack = 0;
  
  uint8_t i = 0;
  inout_work_indication();
  /***********************************************************/
    PORTF = 0b11111111;
    char dlm = '.';

  while(1){

    if(uart_byte_available()){
      uart_command[i] = uart_get_byte();

      if(flag.uart_ack){  //Uart acknowledgement ?
        send_char(uart_command[i]);
      }

      if(uart_command[i] == dlm){
      
        uint8_t count_1;
        uint8_t count_2;
        uint8_t j = 1;

        for(count_1 = 0 ; (uart_command[count_1] != ':' && uart_command[count_1] != dlm) ; count_1++){
          signal[count_1] = uart_command[count_1];
        }  //end for      
        
        if(uart_command[count_1] != dlm){
          count_1++;
          for(count_2 = 0 ; uart_command[count_2 + count_1] != dlm ; count_2++){
            if(j){
              value = uart_command[count_2 + count_1] - 48;
              j = 0;
            }
            else{
              value = (value * 10) + (uart_command[count_2 + count_1] - 48); 
            }
          }  //end for
        }  //end if
        j = 1;

        if(flag.uart_ack){  //Uart acknowledgement ?
          send_char('\n');
          send_char('\r');
        }

        /***** UART-COMMANDS ************************************/
        //Voltage High Values
        if(equation_string(signal,"vlevel") && (vlevel_min <= value) && (value <= vlevel_max)){
          vlevel = value;
          dac_write((uint16_t)((((uint32_t)value)*4095)/10000),DA_HIGH_VOLTAGE);
        }
        if(equation_string(signal,"plevel") && (plevel_min <= value) && (value <= plevel_max)){
          plevel = (uint8_t)value;
          dac_write((uint16_t)((((uint32_t)value)*4095)/100),DA_LINKAGE_POSITION);
          inout_work_indication();
        }

        //Theoretical pulses and speed
        if(equation_string(signal,"tpulse") && (tspeed_pulse_min <= value) && (value <= tspeed_pulse_max)){
          theoretical_speed.pulse = value;
          timer1_init();
        }
        if(equation_string(signal,"tspeed") && (tspeed_speed_min <= value) && (value <= tspeed_speed_max)){
          theoretical_speed.speed = value;
          timer1_init();
        }

        //Ground pulses and speed
        if(equation_string(signal,"gpulse") && (gspeed_pulse_min <= value) && (value <= gspeed_pulse_max)){
          ground_speed.pulse = value;
          timer3_init();
        }
        if(equation_string(signal,"gspeed") && (gspeed_speed_min <= value) && (value <= gspeed_speed_max)){
          ground_speed.speed = value;
          timer3_init();
        }

        //PTO pulses and speed
        if(equation_string(signal,"ppulse") && (pspeed_pulse_min <= value) && (value <= pspeed_pulse_max)){
          pto_speed.pulse = value;
          timer2_init();
        }
        if(equation_string(signal,"pspeed") && (pspeed_speed_min <= value) && (value <= pspeed_speed_max)){
          pto_speed.speed = value;
          timer2_init();
        }

        //In-Work / Out-Work Indication
        if(equation_string(signal,"iowork") && (iowork_min <= value) && (value <= iowork_max)){
          iowork = (uint8_t)value;
          inout_work_indication();
        }

        //connect -> Send all values
        if(equation_string(signal,"con")){
        //PORTF |= (1<<PF0);
          send_int(theoretical_speed.speed);
          send_char(':');
          send_int(theoretical_speed.pulse);
          send_char(':');
          send_int(ground_speed.speed);
          send_char(':');
          send_int(ground_speed.pulse);
          send_char(':');
          send_int(pto_speed.speed);
          send_char(':');
          send_int(pto_speed.pulse);
          send_char(':');
          send_int(plevel);
          send_char(':');
          send_int(vlevel);
          send_char(':');
          send_int(iowork);
          send_char(':');
        }

        //enable - disable uart acknowledgement
        if(equation_string(signal,"ack")){
          flag.uart_ack = !flag.uart_ack;  
        }
        /*******************************************************/

        /***** DELET BUFFER ************************************/
        for(uint8_t k=i+2 ; k != 0 ; k--){
          uart_command[i] = 0;
          i--;
        }
        count_1++;
        for( ; count_1 != 0 ; count_1--){
          signal[count_1-1] = 0;
        }
        /*******************************************************/

        i = 0;
      }
      else i++;
  
    }  //end if(uart_byte_available)
      
  }  //end while

}  //end main

[MWS (Gast)]

Daraus ist nicht viel zu erkennen, außer den paar UART-Ausgabeaufrufen.
Seit wann hast Du denn das Problem ? Sieht mir doch wie einigermaßen 
fortgeschrittener Code aus, der zudem das UART benötigt, das muss Dir 
doch schon länger aufgefallen sein.

Die HW-Seite sollte man zuerst überprüfen, da gibt's 2 Jumper am UART, 
sind die richtig gesteckt ? Auch geht das UART an den ISP, da ist auch 
nichts verbunden ?

Ich würde versuchen ob die Kommunikation über den PC ohne Controller 
klappt. Schau Dir den Schaltplan zu dem Modul an. Man könnte über einen 
Kontakt des Jumpers an Out des MAX3232 wieder auf den anderen Kontakt 
des Jumpers an In zurückschleifen. Damit sieht man dann im Terminal ob 
die Verbindung PC/MAX und zurück ok ist.

Auch wär's sinnvoll einen abgespeckten Code zu schreiben, der nur den 
Fehler des UART's zeigt und dann eine compilierbare Version hier 
einstellen, sonst ist das wie im Trüben fischen.

[Jens (Gast)]

Der Fehler ist mir erst seit ein paar Tagen bekannt. Ich habe aber noch 
keine funktionierende Version gehabt, da ich es erst vor kurzem 
fertiggestellt habe.
Die Register habe ich jetzt wie folgt geändert.

void uart_init( void ){
  UBRR0H = 0x00;//(unsigned char)(BAUDRATE>>8);     //Set baud rate
  UBRR0L = 0x33;//(unsigned char)BAUDRATE;
  UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(0<<TXCIE0)|(0<<UDRIE0)|(0<<RXB80)|(0<<TXB80)|(0<<UCSZ2);  //Enable receiver and transmitter
  UCSR0C = (0<<UMSEL0)|(0<<UPM00)|(0<<UPM01)|(1<<UCSZ01)|(1<<USBS0)|(1<<UCSZ00)|(1<<UCSZ01)|(0<<UCSZ02);      //Set frame format: 8data, 1stop bit
    UCSR0A = (0<<U2X0)|(0<<MPCM0)|(0<<UDRE0);
  read = buffer;      //Initialization of the pointer
  write = buffer;
}

Die Jumper sind richtig gesetzt, das habe ich schon mehrmals geprüft. 
Den Programmer ziehe ich immer wieder ab, sodass am ISP ebenfalls nichts 
verbunden ist.
Den Code werde ich mal auf ein Minimum herabsetzen. Den letzten Teil 
habe ich nicht verstanden. Ich soll quasi die TxD und RxD Leitungen 
kurzschliessen, aber die Verbindung über das RS232-Kabel bestehen 
lassen, damit ich das abgeschickte Zeichen im Terminal auch empfange?

[MWS (Gast)]

Jens schrieb:
> Den letzten Teil
> habe ich nicht verstanden. Ich soll quasi die TxD und RxD Leitungen
> kurzschliessen, aber die Verbindung über das RS232-Kabel bestehen
> lassen, damit ich das abgeschickte Zeichen im Terminal auch empfange?

Ja, genau. Ein Loopback-Test. Ich fand 2 Schaltpläne, einmal mit 
externen Ram, einmal ohne, bei beiden sind es aber R12/R13 470 Ohm, die 
vom MAX auf die Jumper gehen, verbindet man diese an den Jumpern 
miteinander, so müssen eingegebene Zeichen am Terminal erscheinen. Wenn 
das nicht klappen würde, braucht man an der SW nicht groß weitersuchen.

Hab' mir die Fusesettings von oben nochmal angesehen, wenn Du nichts 
verändert hast, dürftest Du sowieso keine Probleme mit dem Bootlader 
bzw. mit Überresten davon bekommen, da der ausgeschaltet ist, BOOTRST = 
1.

[Jens (Gast)]

Die Fuse Bits sind genauso wie im Bild gesetzt.
Ich habe jetzt einfach die beiden Kabel RxD und TxD vom RS232-Kabel das 
am PC angeschlossen ist kurzgeschlossen. Die abgesendeten Zeichen kamen 
nicht an. Allerdings bin ich mir jetzt nicht sicher ob ich es richtig 
gemacht habe.
Ich habe HTerm verwendet. Im Bild sind die Einstellungen zu sehen.

[MWS (Gast)]

Jens schrieb:
> Allerdings bin ich mir jetzt nicht sicher ob ich es richtig
> gemacht habe.

Das Zusammenschließen oder die Benutzung von HTerm ?

Aber mir ist da auch ein faux-pas unterlaufen, sorr. Hab's gerade 
gemerkt als ich die Zeichnung für Dich gemacht hab'. Nicht die 
Widerstände untereinander verbinden, sondern so wie in der Zeichnung.

Konnte aber nix passieren, außer daß es halt nicht geht.

[Jens (Gast)]

Ok dann hab ich es richtig gemacht. Da kam nichts am Terminal an.

[MWS (Gast)]

Jens schrieb:
> Ok dann hab ich es richtig gemacht. Da kam nichts am Terminal an.

Einstellungen HTerm alle ok ?
Würd' mir zyklisch immer nur ein Zeichen schicken lassen, außer Du bist 
sicher, daß der Empfang klappt.

Evtl. wär' jetzt ein guter Zeitpunkt die Kabelverbindung PC/µC zu 
prüfen, man kann selbiges auch direkt mit dem Kabel machen, also Brücke 
TX/RX, natürlich ohne angeschlossenen MAX. Sollte das dann gehen, wäre 
der Fehler im oder in der Elektrik zum MAX zu suchen.

Serielles Kabel auch an Pin 34 & 36, DB S. 4 angeschlossen ?

Ich finde die Beschreibung des DB's irreführend, wenn man auf Seite 2 
schaut, steht bei PE0..1 Pin 9 & 10 auch RS232, wobei RS232 da nix zu 
suchen hat, denn das sind die µC-Pins und die haben TTL-Level.

RS232 hat üblicherweise ~ +-12V und ist gegenüber RDX/TXD invertiert, 
genau dafür braucht's ja den MAX.

[Jens (Gast)]

Der Empfang klappt definitiv. Die direkte Brücke am Kabel hab ich auch 
schon getestet. Hat auch nicht geklappt. Mit dem HTerm kenn ich mich 
nicht aus, kann auch ein Bedienungsfehler sein.

Die Anschlüsse am Controller hab ich geprüft, die ist definitiv richtig.

Mit dem Datenblatt hast du Recht, ist ein wenig irreführend. Ich werd 
als nächstes mal das Kabel auf einen Bruch testen. Das kann ich 
allerdings erst morgen machen, da ich kein Messgerät habe.
Ansonsten werde ich mal den zweiten UART ausprobieren.

Vielen Dank, dass du dir die Zeit genommen hast mir zu helfen. Ich werde 
dann morgen berichten.

[Jens (Gast)]

Jetzt funktioniert auch die Datenübertragung vom Controller zum PC. Das 
RS232-Kabel hatte einen Kabelbruch. Nach dem Austausch hat alles 
reibungslos funktioniert.
Vielen Dank an alle, die mir geholfen haben.

[MWS (Gast)]

Besser das Kabel als der Controller ;-)

[Jens (Gast)]

Da hast du Recht.