Difference between revisions of "AVR Embedded Tutorial - UART/de"
Line 1: | Line 1: | ||
{{Translate}} | {{Translate}} | ||
− | |||
− | = | + | =UART Polling= |
==ATmega328p (Arduino uno/nano)== | ==ATmega328p (Arduino uno/nano)== | ||
Line 20: | Line 19: | ||
===Konstanten für Inizialisierung=== | ===Konstanten für Inizialisierung=== | ||
− | <syntaxhighlight lang="pascal"> | + | <syntaxhighlight lang="pascal"> |
const | const | ||
CPU_Clock = 16000000; // Taktfrequenz Arduino, default 16MHz. | CPU_Clock = 16000000; // Taktfrequenz Arduino, default 16MHz. | ||
Line 29: | Line 28: | ||
===Inizialisieren=== | ===Inizialisieren=== | ||
Die UART-Schnittstelle konfigurierieren. | Die UART-Schnittstelle konfigurierieren. | ||
− | <syntaxhighlight lang="pascal"> | + | <syntaxhighlight lang="pascal"> |
procedure UARTInit; | procedure UARTInit; | ||
begin | begin | ||
Line 41: | Line 40: | ||
===Zeichen empfangen=== | ===Zeichen empfangen=== | ||
− | <syntaxhighlight lang="pascal"> | + | <syntaxhighlight lang="pascal"> |
function UARTReadChar: char; | function UARTReadChar: char; | ||
begin | begin | ||
Line 51: | Line 50: | ||
===Zeichen senden=== | ===Zeichen senden=== | ||
− | <syntaxhighlight lang="pascal"> | + | <syntaxhighlight lang="pascal"> |
procedure UARTSendChar(c: char); | procedure UARTSendChar(c: char); | ||
begin | begin | ||
Line 61: | Line 60: | ||
===String senden=== | ===String senden=== | ||
− | <syntaxhighlight lang="pascal"> | + | <syntaxhighlight lang="pascal"> |
procedure UARTSendString(s: ShortString); | procedure UARTSendString(s: ShortString); | ||
var | var | ||
Line 67: | Line 66: | ||
begin | begin | ||
for i := 1 to length(s) do begin | for i := 1 to length(s) do begin | ||
− | UARTSendChar(s[i]); | + | UARTSendChar(s[i]); // Zeichen einzeln senden. |
end; | end; | ||
end; | end; | ||
Line 78: | Line 77: | ||
UARTInit; | UARTInit; | ||
repeat | repeat | ||
− | if UARTReadChar = #32 then begin // space | + | if UARTReadChar = #32 then begin // #32 = space |
UARTSendString('Hello World !'#13#10); | UARTSendString('Hello World !'#13#10); | ||
end; | end; | ||
Line 85: | Line 84: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | ==ATtiny2313== | |
Beim ATtiny2313 haben die Register eine andere Bezeichnung als beim ATmega328p. | Beim ATtiny2313 haben die Register eine andere Bezeichnung als beim ATmega328p. | ||
* Die '''0''' entfällt in der Bezeichnung. | * Die '''0''' entfällt in der Bezeichnung. | ||
Line 100: | Line 99: | ||
(Der Code wurde nicht getestet) | (Der Code wurde nicht getestet) | ||
− | + | =Interrupt= | |
Beim Polling kann es passieren, das Zeichen verschluckt werden, dies passiert, wen ein Zeichen ankommt und man dieses nicht abholt. Aus diesem Grund empfiehlt es sich, den Zeichenempfang Interrupt gesteuert zum machen. | Beim Polling kann es passieren, das Zeichen verschluckt werden, dies passiert, wen ein Zeichen ankommt und man dieses nicht abholt. Aus diesem Grund empfiehlt es sich, den Zeichenempfang Interrupt gesteuert zum machen. | ||
+ | |||
+ | Bei höheren Baudraten, ist dies zwingend. | ||
+ | |||
+ | Es wir ein einfacher Ringpuffer mit 16 Zeichen verwendet. | ||
+ | |||
+ | ==ATmega328p (Arduino uno/nano)== | ||
===Deklaration=== | ===Deklaration=== | ||
Line 133: | Line 138: | ||
procedure UART_RX_Empfang; public Name 'USART__RX_ISR'; interrupt; | procedure UART_RX_Empfang; public Name 'USART__RX_ISR'; interrupt; | ||
var | var | ||
− | + | ch: byte; | |
begin | begin | ||
+ | |||
+ | // Zeichen einlesen | ||
tchr := UDR0; | tchr := UDR0; | ||
− | if | + | |
− | RxBuf[rxwrite] := | + | // Zeichen in Puffer schreiben. |
+ | if ch <> 0 then begin | ||
+ | RxBuf[rxwrite] := ch; | ||
Inc(rxwrite); | Inc(rxwrite); | ||
if rxwrite >= Crxlen then begin | if rxwrite >= Crxlen then begin | ||
Line 160: | Line 169: | ||
// Hauptschleife. | // Hauptschleife. | ||
repeat | repeat | ||
− | + | ||
+ | // Ist ein Zeichen im Puffer ? | ||
while rxwrite <> rxread do begin | while rxwrite <> rxread do begin | ||
+ | |||
+ | // Interrupt sperren. | ||
+ | asm cli end; | ||
+ | |||
+ | // Zeichen aus Puffer lesen | ||
ch := RxBuf[rxread]; | ch := RxBuf[rxread]; | ||
Inc(rxread); | Inc(rxread); | ||
Line 167: | Line 182: | ||
rxread := 0; | rxread := 0; | ||
end; | end; | ||
+ | |||
+ | // Interrupt aktivieren. | ||
+ | asm sei end; | ||
+ | |||
+ | // Wen kleiner Buchstaben, diesen in einen grossen umwandeln. | ||
if ch in [$61..$7A] then begin | if ch in [$61..$7A] then begin | ||
Dec(ch, 32); | Dec(ch, 32); | ||
end; | end; | ||
+ | |||
+ | // Zeichen ausgeben. | ||
UARTSendChar(char(ch)); | UARTSendChar(char(ch)); | ||
end; | end; | ||
− | |||
until 1 = 2; | until 1 = 2; | ||
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
[[Category:AVR]] {{AutoCategory}} | [[Category:AVR]] {{AutoCategory}} |
Revision as of 22:14, 18 November 2017
UART Polling
ATmega328p (Arduino uno/nano)
Für die serielle Ausgabe wird ein Terminal mit folgenden Einstellungen gebraucht:
Baud Rate | 9600 |
Bits | 8 |
Stopbits | 1 |
Parity | none |
Beim Betätigen von [space] im Terminal-Programm, sollte ein "Hello World !" zurück kommen.
Konstanten für Inizialisierung
const
CPU_Clock = 16000000; // Taktfrequenz Arduino, default 16MHz.
Baud = 9600; // Baudrate
Teiler = CPU_Clock div (16 * Baud) - 1;
Inizialisieren
Die UART-Schnittstelle konfigurierieren.
procedure UARTInit;
begin
UBRR0 := Teiler; // Baud
UCSR0A := 0 // Normale Geschwindigkeit
UCSR0B := (1 shl TXEN0) or (1 shl RXEN0); // Empfangen und Senden
UCSR0C := (%011 shl UCSZ0); // 8-Bit Übertragung, 1 Stop-Bits.
end;
Zeichen empfangen
function UARTReadChar: char;
begin
while UCSR0A and (1 shl RXC0) = 0 do begin // Warten, bis Zeichen ankommt.
end;
Result := char(UDR0); // Zeichen einlesen.
end;
Zeichen senden
procedure UARTSendChar(c: char);
begin
while UCSR0A and (1 shl UDRE0) = 0 do begin // Warten, bis letztes Zeichen gesendet.
end;
UDR0 := byte(c); // Zeichen senden.
end;
String senden
procedure UARTSendString(s: ShortString);
var
i: integer;
begin
for i := 1 to length(s) do begin
UARTSendChar(s[i]); // Zeichen einzeln senden.
end;
end;
Hauptschleife
Hier wird gewartet, bis [space] ankommt, anschliessend wir "Hello World !" gesendet.
program Project1;
begin
UARTInit;
repeat
if UARTReadChar = #32 then begin // #32 = space
UARTSendString('Hello World !'#13#10);
end;
until 1 = 2;
end.
ATtiny2313
Beim ATtiny2313 haben die Register eine andere Bezeichnung als beim ATmega328p.
- Die 0 entfällt in der Bezeichnung.
- UBRR0 muss man in UBRRH und UBRRL zerlegen.
Das sieht dann so aus:
UBRRH := Teiler shr 8;
UBRRL := Byte(Teiler);
UCSRB := (1 shl TXEN) or (1 shl RXEN);
UCSRC := (%011 shl UCSZ);
(Der Code wurde nicht getestet)
Interrupt
Beim Polling kann es passieren, das Zeichen verschluckt werden, dies passiert, wen ein Zeichen ankommt und man dieses nicht abholt. Aus diesem Grund empfiehlt es sich, den Zeichenempfang Interrupt gesteuert zum machen.
Bei höheren Baudraten, ist dies zwingend.
Es wir ein einfacher Ringpuffer mit 16 Zeichen verwendet.
ATmega328p (Arduino uno/nano)
Deklaration
Zeichenbuffer deklarieren, hier wir ein Puffer von 16 Zeichen angelegt.
const
Crxlen = 16;
var
RxBuf: array[0..Crxlen - 1] of byte;
rxread: byte = 0;
rxwrite: byte = 0;
Inzialisieren
Dies ist ähnlich des Polling verfahren, der Unterschied, man teilt mit RXCIE0 mit, das beim Zeichenempfang ein Interrupt ausgelöst wird.
procedure UARTInit;
begin
UBRR0 := teiler;
UCSR0A := (0 shl U2X0);
UCSR0B := (1 shl TXEN0) or (1 shl RXEN0) or (1 shl RXCIE0);
UCSR0C := %011 shl UCSZ0;
end;
Interrupt
Bei auslösen des Interrupts, wird das Zeichen vom UART in Zeichenbuffer kopiert.
procedure UART_RX_Empfang; public Name 'USART__RX_ISR'; interrupt;
var
ch: byte;
begin
// Zeichen einlesen
tchr := UDR0;
// Zeichen in Puffer schreiben.
if ch <> 0 then begin
RxBuf[rxwrite] := ch;
Inc(rxwrite);
if rxwrite >= Crxlen then begin
rxwrite := 0;
end;
end;
end;
Hauptschleife
In der Hauptschleife wird geprüft, ob sich etwas im Empfangspuffer, wen ja, wird ein Zeichen davon ausgelesen. In diesem Beispiel werden, die empfangenen Zeichen in Grossbuchstaben umgewandelt und anschiessend wieder ausgegeben.
begin
// UART inizialisieren, die Interrupt gesteuert.
UARTInit;
// Interrupt aktivieren.
asm sei end;
// Hauptschleife.
repeat
// Ist ein Zeichen im Puffer ?
while rxwrite <> rxread do begin
// Interrupt sperren.
asm cli end;
// Zeichen aus Puffer lesen
ch := RxBuf[rxread];
Inc(rxread);
if rxread >= Crxlen then begin
rxread := 0;
end;
// Interrupt aktivieren.
asm sei end;
// Wen kleiner Buchstaben, diesen in einen grossen umwandeln.
if ch in [$61..$7A] then begin
Dec(ch, 32);
end;
// Zeichen ausgeben.
UARTSendChar(char(ch));
end;
until 1 = 2;