Aufbau einer Kommunikation zwischen pc und USART0

[Luffy M. (monkeydluffy)]

Hallo,

ich versuche zur Zeit eine Kommunikation zwischen ein PC und ein 
Atmega644p aufzubauen.

Eigentlich möchte ich Charakter in form von Byte über eine serielle 
Schnittstelle RS232 vom PC zum Atmega644p senden. Ich habe ein Programm 
in c++ geschrieben, um die Charakter zum Mikrocontroller Atmega644p zu 
senden. Danach habe ich ein c-Code  für den Mikrocontroller geschrieben, 
um die Charakter im Puffer UDR0 von USART0 zu erhalten. Dann soll wieder 
die empfangenen Charakter von UDR0 in Richtung des PCs übertragen, um 
die Funktion ReadFile() von der c++-Programm zu testen.

Ich habe ein Test durchgeführt und habe festgestellt, dass der Puffer 
UDR0 ewig auf Charakter von PC wartet, obwohl ich der pin RXC0 manuell 
aktiviert habe. Eigentlich bekommt der Puffer UDR0 keine Charakter. Was 
kann das Problem sein ?

Stimmt zufällig was nicht in mein c- und c++ Code ? Wenn ja, dann würde 
ich mich freuen, wenn sie mir helfen.

Im Anhang liegt meine Datei.

MFG

monkeydluffy

[Stefan (Gast)]

Du solltest nicht zwei Programm gleichzeitig schreiben und dann 
gegeneinander testen.

Tausche das PC Programm durch ein anderes aus, bei dem Du weisst, dass 
es funktioniert (z.B. Hyperterminal von WIndows XP, oder Cutecom oder 
Hammer Terminal).

Dann nimm erstmal den Mikrocontroller aus seinem Sockel heraus un 
verbinde die RxD und TxD Pins des Sockel mit einem Drahtstück.

Dann sendest Du irgendwelche Zeichen mit dem PC. Wenn die Hardware Ok 
ist, kommen die gesendeten Zeichen als Echo zurück zum PC (wegen der 
Drahtschleife).

Erst dann würde ich mich an die Programmierung des Mikrocontrollers 
wagen. Und wenn der dann mit dem Terminalprogramm zusammen arbeitet, 
dann tausche das Terminalprogramm durch dein selbst geschriebenes aus.

[Luffy M. (monkeydluffy)]

Hallo,

ich habe deine Tipps befolgen und habe  versucht, ein Charakter 'X' von 
Hyperterminal in die Variable c zu schreiben und dann der Wert von c 
wieder über die Schnittstelle  zum Hyperterminal zu senden. Leider läuft 
mein Experiment nicht.
Als Einstellung für Hyperterminal habe ich folgende Daten übernommen:

- Bits pro Sekunde : 112500
- Datenbits:           8
- Parität:            Keine
- Stoppbits:            2
- Flusssteuerung:      Keine

Die Implementierung des Mikrocontrollers lautet:

#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include "uart.h"
#include <avr/pgmspace.h>

#define FOSC 8000000 // Clock Speed
#define BAUD 115200UL

// Berechnungen zur Baudrate:

#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1)   // clever runden

/****************************************************/
void USART_Init (unsigned int ubrr)
{
  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char) ubrr;
  UBRR1H = (unsigned char)(ubrr>>8);
  UBRR1L = (unsigned char) ubrr;
  
  UCSR0B = (1<<RXEN1) | (1<<TXEN0) |(0<<RXCIE0)|(0<<TXCIE0);
  UCSR0C = (1<<USBS0) | (0<<UCSZ02)|(1<<UCSZ01)|(1<<UCSZ00);
  
} 

/**********************************************************/

/*-- function receive USART0 --*/

  unsigned char USART0_Receive (void)
{
    while(!(UCSR0A & (1<<RXC0)) ) // warten bis Zeichen verfuegbar
    ;
  return UDR0; // Zeichen aus UDR an Aufrufer zurueckgeben
}


/*-- function transmit USART0 --*/

void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) )// warten bis Senden moeglich 
 
  UDR0 = data0;
} 

/**********************************************************/

/*-Aktivierung der Datenübertragung über RS485 von USART1-*/

 void RS485_Init (void)
{
  DDRD = (1<<PD4)|(1<<PD3)|(1<<PD5);//Steuer- und Datenausgang aktivieren
  PORTD = (1<<PD4);  //auf Senden stellen (Aktivierung Datensendung)
} 


int main (void)

{ 
  unsigned char c ;

  USART_Init(UBRR_VAL) ;  // USART Initialisierung
  RS485_Init (); // serielle Schnittstelle USART1

  while(1)

  {
 
/*-- Test USART0 (Receive and Transmit) --*/
    
//     USART0_Transmit('X');

    c = USART0_Receive();

    USART0_Transmit(c);
}

}

Hat jemand Lösungsvorschläge, damit ich der Test mit Erfolgreich 
durchführen kann.

Danke im Voraus.

[Luffy M. (monkeydluffy)]

Hi,

>> ich habe deine Tipps befolgen und habe  versucht, ein Charakter 'X' von
>> Hyperterminal in die Variable c zu schreiben und dann der Wert von c
>> wieder über die Schnittstelle  zum Hyperterminal zu senden.

Als ich mein Programm debuggt, stelle ich fest, dass der Mikrocontroller 
der Charakter 'X' empfängt, der vom Hyperterminal gesendet wurde.

Allerdings soll wieder der empfangene Charakter 'X'  zum Hyperterminal 
über die serielle Schnittstelle übertragen. Leider läuft dieser Schritt 
meines Programm nicht. Im laufe des Debuggings wird die Funktion 
USART0_Transmit nicht vollständig ausgeführt. Irgendwie landet wieder 
der Charakter 'X' nicht in Hyperterminal.

Bitte, was stimmt eigentlich nicht in meinem Programm ?

Danke im Voraus.

[Karl H. (kbuchegg)]

Nimm hier mal den Kommentar weg

void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) )// warten bis Senden moeglich 
 
  UDR0 = data0;
}

dann steht da

void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) )
  UDR0 = data0;
}

und jetzt rückst du auch noch den Code richtig ein und zwar so, wie der 
COMpiler das ganze sieht

void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) )
    UDR0 = data0;
}

dann steht da:
Solange Senden nicht möglich ist, füttere das UDR0 Register.
Sobald Senden wieder möglich ist, mache nichts mehr.


Da fehlt ein ; der der while Schleife die richtige Bedeutung verpasst.

[Luffy M. (monkeydluffy)]

Hallo,

Karl Heinz Buchegger, danke schön für dein Feedback.

Karl schrieb:

>> Da fehlt ein ; der der while Schleife die richtige Bedeutung verpasst.

Was meinst du da bitte ? Ich verstehe dein Hinweis nicht.

Danke im Voraus.

[Karl H. (kbuchegg)]

Luffy Monkey schrieb:
> Hallo,
>
> Karl Heinz Buchegger, danke schön für dein Feedback.
>
> Karl schrieb:
>
>>> Da fehlt ein ; der der while Schleife die richtige Bedeutung verpasst.
>
> Was meinst du da bitte ? Ich verstehe dein Hinweis nicht.

Dabei hab ich so sehr versucht, herauszuarbeiten, was da passiert ohne 
den Fehler konkret zu benennen. (Am meisten lernt man immer noch, wenn 
man seine Fehler selbst findet.)


Wie soll die Logik in dieser Funktion sein?
( ===> Sollverhalten)


Wie ist die niedergeschriebene Logik tatsächlich?
( ===> Istverhalten)


OK. Ein Hinweis
Was ist der Unterschied zwischen (Pseudocode der sich an C anlehnt)

  Motor ein;
  while( ! Endschalter hat ausgelöst )
    ;
  Motor aus;

und

  Motor ein;
  while( ! Endschalter hat ausgelöst )
  Motor aus;

[Luffy M. (monkeydluffy)]

Hallo nochmal,

>> OK. Ein Hinweis
>> Was ist der Unterschied zwischen (Pseudocode der sich an C anlehnt)

>>  Motor ein;
>>  while( ! Endschalter hat ausgelöst )
    ;
>>  Motor aus;

>>und

>>  Motor ein;
>>  while( ! Endschalter hat ausgelöst )
>>  Motor aus;

Ich vermute, die Anwesenheit in obere Block des Semikolons ';' allein in 
eine Zeile ohne Anweisung verursacht der Unterschied mit dem unteren 
Block.

[Uwe (Gast)]

Nö. Falsch, setzen und C Buch lesen.

Guck doch mal im Debugger nach was passiert.

[Karl H. (kbuchegg)]

Uwe schrieb:
> Nö. Falsch,

Jein.

> setzen und C Buch lesen.

Das allerdings.
Denn das sind wichtige Dinge. Wenn man das nicht erkennt, selbst wenn es 
einem auf einem Silbertablett serviert wird, dann lässt das tief über 
das Verständnis der Grundlagen des AUfbaus von Kontrollstrukturen 
blicken.

[Uwe (Gast)]

Hätte man auch so schreiben könnnen. Ob das Semikolon alleine in einer 
Zeile steht ist egal.

main()
{
  int a=0;
  while( ! Endschalter hat ausgelöst );
  a=100;
}

und

main()
{
  int a=0;
  while( ! Endschalter hat ausgelöst )
  a=100;
}

[Luffy M. (monkeydluffy)]

Hallo nochmal,

danke schön Uwe und Karl Heinz Buchegger für die ausführlichen 
Erklärungen. Ich habe jetzt der Unterschied zwischen die beide Blöcke 
verstanden.

main()
{
  int a=0;
  while( ! Endschalter hat ausgelöst );
  a=100;
}

Im oberen Fall gehört die Variable a  nicht zu der while-Schleife.

main()
{
  int a=0;
  while( ! Endschalter hat ausgelöst )
  a=100;
}

Im unteren Fall gehört die Variable a zu der while-Schleife.

Ich habe einfach  meine Fehler  übersehen, obwohl Karl mir alles  gut 
erklärt hat. Machmal bin ich wirklich dumm.

Vielen Dank noch für ihre Hilfe.

mfg

[Luffy M. (monkeydluffy)]

Hallo,

ich wollte mich nochmal bei euch bedanken. Ich habe geschafft, die 
Kommunikation zwischen dem PC und dem Mikrocontroller Atmega644p 
aufzubauen. Meine c und C++ Code sind kompatibel und laufen einwandfrei, 
so dass der PC und der Mikrocontroller kommunizieren können.

Vielen für eure Hilfe

Monkey Luffy

[Luffy M. (monkeydluffy)]

Morgen,

mit eueren Hilfen habe ich geschafft, die Kommunikation zwischen dem PC 
und dem Mikrocontroller aufzubauen.

Mein Ziele war die Übertragung von Charakter 0,1,2,3,4 von PC zum 
Mikrocontroller über die Serielle Schnittstelle RS232. Dann sollte die 
Routine des Mikrocontrollers wieder die empfangenen Charakter in die 
gleiche serielle Schittstelle zurückschicken, so dass man folgende 
Ergebnisse auf einem Fenster bekommt:

0 : 0
1 : 1
2 : 2
3 : 3
4 : 4

Als ich meine beide Code debuggt habe, habe ich folgende Resultat 
erhalten:

0 :
1 : 0
2 : 1
3 : 2
4 : 3

Ich bekomme eine Byte-verschiebung und ich weiße nicht, wie ich dieser 
Fehler korrigieren kann.

Weiß jemand, wie ich mein problem lösen kann ?

Danke im Voraus.