Korrektes auslesen des USARTs

[Pat K. (c63)]

Hallo zusammen,

habe ein Problem mit folgendem Quellcode:

#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>

extern void uart_init(void);



static inline int
uart_putc (const uint8_t c)
{
  // Warten, bis UDR bereit ist für einen neuen Wert
  while (!(UCSRA & (1 << UDRE)))
  ;

  // UDR Schreiben startet die Übertragung
  UDR = c;

  return 1;
}

static inline uint8_t
uart_getc_wait(void)
{
  // Warten, bis etwas empfangen wird
  while (!(UCSRA & (1 << RXC)))
  ;

  // Das empfangene Zeichen zurückliefern
  return UDR;
}

static inline int
uart_getc_nowait(void)
{
  // Liefer das empfangene Zeichen, falls etwas empfangen wurde; -1 sonst
  return (UCSRA & (1 << RXC)) ? (int) UDR : -1;
}

#endif /* _UART_H_  */

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



#define BAUDRATE 38400UL 

//int a;
volatile unsigned char a = 0x00;

void uart_init()
{
  uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BAUDRATE) - 1);
  
  UBRRH = (uint8_t) (ubrr>>8);
  UBRRL = (uint8_t) (ubrr);
  
  // UART Receiver und Transmitter anschalten
  // Data mode 8N1, asynchron
  UCSRA = (1 << RXC);
  UCSRB = (1 << RXEN) | (1<<RXCIE);
  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

  // Receive-Buffer leeren 
  do
  {
    UDR;
  }
  while (UCSRA & (1 << RXC));

  DDRD |= (1<<PD6);    // PortD als Ausgang deklarieren
  //PORTD = 0x00;   // Ports auf LOW schalten

}


// Einen 0-terminierten String übertragen.

void uart_puts (const char *s)
{
  do
  {
    uart_putc (*s);
  }
  while (*s++);
}



// Interupt wartet, bis Empfangsbit gesetzt wird und führt dann Routine aus

ISR(USART_RXC_vect) 
{
  a = UDR;
  //PORTD ^=(1<<PD6);
  if (a == 1) 
  {
    PORTD |= (1<<PD6);
  }
  else
  {
    PORTD &=~(1<<PD6);
  }

}





int main(void)
{
  
  uart_init();
  sei();
  
  


  while (1) {
    
    while (!(UCSRA & (1 << RXC)));

  }



  return 0;
}

Und zwar sende ich Zeichen mittels VB über die serielle Schnittstelle an 
meinen ATmega8.
In VB befinden sich zwei Buttons, der eine Sendet "1", der andere "0" 
(SerialPort1.Write ("1" & vbCr).
Leider bekomme ich es nicht auf die Reihen, dass PD6 auf High schaltet, 
wenn ich "1" sende und auf Low bei der "0".
Togglen des PD6 funktioniert, sprich die Interrupt Routine wird auch 
ausgeführt.
Mit BASIC läuft es ohne Probleme, nur mit C bekomm ich es einfach nicht 
auf die Reihe.

Für eure Hilfe bedanke ich mich schon mal im Voraus.
mfg
c63

[Roland .. (rowland)]

1 != "1", vermutlich kodiert der Befehl "SerialPort1.Write ("1" & vbCr)" 
die Eins in ASCII.

Versuch im µC Code mal die Abfrage auf

if (a == '1')

zu ändern.

[Pat K. (c63)]

Hi Roland,

danke für die schnelle Antwort.
Leider kein Erfolg.
Hätte auch schon versucht die 1 in Binärschreibweise zu übermitteln, 
leider ohne Resultat :-(

[Roland .. (rowland)]

Hm, und die eingestellte Datenrate ist sicher sowohl beim VB-Programm 
als auch beim µC ident?

[Pat K. (c63)]

Baudrate ist identisch

[Karl H. (kbuchegg)]

Problem Ungelöst schrieb:
> Baudrate ist identisch

Das heißt noch lange nicht, dass die Übertragungsrate korrekt ist. Denn 
die hängt auch von der Taktrate des AVR ab.

Daher wird auch generell gerne der Tipp gegeben.
Bevor du dich an die Übertragung vom PC zum AVR machst, mach erst mal 
die Gegenrichtung: vom AVR zum PC, wobei auf dem PC ein Terminalprogramm 
läuft.
Denn das hat den Vorteil, dass du im Terminalprogramm siehst, was 
eigentlich ankommt, wenn der AVR zb eine ASCII-1 wegschickt. Und das ist 
wiederrum besser, als die umgekehrte Richtung, in der du nur indirekt 
erschliessen kannst, was am AVR ankommt wenn der PC was wegschickt.

Dein erstes Testprogramm sollte also zb lauten ...

int main(void)
{
  uart_init();

  while (1) {
    uart_putc( 'x' );
  }
  return 0;
}

... und solange in deinem Terminalprogramm da nicht lauter 'x' 
auftauchen, brauchst du die Gegenrichtung erst gar nicht versuchen.

Erst dann, wenn das klappt, kannst du soweit sicher sein, dass zumindest 
die technische Komponente der UART Übertragung korrekt abläuft.
Wenn das dann klappt, dann ist dein nächster Milestone, dass du im AVR 
dir einen Empfangscode machst, und dem händisch vom Terminal aus 
"ansteuerst". Wenn dieses dann klappt, dann machst du das ganze von VB 
aus.

Grundprinzip ist es immer: habe so wenig unbekannte Teilsysteme im 
System wie möglich.
Du stehst im Moment mit einem VB Programm da, von dem du nicht weißt ob 
es korrekt ist; mit einem AVR Programm da, von dem du nicht weißt ob es 
korrekt ist; mit einer UART Übertragung, von der du nicht weißt ob sie 
korrekt ist.
Das sind zu viele 'ich weiß nicht, ob das korrekt ist'. Also heißt es 
Teilsysteme eliminieren und erst mal durch 'Von dem und dem Teilsystem 
weiß ich mit Sicherheit dass es korrekt ist' ersetzen.

[Pat K. (c63)]

Thx @ Roland und Karl Heinz für die tolle Unterstützung (y)
Fehler lag in der falschen Baudrate.
Jetzt funktioniert es wie gewünscht.

mfg
c63