PC über USART auf MC und zurück

[flo (Gast)]

Hallo,

hätte da mal ne Frage versuch gerade mittels Atmega8535 über 
Hyperterminal ein ASCII-Zeichen auf den Controller zu schicken und diese 
möchte ich wieder auf dem Hyperterminal ausgeben.
Hab leider keine Ahnung was falsch läuft.
Gruß Flo.

#define F_CPU    4000000L  // Taktfequenz
#define BAUD     9600L    // Baudrate
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <stdlib.h>
#include <util/delay.h>
#define MYUBRR    ((F_CPU)/((BAUD)*16L)-1) // Uebergabewert
#define PORTC_OUT  DDRC = 0xff;
void Portinit(void)
{
  PORTC_OUT;
}
void UARTinit(void)
{
  UBRRH=(unsigned char)(MYUBRR>>8);
  UBRRL=(unsigned char) MYUBRR;

  UCSRC |= (1<<URSEL)|(3<<UCSZ0);  // Asynchron 8N1
  UCSRB |= (1<<TXEN)|(1<<RXEN);  // UART TX und RX einschalten
}
void uart_putc(unsigned int c)
{
    while (!(UCSRA & (1<<UDRE))); // warten bis Senden moeglich
    UDR = c;                      // sende Zeichen
}
void Usart_Rx(void)
{
    while (!(UCSRA & (1<<RXC)))  // warten bis Zeichen verfuegbar
  {
    uart_putc(UDR);   // Zeichen zurück senden
    PORTC ^= 0xff;   // PORTC toggeln
  }
}
int main(void)
{
  Portinit();
  UARTinit();
  while(1)
  {
    Usart_Rx();
  }
  return(0);
}

[BennyS (Gast)]

  while (!(UCSRA & (1<<RXC)))  // warten bis Zeichen verfuegbar
  {
    uart_putc(UDR);   // Zeichen zurück senden
    PORTC ^= 0xff;   // PORTC toggeln
  }

Solang kein Zeichen verfügbar ist läuft die while-Schleife durch, wenn 
dann einskommt springt sie wieder raus.

Nimm mal die { und } weg bzw. den Code dazwischen dannach. Damit er in 
der Schleife bleibt bis er etwas empfangen hat und dann den Code 
abarbeitet.

  while (!(UCSRA & (1<<RXC)))  // warten bis Zeichen verfuegbar
  // { Nich nötig da die While-Schleife hier nur solang durchlaufen soll 
  // } bis was passiert also quasi warten soll
  uart_putc(UDR);   // Zeichen zurück senden
  PORTC ^= 0xff;   // PORTC toggeln

[flo (Gast)]

Wenn doch alles nur so einfach wär.
Vielen Dank, so gehts natürlich.
Gruß flo.
ps: später vielleicht mehr.

[Rahul D. (rahul)]

Das Semikolon nach dem While sollte man nicht vergessen...

while (!(UCSRA & (1<<RXC)));  // warten bis Zeichen verfuegbar

[flo (Gast)]

Wie Semikolon nach einem While???

[Rahul D. (rahul)]

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

[Karl heinz B. (kbucheg)]

Schreib das ; in eine neue Zeile. Dann sieht man es besser

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

Wenn du abolut klarstellen willst, dass das interessante
an der while-Schleife einzi gund alleine in der
Bedinung zu suchen ist und der Schleifenrumpf leer
ist, schreibe ich auch mal gerne

  while (!(UCSRA & (1<<RXC)))
  {
    // do nothing
  }

Jetzt kann nur noch ein Blinder nicht mitbekommen
was da abläuft.

[Rahul D. (rahul)]

>Schreib das ; in eine neue Zeile.

Dann sieht es aber sehr verloren aus... ;-)
Ich mache das Semikolon immer ans Ende einer Zeile.
Wenn man noch eine Anweisung hinter dem while(..) stehen hat, kommt da 
ja auch das Semikolon ans Ende. Sobald mehr als eine Anweisung folgt, 
braucht man ja eh die geschweiftenen Klammern. Die fangen dann in einer 
neuen Zeile an.
Das habe ich mir beim Pascal-Programmieren angewöhnt...
Ist aber wie immer eine Anschauungssache...

[Karl heinz B. (kbucheg)]

> Wenn man noch eine Anweisung hinter dem while(..) stehen hat, kommt da
> ja auch das Semikolon ans Ende.

Wenn ich noch eine Anweisung hinter dem while habe, kommt
die ebenfalls bei mir in eine neue Zeile.

  while( xyz )
    bla-bla;

Übrigens: Das ; alleine ist eine eigene Anweisung. Eine leere 
Anweisung.
Das ; hat in diesem Fall nichts mit dem while zu tun. Keine der
Kontrollstrukturen wird in C mit einem ; abgeschlossen.

[Rahul D. (rahul)]

Wie gesagt: Ich hab mir die Schreibweise in meiner Schulzeit (ewig her) 
mit dem Programmieren in Pascal angewöhnt....

[Karl heinz B. (kbucheg)]

Wie du schon sagtest. Ist Anschauungssache

[flo (Gast)]

ist es so auch Okay?

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

Oder eher sehr schlechter Programmierstiel.

[Karl heinz B. (kbucheg)]

Na ja.
Die Frage ist, wie schreibst du das ganze, wenn in den {} eine
Anweisung drinnen ist?

Ich schreibs so

  while( xyyz ) {
    abcd;
  }

Konsequenterweise lautet das ganze dann

  while( xyz ) {
  }


Andere schreiben ersteres so

  while( xyyz )
  {
    abcd;
  }

folgerichtig schreiben sie dann

  while( xyz )
  {
  }

Das wichtigste bei Formatierregeln ist: Es ist weniger wichtig,
welchen Stil du benutzt. Viel wichtiger ist, dass du den Stil
konsequent durchziehst und sowenig Ausnahmen wie möglich machst.