Uart, Uart0, Uart1, Uart2, Uart3
Uartn sind die Interfaces für die seriellen Uart-Schnittstellen des Controllers (RS232, RS485, ..).
Eigenschaften (nur schreiben)
| Name | Beschreibung | Werte |
|---|---|---|
| .Baud | Baudrate einstellen | Baudrate (word) |
| .Recv/.Rxd | Empfangen ein/aus | .enable, .disable |
| .Send/.Txd | Senden ein/aus | .enable, .disable |
| .Recv.Fifo=bytes | Empfangs-Fifobuffer einrichten/initialisieren. | 2-65534 (Konstante) |
| .Send.Fifo=bytes | Sende-Fifobuffer einrichten/initialisieren. | 2-65534 (Konstante) |
| .DirPin=<portpin> | TX/RX Direction Pin definieren für Protokolle die ein Signal benötigen um die Datenrichtung einzustellen (RE/DE) wie z,Bsp. bei RS485-Transceivern. Sämtliche Uartfunktionen setzen diesen Pin dann automatisch je nach Ausgaberichtung (auch im Fifo-Mode). | <port>.<pin> |
| .DirPin.Mode=<modus> | Logikmodus des DirPin einstellen (optional). Vorgabe ist High bei Schreibvorgang. Inverted ist Low bei Schreibvorgang. | normal/inverted |
| .IsrSend | Serviceroutine für Send-complete setzen | Isr-Name |
| .IsrRecv | Serviceroutine für Receive-complete setzen | Isr-Name |
| .IsrEmpty | Serviceroutine für Data-empty setzen | Isr-Name |
| .IsrSend | Interrupt Send-complete ein/aus | .enable, .disable |
| .IsrRecv | Interrupt Receive-complete ein/aus | .enable, .disable |
| .IsrEmpty | Interrupt Data-empty ein/aus | .enable, .disable |
Eigenschaften (nur lesen)
| Name | Beschreibung | Typ |
|---|---|---|
| .ByteAvailable | Abfragen ob ein Zeichen verfügbar ist und gelesen werden kann. | byte (0=false) |
| .RxReady | wie .ByteAvailable | byte (0=false) |
| .TxReady | Abfragen ob ein Zeichen gesendet werden kann. | byte (0=false) |
| .RxOverrun | Abfragen ob der Empfangsbuffer während des bisherigen Betriebs übergelaufen ist (nur mit Fifo verfügbar). | byte (0=false) |
| .Status | Uart-Status (Bitvektor), siehe Atmel-Dokumentation zu Port „USR“ | byte (0=false) |
Methoden
| Name | Beschreibung | Typ | r/w |
|---|---|---|---|
| Ausgabe mehrerer Werte, siehe Print. | - | schreiben | |
| .InpStr([echo,[breakChar]]) | Liest maximal 254 Zeichen von der Schnittstelle und bricht ab, wenn breakChar (Vorgabewert: 13) eintrifft. Hinweis: Die empfangenen Zeichen werden temporär auf dem Programmstack abgelegt. Die Eingabe stoppt wenn das Ende des Stacks erreicht wird. Ist echo Null (Vorgabewert: 1), wird ein Echo zum Sender unterbunden. Die beiden Parameter sind optional. | string | lesen |
| .GetByte | Byte lesen (direkt, ohne Statusprüfung. Liefert den Wert 0x00 wenn kein Byte empfangen wurde.) | byte | lesen |
| .ReadByte | Byte lesen (warten bis Zeichen verfügbar) | byte | lesen |
| .ReadWord | Word lesen (warten bis Zeichen verfügbar) | word | lesen |
| .ReadInteger | Integer lesen (warten bis Zeichen verfügbar) | integer | lesen |
| .ReadLong | Long lesen (warten bis Zeichen verfügbar) | long | lesen |
| .ReadSingle | Single lesen (warten bis Zeichen verfügbar) | single | lesen |
| .Read sramAdresse,Anzahl | Angegebene Anzahl Bytes lesen und in den Arbeitsspeicher schreiben (wartet bis alle Zeichen gelesen). | - | lesen |
| .ReadC sramAdresse | Bytes lesen und in den Arbeitsspeicher schreiben (Wartet bis ein Nullbyte gelesen wurde, das Nullbyte wird nicht gespeichert.). | - | lesen |
| .ReadP sramAdresse | Bytes lesen und in den Arbeitsspeicher schreiben (Das erste empfangene zeichen beziffert die zu lesende Anzahl Bytes. Wartet bis alle Zeichen gelesen.). | - | lesen |
| .PutByte | Byte schreiben (direkt, ohne Statusprüfung) | byte | schreiben |
| .WriteByte | Byte schreiben (warten bis Ausgabe bereit) | byte | schreiben |
| .WriteWord | Word schreiben (warten bis Ausgabe bereit) | word | schreiben |
| .WriteInteger | Integer schreiben (warten bis Ausgabe bereit) | integer | schreiben |
| .WriteLong | Long schreiben (warten bis Ausgabe bereit) | long | schreiben |
| .WriteSingle | Single schreiben (warten bis Ausgabe bereit) | single | schreiben |
| .Write sramAdresse,Anzahl | Angegebene Anzahl Zeichen aus Arbeitsspeicher schreiben (wartet bis alle Zeichen geschrieben). | - | schreiben |
| .WriteC sramAdresse | Mehrere Zeichen aus Arbeitsspeicher schreiben bis Nullbyte erscheint (wartet bis alle Zeichen geschrieben mit Ausnahme des Nullbytes). | - | schreiben |
| .WriteP sramAdresse | Mehrere Zeichen aus Arbeitsspeicher schreiben, das erste Zeichen beziffert die Anzahl (wartet bis alle Zeichen geschrieben. | - | schreiben |
| .CWrite flashAdresseBytes,Anzahl | Angegebene Anzahl Zeichen aus Flashspeicher schreiben (wartet bis alle Zeichen geschrieben). | - | schreiben |
| .CWriteC flashAdresseBytes | Mehrere Zeichen aus Flashspeicher schreiben bis Nullbyte erscheint (wartet bis alle Zeichen geschrieben mit Ausnahme des Nullbytes). | - | schreiben |
| .CWriteP flashAdresseBytes | Mehrere Zeichen aus Flashspeicher schreiben, das erste Zeichen beziffert die Anzahl (wartet bis alle Zeichen geschrieben. | - | schreiben |
| .Flush | Empfangsbuffer zurücksetzen/löschen | - | aufrufen |
| .Dump | Hexdump-Ausgabe zum Debugging, siehe Dump. | - | aufrufen |
Standardschnittstelle "Uart" (ohne Nummer)
Die Verwendung von Uart bezieht sich immer auf die eingestellte Standard-Schnittstelle. Voreinstellung ist Uart0. Dies betrifft auch die Funktionen Print und InpStr. Ab der Version 2013.R4 kann mittels einer global wirksamen Eigenschaft die Standardschnittstelle zum Programmstart einmalig eingestellt werden:
| Zusätzliche Eigenschaft für „Uart“ (nur schreiben) | ||
|---|---|---|
| Name | Beschreibung | Werte |
| Uart.Interface = Schnittstelle | Standard-Schnittstelle bei der Verwendung von „Uart“ (ohne Nummer) festlegen. | Uart0, Uart1, Uart2 oder Uart3 |
Beispiel (Uart Pollmode)
' Simples Terminal mit Echo
Uart0.Baud = 19200
Uart0.Recv.enable
Uart0.Send.enable
dim char as byte
do
char = Uart0.ReadByte ' Warten bis Zeichen verfügbar und dann lesen
select case char
case 0,10 ' Nullbytes und LF ignorieren
case 13 ' Return?
Uart0.WriteByte 13 ' CR ausgeben
Uart0.WriteByte 10 ' LF ausgeben
default
Uart0.WriteByte char ' Zeichen wieder ausgeben (Echo)
endselect
loop
Siehe auch: Idle-EndIdle
Beispiel (Uart Interrupt Mode)
Man kann den UartX auch im Interruptbetrieb nutzen, dazu bedarf es nur der Deklaration der jeweiligen TX- oder RX-FiFos. Natürlich muss auch das globale Interrupt Flag gesetzt werden.
' -------------------------------------- ' System Settings ' -------------------------------------- ' 2015-05-09 de0508, Uwe ' -------------------------------------- const F_CPU = 8000000 avr.device = atmega168 avr.clock = F_CPU avr.stack = 42 ' -------------------------------------- ' Konstanten ' -------------------------------------- const EOS = 0 const TAB = 9 const CR = 13 const LF = 10 ' -------------------------------------- ' gloable Variable ' -------------------------------------- dim read_ch as byte ' -------------------------------------- ' Uart Pins Initialisieren ' -------------------------------------- ' Sie ist eine Workaround ' Wenn man an TXD/ RXD einen Seriell zu USB-Wandler betreibt, ' sonst kann es passieren, dass der Atmel AVR µC nicht richtig startet. #define UART_RXD as portd.0 #define UART_TXD as portd.1 ' TXD und RXD auf Ausgang, bzw. Eingang schalten, ' so dass die Pins einen definierten Pegel haben UART_RXD.mode = input, pullup UART_TXD.mode = output, high ' -------------------------------------- ' Standart Uart0 mit FiFo ' -------------------------------------- const UART_BAUDRATE = 19200 const UART_RX_FIFO = 16 const UART_TX_FIFO = 16 ' Standard-Schnittstelle bei der Verwendung von "Uart" (ohne Nummer) festlegen. uart.interface = uart0 ' Uart0 initialisieren uart0.baud = UART_BAUDRATE uart0.Rxd.Fifo = UART_RX_FIFO uart0.Rxd.enable uart0.Txd.fifo = UART_TX_FIFO uart0.Txd.enable ' -------------------------------------- ' System Initialisieren ' -------------------------------------- ' Enable all Interrupt Avr.Interrupts.Enable ' -------------------------------------- ' Main - Loop ' -------------------------------------- do // Alle Zeichen aus dem Uart0 FiFo lesen und verbarbeiten while ( uart0.RxReady() ) read_ch = uart0.ReadByte() ' lokales echo uart0.WriteByte( read_ch ) ' CR-LF ausgeben when (read_ch = CR) do uart0.WriteByte( LF ) // more code wend // more code loop ' -------------------------------------- ' Loop - End ' --------------------------------------