mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Byterkennung UART


Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hab da mal ne allgemene Frage:

Wie erkennt die UART, welches Byte für was verwendet werden soll?

Also will ich zum Beispiel zwei AD-Wandler benutzen. Den einem zum
steuern für ein Servo, den anderen zum steuern eines PWM Signals. Die
AD-Wandler beziehen ihre Spannungen über ein Poti.

Nun funktioniert es ja so, das bei einer bestimmten am AD-Wandler
anliegenden Spannung ein Wert zwischen 0 und 255 erzeugt wird. Diesen
Wert will ich dann über UART zum steuern des PWM und Servos an einen
anderen Controller schicken.

Doch wie erkennt der andere Controller, ob er diesen Wert jetzt für das
PWM oder für den Servo verwenden soll.

Muss ich da noch irgendwie ein Byte mitschicken, welches angibt für was
das nachfolgende Byte verwendet werden soll.

Wie realisiert man so etwas am besten?

Autor: johnny.m (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Muss ich da noch irgendwie ein Byte mitschicken, welches angibt für
> was das nachfolgende Byte verwendet werden soll.

Das wirst Du wohl müssen. Das Übertragungsprotokoll ist eine Sache, die
Du als Anwender in der Hand hast. Wenn es nur zwei Möglichkeiten der
Verwendung gibt, dann kannst Du z.B. eine 9-Bit-Übertragung machen
(wenn Du nicht unbedingt ein zweites Stopbis brauchen solltest) und das
9. Datenbit als Indikator für den Verwendungszweck nutzen.

Autor: Thomas O. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
oder einfach anhang der Reichenfolge. Du überträgst also immer 2 Bytes
nacheinander der 2te Controller weiß das das erste Byte für xxx ist und
das 2te für xxx.

Autor: Profi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Thomas meint, Du schickst die Bytes immer paarweise mit einer Pause
dazwischen, welche Du auswertest.

Wie immer gibt es noch weitere Möglichkeiten:
Du kannst Parity für die Übertragung eines weiteren Bits
zweckentfremden.
Es gibt ja mehrere Möglichkeiten für Parity:
no, even, odd, mark, space. Bei den beiden letzten hast Du es selbst in
der Hand, ob L oder H übertragen werden soll. Das würde ich verwenden.
Oder even/odd, dann bast Du z.B. als Kennzeichen des 2.Bytes einen
Parity-Error.

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi, erst mal Danke für die Infos!

Welche Methode ist den zu empfehlen? Hab 6 Bytes die in einen
Programmdurchlauf gesendet werden sollen.

Wie funktioniert das denn genau mit der Zeichenfolge?

Ungfähr so in der Interrupt Routine des sendenden µC:

1. Start Interrupt

2. Weise dem UDR0 den Wert des ersten zu übertragenden Byte zu.

3. Pause

4. Weise dem UDR0 den Wert des zweiten zu übertragenden Byte zu.

5. Pause.....usw.

6. nach dem 6 Byte ende Interrupt

Und wie liest der empfangene Controller die dann aus?

Im Moment hab ich eine Auswertung, welche mir ein emfangenes Byte
bitweise ausließt und dann je nach 0 oder 1 entsprechenden Werte in ein
Array schreibt.

Kann ich diese Auswertung einfach zweimal hintereinander laufen lassen
und beim zweiten mal einfach die Werte in ein anderes Array schreiben?

Gruß

Stefan

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich mache sowas immer mit einer state-machine:

http://de.wikipedia.org/wiki/Endlicher_Automat

gruss, bjoern.

Autor: Netzpolizei (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das mit der Interrupt-Routine würde ich nicht machen. Sende die Daten
lieber in der Hauptschleife. Das Warten, bis das nächste Byte gesendet
werden kann, dauert (für µC-Verhältnisse) ziemlich lange, und
währenddessen ist alles andere blockiert, wenn du das in der
Interrupt-Routine machst.

> Im Moment hab ich eine Auswertung, welche mir ein emfangenes Byte
> bitweise ausließt und dann je nach 0 oder 1 entsprechenden Werte
> in ein Array schreibt.

Wieso bitweise? Hat der lesende µC keinen UART, USART oder USI, oder
ist der schon von was anderem belegt?

> Kann ich diese Auswertung einfach zweimal hintereinander laufen
> lassen und beim zweiten mal einfach die Werte in ein anderes
> Array schreiben?

Warum solltest du das nicht können?

Wichtig bei der Übertragung mehrerer Bytes ist, daß du dir was zur
Synchronisation überlegst. Falls bei der Übertragung was verlorengeht
oder der Empfänger vor dem Sender eingeschaltet wird, muß ja irgendwie
sichergestellt werden, daß der Empfänger die Daten nicht versetzt
kriegt und damit die Bytes für ihn auf einmal eine ganz andere
Bedeutung haben. Das Ende eines Pakets kann man z.B. mit einer Pause
mit definierter Mindestlänge kennzeichnen oder mit einer Bytesequenz,
die in den Nutzdaten nicht vorkommt.

Autor: Netzpolizei (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
...oder der Empfänger vor dem Sender eingeschaltet wird...

Ich meinte natürlich "nach" statt "vor".

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
koennte ungefaehr so aussehen:

#define STATE_IDLE
#define STATE_RECEIVE

uart_fsm(uint8_t c)
{
    static uint8_t state=STATE_IDLE;
    static uint8_t counter=0;

    switch(state)
    {
         case STATE_IDLE:
            buffer[0]=c;
            counter = 1;
            state = STATE_RECEIVE;
            break;
         case STATE_RECEIVE:
            buffer[counter++]=c;
            if (counter>6)
            {
                receive_flag=1;
                state = STATE_IDLE;
            }
    }
}

keine gewaehr.

gruss, bjoern.

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ups, so sollte es heissen:
#define STATE_IDLE    0
#define STATE_RECEIVE 1

default: und 2 breaks; fehlen auch...

Autor: inoffizieller WM-Rahul (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie wäre es, ein Feld(Array) zu benutzen?

unsigned char daten[6];

In das kann man dann ganz wunderbar die zu sendenden Daten schreiben.

Dann kann man mit einem Zaehler von 0 bis 5 die Dinger in einer
Schleife verschicken.

Quasi so:

USART initialisiern
Feld füllen
tue folgendes, solange Zaehler < 6:
{
  warte, ob Sendepuffer frei ist
  schreibe Feldeintrag(Zaehler) ins UDR
  erhöhe Zaehler
}

Der Empfang sieht ähnlich aus...
(Es handelt sich definitiv um keinen C-Code!)

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für die Antworten!

Das mit dem state kapier ich nicht ganz. Aber der Tip mit dem Array von
Rahul hört sich ganz gut an!

Also beim senden ungefähr so:

unsigned char feld[6];
unsigned char zaehler = 0;

feld[0] = Byte1;
feld[1] = Byte2;
feld[2] = Byte3;
feld[3] = Byte4;
feld[4] = Byte5;
feld[5] = Byte6;

while(zaehler <=5)
{
  if(1 << UDRE)
  {
    UDR0 = feld[zaehler];
    zaehler++;
  }
}

Und wie beim empfangen?

Autor: inoffizieller WM-Rahul (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>if(1 << UDRE)
da fehlt zwar noch das Register, aber sonst sieht das gut aus.

>Und wie beim empfangen?
Guck dir mal die Beispiele im Datenblatt an.

Das beste wäre sich ein Protokoll auszudenken, bei dem ein Start-Byte
benutzt wird, dessen Wert sonst nicht vorkommt. Z.B. 0x80, dann sollten
der Wert der folgenden Bytes kleiner als 128 sein.

>Im Moment hab ich eine Auswertung, welche mir ein emfangenes Byte
>bitweise ausließt und dann je nach 0 oder 1 entsprechenden Werte in
>ein Array schreibt.
>Kann ich diese Auswertung einfach zweimal hintereinander laufen
>lassen und beim zweiten mal einfach die Werte in ein anderes Array
>schreiben?

Was meinst du damit? Welche Art Daten überträgst du jetzt?

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das mit dem Startbyte ist mein Problem, da weiß ich nicht wie ich das
realisieren soll. Denn meine Werte in den nachfolgenden Bytes sind
zwischen 0 und 255.

>Im Moment hab ich eine Auswertung, welche mir ein emfangenes Byte
>bitweise ausließt und dann je nach 0 oder 1 entsprechenden Werte in
>ein Array schreibt.

Mit diesem empfangenen Byte erzeuge ich ein Signal mit 8 verschiedenen
Impulsen. Das Signal wird durch ein 18ner Array erzeugt, wobei die
Felder Aray 3,5,7,9,11,13,15 und 17 mit entsprechenden Werten für die
Impulslängen beschrieben werden. Nun werden bei einem empfangenen Byte
die einzelnen Bits auf 0 oder 1 verglichen. Ist das erste Bit 1
schreibe eine 30 in das Feld 3 das Array, ist das Bit 0 schreibe eine
20 rein....usw.

>Kann ich diese Auswertung einfach zweimal hintereinander laufen
>lassen und beim zweiten mal einfach die Werte in ein anderes Array
>schreiben?

Da wollte ich das ganze nochmal wiederholen, um das zweite Byte in ein
anderes Array zu schreiben. Nur gibt es halt das Problem, dass der
emfangene Controller wiisen muss, welches Byte das erste und was das
zweite ist.

>Welche Art Daten überträgst du jetzt?

Im Moment lese ich eine Spannung über einen AD-Wandler ein, welcher mir
einen Wert zwischen 0 und 255 erzeugt. Diesen sende ich dann an den
anderen Mikrocontroller. Nun will ich noch einen zweiten AD-Wandler
zusätzlich benutzen.

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Das mit dem state kapier ich nicht ganz.
Das hatte ich befuerchtet. Ansich ist das keine Hexerei, aber man muss
es verstanden haben, damit man es benutzen kann. Interessant wirds wenn
man das empfangene Zeichen auch noch auswertet und ein paar mehr
Zustaende dazukommen:

sagen wir mal dein protokoll sieht so aus:
als erstes zeichen kommt die unterscheidung zwischen pwm und servo;
danach kommen, sagen wir mal entweder 2 byte, falls es pwm werte sind
oder 3 byte, falls es servowerte sind.
jedes empfangene zeichen wird in die state-machine "geschmissen" und
je nach dem, in welchem zustand sich die fsm befindet, fuehrt sie
bestimmte befehle aus und wechselt ggfalls den zustand.

switch (state)
{
    case STATE_IDLE:
             if(c='a')
             {
                 counter=0;
                 state=STATE_PWM;
             }
             if(c='b')
             {
                 counter=0;
                 state=STATE_SERVO;
             }
             break;
    case STATE_PWM:
             buffer[counter++]=c;
             if (counter==2)
             {
                 setze_pwm(buffer);
                 state = STATE_IDLE;
             }
             break;
    case STATE_SERVO:
             buffer[counter++]=c;
             if (counter==3)
             {
                 setze_servo(buffer);
                 state = STATE_IDLE;
             }
             break;
    default:
             break;
}

ich hoffe, es wird ein bisschen verstaendlicher. viel mit worten kann
ich da nicht mehr zu erklaeren; ueber "automatentheorie" wurden ganze
buecher geschrieben und es ist ein elementares werkzeug der informatik.

gruss, bjoern.

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
if(c='a') sollte besser if(c=='a') heissen :)

koennte genausogut if(c==1) oder so heissen. ich waehl immer
ascii-zeichen fuer befehle, damit ich das ganze auch schnell mit einem
terminalprog testen kann...

gruss, bjoern.

Autor: Dirk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

erstmal solltest du Dir ein FIFO erstellen. Beispiele findest du in der
Fleury Uart Lib oder im GCC Port von Martin Thomas zum Butterfly.

Als naechstes wuerdem ich mir ein Protokoll ausdenken z.B.

Uppernibble vom Byte ist die Startadresse z.B. "1111" das Lowernibble
kannst du dann als Teilnehmer (AVR0 o. AVR1 usw.) benutzen, dann ein
Byte als Command or Data Erkennung. Das naechste Byte als Commandlength
oder Datalength und zum Schluss CRC und ein Stopbyte.

So kannst du wirklich sicher sein das ein komplettes Frame empfangen
wurde.

Vom Programmiertechnischen hat dir schon Bjoern Mueller
weitergeholfen.

Gruß,
Dirk

Autor: Chief brady (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und wenn du die Daten einfach nibbleweise sendest?

Zu sendendes Byte: 0x83

Übertragen wird:

  0xF8 0xF3  für Servo  oder
  0xE8 0xE3  für PWM

D.h. das erste Nibble eines Bytes gibt an Servo (E) oder PWM (F) und im
zweiten Nibble stehen die Nutz-Bits

Autor: Michael Wilhelm (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Oder eine 9-bit UART deklarieren, wo dann das 1. Datenbyte ein 1 als 9.
Bit bekommt und die Folgebytes eine 0.

MW

Autor: Rolf Magnus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Rolf:
Den (letztlich) gleichen Link hab ich schon um 14:05 gepostet.
Allerdings finde ich nicht, dass man damit viel anfangen kann.
Zumindest nicht, wenn man noch nie was von FSMs gehoert hat...

gruss, bjoern.

Autor: Stefan (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo, erst ein mal vielen Dank für die ganzen Antworten!

Hab es nun mal nach der Methode von Björn Mueller versucht. Wollte
einfach nur mal zum testen zwei LED's ein und aus schalten. Leider
haut das mit dem STATE nicht hin.

Wenn ich es auf so mache, klappts:

//Interrupt UART
ISR(USART_RX_vect )
{

  unsigned char buffer;

  buffer = UDR0;

    switch(buffer) {

     case '1': // LED1 ein/ausschalten
    if (PORTB & (1 << PB2))

        PORTB &= ~(1 << PB2);
    else
        PORTB |= (1 << PB2);
                break;

           case '2'://LED2 ein/ausschalten
                if (PORTB & (1 << PB0))

        PORTB &= ~(1 << PB0);
    else
        PORTB |= (1 << PB0);
                break;
                   }
}

Nur auf diese Weise klappt das dann mit der Byteerkennung nicht.

Hab mal den kompletten Code mit den STATE angehängt, vielleicht kann ja
mal jemand schauen wo der Fehler liegt.

Gruß

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Falls beide Varianten das gleiche machen sollen, hast du das Konzept
noch nicht verstanden. Eine fsm fuehrt pro Durchlauf nur die Befehle
aus, die zum jeweils aktuellen state gehoeren. Du wechselt zwar bei
einem empfangen Zeichen in einen anderen state, aber die Aktionen aus
diesem werden erst beim naechsten Durchlauf(=naechstes Zeichen wird
empfangen) ausgefuehrt. Du muesstet also, damit dein fsm-code das
gleiche macht wie der "normale" code ein weiteres beliebiges Zeichen
senden, das die fsm einen "Takt weiterschaltet".

Desweiteren setzt du mit "unsigned char state = STATE_IDLE;" die fsm
bei jedem Durchlauf auf den Grundzustand. Du willst aber eigentlich,
dass die fsm sich bei jedem Durchlauf an ihren beim vorigen Durchlauf
gesetzten state "erinnert". Das geht entweder mit einer globalen
Variablen "state" oder mit dem Bezeichner "static" innerhalb der
Funktion.

Konkret:
aender mal "unsigned char state = STATE_IDLE;" in "static unsigned
char state = STATE_IDLE;" und sende 2 Zeichen also zb "ax" oder
"bz", dann sollte sich deine fsm so verhalten, also ob du an den
"normalen" code "1" oder "2" schickst.

gruss, bjoern.

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Cool, so gehts!

Also heißt das konkret, das erste Byte (also das 'a') sagt mir das er
beim nächsten Durchlauf und einem empfangenen Byte den case STATE_LICHT1
ausführt. Dabei ist es egal, welchen Inhalt das zweite Byte besitzt weil
ich darauf keine Abfrage mache. Es wird, egal was in dem Byte steht
dieser case ausgeführt.

Wenn ich jetzt aber den Inhalt des Bytes verwenden will, muss wieder
eine Zuweisung von c auf z.B. den Servo erfolgen.

Richtig?

Autor: Bjoern M. (salival)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Also heißt das konkret, das erste Byte (also das 'a') sagt mir das
er
>beim nächsten Durchlauf und einem empfangenen Byte den case
>STATE_LICHT1 ausführt.
Jetzt hats "klick" gemacht ;)

>Wenn ich jetzt aber den Inhalt des Bytes verwenden will, muss wieder
>eine Zuweisung von c auf z.B. den Servo erfolgen.
Genau. Was in dem jeweiligen state passiert, bestimmst du. Du kannst zb
einen buffer fuellen und einen counter hochzaehlen, falls du in dem
state eine bestimmte Anzahl bytes erwartest; oder einfach nur mit dem
empfangenen byte zb eine andere Funktion aufrufen und gleich wieder in
den "warte-auf-weitere-befehle"-state zurueckwechseln.
Du muss auch nicht zwingend aus dem idle-state rauswechseln, wenn ein
befehl ankommt, der keine weiteren daten erwartet. in deinem beispiel
mit den 2 leds koenntest du auch einfach nur die led an/ausschalten und
einfach weiter auf andere Befehle warten.

gruss, bjoern.

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich hab noch ne Frage.

erkennt der Microcontroller den Unterschied zwischen ASCI und Dezimal?

Autor: inoffizieller WM-Rahul (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nö. Für ihn sind das alles nur Bits.
Eigentlich handelt es sich bei den beiden Sachen nur um verschiedene
Darstellungsformen.
ASCII ist nichts anderes als eine Tabelle mit Symbolen, die für
Menschen verständlich ist. Und das Dezimalsystem ist wird auch nur
benutzt, weil der Mensch im Regelfall 10 Finger hat.
Mit den 10 Fingern könnte man in binären Zahlenraum allerdings
wesentlich mehr zählen...
Wenn man abfragt x == 'U', dann setzt der Compiler für 'U' die
Hexadezimalzahl 0x55, was eine andere Darstellungsform für 85 dezimal
oder 01010101 binär ist, sofern er mit der ASCII-Tabelle arbeitet.
Man könnte sich auch eine eigene Tabelle aufbauen, was man für einfache
Verschlüsselungstechniken benutzen könnte.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.