merkwürdeges Phänomen

Shit ich habe mich da oben vertan ich habe den Code benutzt.
while()
  {
   if(getchar() == 'h')
       tagesprofil();
  }

Wenn ich in dem Hauptprogramm dies hier vewende:

while()
  {
   if(tasten() == 3)
           tagesprofil();
  }

Dann tut es auch korrekt. Also die Uhr bleibt dann in der
Anzeige(Display) nicht sethen

Ich kenn mich nicht so damit aus, aber von C++ kenne ich ein getch() -
welches auf die Tasteneingabe wartet. Mit if prüfst du einen Wert  -
hier ist es egal, ob der Wert übergeben wurde.

Ja ich ich weiss da nicht weiter. Wie gesagt meine Uhr auf dem Display
läuft da nicht mehr. Nur wenn ich eine Anforderung sende, dass das
Tagesprofil gesendet werden soll, dann läuft die Uhr kurz weiter.
Ich glaube schon dass der Timer da ganz normal arbeitet. Es hängt
möglicherweise mit dem Display zusammen. Hmmmm...

kommt getchar() nicht erst zurück, wenn ein Zeichen empfangen wurde ?
Damit würde Dein System stehen.

Hmmm...ich habe halt deswegen die Funktion getchar() verwendet, weil ich
von der UART auf ein bestimmtes Zeichen warte und dann soll die
entsprechende Aktion ausgeführt werden. In diesem Falle wird das
Tagesprofil gesendet.

Welche Funktion müsste ich dann verwenden um ein Zeichen von der UART
zu empfangen(Controller)?

einfach einen neue Function schreiben.

char rec_char(void)
{
   if((UCSRA & (1<<RXC)));
       return UDR;
   else
       return 0x00;
}

Die Funktion hab ich mal getestet. Funzt nicht!
Wenn ich die Funktion uart_recieve() ausführe und ich sende vom PC aus
ein Zeichen dann hört die UART nicht mehr auf zu empfangen.
Kann ich überhaupt die UART Interrupt so verwenden?

interrupt [USART_RXC] void uart_rx_isr(void)
{
 uart_recieve = UDR;
}

interrupt [USART_TXC] void uart_tx_isr(void)
{
}


unsigned char uart_recieve(void)
{
 while(!(UCSRA & 0x80))
 return UDR;
}

Wenn ich es so mache wie Steffen beschrieben hat, dann tut sich gar
nix.

char rec_char(void)
{
   if((UCSRA & (1<<RXC)));
       return UDR;
   else
       return 0x00;
}

Stimmt der Code wirklich?

Also das mit der UART klappt nach nicht so richtig.
Ich habe mich entschlossen das ganze ohne UART Interrupt zu machen.

unsigned char uart_recieve(void)
{
 while(!(UCSRA & 0x80))
 return UDR;
}

unsigned char uart_transmit(void)
{
 while(!(UCSRA & 0x20))
 UDR = data;
}

Die uart_transmit Funktion tut soweit. Die andere Funktion funktioniert
noch nicht.
Die UART tue ich im Hauptprogramm so initialisieren:
UCSRB = 0x18; //ohne Interrupt //für Interrupt 0xD8 verwenden:
UBRRH = 0;
UBRRL = 0x33;
Was ist in meiner Empfangfunktion falsch?

solltest Du nicht auch noch mitteilen, dass das Zeichen abgeholt wurde?
interrupt [USART_RXC] void uart_rx_isr(void)
{
 uart_recieve = UDR;
 lösche_IRQ_Flag();
}
kenn mich mit Atmel wenig aus.

Steffen löst es mit Polling, es gilt:
entweder pollen oder mit Interrupt

Ich verwende keinen Interrupt. Ich habe zwei Funktionen.

unsigned char uart_recieve(void)
{
 while(!(UCSRA & 0x80))
 return UDR;
}

unsigned char uart_transmit(void)
{
 while(!(UCSRA & 0x20))
 UDR = data;
}

Nur die uart_recieve Funktion tut gar nicht.

warum lässt du die uhr nicht per interrupt aktualisieren?
dann kann das hauptprogramm auf ungestört auf deine anfragen reagieren
und deine uhr läuft ordentlich.

wenn das display ein busy flag hat, dann ist das mit dem schreiben auf
das display auch nicht schlimm. das hauptprogramm muss halt vor jedem
schreiben auf das fertigstellen des kommandos im display warten.
in der isr brauchst du nur auf das display schreiben und eigentlich
nicht warten, bis es fertig ist.

Hmmm..wei meinst du das genau?

Wie müsste die uart_recieve() FUnktion korrekt aussehen?

Ich lasse doch bei mir die Uhr per Interrupt aktualisieren.
Ich verwende den Timer Compare. Und da wird meine Uhrzeit aktualisiert.

Deshalb verstehe ich das nicht was hans dieter da geschrieben hat.

Ich hab ein Problem mit dem Empfangen von der UART.
Die uart_recieve Funktion tut nicht. Senden funktioniert ja.
Muss ich bei der uart_recieve Funktion irgend ein Bit löschen?
Als Controller verwende ich den ATMEGA8535

unsigned char uart_recieve(void)
{
 while(!(UCSRA & 0x80))
 return UDR;
}

unsigned char uart_transmit(void)
{
 while(!(UCSRA & 0x20))
 UDR = data;
}

schau mal im Datenblatt, ob das Lesen des UDR das Bit7 (RXC) im UCSRA
wieder zurücksetzt, oder ob Du das selbst machen musst.

Super! Ich kann jetzt von der UART senden und empfangen.
Leider funzt es noch als nicht zu 100% korrekt.
Ich habe in meiner Main in der while Schleife drei if Bedingungen
eingebaut.

        if(uart_recieve() == 'A')
         {
          test();
         }
        if(uart_recieve() == 'B')
         {
          uart_transmit('E');
         }
        if(uart_recieve() == 'C')
         {
          tagesprofil();
         }
Wenn ich das Zeichen 'A' an den Controller sende dann sendet der
Controller auch --> test();

Wenn ich das Zeichen 'B' oder 'C' sende dann sendet der Controller
da nix.Überhaupt kein Zeichen.
nur wenn ich wieder das Zeichen 'A' sende dann tut es.
Wenn ich das Zeichen'B' sende warum tut sich da nichts?

Ich habe mal das Register UCSRA in der while Schleife ausgelesen.
Am Anfang steht dort 0x20 wenn ich das Zeichen 'A' drücke dann
erscheint der HEX Wert 0x60. Warscheinlich muss man das TxC Register
wieder löschen oder? Wie kann ich denn von dem UCSRA Register das 7Bit
löschen?

//Funktionen zur UART
void uart_transmit(unsigned char data)
{
 while(!(UCSRA & 0x20));
 UDR = data;
}

unsigned char uart_recieve(void)
{
 while((UCSRA & 0x80))
 return UDR;
}

In den beiden Bilder befindet sich die genauere Beschreibung der UARt
Register vom ATMEGA8535.