Steuerzeichen Empfangen UART MEGA32

[TanjaF (Gast)]

Hallo liebe Gemeinde!!!

Ich bin gerade dabei, eine Kommunikation zw. 2 AVR ATMEGA32 aufzubauen.
Das Senden der Daten funktioniert, wenn der 1. MEGA sendet empfängt mein 
Putty die Daten, der 2 MEGA reagiert auf Daten die ich ihm mit Putty 
Sende.

Nur leider bekomme ich keine Anzeige der Steuerzeichen 0..32 (ASCII) 
oder nur komische Reaktionen auf dem Terminal. Was macht der AVR damit 
wenn er die Zeichen empfängt? kann man das emfangene Steuerzeichen über 
den Absoluten wert auswerten?

Also das ich quasi 0..255 mit einem Zeichen übertragen kann??

vielen Dank für eure Hilfe

Liebe Grüße

[Peter II (Gast)]

der Atmel senden und empfängt 8bit  also 0-255 - was dein Programm damit 
macht können wir schlecht wissen.

[Thomas Forster (Gast)]

Ein Terminalprogramm ist ja auch deshalb Terminal, weil es Steuerzeichen 
verarbeitet, wie z.B CR und LF.

Du willst die empfangenen Daten einfach nur ansehen, z.B als Hex oder 
Dezimal.
Ein fertiges Programm kenne ich auf Anhieb nicht.
Eine Möglichkeit: Die Daten vom Terminalprogramm mitloggen lassen und 
die Datei dann im Hexeditor ansehen.

[TanjaF (Gast)]

Peter II schrieb:
> der Atmel senden und empfängt 8bit  also 0-255 - was dein Programm
> damit
> macht können wir schlecht wissen.


den hätte ich wohl auch posten sollen... Tut mir leid

Die Positionsroutinen für den Modellbauservo sind von meinem Prof und 
die darf ich hier nicht veröffentlichen.

#define F_CPU 4000000UL
#define BAUD 125000UL
#include <avr\io.h>
#include <avr\interrupt.h>


void init_timer1 (void);
void init_UART (void);
char uart_recv (void);

typedef union
{
   uint32_t      myLong;
   uint8_t       myChar[4];
} data32bit;
data32bit axPos;


int main (void)
{
  axPos.myChar[0]=uart_recv;
  axPos.myChar[1]=uart_recv;
  axPos.myChar[2]=uart_recv;
  axPos.myChar[3]=uart_recv;
  
  asm volatile ("SEI");
  
  while (1)
  {
    asm volatile ("NOP");
  }

  
}


void init_UART (void)
{  
  unsigned long UBRRVAL=((F_CPU/(16*BAUD))-1);
  UBRRH = (char)(UBRRVAL>>8);
  UBRRL = (char) UBRRVAL;
  
  UCSRB = (1<<RXEN)|(1<<TXEN);
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0)|(1<<USBS);
}

char uart_recv (void)
{
    while (!(UCSRA & (1<<RXC)))
    {
    }
      return UDR;
}

Aber der Hauptzweck ist es, einen 32BIT Integer zu übertragen. Also mit 
Union zerlegen und wieder zusammensetzen.

Warum ich überhaupt frage ist, ich kann die Steuerzeichen 0...32 nicht 
senden und somit auch nicht genau simulieren ob es funktioniert.

Habe ich das richtig verstanden das es dem AVR egal ist ob er ein 
Steuerzeichen bekommt?? Ergo empfängt er das Zeichen im UDR und das kann 
ich dann auslesen

Danke nochmals

[g457 (Gast)]

hterm kann sowas. Hat einige Macken, aber zumindest das geht :-) gtkterm 
kanns auch, das hat aber wesentlich mehr Problemstellen.

[Thomas E. (thomase)]

> Habe ich das richtig verstanden das es dem AVR egal ist ob er ein
> Steuerzeichen bekommt?? Ergo empfängt er das Zeichen im UDR und das kann
> ich dann auslesen
Nicht einmal der grösste Computer, den die Menschheit jemals bauen wird, 
wird irgendeinen blassen Schimmer davon haben, was ein Steuerzeichen 
ist.
Das gilt somit auch für einen AVR. Ein UART empfängt 8 Bit. Wie dieses 
Byte interpretiert wird, ist einzig und allein Sache der Software, die 
dahinter steckt. Mal abgesehen von XON/XOFF vielleicht.

mfg.

[g457 (Gast)]

> Aber der Hauptzweck ist es, einen 32BIT Integer zu übertragen. Also mit
> Union zerlegen und wieder zusammensetzen.

Noch einfacher (und auch einfacher zu debuggen) ist es wenn Du eine 
Stringrepräsentation überträgst - zumindest wenn es die 
Laufzeitbedingungen zulassen.

[Matthias Li. (Gast)]

Thomas Eckmann schrieb:

> Das gilt somit auch für einen AVR. Ein UART empfängt 8 Bit. Wie dieses
> Byte interpretiert wird, ist einzig und allein Sache der Software, die
> dahinter steckt. Mal abgesehen von XON/XOFF vielleicht.
>
> mfg.

Ahh, jetzt ist der "Groschen gefallen".

Vielen Vielen Dank an Thomas Eckmann und an alle Anderen die mir 
geholfen haben!!!

Viele grüße

[Peter II (Gast)]

TanjaF schrieb:
> int main (void)
> {
>   axPos.myChar[0]=uart_recv;
>   axPos.myChar[1]=uart_recv;
>   axPos.myChar[2]=uart_recv;
>   axPos.myChar[3]=uart_recv;

wenn hier einmal etwas verloren geht, dann hast geht nichts mehr.

So einfach kann man nicht binary Daten übertragen, da musst du dir noch 
ein Protokoll einfallen lassen. Für den Anfang ist es einfacher es als 
HEX zu übertragen.