Uartn sind die Interfaces für die seriellen Uart-Schnittstellen des Controllers (RS232, RS485, ..).
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 |
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) |
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 |
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 |
' 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
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 ' --------------------------------------