RN-Wissen.de - Benutzerbeiträge [de]

Software-UART mit avr-gcc

2009-08-13T20:36:52Z

Phaiax:

Ein '''Software-UART''' ist eine Software, welche die Funktionalität eines [[UART]] (''Universal Asynchronous Receiver and Transmitter'') implementiert., oder kurz: eine serielle Schnittstelle in Software nachbildet.

== Einführung ==
Stehen keine oder nicht genügend Hardware-UARTs zur Verfügung, muss man selbst Hand anlegen. Die Herausforderung ist dabei, die festgelegten Zeitrahmen bzw. Übertragungsraten/Bitlängen möglichst genau einzuhalten, um die Kommunikation fehlerfrei zu halten. Dies gilt in besonderem Maße für den Empfänger (Receiver), der nicht entscheiden kann, wann Daten eintreffen.

Dafür benötigt man eine Zeitbasis. Am konfortabelsten geht das mit einem Timer. Ohne Timer muss man die Zeit durch Abzählen von Maschinenzyklen machen, während die restliche Software warten muss bzw. Interrupts deaktiviert sein müssen.

Jeder diese Herangehensweisen hat ihre Vor- und Nachteile. Welcher Weg der bessere ist, kann nur im Gesamtzusammenhang des Programmes entschieden werden.

Wie auch immer; Ziel der Software ist es, UART-Datenframes senden und empfangen zu können. Bei Inaktivität (idle) ist die Signalleitung auf 1 (High). Jeder Frame beginnt mit einem Startbit (S), das 0 ist. Danach folgen die 8 Datenbits und schliesslich ein Stop-Bit (P), das immer 1 ist. Danach ist die Leitung wieder inaktiv oder es folgen weitere Frames.
<center>
[[Bild:UART-Frame.png|UART-Frame]]
</center>

Läuft der AVR mit einer Taktrate von <tt>F_CPU</tt> und die Übertragung mit der Baudrate BAUDRATE, dann dauert ein Bit
:<math>Z_\mathrm{bit} = \frac\mathrm{F_{CPU}}\mathrm{BAUDRATE}</math>
Zyklen. Bei 16MHz und 38400 Baud dauert ein Bit also rund 417 Zyklen, bei 1MHz und 9600 hat man nur rund 104 Zyklen Zeit.

== Mit Verwendung von Timer1 ==

=== Dateikopf ===

Im Dateikopf wird festgelegt, an welchen Ports die Ein- und Ausgabe stattfindet, mit welcher Baudrate übertragen wird und welche Teile des Soft-UARTs aktiv sind, also übersetzt werden und als Funktionen zur Verfügung stehen bzw. Flash verbrauchen. Damit eintreffende Daten nicht verloren gehen, können die Eingabedaten in einer [[FIFO mit avr-gcc|FIFO]] zwischengespeichert werden.

Die verwendeten Ports sind aus Effizienzgründen hartcodiert. Der Receiver-Eingang liegt an einem ICP (InputCapture-Eingang). Ebenfalls hartcodiert ist das Sendeformat 8N1 (8 Datenbits, kein Parity, 1 Stopbit).
;<tt>F_CPU</tt>: ist die Taktrate des AVR und muss irgendwo definiert worden sein, entweder über ein <tt>#define</tt> oder per Kommandozeile mit <tt>-DF_CPU=...</tt>
;<tt>#define BAUDRATE ...</tt>: Die Baudrate, gleich für Receiver und Transmitter.
;<tt>#define SUART_TXD</tt>: Wenn dieses Define gesetzt ist, wird der Transmitter aktiv bzw. die für ihn notwendigen Code-Sequenzen werden eingeblendet.
;<tt>#define SUART_RXD</tt>: Wenn dieses Define gesetzt ist, wird der Receiver aktiv bzw. die für ihn notwendigen Code-Sequenzen werden eingeblendet.
;FIFO aktivieren: Um die FIFO zu aktivieren, wird einfach der Header <tt>fifo.h</tt> includet und dadurch die entsprechende Codeerzeugung veranlasst.
:;<tt>#define INBUF_SIZE ...</tt>: Die Größe des Eingabe-Puffers für die Receiver-FIFO

#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef SIGNAL
#include <avr/signal.h>
#endif {{ccomment|SIGNAL }}

#include "uart.h"

{{ccomment|Folgende Zeile einkommentieren, falls FIFO verwendet werden soll }}
{{ccomment|#include "fifo.h" }}

#define BAUDRATE 38400

#define nop() __asm volatile ("nop")

#ifdef SUART_TXD
#define SUART_TXD_PORT PORTB
#define SUART_TXD_DDR DDRB
#define SUART_TXD_BIT PB1
static volatile uint16_t outframe;
#endif {{ccomment|SUART_TXD }}

#ifdef SUART_RXD
#define SUART_RXD_PORT PORTB
#define SUART_RXD_PIN PINB
#define SUART_RXD_DDR DDRB
#define SUART_RXD_BIT PB0
static volatile uint16_t inframe;
static volatile uint8_t inbits, received;

#ifdef _FIFO_H_
#define INBUF_SIZE 4
static uint8_t inbuf[INBUF_SIZE];
fifo_t infifo;
#else {{ccomment|_FIFO_H_ }}
static volatile uint8_t indata;
#endif {{ccomment|_FIFO_H_ }}
#endif {{ccomment|SUART_RXD }}

=== Initialisierung ===

Hier wird der Software-UART initialisiert. Die Initialisierung ist gegen Interrupts gesperrt. Das Modus- und OCR1A-Register von Timer1 werden so initialisiert, daß eine Zeitbasis für den UART entsteht.

{{ccomment|Initialisierung für einen ATmega8 }}
{{ccomment|Für andere AVR-Derivate sieht dies vermutlich anders aus: }}
{{ccomment|Registernamen ändern sich (zB TIMSK0 anstatt TIMSK, etc). }}
void uart_init()
{
uint8_t tifr = 0;
uint8_t sreg = SREG;
cli();

{{ccomment|Mode #4 für Timer1 }}
{{ccomment|und volle MCU clock }}
{{ccomment|IC Noise Cancel }}
{{ccomment|IC on Falling Edge }}
TCCR1A = 0;
TCCR1B = (1 << WGM12) | (1 << CS10) | (0 << ICES1) | (1 << ICNC1);

{{ccomment|OutputCompare für gewünschte Timer1 Frequenz }}
OCR1A = (uint16_t) ((uint32_t) F_CPU/BAUDRATE);

#ifdef SUART_RXD
SUART_RXD_DDR &= ~(1 << SUART_RXD_BIT);
SUART_RXD_PORT |= (1 << SUART_RXD_BIT);
TIMSK |= (1 << TICIE1);
tifr |= (1 << ICF1) | (1 << OCF1B);
#else
TIMSK &= ~(1 << TICIE1);
#endif {{ccomment|SUART_RXD }}

#ifdef SUART_TXD
tifr |= (1 << OCF1A);
SUART_TXD_PORT |= (1 << SUART_TXD_BIT);
SUART_TXD_DDR |= (1 << SUART_TXD_BIT);
outframe = 0;
#endif {{ccomment|SUART_TXD }}

TIFR = tifr;

SREG = sreg;

#ifdef _FIFO_H_
fifo_init (&infifo, inbuf, INBUF_SIZE);
#endif // _FIFO_H_

}

=== Transmitter ===
Das Senden ist am einfachsten: Zuerst wird gewartet, bis eine evtl. laufende Sendung abgeschlossen ist. Dann wird der Ausgabe-Frame zusammengebaut (1 Startbit, 8 Datenbits, 1 Stopbit und 1 Bit als interne Endekennung). Dann wird OutputCompare1A-Interrupt aktiviert das entsprechende Interrupt-Flag zurückgesetzt, damit das erste Bit nicht zu kurz wird (wenn das Flag gesetzt wäre, würde direkt nach dem <tt>sei()</tt> ein Interrupt auftreten. Ein Transmit ist fertig, wenn <tt>outframe</tt> gleich 0 ist. Das Auslesen von <tt>outframe</tt> muss unter Interrupt-Deaktivierung geschehen. <tt>uart_putc</tt> geht davon aus, daß Interrupts global aktiviert sind (ansonsten hängt es sich auf bzw. es wird nicht ausgegeben).
#ifdef SUART_TXD
void uart_putc (const char c)
{
do
{
sei(); nop(); cli(); {{ccomment|yield(); }}
} while (outframe);

{{ccomment|frame = *.P.7.6.5.4.3.2.1.0.S S=Start(0), P=Stop(1), *=Endemarke(1) }}
outframe = (3 << 9) | (((uint8_t) c) << 1);

TIMSK |= (1 << OCIE1A);
TIFR = (1 << OCF1A);

sei();
}
#endif {{ccomment|SUART_TXD }}

Danach kommt es zu OC1A-Interrupts. Für jeden [[IRQ]] wird ein Bit ausgegeben. Im letzten Interrupt wird das Senden eingestellt und die [[ISR]] deaktiviert ihren eigenen IRQ.
<pre>
#ifdef SUART_TXD
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
uint16_t data = outframe;

if (data & 1) SUART_TXD_PORT |= (1 << SUART_TXD_BIT);
else SUART_TXD_PORT &= ~(1 << SUART_TXD_BIT);

if (1 == data)
{
TIMSK &= ~(1 << OCIE1A);
}

outframe = data >> 1;
}
#endif // SUART_TXD
</pre>

=== Receiver ===
Eine fallende Flanke löst einen Input-Capture-IRQ aus. Der in ICR1 gesicherte Timer1-Wert wird gelesen, und die halbe Bit-Zeit OCR1A/2 wird draufaddiert, um den Empfangszeitpunkt (sample time) zu erhalten. Die ISR deaktiviert ihren IRQ und aktiviert stattdessen den OutputCompare1B-Interrupt, der die Bits einsammelt.
<pre>
#ifdef SUART_RXD
SIGNAL (SIG_INPUT_CAPTURE1)
{
uint16_t icr1 = ICR1;
uint16_t ocr1a = OCR1A;

// Eine halbe Bitzeit zu ICR1 addieren (modulo OCR1A) und nach OCR1B
uint16_t ocr1b = icr1 + ocr1a/2;
if (ocr1b >= ocr1a)
ocr1b -= ocr1a;
OCR1B = ocr1b;

TIFR = (1 << OCF1B);
TIMSK = (TIMSK & ~(1 << TICIE1)) | (1 << OCIE1B);
inframe = 0;
inbits = 0;
}
#endif // SUART_RXD
</pre>

Die OutputCompare1B-ISR sammelt die Bits ein. Wurden 10 Bits übertragen, wird das empfangene Byte gespeichert, falls es nicht ungültig ist. Gespeichert wird in der Modul-globalen Variablen <tt>indata</tt> (oder bei aktiviertem FIFO-Mechanismus in <tt>infifo</tt>), und der Empfangsmerker <tt>received</tt> wird gesetzt.
<pre>
#ifdef SUART_RXD
SIGNAL (SIG_OUTPUT_COMPARE1B)
{
uint16_t data = inframe >> 1;

if (SUART_RXD_PIN & (1 << SUART_RXD_BIT))
data |= (1 << 9);

uint8_t bits = inbits+1;

if (10 == bits)
{
if ((data & 1) == 0)
if (data >= (1 << 9))
{
#ifdef _FIFO_H_
_inline_fifo_put (&infifo, data >> 1);
#else
indata = data >> 1;
#endif // _FIFO_H_
received = 1;
}

TIMSK = (TIMSK & ~(1 << OCIE1B)) | (1 << TICIE1);
TIFR = (1 << ICF1);
}
else
{
inbits = bits;
inframe = data;
}
}
#endif // SUART_RXD
</pre>
Zwei Funktionen, um empfangene Daten zu lesen. Je nachdem, ob die FIFO verwendet wird, sind diese Funktionen unterschiedlich implementiert. Das Benutzer-Interface bleibt jedoch gleich, und die Verwendung einer FIFO transparent.
<pre>
#ifdef SUART_RXD
#ifdef _FIFO_H_

int uart_getc_wait()
{
return (int) fifo_get_wait (&infifo);
}

int uart_getc_nowait()
{
return fifo_get_nowait (&infifo);
}

#else // _FIFO_H_

int uart_getc_wait()
{
while (!received) {}
received = 0;

return (int) indata;
}

int uart_getc_nowait()
{
if (received)
{
received = 0;
return (int) indata;
}

return -1;
}

#endif // _FIFO_H_
#endif // SUART_RXD
</pre>

=== Benutzer-Interface und Header ===
Im Header <tt>uart.h</tt> werden die Funktionen veröffentlicht und stehen in anderen Modulen zur Verfügung:
;<tt>extern void uart_init()</tt>: Initialisiert den Soft-UART. Vor Verwendung des Soft-UARTs müssen Interrupts mit <tt>sei()</tt> global aktiviert worden sein (egal, ob vor oder nach dem Aufruf von <tt>uart_init</tt>).
;<tt>extern void uart_putc (const char c)</tt>: Sendet das Zeichen <tt>c</tt>. Vorher wird gewartet, bis eine evtl. laufende Sendung beendet ist.
;<tt>extern int uart_getc_wait()</tt>: Wartet bis zum nächsten Empfang bzw. liefert das empfangene Zeichen im Wertebereich 0...255.
;<tt>extern int uart_getc_nowait()</tt>: Schaut nach, ob ein Zeichen empfangen wurde und liefert dieses gegebenenfalls als <tt>int</tt> zurück (Wertebereich ist 0...255). Wurde nichts empfangen, wird <tt>-1</tt> geliefert.
Die Defines <tt>SUART_TXD</tt> und <tt>SUART_RXD</tt> zum Aktivieren der Code-Sequenzen für Transmitter resp. Receiver stehen hier im Header; das kann natürlich auch in die Kommandozeile/ins [[make|Makefile]] wandern und mit <tt>-DSUART_RXD</tt> etc. angeschaltet werden, Gleiches gilt für <tt>F_CPU</tt> und <tt>BAUDRATE</tt>.
<pre>
#ifndef _UART_H_
#define _UART_H_

#define SUART_TXD
#define SUART_RXD

extern void uart_init();

#ifdef SUART_TXD
extern void uart_putc (const char);
#endif // SUART_RXD

#ifdef SUART_RXD
extern int uart_getc_wait ();
extern int uart_getc_nowait();
#endif // SUART_RXD

#endif /* _UART_H_ */
</pre>

== Weblinks ==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=240 UART-Software-Simulation mit ISRs]

== Siehe auch ==

*[[UART]]
*[[RS232]]
*[[FIFO mit avr-gcc]]
*[[UART mit avr-gcc]]
*[[avr-gcc]]

[[Kategorie:Kommunikation|UART]]
[[Kategorie:Praxis|UART]]
[[Kategorie:Quellcode C|UART]]
[[Kategorie:Software|UART]]
[[Kategorie:Microcontroller|UART]]

Software-UART mit avr-gcc

2009-08-13T20:36:29Z

Phaiax:

Software-UART mit avr-gcc

2009-08-13T20:36:03Z

Phaiax:

Diskussion:Software-UART mit avr-gcc

2008-10-08T22:52:04Z

Phaiax: fifo_init

== Full oder Half-Duplex? ==
Sollte dazugesagt werden, ob das Verfahren full- oder halbduplex arbeiten kann.

--PicNick 14:38, 7. Feb 2006 (CET)

----

Vom Konzept her hatte ich es als full duplex ausgelegt. Momentan denke ich auch, daß die Timer-Lösung das leistet. Allerdings ist das natürlich auch abhängig davon, was sonst so im System abgeht, insbesondere die Interrupt-Last und respond Zeiten. Falls die hoch werden, ist zu erwarten, daß die Übertragung nicht mehr immer korrekt ist, weil die Zeiten nicht eingehalten werden. Dadurch sampelt man nicht mehr in der Mitte eines Bits bzw. das Signal fängt an zu jittern, man verpasst Zeichen. Das Verpassen sollte durch eine FIFO entschärft werden. Alternativ wäre an eine HW-Flussteuerung zu denken, zumindest in eine Richtung. Eingehende Analysen hab ich nicht gemacht und auch nicht die Mittel dazu. Falls du Vorschläge hast, können die ja eingebaut werden, oder falls du ne Stelle siehst, warum es nicht voll Duplex ist.

--[[Benutzer:SprinterSB|SprinterSB]] 11:30, 8. Feb 2006 (CET)
----
Sollte keine Kritik sein. Ich hab zusammen mit einen Forum User mal die entsprechende AVR-Appl-Note f. Soft Uart durchgezogen, mir reicht es :-) .
--PicNick 19:44, 8. Feb 2006 (CET)

== Senden ohneStart/Stop/Parität ? ==

[[Benutzer:TurboFischer|TurboFischer]] schrieb:
:''Hallo,''

:''ich bin neu hier und hab deinen Beitrag im Wiki über den Software Uart gesehen. Jetzt hätte ich da eine Frage dazu. Ich brauche für mein Projekt nur einen Teil und zwar um Daten zu übertragen, empfangen brauch ich nichts.''

:''Jetzt wollte ich fragen ob es möglich ist Daten ohne Start-, Stop- und Paritätsbit zu senden? Also rein nur die Daten das die in der eingestellten Baudrate an dem definierten PIN ausgesendet werden? Wenn ja wie man das realiesieren könnte bzw. was man ändern müste.''

:''Wäre über deine Hilfe sehr dankbar. Vielen Dank im Voraus.''
:''Mit freundlichen Grüssen''

:''Thomas''

Das Paritätsbit wird ohnehin nicht bedient, die Software implementiert 8N1.

Ob Code für Empfänger/Sender erzeugt wird, sollte durch die Defines SUART_RXD resp. SUART_TXD zu steuern sein, weil nur mit gesetzten Defines die Codesequenzen eingeblendet sind.

Um Start/Stop zu vermeiden machst du folgende Änderung in <tt>uart_putc</tt>:

<pre>
// frame = *.7.6.5.4.3.2.1.0 *=Endemarke(1)
outframe = (1 << 8) | ((uint8_t) c);
</pre>
Aber ich vermute mal, weder Start noch Stop zu senden ist nicht das, was du willst...

== fifo_init ==

Frage als Neuling: Müsste die FIFO nicht in der funktion uart_init initialisiert werden?