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
.Print 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
' --------------------------------------