Mikrocontroller.net - Benutzerbeiträge [de]

Datei:Sam.zip

2015-08-17T08:01:51Z

Klaus2m5: Klaus2m5 lud eine neue Version von Datei:Sam.zip hoch

Structured Assembly Macros

Datei:Sam.zip

2015-08-16T06:48:22Z

Klaus2m5: Klaus2m5 lud eine neue Version von Datei:Sam.zip hoch

Structured Assembly Macros

AVR 6502 Emulator

2014-01-11T14:38:54Z

Klaus2m5: weitere AVR basierte Emulatoren hinzugefügt

== 6502-Emulation auf Atmel AVR-Controllern ==

Diese Seite faßt Diskussionen aus dem Thread "KIM-1 in AVR?" ([http://www.mikrocontroller.net/topic/193632]) zusammen und soll als Sammelstelle für weitere Informationen und zur Koordination der Entwicklung einer 6502-Emulationsbibliothek für AVR-Controller dienen.

== Warum? ==

In "alten" Homecomputer-Zeiten war der MOS 6502 und seine Derivate - neben dem Z80 von Zilog - die CPU der Wahl für (damals) schnelle, kostengünstige Systeme. Beispiele sind die Commodore-Systeme (C64, VC20, C128, PET, CBM), ATARI XL/XE und Apple II. Aber auch Spielekonsolen der 80er-Jahre verwenden vielmals einen 6502 - Atari 2600 und Nintendo NES sind wohl die bekanntesten Beispiele

Mit einer Taktfrequenz von 1 MHz ist die verfügbare Rechenleistung eher gering. Daraus entstand der Gedanke, ein 8-Bit-System der 80er auf einem modernen, kostengünstigen 8-Bit-Controller in Software zu emulieren. Ein Projekt, das den intel 8080 (Vorgänger des Z80) emuliert und das damalige Standardbetriebssystem CP/M ausführen kann, ist in Ursprüngen [http://spritesmods.com/?art=avrcpm hier] zu finden und wird in [http://www.mikrocontroller.net/topic/177481 diesem Thread] weiterentwickelt (siehe auch die [http://www.mikrocontroller.net/articles/AVR_CP/M Projektseite]).

Was mit einem 8080 möglich ist, sollte für den 6502 auch möglich sein! Das dürfte genug Herausforderung sein - die "Grabenkämpfe" der 80er-Jahre fanden meist zwischen 8080/Z80-Anhängern und 6502-Begeisterten statt...

== Eine neue Idee? ==

Einen 6502 auf AVR zu emulieren ist keine neue Idee. Es existieren bereits einige Projekte, die mehr oder weniger erfolgreich einen 6502 emulieren:

[http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/s2009/bhp7_teg25/bhp7_teg25/index.html NES-Emulator] - Projekt von Studenten der Cornell University.

[http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/s2007/bcr22/final%20webpage/final.html Apple II-Emulator], ebenfalls von Cornell.

[http://www.belanger.pwp.blueyonder.co.uk/Projects/Vic%20Emu/vicemu.htm Commodore VC20-Emulator] (6502, VIC, Display, Tastatur) als AVR-Studio Assembler-Projekt.

[http://sites.google.com/site/retroelec/ ATMega based home computer] - ATMega162 emuliert 6502 mit SCART Video Ausgang, PS2 Tastatur und SD Kartenslot.

[http://sbc.rictor.org/avr65c02.html AVR 65C02 Emulator] - ATMega1284 emuliert 65C02 mit on Chip RAM und ROM, erlaubt direkten Zugriff der emulierten CPU auf die AVR IO-Register.

[http://2m5.de/6502_Emu/index.htm Modular 6502 SBC with emulated CPU] - ATMega16 emuliert wahlweise 6502 oder 65C02 mit variabler IO-Konfiguration.

== Projekt: 6502-Emulations-Bibliothek ==

Ein Ziel des Projektes soll es sein, eine universelle 6502-Emulations-Bibliothek für AVR-Mikrocontroller zu erstellen, die dann Basis für weitere Entwicklungen (Systememulatoren für KIM-1, Commodore 1541 usw.) sein soll.

Eine optionale Anforderung an die Emulation ist Zyklenexaktheit der Software. Dies wird z.B. für die Verwendung von Floppy-Speedern für die Emulation des Commodore 1541-Diskettenlaufwerks benötigt.

Wenn Zyklenexaktheit erreicht werden kann, ist die nächste Frage, ob die Software-6502-Emulation auch (mit Hilfe einer Adapterplatine) als pinkompatibler Ersatz für einen "echten" 6502/6510 dienen kann. Dies ist aktuell unter Diskussion.

== KIM 1-Emulation ==

Der KIM-1 war eine Entwicklungsplattform für den 6502. Die Idee, den KIM-1 als Software-Emulation im AVR zu realisieren, war der Startpunkt für dieses Projekt. Der Fortschritt des Projekts wird [http://t-winkler.net/dokuwiki/doku.php?id=kim:kim1284 hier] beschrieben.

== Commodore 1541-Emulation ==

Bisherige Emulationsprojekte basierten auf einer Reimplementierung des IEC-Bus-Protokolls sowie der Funktionalität der 1541-Firmware (DOS), bekanntestes Projekt hier ist [http://www.c64-wiki.com/index.php/sd2iec_%28firmware%29 sd2iec].

Eine komplette Hardware-Reimplementierung der 1541-Elektronik auf FPGA findet sich bei [http://commodore-gg.hobby.nl/innovatie_1541kaart_eng.htm 1541 "Ultimate"]und [http://www.das-labor.org/wiki/1541_im_FPGA das Labor].

Ideen zur 1541-Realisierung auf AVR mit 6502-Emulator finden sich [http://t-winkler.net/dokuwiki/doku.php?id=1541-emul:start hier].

== Alternativen? ==

Es gibt jede Menge 6502-Implementierungen für FPGAs (in VHDL und Verilog):

[http://www.syntiac.com/fpga64.html Peter Wendrichs C64 für FPGAs]

[http://www.fpgaarcade.com/vic20_main.htm VC20 im FPGA bei fpgaarcade]

[http://alexfreed.com/FPGApple/revisited.html Apple II-Emulator auf Altera DE1 Evaluationsboard]

Projekte bei Opencores:

[http://opencores.org/project,6502vhdl 6502 in VHDL]

[http://opencores.org/project,t65 T65 CPU (VHDL)]

[http://opencores.org/project,cpu6502_true_cycle Zyklengenauer 6502 (VHDL)]

[http://opencores.org/project,lattice6502 6502 in VHDL für Lattice FPGAs]

Software-Emulation des 6502:

[http://www.piumarta.com/software/lib6502/ lib6502 (C) von Ian Piumarta]

[http://www.6502.org/tools/emu/la6502emu.txt 6502-Emulation in 68k-Assembler]

[http://www.6502asm.com/ 6502-Emulation in Javascript]

[http://mdawson.net/vic20beta/vic20.php VC-20 Emulation in Javascript]

Software-Simulation des 6502:

[http://www.visual6502.org/ Simulation des 6502 auf Transistorebene]

[[Kategorie:AVR-Projekte]]

I2C-slave USART

2013-01-11T14:37:52Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Baudrate, I2C-Adresse und Einstellungen zur Flusskontrolle haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.

==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

Bugfix Version 1.1a 11.1.2013 - Resolved conflict of the sniffer state machine with the slave I2C state.

[[Media:I2C-slave_USART_11a.zip|I2C-slave_USART.zip]]

[[Kategorie:AVR-Projekte]]
[[Kategorie:I2C]]

Datei:I2C-slave USART 11a.zip

2013-01-11T14:35:54Z

Klaus2m5:

I2C-slave USART

2013-01-11T14:33:06Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Baudrate, I2C-Adresse und Einstellungen zur Flusskontrolle haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.

==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

Bugfix Version 1.1a 11.1.2013 - Resolved conflict of the sniffer state machine with the slave I2C state.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

[[Kategorie:AVR-Projekte]]
[[Kategorie:I2C]]

I2C-slave USART

2013-01-11T14:19:43Z

Klaus2m5: /* Zukünftige Erweiterungen */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Baudrate, I2C-Adresse und Einstellungen zur Flusskontrolle haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.

==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

[[Kategorie:AVR-Projekte]]
[[Kategorie:I2C]]

AVR Assembler Makros

2012-11-01T18:38:56Z

Klaus2m5: /* Align */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Location Pointer ==
=== Align ===
Manchmal ist es notwendig, Tabellen oder Puffer auf eine bestimmte Byte- oder Wortgrenze zu bringen, z.B. um beim Zugriff einen Überlauf des Index in das obere Adressbyte zu verhindern.

<avrasm>
.macro align ;align to 1<<@0
alignfromhere:
.if (alignfromhere & ((1<<@0)-1)) ;if not already aligned
.org (alignfromhere & (0xffff<<@0)) + (1<<@0)
.endif
.endmacro
</avrasm>

@0 bezeichnet die Anzahl rechtsbündiger binärer Nullen.
Beispiel: align 8 setzt die nächste Adresse auf $xx00.
Funktioniert in allen Segmenten.

== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>

== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich. Läuft unter aktuellen Versionen von AVRASM2.

Einige Beispiele:

Verschachteltes If-Then-Else<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als [[Media:sam.zip|Download.]]

AVR Assembler Makros

2012-11-01T18:34:26Z

Klaus2m5: /* Align */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Location Pointer ==
=== Align ===
Manchmal ist es notwendig, Tabellen oder Puffer auf eine bestimmte Byte- oder Wortgrenze zu bringen, z.B. um beim Zugriff einen Überlauf des Index in das obere Adressbyte zu verhindern.

<avrasm>
;align to 1<<@0
.macro align
alignfromhere:
.if (alignfromhere & ((1<<@0)-1)) ;if not already aligned
.org (alignfromhere & (0xffff<<@0)) + (1<<@0)
.endif
.endmacro
</avrasm>

@0 bezeichnet die Anzahl rechtsbündiger binärer Nullen.
Beispiel: align 8 setzt die nächste Adresse auf $xx00.
Funktioniert in allen Segmenten.

== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>

== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich. Läuft unter aktuellen Versionen von AVRASM2.

Einige Beispiele:

Verschachteltes If-Then-Else<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als [[Media:sam.zip|Download.]]

AVR Assembler Makros

2012-11-01T18:25:31Z

Klaus2m5: /* Delay */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Location Pointer ==
=== Align ===
Manchmal ist es notwendig, Tabellen oder Puffer auf eine bestimmte Byte- oder Wortgrenze zu bringen, z.B. um beim Zugriff einen Überlauf des Index in das obere Adressbyte zu verhindern.

<avrasm>
;align to 1<<@0
.macro align
alignfromhere:
.if (alignfromhere & ((1<<@0)-1)) ;if not already aligned
.org (alignfromhere & (0xffff<<@0)) + (1<<@0)
.endif
.endmacro
</avrasm>

Beispiel: align 8 setzt die nächste Adresse auf $xx00.
Funktioniert in allen Segmenten.

== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>

== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich. Läuft unter aktuellen Versionen von AVRASM2.

Einige Beispiele:

Verschachteltes If-Then-Else<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als [[Media:sam.zip|Download.]]

AVR-Tutorial: LCD

2011-12-16T16:40:18Z

Klaus2m5: /* Benutzerdefinierte Zeichen */

Kaum ein elektronisches Gerät kommt heutzutage noch ohne ein LCD daher. Ist doch auch praktisch, Informationen im Klartext anzeigen zu können, ohne irgendwelche LEDs blinken zu lassen. Kein Wunder also, dass die häufigste Frage in Mikrocontroller-Foren ist: "Wie kann ich ein LCD anschließen?"

==Das LCD und sein Controller==

Die meisten Text-LCDs verwenden den Controller [[HD44780|'''HD44780''']] oder einen kompatiblen (z. B. KS0070) und haben 14 oder 16 Pins. 
Die Pinbelegung ist meist (Ausnahme z. B. TC1602E (Pollin 120420): VDD und VSS vertauscht) folgendermaßen:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen!

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Pin # || Bezeichnung || Funktion
|-
|align="center" | 1
|align="center" | VSS (selten: VDD)
|| GND (selten: +5 V)
|-
|align="center" | 2
|align="center" | VDD (selten: VSS)
|| +5 V (selten: GND)
|-
|align="center" | 3
|align="center" | VEE, V0, V5
|| Kontrastspannung (-5 V / 0 V bis 5 V)
|-
|align="center" | 4
|align="center" | RS
|| Register Select (0=Befehl/Status 1=Daten)
|-
|align="center" | 5
|align="center" | RW
|| 1=Read 0=Write
|-
|align="center" | 6
|align="center" | E
|| 0=Disable 1=Enable
|-
|align="center" | 7
|align="center" | DB0
|| Datenbit 0
|-
|align="center" | 8
|align="center" | DB1
|| Datenbit 1
|-
|align="center" | 9
|align="center" | DB2
|| Datenbit 2
|-
|align="center" | 10
|align="center" | DB3
|| Datenbit 3
|-
|align="center" | 11
|align="center" | DB4
|| Datenbit 4
|-
|align="center" | 12
|align="center" | DB5
|| Datenbit 5
|-
|align="center" | 13
|align="center" | DB6
|| Datenbit 6
|-
|align="center" | 14
|align="center" | DB7
|| Datenbit 7
|-
|align="center" | 15
|align="center" | A
|| LED-Beleuchtung, meist Anode
|-
|align="center" | 16
|align="center" | K
|| LED-Beleuchtung, meist Kathode
|-
|}
</center>

Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist das Pin1-Pad eckig oder daneben eine kleine 1 auf der LCD-Platine, ansonsten im Datenblatt nachschauen.

Bei der DIL-Version (2x7, 2x8 Kontakte) auch darauf achten, auf welcher Platinen-Seite der Stecker montiert wird: auf der falschen (meist hinteren) Seite sind dann die Flachbandleitungen 1 und 2, 3 und 4 usw. vertauscht. Das kann man kompensieren, indem man es auf der anderen Kabelseite genauso permutiert oder es auf dem Layout bewusst so legt (Stecker auf der Bottom-Seite plazieren). Man kann es NICHT kompensieren, indem man das Flachbandkabel auf der anderen Seite in den Stecker führt.

Bei LCDs mit 16-poligem Anschluss sind die beiden letzten Pins für die Hintergrundbeleuchtung reserviert. Hier unbedingt das Datenblatt zu Rate ziehen. Die beiden Anschlüsse sind je nach Hersteller verdreht beschaltet. Falls kein Datenblatt vorliegt, kann man mit einem Durchgangsprüfer feststellen, welcher Anschluss mit Masse (GND) verbunden ist.

VSS wird ganz einfach an GND angeschlossen und VCC=VDD an +5 V. VEE = V0 = V5 kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte, muss man ein 10kΩ-Potentiometer zwischen GND und 5 V schalten, mit dem Schleifer an VEE. Meist kann man den +5 V-Anschluss am Poti weglassen, da im Display ein Pull-up-Widerstand ist:

[[Bild:LCD_Vee.gif|framed|center| Gewinnung der Kontrastspannung]]

Wenn der Kontrast zu schwach sein sollte (z.B. bei tiefen Temperaturen), kann man anstelle von GND eine negative Spannung ans Kontrast-Poti legen. Diese kann bis -5 V gehen und kann leicht aus einem Timerpin des µC, einem Widerstand, zwei Dioden und zwei Kondensatoren erzeugt werden. So wird auch ein digital einstellbarer Kontrast mittels PWM ermöglicht.

Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-Bit-''' und den '''4-Bit-'''Modus.
* Für den '''8-Bit-Modus''' werden (wie der Name schon sagt) alle acht Datenleitungen zur Ansteuerung verwendet, somit kann durch einen Zugriff immer ein ganzes Byte übertragen werden.
* Der '''4-Bit-Modus''' verwendet nur die oberen vier Datenleitungen ('''DB4-DB7'''). Um ein Byte zu übertragen, braucht man somit zwei Zugriffe, wobei zuerst das höherwertige '''"Nibble"''' (= 4 Bits), also Bit 4 bis Bit 7 übertragen wird und dann das niederwertige, also Bit 0 bis Bit 3. Die unteren Datenleitungen des LCDs, die beim Lesezyklus Ausgänge sind, lässt man offen (siehe Datasheets, z. B. vom KS0070).

Der 4-Bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-Bit-Modus. 6 bzw. 7 Pins (eines Portes) reichen aus.

Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' benötigt.

* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Beim Schreiben gilt: ist RS Low, dann wird das ankommende Byte als Befehl interpretiert; Ist RS high, wird das Byte auf dem LCD angezeigt (genauer: ins Data-Register geschrieben, kann auch für den CG bestimmt sein).
* '''RW''' legt fest, ob geschrieben oder gelesen werden soll. High bedeutet lesen, low bedeutet schreiben. Wenn man RW auf lesen einstellt und RS auf Befehl, dann kann man das '''Busy-Flag''' an DB7 lesen, das anzeigt, ob das LCD den vorhergehenden Befehl fertig verarbeitet hat. Ist RS auf Daten eingestellt, dann kann man z. B. den Inhalt des Displays lesen - was jedoch nur in den wenigsten Fällen Sinn macht. Deshalb kann man RW dauerhaft auf low lassen (= an GND anschließen), so dass man noch ein IO-Pin am Controller einspart. Der Nachteil ist, dass man dann das Busy-Flag nicht lesen kann, weswegen man nach jedem Befehl ca. 50 µs (beim Return Home 2 ms, beim Clear Display 20 ms) warten sollte, um dem LCD Zeit zum Ausführen des Befehls zu geben. Dummerweise schwankt die Ausführungszeit von Display zu Display und ist auch von der Betriebsspannung abhängig. Für professionellere Sachen also lieber den IO-Pin opfern und Busy abfragen.
* Der '''E''' Anschluss schließlich signalisiert dem LCD, dass die übrigen Datenleitungen jetzt korrekte Pegel angenommen haben und es die gewünschten Daten von den Datenleitungen bzw. Kommandos von den Datenleitungen übernehmen kann. Beim Lesen gibt das Display die Daten / Status so lange aus, wie E high ist. Beim Schreiben übernimmt das Display die Daten mit der fallenden Flanke.

== Anschluss an den Controller ==

Jetzt, da wir wissen, welche Anschlüsse das LCD benötigt, können wir das LCD mit dem Mikrocontroller verbinden:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen.

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
!Pinnummer LCD || Bezeichnung || Anschluss
|-
| align="center" |1 || VSS || GND
|-
| align="center" |2 || VCC || +5 V
|-
| align="center" |3 || VEE || GND oder [[Potentiometer | Poti]]
|-
| align="center" |4 || RS || PD4 am AVR
|-
| align="center" |5 || RW || GND
|-
| align="center" |6 || E || PD5 am AVR
|-
| align="center" |7 || DB0 || nicht angeschlossen
|-
| align="center" |8 || DB1 || nicht angeschlossen
|-
| align="center" |9 || DB2 || nicht angeschlossen
|-
| align="center" |10 || DB3 || nicht angeschlossen
|-
| align="center" |11 || DB4 || PD0 am AVR
|-
| align="center" |12 || DB5 || PD1 am AVR
|-
| align="center" |13 || DB6 || PD2 am AVR
|-
| align="center" |14 || DB7 || PD3 am AVR
|-
| align="center" |15 || A || Vorsicht! Meistens nicht direkt an +5 V abschließbar, sondern nur über einen Vorwiderstand, der an die Daten der Hintergrundbeleuchtung angepasst werden muss.
|-
| align="center" |16 || K || GND
|}
</center>

Ok. Alles ist verbunden. Wenn man jetzt den Strom einschaltet, sollten ein oder zwei schwarze Balken auf dem Display angezeigt werden.

Doch wie bekommt man jetzt die Befehle und Daten in das Display? Dazu muss das LCD initialisiert werden und man muss Befehle (Commands) und seine Daten an das LCD senden. Weil die Initialisierung ein Spezialfall der Übertragung von Befehlen ist, im Folgenden zunächst die Erklärung für die Übertragung von Werten an das LCD.

== Ansteuerung des LCDs im 4-Bit-Modus ==

Um ein Byte zu übertragen, muss man es erstmal in die beiden Nibbles zerlegen, die getrennt übertragen werden. Da das obere Nibble (Bit 4 - Bit 7) als erstes übertragen wird, die 4 Datenleitungen jedoch an die vier unteren Bits des Port D angeschlossen sind, muss man die beiden Nibbles des zu übertragenden Bytes erstmal vertauschen. Der AVR kennt dazu praktischerweise einen eigenen Befehl:

<avrasm>
swap r16 ; vertauscht die beiden Nibbles von r16
</avrasm>

Aus 0b00100101 wird so z. B. 0b01010010.

Jetzt sind die Bits für die erste Phase der Übertragung an der richtigen Stelle. Trotzdem wollen wir das Ergebnis nicht einfach so mit '''out PORTD, r16''' an den Port geben. Um die Hälfte des Bytes, die jetzt nicht an die Datenleitungen des LCDs gegeben wird auf null zu setzen, verwendet man folgenden Befehl:

<avrasm>
andi r16, 0b00001111 ; Nur die vier unteren (mit 1 markierten)
; Bits werden übernommen, alle anderen werden null
</avrasm>

Also: Das obere Nibble wird erst mit dem unteren vertauscht, damit es unten ist. Dann wird das obere (das wir jetzt noch nicht brauchen) auf null gesetzt.

Jetzt müssen wir dem LCD noch mitteilen, ob wir Daten oder Befehle senden wollen. Das machen wir, indem wir das Bit, an dem RS angeschlossen ist (PD4), auf 0 (Befehl senden) oder auf 1 (Daten senden) setzen. Um ein Bit in einem normalen Register zu setzen, gibt es den Befehl sbr (Set Bit in Register). Dieser Befehl unterscheidet sich jedoch von sbi (das nur für IO-Register gilt) dadurch, dass man nicht die Nummer des zu setzenden Bits angibt, sondern eine Bitmaske. Das geht so:

<avrasm>
sbr r16, 0b00010000 ; Bit 4 setzen, alle anderen Bits bleiben gleich
</avrasm>

RS ist an PD4 angeschlossen. Wenn wir r16 an den Port D ausgeben, ist RS jetzt also high und das LCD erwartet Daten anstatt von Befehlen.

Das Ergebnis können wir jetzt endlich direkt an den Port D übergeben:

<avrasm>
out PORTD, r16
</avrasm>

Natürlich muss vorher der Port D auf Ausgang geschaltet werden, indem man 0xFF ins Datenrichtungsregister DDRD schreibt.

Um dem LCD zu signalisieren, dass es das an den Datenleitungen anliegende Nibble übernehmen kann, wird die E-Leitung (Enable, an PD5 angeschlossen) auf high und kurz darauf wieder auf low gesetzt. Ein Puls an dieser Leitung teilt also dem LCD mit, das die restlichen Leitungen jetzt ihren vom Programm gewollten Pegel eingenommen haben und gültig sind.

<avrasm>
sbi PORTD, 5 ; Enable high
nop ; 3 Taktzyklen warten ("nop" = nichts tun)
nop
nop
cbi PORTD, 5 ; Enable wieder low
</avrasm>

Die eine Hälfte des Bytes wäre damit geschafft! Die andere Hälfte kommt direkt hinterher: Alles, was an der obenstehenden Vorgehensweise geändert werden muss, ist, das "swap" (Vertauschen der beiden Nibbles) wegzulassen.

== Initialisierung des Displays ==

Allerdings gibt es noch ein Problem. Wenn ein LCD eingeschaltet wird, dann läuft es zunächst im 8 Bit Modus. Irgendwie muss das Display initialisiert und auf den 4 Bit Modus umgeschaltet werden, und zwar nur mit den 4 zur Verfügung stehenden Datenleitungen. 

Wenn es Probleme gibt, dann meistens an diesem Punkt. Die "kompatiblen" Kontroller sind gelegentlich doch nicht 100% identisch. Es lohnt sich, das Datenblatt (siehe Weblinks im Artikel [[LCD]]) genau zu lesen, in welcher Reihenfolge und mit welchen Abständen (Delays) die Initialisierungbefehle gesendet werden. Eine weitere Hilfe können Ansteuerungsbeispiele in Forenbeiträgen geben z. B.

* [http://www.mikrocontroller.net/topic/79609#664268 (A) KS0066U oder Ähnliche --- LCD Treiber]

=== Initialisierung für 4 Bit Modus ===

Achtung: Im Folgenden sind alle Bytes aus Sicht des LCD-Kontrollers angegeben! Da LCD-seitig nur die Leitungen DB4 - DB7 verwendet werden, ist daher immer nur das höherwertige Nibble gültig. Durch die Art der Verschaltung (DB4 - DB7 wurde auf dem PORT an PD0 bis PD3 angeschlossen) ergibt sich eine Verschiebung, so dass das am Kontroller auszugebende Byte nibblemässig vertauscht ist!

Die Sequenz, aus Sicht des Kontrollers, sieht so aus:

* Nach dem Anlegen der Betriebsspannung muss eine Zeit von mindestens ca. 15ms gewartet werden, um dem LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
* $3 ins Steuerregister schreiben (RS = 0)
* Mindestens 4.1ms warten
* $3 ins Steuerregister schreiben (RS = 0)
* Mindestens 100µs warten
* $3 ins Steuerregister schreiben (RS = 0)
* $2 ins Steuerregister schreiben (RS = 0), dadurch wird auf 4 Bit Daten umgestellt
* Ab jetzt muss für die Übertragung eines Bytes jeweils zuerst das höherwertige Nibble und dann das niederwertige Nibble übertragen werden, wie oben beschrieben
* Mit dem Konfigurier-Befehl $20 das Display konfigurieren (4-Bit, 1 oder 2 Zeilen, 5x7 Format)
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.

Eine Begründung, warum die ersten Befehle dreifach geschickt werden sollen, findet sich [http://www.mikrocontroller.net/topic/158983#1508510 im Forum].

=== Initialisierung für 8 Bit Modus ===

Der Vollständigkeit halber hier noch die notwendige Initialiserungssequenz für den 8 Bit Modus. Da hier die Daten komplett als 1 Byte übertragen werden können, sind einige Klimmzüge wie im 4 Bit Modus nicht notwendig. Begründung für die anfänglichen Wiederholungen siehe oben.

* Nach dem Anlegen der Betriebsspannung muss eine Zeit von mindestens ca. 15ms gewartet werden, um dem LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
* $30 ins Steuerregister schreiben (RS = 0)
* Mindestens 4.1ms warten
* $30 ins Steuerregister schreiben (RS = 0)
* Mindestens 100µs warten
* $30 ins Steuerregister schreiben (RS = 0)
* Mit dem Konfigurier-Befehl 0x30 das Display konfigurieren (8-Bit, 1 oder 2 Zeilen, 5x7 Format)
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.

== Routinen zur LCD-Ansteuerung im 4-Bit-Modus ==

Im Folgenden werden die bisherigen Grundroutinen zur LCD-Ansteuerung im 4-Bit-Modus zusammengefasst und kommentiert. Die darin enthaltenen Symbole (temp1, PORTD,...) müssen in einem dazugehörenden Hauptprogramm definiert werden. Dies wird nächsten Abschnitt ''Anwendung'' weiter erklärt.

<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LCD-Routinen ;;
;; ============ ;;
;; (c)andreas-s@web.de ;;
;; ;;
;; 4bit-Interface ;;
;; DB4-DB7: PD0-PD3 ;;
;; RS: PD4 ;;
;; E: PD5 ;;
;; ;;
;; Takt: 4 MHz ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sendet ein Datenbyte an das LCD
lcd_data:
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<4 ; entspricht 0b00010000 (Anm.1)
out PORTD, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<4 ; entspricht 0b00010000
out PORTD, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command: ; wie lcd_data, nur RS=0
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out PORTD, temp1
rcall lcd_enable
andi temp2, 0b00001111
out PORTD, temp2
rcall lcd_enable
rcall delay50us
ret

; erzeugt den Enable-Puls
;
; Bei höherem Takt (>= 8 MHz) kann es notwendig sein,
; vor dem Enable High 1-2 Wartetakte (nop) einzufügen.
; Siehe dazu http://www.mikrocontroller.net/topic/81974#685882
lcd_enable:
sbi PORTD, 5 ; Enable high
nop ; mindestens 3 Taktzyklen warten
nop
nop
cbi PORTD, 5 ; Enable wieder low
ret ; Und wieder zurück

; Pause nach jeder Übertragung
delay50us: ; 50µs Pause (bei 4 MHz)
ldi temp1, $42
delay50us_:dec temp1
brne delay50us_
ret ; wieder zurück

; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause (bei 4 MHz)
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück

; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden
lcd_init:
ldi temp3,50
powerupwait:
rcall delay5ms
dec temp3
brne powerupwait
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet
out PORTD, temp1 ; werden zur Initialisierung
rcall lcd_enable ; 1
rcall delay5ms
rcall lcd_enable ; 2
rcall delay5ms
rcall lcd_enable ; und 3!
rcall delay5ms
ldi temp1, 0b00000010 ; 4bit-Modus einstellen
out PORTD, temp1
rcall lcd_enable
rcall delay5ms
ldi temp1, 0b00101000 ; 4Bit / 2 Zeilen / 5x8
rcall lcd_command
ldi temp1, 0b00001100 ; Display ein / Cursor aus / kein Blinken
rcall lcd_command
ldi temp1, 0b00000100 ; inkrement / kein Scrollen
rcall lcd_command
ret

; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret

; Sendet den Befehl: Cursor Home
lcd_home:
ldi temp1, 0b00000010 ; Cursor Home
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Anm.1: Siehe [[Bitmanipulation]]

Weitere Funktionen (wie z. B. Cursorposition verändern) sollten mit Hilfe der [[AVR-Tutorial:_LCD#Welche_Befehle_versteht_das_LCD.3F|Befehlscodeliste]] nicht schwer zu realisieren sein. Einfach den Code in temp laden, lcd_command aufrufen und ggf. eine Pause einfügen. 
Natürlich kann man die LCD-Ansteuerung auch an einen anderen Port des Mikrocontrollers "verschieben": Wenn das LCD z. B. an Port B angeschlossen ist, dann reicht es, im Programm alle "PORTD" durch "PORTB" und "DDRD" durch "DDRB" zu ersetzen. 
Wer eine höhere Taktfrequenz als 4 MHz verwendet, der sollte daran denken, die Dauer der Verzögerungsschleifen anzupassen.

==Anwendung==

Ein Programm, das diese Routinen zur Anzeige von Text verwendet, kann z. B. so aussehen (die Datei lcd-routines.asm muss sich im gleichen Verzeichnis befinden). Nach der Initialisierung wird zuerst der Displayinhalt gelöscht. Um dem LCD ein Zeichen zu schicken, lädt man es in temp1 und ruft die Routine "lcd_data" auf. Das folgende Beispiel zeigt das Wort "Test" auf dem LCD an.

[http://www.mikrocontroller.net/sourcecode/tutorial/lcd-test.asm Download lcd-test.asm]

<avrasm>
.include "m8def.inc"

; .def definiert ein Synonym (Namen) für ein µC Register
.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse
out SPL, temp1
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse
out SPH, temp1

ldi temp1, 0xFF ; Port D = Ausgang
out DDRD, temp1

rcall lcd_init ; Display initialisieren
rcall lcd_clear ; Display löschen

ldi temp1, 'T' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 'e' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 's' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 't' ; Zeichen anzeigen
rcall lcd_data

loop:
rjmp loop

.include "lcd-routines.asm" ; LCD-Routinen werden hier eingefügt
</avrasm>

Für längere Texte ist die Methode, jedes Zeichen einzeln in das Register zu laden und "lcd_data" aufzurufen natürlich nicht sehr praktisch. Dazu später aber mehr.

Bisher wurden in Register immer irgendwelche Zahlenwerte geladen, aber in diesem Programm kommt plötzlich die Anweisung
<avrasm>
ldi temp1, 'T'
</avrasm>
vor. Wie ist diese zu verstehen? Passiert hier etwas grundlegend anderes als beim Laden einer Zahl in ein Register?

Die Antwort darauf lautet: Nein. Auch hier wird letztendlich nur eine Zahl in ein Register geladen. Der Schlüssel zum Verständnis beruht darauf, dass zum LCD, so wie zu allen Ausgabegeräten, für die Ausgabe von Texten immer nur Zahlen übertragen werden, sog. Codes. Zum Beispiel könnte man vereinbaren, dass ein LCD, wenn es den Ausgabecode 65 erhält, ein 'A' anzeigt, bei einem Ausgabecode von 66 ein 'B' usw. Naturgemäß gibt es daher viele verschiedene Code-Buchstaben Zuordnungen. Damit hier etwas Ordnung in das potentielle Chaos kommt, hat man sich bereits in der Steinzeit der Programmierung auf bestimmte Codetabellen geeinigt, von denen die verbreitetste sicherlich die ASCII-Zuordnung ist.

==ASCII==

ASCII steht für ''American Standard Code for Information Interchange'' und ist ein standardisierter Code zur Zeichenumsetzung. Die Codetabelle sieht hexadezimal dabei wie folgt aus:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ||x0||x1||x2||x3||x4||x5||x6||x7||x8||x9||xA||xB||xC||xD||xE||xF
|-
!style="background-color:#ffddcc"| 0x
|NUL||SOH||STX||ETX||EOT||ENQ||ACK||BEL||BS||HT||LF||VT||FF||CR||SO||SI
|-
!style="background-color:#ffddcc"| 1x
|DLE||DC1||DC2||DC3||DC4||NAK||SYN||ETB||CAN||EM||SUB||ESC||FS||GS||RS||US
|-
!style="background-color:#ffddcc"| 2x
|SP||!||"||#||$||%||&||'||(||)||*||+||,||-||.||/
|-
!style="background-color:#ffddcc"| 3x
|0||1||2||3||4||5||6||7||8||9||:||;||<||=||>||?
|-
!style="background-color:#ffddcc"| 4x
|@||A||B||C||D||E||F||G||H||I||J||K||L||M||N||O
|-
!style="background-color:#ffddcc"| 5x
|P||Q||R||S||T||U||V||W||X||Y||Z||[||\||]||^||_
|-
!style="background-color:#ffddcc"| 6x
|`||a||b||c||d||e||f||g||h||i||j||k||l||m||n||o
|-
!style="background-color:#ffddcc"| 7x
|p||q||r||s||t||u||v||w||x||y||z||{|| | ||}||~||DEL
|}
</center>

Die ersten beiden Zeilen enthalten die Codes für einige Steuerzeichen, ihre vollständige Beschreibung würde hier zu weit führen. Das Zeichen '''SP''' steht für ein ''Space'', also ein Leerzeichen. '''BS''' steht für ''Backspace'', also ein Zeichen zurück. '''DEL''' steht für ''Delete'', also das Löschen eines Zeichens. '''CR''' steht für ''Carriage Return'', also wörtlich: der Wagenrücklauf (einer Schreibmaschine), während '''LF''' für ''Line feed'', also einen Zeilenvorschub steht.

Der Assembler kennt diese Codetabelle und ersetzt die Zeile

<avrasm>
ldi temp1, 'T'
</avrasm>

durch

<avrasm>
ldi temp1, $54
</avrasm>

was letztendlich auch der Lesbarkeit des Programmes zugute kommt. Funktional besteht kein Unterschied zwischen den beiden Anweisungen. Beide bewirken, dass das Register temp1 mit dem Bitmuster 01010100 ( = hexadezimal 54, = dezimal 84 oder eben der ASCII Code für '''T''') geladen wird.

Das LCD wiederrum kennt diese Code-Tabelle ebenfalls und wenn es über den Datenbus die Codezahl $54 zur Anzeige empfängt, dann schreibt es ein '''T''' an die aktuelle Cursorposition. Genauer gesagt, weiss das LCD nichts von einem '''T'''. Es sieht einfach in seinen internen Tabellen nach, welche Pixel beim Empfang der Codezahl $54 auf schwarz zu setzen sind. 'Zufällig' sind das genau jene Pixel, die für uns Menschen ein '''T''' ergeben.

==Welche Befehle versteht das LCD?==

Auf dem LCD arbeitet ein Controller vom Typ HD44780. Dieser Kontroller versteht eine Reihe von Befehlen, die allesamt mittels lcd_command gesendet werden können. Ein Kommando ist dabei nichts anderes als ein Befehlsbyte, in dem die verschiedenen Bits verschiedene Bedeutungen haben:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Bitwert || Bedeutung
|-
|align="center" | 0
||dieses Bit muss 0 sein
|-
|align="center" | 1
||dieses Bit muss 1 sein
|-
|align="center" | x
||der Zustand dieses Bits ist egal
|-
|align="center" | sonstige Buchstaben
||das Bit muss je nach gewünschter Funktionalität gesetzt werden. Die mögliche Funktionalität des jeweiligen Bits geht aus der Befehlsbeschreibung hervor.
|}
</center>

Beispiel: Das Kommando 'ON/OFF Control' soll benutzt werden, um das Display einzuschalten, der Cursor soll eingeschaltet werden und der Cursor soll blinken.
Das Befehlsbyte ist so aufgebaut:
0b00001dcb
Aus der Befehlsbeschreibung entnimmt man:
* Display ein bedeutet, dass an der Bitposition d eine 1 stehen muss. 
* Cursor ein bedeutet, dass an der Bitposition c ein 1 stehen muss. 
* Cursor blinken bedeutet, dass an der Bitposition b eine 1 stehen muss. 
Das dafür zu übertragende Befehlsbyte hat also die Gestalt 0b00001111 oder in hexadezimaler Schreibweise $0F.

===Clear display: 0b00000001===

Die Anzeige wird gelöscht und der Ausgabecursor kehrt an die Home Position (links, erste Zeile) zurück.

Ausführungszeit: 1.64ms

===Cursor home: 0b0000001x===

Der Cursor kehrt an die Home Position (links, erste Zeile) zurück. Ein verschobenes Display wird auf die Grundeinstellung zurückgesetzt.

Ausführungszeit: 40µs bis 1.64ms

===Entry mode: 0b000001is===

Legt die Cursor Richtung sowie eine mögliche Verschiebung des Displays fest
* i = 1, Cursorposition bei Ausgabe eines Zeichens erhöhen
* i = 0, Cursorposition bei Ausgabe eines Zeichens vermindern
* s = 1, Display wird gescrollt, wenn der Cursor das Ende/Anfang, je nach Einstellung von i, erreicht hat.

Ausführungszeit: 40µs

===On/off control: 0b00001dcb===

Display insgesamt ein/ausschalten; den Cursor ein/ausschalten; den Cursor auf blinken schalten/blinken aus. Wenn das Display ausgeschaltet wird, geht der Inhalt des Displays nicht verloren. Der vorher angezeigte Text wird nach wiedereinschalten erneut angezeigt.
Ist der Cursor eingeschaltet, aber Blinken ausgeschaltet, so wird der Cursor als Cursorzeile in Pixelzeile 8 dargestellt. Ist Blinken eingeschaltet, wird der Cursor als blinkendes ausgefülltes Rechteck dargestellt, welches abwechselnd mit dem Buchstaben an dieser Stelle angezeigt wird.

* d = 0, Display aus
* d = 1, Display ein
* c = 0, Cursor aus
* c = 1, Cursor ein
* b = 0, Cursor blinken aus
* b = 1, Cursor blinken ein

Ausführungszeit: 40µs

===Cursor/Scrollen: 0b0001srxx===

Bewegt den Cursor oder scrollt das Display um eine Position entweder nach rechts oder nach links.

* s = 1, Display scrollen
* s = 0, Cursor bewegen
* r = 1, nach rechts
* r = 0, nach links

Ausführungszeit: 40µs

===Konfiguration: 0b001dnfxx===

Einstellen der Interface Art, Modus, Font
* d = 0, 4-Bit Interface
* d = 1, 8-Bit Interface
* n = 0, 1 zeilig
* n = 1, 2 zeilig
* f = 0, 5x7 Pixel
* f = 1, 5x11 Pixel

Ausführungszeit: 40µs

===Character RAM Address Set: 0b01aaaaaa===

Mit diesem Kommando werden maximal 8 selbst definierte Zeichen definiert. Dazu wird der Character RAM Zeiger auf den Anfang des Character Generator (CG) RAM gesetzt und das Zeichen durch die Ausgabe von 8 Byte definiert. Der Adresszeiger wird nach Ausgabe jeder Pixelspalte (8 Bit) vom LCD selbst erhöht. Nach Beendigung der Zeichendefinition muss die Schreibposition explizit mit dem Kommando "Display RAM Address Set" wieder in den DD-RAM Bereich gesetzt werden.

aaaaaa 6-bit CG RAM Adresse

Ausführungszeit: 40µs

===Display RAM Address Set: 0b1aaaaaaa===

Den Cursor neu positionieren. Display Data (DD) Ram ist vom Character Generator (CG) Ram unabhängig. Der Adresszeiger wird bei Ausgabe eines Zeichens ins DD Ram automatisch erhöht. Das Display verhält sich so, als ob eine Zeile immer aus 40 logischen Zeichen besteht, von der, je nach konkretem Displaytyp (16 Zeichen, 20 Zeichen) immer nur ein Teil sichtbar ist.

aaaaaaa 7-bit DD RAM Adresse. Auf 2-zeiligen Displays (und den meisten 16x1 Displays), kann die Adressangabe wie folgt interpretiert werden:

1laaaaaa
* l = Zeilennummer (0 oder 1)
* a = 6-Bit Spaltennummer

--------------------------------
DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
--- --- --- --- --- --- --- ---
1 A A A A A A A

Setzt die DDRAM Adresse:

Wenn N = 0 (1 line display)
AAAAAAA = "00h" - "4Fh"

Wenn N = 1 (2 line display) ((1x16))
AAAAAAA = "00h" - "27h" Zeile 1. (0x80)
AAAAAAA = "40h" - "67h" Zeile 2. (0xC0)

Ausführungszeit: 40µs

==Einschub: Code aufräumen==

Es wird Zeit, sich einmal etwas kritisch mit den bisher geschriebenen Funktionen auseinander zu setzen.

===Portnamen aus dem Code herausziehen===

Wenn wir die LCD-Funktionen einmal genauer betrachten, dann fällt sofort auf, dass über die Funktionen verstreut immer wieder das '''PORTD''' sowie einzelne Zahlen für die Pins an diesem Port auftauchen. Wenn das LCD an einem anderen Port betrieben werden soll, oder sich die Pin-Belegung ändert, dann muss an all diesen Stellen eine Anpassung vorgenommen werden. Dabei darf keine einzige Stelle übersehen werden, ansonsten würden die LCD-Funktionen nicht oder nicht vollständig funktionieren.

Eine Möglichkeit, dem vorzubeugen, ist es, diese immer gleichbleibenden Dinge an den Anfang der LCD-Funktionen vorzuziehen. Anstelle von PORTD wird dann im Code ein anderer Name benutzt, den man frei vergeben kann. Dem Assembler wird nur noch mitgeteilt, das dieser Name für PORTD steht. Muss das LCD an einen anderen Port angeschlossen werden, so wird nur diese Zurodnung geändert und der Assembler passt dann im restlichen Code alle davon abhängigen Anweisungen an:

<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LCD-Routinen ;;
;; ============ ;;
;; (c)andreas-s@web.de ;;
;; ;;
;; 4bit-Interface ;;
;; DB4-DB7: PD0-PD3 ;;
;; RS: PD4 ;;
;; E: PD5 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; .equ definiert ein Symbol und dessen Wert
.equ LCD_PORT = PORTD
.equ LCD_DDR = DDRD
.equ PIN_E = 5
.equ PIN_RS = 4

;sendet ein Datenbyte an das LCD
lcd_data:
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD

lcd_command: ; wie lcd_data, nur RS=0
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out LCD_PORT, temp1
rcall lcd_enable
andi temp2, 0b00001111
out LCD_PORT, temp2
rcall lcd_enable
rcall delay50us
ret

; erzeugt den Enable-Puls
lcd_enable:
sbi LCD_PORT, PIN_E ; Enable high
nop ; 3 Taktzyklen warten
nop
nop
cbi LCD_PORT, PIN_E ; Enable wieder low
ret ; Und wieder zurück

; Pause nach jeder Übertragung
delay50us: ; 50µs Pause
ldi temp1, $42
delay50us_:dec temp1
brne delay50us_
ret ; wieder zurück

; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück

; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden
lcd_init:
ldi temp1, 0xFF ; alle Pins am Ausgabeport auf Ausgang
out LCD_DDR, temp1

ldi temp3,6
powerupwait:
rcall delay5ms
dec temp3
brne powerupwait
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet
out LCD_PORT, temp1 ; werden zur Initialisierung
rcall lcd_enable ; 1
rcall delay5ms
rcall lcd_enable ; 2
rcall delay5ms
rcall lcd_enable ; und 3!
rcall delay5ms
ldi temp1, 0b00000010 ; 4bit-Modus einstellen
out LCD_PORT, temp1
rcall lcd_enable
rcall delay5ms
ldi temp1, 0b00101000 ; 4 Bit, 2 Zeilen
rcall lcd_command
ldi temp1, 0b00001100 ; Display on, Cursor off
rcall lcd_command
ldi temp1, 0b00000100 ; endlich fertig
rcall lcd_command
ret

; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret

; Sendet den Befehl: Cursor Home
lcd_home:
ldi temp1, 0b00000010 ; Cursor Home
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Mittels '''.equ''' werden mit dem Assembler Textersetzungen vereinbart. Der Assembler ersetzt alle Vorkomnisse des Quelltextes durch den zu ersetzenden Text. Dadurch ist es z. B. möglich, alle Vorkommnisse von '''PORTD''' durch '''LCD_PORT''' auszutauschen. Wird das LCD an einen anderen Port, z. B. '''PORTB''' gelegt, dann genügt es, die Zeilen
<avrasm>
.equ LCD_PORT = PORTD
.equ LCD_DDR = DDRD
</avrasm>
durch
<avrasm>
.equ LCD_PORT = PORTB
.equ LCD_DDR = DDRB
</avrasm>
zu ersetzen. Der Assembler sorgt dann dafür, dass diese Portänderung an den relevanten Stellen im Code über die Textersetzungen einfließt. Selbiges natürlich mit der Pin-Zuordnung.

===Registerbenutzung===

Bei diesen Funktionen mussten einige Register des Prozessors benutzt werden, um darin Zwischenergebnisse zu speichern bzw. zu bearbeiten.

Beachtet werden muss dabei natürlich, dass es zu keinen Überschneidungen kommt. Solange nur jede Funktion jeweils für sich betrachtet wird, ist das kein Problem. In 20 oder 30 Code-Zeilen kann man gut verfolgen, welches Register wofür benutzt wird. Schwieriger wird es, wenn Funktionen wiederum andere Funktionen aufrufen, die ihrerseits wieder Funktionen aufrufen usw. Jede dieser Funktionen benutzt einige Register und mit zunehmender Programmgröße wird es immer schwieriger, zu verfolgen, welches Register zu welchem Zeitpunkt wofür benutzt wird.

Speziell bei Basisfunktionen wie diesen LCD-Funktionen, ist es daher oft ratsam, dafür zu sorgen, dass jede Funktion die Register wieder in dem Zustand hinterlässt, indem sie sie auch vorgefunden hat. Wir benötigen dazu wieder den Stack, auf dem die Registerinhalte bei Betreten einer Funktion zwischengespeichert werden und von dem die Register bei Verlassen einer Funktion wiederhergestellt werden.

Nehmen wir die Funktion
<avrasm>
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Diese Funktion verändert das Register temp1. Um das Register abzusichern, schreiben wir die Funktion um:

<avrasm>
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
push temp1 ; temp1 auf dem Stack sichern
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
pop temp1 ; temp1 vom Stack wiederherstellen
ret
</avrasm>

Am besten hält man sich an die Regel: Jede Funktion ist dafür zuständig, die Register zu sichern und wieder herzustellen, die sie auch selbst verändert. '''lcd_clear''' ruft die Funktionen '''lcd_command''' und '''delay5ms''' auf. Wenn diese Funktionen selbst wieder Register verändern (und das tun sie), so ist es die Aufgabe dieser Funktionen, sich um die Sicherung und das Wiederherstellen der entsprechenden Register zu kümmern. '''lcd_clear''' sollte sich nicht darum kümmern müssen. Auf diese Weise ist das Schlimmste, das einem passieren kann, dass ein paar Register unnütz gesichert und wiederhergestellt werden. Das kostet zwar etwas Rechenzeit und etwas Speicherplatz auf dem Stack, ist aber immer noch besser als das andere Extrem: Nach einem Funktionsaufruf haben einige Register nicht mehr den Wert, den sie haben sollten, und das Programm rechnet mit falschen Zahlen weiter.

===Lass den Assembler rechnen===
Betrachtet man den Code genauer, so fallen einige konstante Zahlenwerte auf (Das vorangestellte $ kennzeichnet die Zahl als Hexadezimalzahl):

<avrasm>
delay50us: ; 50µs Pause
ldi temp1, $42
delay50us_:
dec temp1
brne delay50us_
ret ; wieder zurück
</avrasm>

Der Code benötigt eine Warteschleife, die mindestens 50µs dauert. Die beiden Befehle innerhalb der Schleife benötigen 3 Takte: 1 Takt für den '''dec''' und der '''brne''' benötigt 2 Takte, wenn die Bedingung zutrifft, der Branch also genommen wird. Bei 4 Mhz werden also 4000000 / 3 * 50 / 1000000 = 66.6 Durchläufe durch die Schleife benötigt, um eine Verzögerungszeit von 50µs (0.000050 Sekunden) zu erreichen, hexadezimal ausgedrückt: $42.

Der springende Punkt ist: Bei anderen Taktfrequenzen müsste man nun jedesmal diese Berechnung machen und den entsprechenden Zahlenwert einsetzen. Das kann aber der Assembler genausogut erledigen. Am Anfang des Codes wird ein Eintrag definiert, der die Taktfrequenz festlegt. Traditionell heißt dieser Eintrag XTAL:

<avrasm>
.equ XTAL = 4000000

...

delay50us: ; 50µs Pause
ldi temp1, ( XTAL * 50 / 3 ) / 1000000
delay50us_:
dec temp1
brne delay50us_
ret ; wieder zurück
</avrasm>

An einer anderen Codestelle gibt es weitere derartige magische Zahlen:

<avrasm>
; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück
</avrasm>

Was geht hier vor?
Die innere Schleife benötigt wieder 3 Takte pro Durchlauf. Bei $C9 = 201 Durchläufen werden also 201 * 3 = 603 Takte verbraucht. In der äußeren Schleife werden pro Durchlauf alo 1 + 603 + 1 + 2 = 607 Takte verbraucht. Da die äußere Schleife $21 = 33 mal wiederholt wird, werden 20031 Takte verbraucht. Bei 4Mhz benötigt der Prozessor 20031 / 4000000 = 0.005007 Sekunden, also 5 ms.
Wird der Wiederholwert für die innere Schleife bei $C9 belassen, so werden 4000000 / 607 * 5 / 1000 Wiederholungen der äusseren Schleife benötigt. Auch diese Berechnung kann wieder der Assembler übernehmen:

<avrasm>
; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, ( XTAL * 5 / 607 ) / 1000
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück
</avrasm>

Ein kleines Problem kann bei der Verwendung dieses Verfahrens entstehen: Bei hohen Taktfrequenzen und großen Wartezeiten kann der berechnete Wert größer als 255 werden und man bekommt die Fehlermeldung "Operand(s) out of range" beim Assemblieren. Dieser Fall tritt zum Beispiel für obige Konstruktion bei einer Taktfrequenz von 16 MHz ein (genauer gesagt ab 15,3 MHz), während darunter XTAL beliebig geändert werden kann. Als einfachste Lösung bietet es sich an, die Zahl der Takte pro Schleifendurchlauf durch das Einfügen von '''nop''' zu erhöhen und die Berechnungsvorschrift anzupassen.

== Ausgabe eines konstanten Textes ==

Weiter oben wurde schon einmal ein Text ausgegeben. Dies geschah durch Ausgabe von einzelnen Zeichen. Das können wir auch anders machen. Wir können den Text im Speicher ablegen und eine Funktion schreiben, die die einzelnen Zeichen aus dem Speicher liest und aus gibt. Dabei stellt sich Frage: Woher 'weiß' die Funktion eigentlich, wie lang der Text ist? Die Antwort darauf lautet: Sie kann es nicht wissen. Wir müssen irgendwelche Vereinbarungen treffen, woran die Funktion erkennen kann, dass der Text zu Ende ist. Im Wesentlichen werden dazu 2 Methoden benutzt:
* Der Text enthält ein spezielles Zeichen, welches das Ende des Textes markiert
* Wir speichern nicht nur den Text selbst, sondern auch die Länge des Textes
Mit einer der beiden Methoden ist es der Textausgabefunktion dann ein Leichtes, den Text vollständig auszugeben.

Wir werden uns im Weiteren dafür entscheiden, ein spezielles Zeichen, eine 0 (den Wert 0, nicht das Zeichen '0'), dafür zu benutzen. Die Ausgabefunktionen werden dann etwas einfacher, als wenn bei der Ausgabe die Anzahl der bereits ausgegebenen Zeichen mitgezählt werden muss.

Den Text selbst speichern wir im Flash-Speicher, also dort, wo auch das Programm gespeichert ist:

<avrasm>
; Einen konstanten Text aus dem Flash Speicher
; ausgeben. Der Text wird mit einer 0 beendet
lcd_flash_string:
push temp1
push ZH
push ZL

lcd_flash_string_1:
lpm temp1, Z+
cpi temp1, 0
breq lcd_flash_string_2
rcall lcd_data
rjmp lcd_flash_string_1

lcd_flash_string_2:
pop ZL
pop ZH
pop temp1
ret
</avrasm>

Diese Funktion benutzt den Befehl '''lpm''', um das jeweils nächste Zeichen aus dem Flash Speicher in ein Register zur Weiterverarbeitung zu laden. Dazu wird der sog. '''Z-Pointer''' benutzt. So nennt man das Registerpaar '''R30''' und '''R31'''. Nach jedem Ladevorgang wird dabei durch den Befehl
<avrasm>
lpm temp1, Z+
</avrasm>
dieser Z-Pointer um 1 erhöht. Mittels '''cpi''' wird das in das Register '''temp1''' geladene Zeichen mit 0 verglichen. '''cpi''' vergleicht die beiden Zahlen und merkt sich das Ergebnis in einem speziellen Register in Form von Status Bits. '''cpi''' zieht dabei ganz einfach die beiden Zahlen voneinander ab. Sind sie gleich, so kommt da als Ergebnis 0 heraus und '''cpi''' setzt daher konsequenter Weise das Zero-Flag, das anzeigt, dass die vorhergegangene Operation eine 0 als Ergebnis hatte.'''breq''' wertet diese Status-Bits aus. Wenn die vorhergegangene Operation ein 0-Ergebnis hatte, das Zero-Flag also gesetzt ist, dann wird ein Sprung zum angegebenen Label durchgeführt. In Summe bewirkt also die Sequenz
<avrasm>
cpi temp1, 0
breq lcd_flash_string_2
</avrasm>
dass das gelesene Zeichen mit 0 verglichen wird und falls das gelesene
Zeichen tatsächlich 0 war, an der Stelle lcd_flash_string_2 weiter gemacht wird. Im anderen Fall wird die bereits geschriebene Funktion '''lcd_data''' aufgerufen, welche das Zeichen ausgibt. '''lcd_data''' erwartet dabei das Zeichen im Register '''temp1''', genau in dem Register, in welches wir vorher mittels '''lpm''' das Zeichen geladen hatten.

Das verwendende Programm sieht dann so aus:

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse
out SPL, temp1
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse
out SPH, temp1

rcall lcd_init ; Display initialisieren
rcall lcd_clear ; Display löschen

ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden

rcall lcd_flash_string ; Unterprogramm gibt String aus der
; durch den Z-Pointer adressiert wird
loop:
rjmp loop

text:
.db "Test",0 ; Stringkonstante, durch eine 0
; abgeschlossen

.include "lcd-routines.asm" ; LCD Funktionen
</avrasm>

Genaueres über die Verwendung unterschiedlicher Speicher findet sich im Kapitel [[AVR-Tutorial:_Speicher|Speicher]]

==Zahlen ausgeben==
Um Zahlen, die beispielsweise in einem Register gespeichert sind, ausgeben zu können, ist es notwendig sich eine Textrepräsentierung der Zahl zu generieren. Die Zahl 123 wird also in den Text "123" umgewandelt welcher dann ausgegeben wird. Aus praktischen Gründen wird allerdings der Text nicht vollständig generiert (man müsste ihn ja irgendwo zwischenspeichern) sondern die einzelnen Buchstaben werden sofort ausgegeben, sobald sie bekannt sind.

===Dezimal ausgeben===
Das Prinzip der Umwandlung ist einfach. Um herauszufinden wieviele Hunderter in der Zahl 123 enthalten sind, genügt es in einer Schleife immer wieder 100 von der Zahl abzuziehen und mitzuzählen wie oft dies gelang, bevor das Ergebnis negativ wurde. In diesem Fall lautet die Antwort: 1 mal, denn 123 - 100 macht 23. Versucht man erneut 100 anzuziehen, so ergibt sich eine negative Zahl.
Also muss eine '1' ausgeben werden. Die verbleibenden 23 werden weiter behandelt, indem festgestellt wird wieviele Zehner darin enthalten sind. Auch hier wiederum: In einer Schleife solange 10 abziehen, bis das Ergebnis negativ wurde. Konkret geht das 2 mal gut, also muss das nächste auszugebende Zeichen ein '2' sein. Damit verbleiben noch die Einer, welche direkt in das entsprechende Zeichen umgewandelt werden können. In Summe hat man also an das Display die Zeichen '1' '2' '3' ausgegeben.

<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine
;
lcd_number:
push temp1 ; die Funktion verändert temp1 und temp2,
push temp2 ; also sichern wir den Inhalt, um ihn am Ende
; wieder herstellen zu können

mov temp2, temp1 ; das Register temp1 frei machen
; abzählen wieviele Hunderter
; in der Zahl enthalten sind
;** Hunderter **
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen
lcd_number_1:
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten
; Durchlauf eine '0' in temp1)
subi temp2, 100 ; 100 abziehen
brcc lcd_number_1 ; ist dadurch kein Unterlauf entstanden?
; nein, dann zurück zu lcd_number_1
subi temp2, -100 ; 100 wieder dazuzählen, da die
; vorherhgehende Schleife 100 zuviel
; abgezogen hat
rcall lcd_data ; die Hunderterstelle ausgeben

;** Zehner **
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen
lcd_number_2:
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten
; Durchlauf eine '0' in temp1)
subi temp2, 10 ; 10 abziehen
brcc lcd_number_2 ; ist dadurch kein Unterlauf enstanden?
; nein, dann zurück zu lcd_number_2
subi temp2, -10 ; 10 wieder dazuzählen, da die
; vorherhgehende Schleife 10 zuviel
; abgezogen hat
rcall lcd_data ; die Zehnerstelle ausgeben

;** Einer **
ldi temp1, '0' ; die Zahl in temp2 ist jetzt im Bereich
add temp1, temp2 ; 0 bis 9. Einfach nur den ASCII Code für
rcall lcd_data ; '0' dazu addieren und wir erhalten dierekt
; den ASCII Code für die Ziffer

pop temp2 ; den gesicherten Inhalt von temp2 und temp1
pop temp1 ; wieder herstellen
ret ; und zurück
</avrasm>

Beachte: Diese Funktion benutzt wiederrum die Funktion '''lcd_data'''. Anders als bei den bisherigen Aufrufen ist '''lcd_number''' aber darauf angewiesen, dass '''lcd_data''' das Register '''temp2''' unangetastet lässt. Falls sie es noch nicht getan haben, dann ist das jetzt die perfekte Gelegenheit, '''lcd_data''' mit den entsprechenden '''push''' und '''pop''' Befehlen zu versehen. Sie sollten dies unbedingt zur Übung selbst machen. Am Ende muß die Funktion dann wie diese hier aussehen:

<avrasm>
;sendet ein Datenbyte an das LCD
lcd_data:
push temp2
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
pop temp2
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command: ; wie lcd_data, nur ohne RS zu setzen
push temp2
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out LCD_PORT, temp1
rcall lcd_enable
andi temp2, 0b00001111
out LCD_PORT, temp2
rcall lcd_enable
rcall delay50us
pop temp2
ret
</avrasm>

Kurz zur Funktionsweise der Funktion '''lcd_number''': Die Zahl in einem Register bewegt sich im Wertebereich 0 bis 255. Um herauszufinden, wie die Hunderterstelle lautet, zieht die Funktion einfach in einer Schleife immer wieder 100 von der Schleife ab, bis bei der Subtraktion ein Unterlauf, angezeigt durch das Setzen des Carry-Bits bei der Subtraktion, entsteht. Die Anzahl wird im Register '''temp1''' mitgezählt. Da dieses Register mit dem ASCII Code von '0' initialisiert wurde, und dieser ASCII Code bei jedem Schleifendurchlauf um 1 erhöht wird, können wir das Register '''temp1''' direkt zur Ausgabe des Zeichens für die Hunderterstelle durch die Funktion '''lcd_data''' benutzen. Völlig analog funktioniert auch die Ausgabe der Zehnerstelle.

===Unterdrückung von führenden Nullen===

Diese Funktion gibt jede Zahl im Register '''temp1''' immer mit 3 Stellen aus. Führende Nullen werden nicht unterdrückt. Möchte man dies ändern, so ist das ganz leicht möglich: Vor Ausgabe der Hunderterstelle muss lediglich überprüft werden, ob die Entsprechende Ausgabe eine '0' wäre. Ist sie das, so wird die Ausgabe übersprungen. Ist es allerdings eine Zahl 1..9, so muss sie der Zehner Stelle signalisieren, daß eine Prüfung auf eine '0' nicht stattfinden darf. Und dazu wird das T-Flag im SREG genutzt. Lediglich in der Einerstelle wird jede Ziffer wie errechnet ausgegeben.

<avrasm>
...
; die Hunderterstelle ausgeben, wenn
; sie nicht '0' ist
clt ; T-Flag löschen
cpi temp1, '0'
breq lcd_number_1a
rcall lcd_data ; die Hunderterstelle ausgeben
set ; T-Flag im SREG setzen da 100er Stelle eine
; 1..9 war

lcd_number_1a:
...

...
brts lcd_number_2a ; Test auf '0' überspringen, da 100er eine
; 1..9 war (unbedingt anzeigen
; auch wenn der Zehner eine '0' ist)
cpi temp1, '0' ; ansonsten Test auf '0'
breq lcd_number_2b
lcd_number_2a:
rcall lcd_data
lcd_number_2b:
...

</avrasm>

Das Verfahren, die einzelnen Stellen durch Subtraktion zu bestimmen, ist bei kleinen Zahlen eine durchaus gängige Alternative. Vor allem dann, wenn keine hardwaremäßige Unterstützung für Multiplikation und Division zur Verfügung steht. Ansonsten könnte man die die einzelnen Ziffern auch durch Division bestimmen. Das Prinzip ist folgendes (beispielhaft an der Zahl 52783 gezeigt)

<pre>
52783 / 10 -> 5278
52783 - 5278 * 10 -> 3

5278 / 10 -> 527
5278 - 527 * 10 -> 8

527 / 10 -> 52
527 - 52 * 10 -> 7

52 / 10 -> 5
52 - 5 * 10 -> 2

5 / 10 -> 0
5 - 0 * 10 -> 5
</pre>

Das Prinzip ist also die Restbildung bei einer fortgesetzten Division durch 10, wobei die einzelnen Ziffern in umgekehrter Reihenfolge ihrer Wertigkeit entstehen. Dadurch hat man aber ein Problem: Damit die Zeichen in der richtigen Reihenfolge ausgegeben werden können, muß man sie meistens zwischenspeichern um sie in der richtigen Reihenfole ausgeben zu können. Wird die Zahl in einem Feld von immer gleicher Größe ausgegeben, dann kann man auch die Zahl von rechts nach links ausgeben (bei einem LCD ist das möglich).

===Hexadezimal ausgeben===

Zu guter letzt hier noch eine Funktion, die eine Zahl aus dem Register '''temp1''' in hexadezimaler Form ausgibt. Die Funktion weist keine Besonderheiten auf und sollte unmittelbar verständlich sein.

<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen hexadezimal ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine
;
lcd_number_hex:
swap temp1
rcall lcd_number_hex_digit
swap temp1

lcd_number_hex_digit:
push temp1

andi temp1, $0F
cpi temp1, 10
brlt lcd_number_hex_digit_1
subi temp1, -( 'A' - '9' - 1 ) ; es wird subi mit negativer
; Konstante verwendet,
; weil es kein addi gibt
lcd_number_hex_digit_1:
subi temp1, -'0' ; ditto
rcall lcd_data

pop temp1
ret
</avrasm>

===Binär ausgeben===
Um die Sache komplett zu machen; Hier eine Routine mit der man eine 8 Bit-Zahl binär auf das LC-Display ausgeben kann:
<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen binär ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine

; eine Zahl aus dem Register temp1 binär ausgeben
lcd_number_bit:
push temp1 ; temp1 gesichert
push temp2
push temp3

mov temp2, temp1;

ldi temp3, 8; ; 8 Bits werden ausgelesen
lcd_number_loop:
dec temp3;
rol temp2; ; Datenbits ins Carry geschoben ...
brcc lcd_number_bit_carryset_0;
brcs lcd_number_bit_carryset_1;
rjmp lcd_number_loop;

lcd_number_bit_carryset_0:
ldi temp1, '0' ; Bit low ausgeben
rcall lcd_data
tst temp3;
breq lcd_number_ende;
rjmp lcd_number_loop;

lcd_number_bit_carryset_1:
ldi temp1, '1' ; Bit high ausgeben
rcall lcd_data
tst temp3;
breq lcd_number_ende;
rjmp lcd_number_loop;

lcd_number_ende:
pop temp3
pop temp2
pop temp1
ret
</avrasm>

===Eine 16-Bit Zahl aus einem Registerpärchen ausgeben===

Um eine 16 Bit Zahl auszugeben wird wieder das bewährte Schema benutzt die einzelnen Stellen durch Subtraktion abzuzählen. Da es sich hierbei allerdings um eine 16 Bit Zahl handelt, müssen die Subtraktionen als 16-Bit Arithmetik ausgeführt werden.

<avrasm>
;**********************************************************************
;
; Eine 16 Bit Zahl ohne Vorzeichen ausgeben
;
; Übergabe: Zahl im Register temp2 (low Byte) / temp3 (high Byte)
; veränderte Register: keine
;
lcd_number16:
push temp1
push temp2
push temp3

; ** Zehntausender **
ldi temp1, '0'-1
lcd_number1:
inc temp1
subi temp2, low(10000)
sbci temp3, high(10000)
brcc lcd_number1
subi temp2, low(-10000)
sbci temp3, high(-10000)
rcall lcd_data

; ** Tausender **
ldi temp1, '0'-1
lcd_number2:
inc temp1
subi temp2, low(1000)
sbci temp3, high(1000)
brcc lcd_number2
subi temp2, low(-1000)
sbci temp3, high(-1000)
rcall lcd_data

; ** Hunderter **
ldi temp1, '0'-1
lcd_number3:
inc temp1
subi temp2, low(100)
sbci temp3, high(100)
brcc lcd_number3
subi temp2, -100 ; + 100 High-Byte nicht mehr erforderlich
rcall lcd_data

; ** Zehner **
ldi temp1, '0'-1
lcd_number4:
inc temp1
subi temp2, 10
brcc lcd_number4
subi temp2, -10
rcall lcd_data

; ** Einer **
ldi temp1, '0'
add temp1, temp2
rcall lcd_data

; ** Stack aufräumen **
pop temp3
pop temp2
pop temp1

ret
</avrasm>

===Eine BCD Zahl ausgeben===

<avrasm>
;**********************************************************************
;
; Übergabe: BCD Zahl in temp1
; veränderte Register: keine
;
lcd_bcd:
push temp2

mov temp2, temp1 ; temp1 sichern
swap temp1 ; oberes mit unterem Nibble tauschen
andi temp1, 0b00001111 ; und "oberes" ausmaskieren
subi temp1, -0x30 ; in ASCII umrechnen
rcall lcd_data ; und ausgeben
mov temp1, temp2 ; ... danach unteres
andi temp1, 0b00001111
subi temp1, -0x30
rcall lcd_data
mov temp1, temp2 ; temp1 rekonstruieren

pop temp2
ret
</avrasm>

== Benutzerdefinierte Zeichen ==
[[Bild:LCD_Character_Grid.png | framed | right| Zeichenraster für 1 Zeichen]]

Das LCD erlaubt für spezielle Zeichen, welche sich nicht im Zeichensatz finden, eigene Zeichen zu definieren. Dazu werden die ersten 8 ASCII Codes reserviert, auf denen sich laut ASCII Tabelle spezielle Steuerzeichen befinden, die normalerweise keine sichtbare Anzeige hervorrufen sondern zur Steuerung von angeschlossenen Geräten dienen. Da diese Zeichen auf einem LCD keine Rolle spielen, können diese Zeichen benutzt werden um sich selbst Sonderzeichen zu erzeugen, die für die jeweilige Anwendung massgeschneidert sind.

Das LCD stellt für jedes Zeichen eine 8*5 Matrix zur Verfügung. Um sich selbst massgeschneiderte Zeichen zu erstellen, ist es am einfachsten sich zunächst auf einem Stück karriertem Papier zu erstellen.

[[Bild:BellCharacter.png | framed | right| Zeichenraster für ein Glockensymbol]]

In diesem Raster markiert man sich dann diejenigen Pixel, die im fertigen Zeichen dunkel erscheinen sollen. Als Beispiel sei hier ein Glockensymbol gezeichnet, welches in einer Telefonapplikation zb als Kennzeichnung für einen Anruf dienen könnte.

Eine Zeile in diesem Zeichen repräsentiert ein an das LCD zu übergebendes Byte, wobei nur die Bits 0 bis 4 relevant sind. Gesetzte Pixel stellen ein 1 Bit dar, nicht gesetzte Pixel sind ein 0-Bit. Das niederwertigste Bit einer Zeile befindet sich rechts. Auf diese Art wird jede Zeile in eine Binärzahl übersetzt, und 8 Bytes repräsentieren ein komplettes Zeichen. Am Beispiel des Glockensymboles: Die 8 Bytes, welches das Symbol repräsentiern, lauten: 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x1F, 0x04, 0x00,

Dem LCD wird die neue Definition übertragen, indem man dem LCD die 'Schreibposition' mittels des Kommandos ''Character RAM Address Set'' in den Zeichensatzgenerator verschiebt. Danach werden die 8 Bytes ganz normal als Daten ausgegeben, die das LCD damit in seine Zeichensatztabelle schreibt.

Durch die Wahl der Speicheradresse definiert man, welches Zeichen (0 bis 7) man eigentlich durch eine eigene Definition ersetzen will.
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ASCII Code || Zeichensatzadresse
|-
| 0 || 0x00
|-
| 1 || 0x08
|-
| 2 || 0x10
|-
| 3 || 0x18
|-
| 4 || 0x20
|-
| 5 || 0x28
|-
| 6 || 0x30
|-
| 7 || 0x38
|}

Nach erfolgter Definition des Zeichens, muss die Schreibposition wieder explizit in den DDRAM-Bereich gesetzt werden.
Danach kann ein entsprechendes Zeichen mit dem definierten ASCII Code ausgegeben werden, wobei das LCD die von uns definierte Pixelform zur Anzeige benutzt.

Zuerst müssen natürlich erstmal die Zeichen definiert werden.
Dieses geschieht einmalig durch den Aufruf der Routine "lcd_load_user_chars"
unmittelbar nach der Initialisierung des LCD-Displays.

<avrasm>
.
.
rcall lcd_init ; Display initialisieren
rcall lcd_load_user_chars ; User Zeichen in das Display laden
rcall lcd_clear ; Display löschen
.
.
</avrasm>

Durch diesen Aufruf werden die im Flash definierten Zeichen in den
GC-Ram übertragen. Diese Zeichen werden ab Adresse 0 im GC-Ram
gespeichert und sind danach wie jedes andere Zeichen nutzbar.

<avrasm>
.
.
ldi temp1, 0 ; Ausgabe des User-Char "A"
rcall lcd_data
ldi temp1, 6 ; Ausgabe des User-Char "G"
rcall lcd_data
ldi temp1, 5 ; Ausgabe des User-Char "E"
rcall lcd_data
ldi temp1, 4 ; Ausgabe des User-Char "M"
rcall lcd_data
ldi temp1, 3 ; Ausgabe des User-Char "-"
rcall lcd_data
ldi temp1, 2 ; Ausgabe des User-Char "R"
rcall lcd_data
ldi temp1, 1 ; Ausgabe des User-Char "V"
rcall lcd_data
ldi temp1, 0 ; Ausgabe des User-Char "A"
rcall lcd_data
.
.
</avrasm>

Jetzt sollte der Schriftzug "AVR-MEGA"
verkehrt herum (180 Grad gedreht) erscheinen.

Es fehlt natürlich noch die Laderoutine:

<avrasm>
;**********************************************************************
;
; Lädt User Zeichen in den GC-Ram des LCD bis Tabellenende (0xFF)
; gelesen wird. (max. 8 Zeichen können geladen werden)
;
; Übergabe: -
; veränderte Register: temp1, temp2, temp3, zh, zl
; Bemerkung: ist einmalig nach lcd_init aufzurufen
;

lcd_load_user_chars:
ldi zl, LOW (ldc_user_char * 2) ; Adresse der Zeichentabelle
ldi zh, HIGH(ldc_user_char * 2) ; in den Z-Pointer laden
clr temp3 ; aktuelles Zeichen = 0

lcd_load_user_chars_2:
clr temp2 ; Linienzähler = 0

lcd_load_user_chars_1:
ldi temp1, 0b01000000 ; Kommando: 0b01aaalll
add temp1, temp3 ; + akt. Zeichen (aaa)
add temp1, temp2 ; + akt. Linie (lll)
rcall lcd_command ; Kommando schreiben

lpm temp1, Z+ ; Zeichenline laden
rcall lcd_data ; ... und ausgeben

ldi temp1, 0b01001000 ; Kommando: 0b01aa1lll
add temp1, temp3 ; + akt. Zeichen (aaa)
add temp1, temp2 ; + akt. Linie (lll)
rcall lcd_command

lpm temp1, Z+ ; Zeichenline laden
rcall lcd_data ; ... und ausgeben

inc temp2 ; Linienzähler + 1
cpi temp2, 8 ; 8 Linien fertig?
brne lcd_load_user_chars_1 ; nein, dann nächste Linie

subi temp3, -0x10 ; zwei Zeichen weiter (addi 0x10)
lpm temp1, Z ; nächste Linie laden
cpi temp1, 0xFF ; Tabellenende erreicht?
brne lcd_load_user_chars_2 ; nein, dann die nächsten
; zwei Zeichen
ret
</avrasm>

... und die Zeichendefinition:

<avrasm>
ldc_user_char:
; Zeichen
; 0 1
.db 0b10001, 0b00100 ; @ @ , @
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b11111, 0b10001 ; @@@@@ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b01110, 0b10001 ; @@@ , @ @
.db 0b00000, 0b00000 ; ,

; Zeichen
; 2 3
.db 0b10001, 0b00000 ; @ @ ,
.db 0b01001, 0b00000 ; @ @ ,
.db 0b00101, 0b00000 ; @ @ ,
.db 0b11111, 0b11111 ; @@@@@ , @@@@@
.db 0b10001, 0b00000 ; @ @ ,
.db 0b10001, 0b00000 ; @ @ ,
.db 0b01111, 0b00000 ; @@@@ ,
.db 0b00000, 0b00000 ; ,

; Zeichen
; 4 5
.db 0b10001, 0b11111 ; @ @ , @@@@@
.db 0b10001, 0b00001 ; @ @ , @
.db 0b10001, 0b00001 ; @ @ , @
.db 0b10001, 0b01111 ; @ @ , @@@@
.db 0b10101, 0b00001 ; @ @ @ , @
.db 0b11011, 0b00001 ; @@ @@ , @
.db 0b10001, 0b11111 ; @ @ , @@@@@
.db 0b00000, 0b00000 ; ,

; Zeichen
; 6 7
.db 0b11110, 0b11111 ; @@@@ , @@@@@
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b10001, 0b00100 ; @ @ , @
.db 0b11101, 0b01110 ; @@@ @ , @@@
.db 0b00001, 0b00100 ; @ , @
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b01110, 0b11111 ; @@@ , @@@@@
.db 0b00000, 0b00000 ; ,

; End of Tab
.db 0xFF, 0xFF
</avrasm>

==Der überarbeitete, komplette Code==

Hier also die komplett überarbeitete Version der LCD Funktionen.

Die für die Benutzung relevanten Funktionen
* '''lcd_init'''
* '''lcd_clear'''
* '''lcd_home'''
* '''lcd_data'''
* '''lcd_command'''
* '''lcd_flash_string'''
* '''lcd_number'''
* '''lcd_number_hex'''
sind so ausgeführt, dass sie kein Register (ausser dem Statusregister '''SREG''') verändern. Die bei manchen Funktionen notwendige Argumente werden immer im Register '''temp1''' übergeben, wobei '''temp1''' vom Usercode definiert werden muss.

[[Media:lcd-routines.asm|Download lcd-routines.asm]]

----

{{Navigation_zurückhochvor|
zurücktext=Stack|
zurücklink=AVR-Tutorial: Stack|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Interrupts|
vorlink=AVR-Tutorial: Interrupts}}

[[Category:AVR-Tutorial]]
[[Category:LCD]]

AVR-Tutorial: LCD

2011-12-16T16:29:54Z

Klaus2m5: /* Benutzerdefinierte Zeichen */

Kaum ein elektronisches Gerät kommt heutzutage noch ohne ein LCD daher. Ist doch auch praktisch, Informationen im Klartext anzeigen zu können, ohne irgendwelche LEDs blinken zu lassen. Kein Wunder also, dass die häufigste Frage in Mikrocontroller-Foren ist: "Wie kann ich ein LCD anschließen?"

==Das LCD und sein Controller==

Die meisten Text-LCDs verwenden den Controller [[HD44780|'''HD44780''']] oder einen kompatiblen (z. B. KS0070) und haben 14 oder 16 Pins. 
Die Pinbelegung ist meist (Ausnahme z. B. TC1602E (Pollin 120420): VDD und VSS vertauscht) folgendermaßen:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen!

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Pin # || Bezeichnung || Funktion
|-
|align="center" | 1
|align="center" | VSS (selten: VDD)
|| GND (selten: +5 V)
|-
|align="center" | 2
|align="center" | VDD (selten: VSS)
|| +5 V (selten: GND)
|-
|align="center" | 3
|align="center" | VEE, V0, V5
|| Kontrastspannung (-5 V / 0 V bis 5 V)
|-
|align="center" | 4
|align="center" | RS
|| Register Select (0=Befehl/Status 1=Daten)
|-
|align="center" | 5
|align="center" | RW
|| 1=Read 0=Write
|-
|align="center" | 6
|align="center" | E
|| 0=Disable 1=Enable
|-
|align="center" | 7
|align="center" | DB0
|| Datenbit 0
|-
|align="center" | 8
|align="center" | DB1
|| Datenbit 1
|-
|align="center" | 9
|align="center" | DB2
|| Datenbit 2
|-
|align="center" | 10
|align="center" | DB3
|| Datenbit 3
|-
|align="center" | 11
|align="center" | DB4
|| Datenbit 4
|-
|align="center" | 12
|align="center" | DB5
|| Datenbit 5
|-
|align="center" | 13
|align="center" | DB6
|| Datenbit 6
|-
|align="center" | 14
|align="center" | DB7
|| Datenbit 7
|-
|align="center" | 15
|align="center" | A
|| LED-Beleuchtung, meist Anode
|-
|align="center" | 16
|align="center" | K
|| LED-Beleuchtung, meist Kathode
|-
|}
</center>

Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist das Pin1-Pad eckig oder daneben eine kleine 1 auf der LCD-Platine, ansonsten im Datenblatt nachschauen.

Bei der DIL-Version (2x7, 2x8 Kontakte) auch darauf achten, auf welcher Platinen-Seite der Stecker montiert wird: auf der falschen (meist hinteren) Seite sind dann die Flachbandleitungen 1 und 2, 3 und 4 usw. vertauscht. Das kann man kompensieren, indem man es auf der anderen Kabelseite genauso permutiert oder es auf dem Layout bewusst so legt (Stecker auf der Bottom-Seite plazieren). Man kann es NICHT kompensieren, indem man das Flachbandkabel auf der anderen Seite in den Stecker führt.

Bei LCDs mit 16-poligem Anschluss sind die beiden letzten Pins für die Hintergrundbeleuchtung reserviert. Hier unbedingt das Datenblatt zu Rate ziehen. Die beiden Anschlüsse sind je nach Hersteller verdreht beschaltet. Falls kein Datenblatt vorliegt, kann man mit einem Durchgangsprüfer feststellen, welcher Anschluss mit Masse (GND) verbunden ist.

VSS wird ganz einfach an GND angeschlossen und VCC=VDD an +5 V. VEE = V0 = V5 kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte, muss man ein 10kΩ-Potentiometer zwischen GND und 5 V schalten, mit dem Schleifer an VEE. Meist kann man den +5 V-Anschluss am Poti weglassen, da im Display ein Pull-up-Widerstand ist:

[[Bild:LCD_Vee.gif|framed|center| Gewinnung der Kontrastspannung]]

Wenn der Kontrast zu schwach sein sollte (z.B. bei tiefen Temperaturen), kann man anstelle von GND eine negative Spannung ans Kontrast-Poti legen. Diese kann bis -5 V gehen und kann leicht aus einem Timerpin des µC, einem Widerstand, zwei Dioden und zwei Kondensatoren erzeugt werden. So wird auch ein digital einstellbarer Kontrast mittels PWM ermöglicht.

Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-Bit-''' und den '''4-Bit-'''Modus.
* Für den '''8-Bit-Modus''' werden (wie der Name schon sagt) alle acht Datenleitungen zur Ansteuerung verwendet, somit kann durch einen Zugriff immer ein ganzes Byte übertragen werden.
* Der '''4-Bit-Modus''' verwendet nur die oberen vier Datenleitungen ('''DB4-DB7'''). Um ein Byte zu übertragen, braucht man somit zwei Zugriffe, wobei zuerst das höherwertige '''"Nibble"''' (= 4 Bits), also Bit 4 bis Bit 7 übertragen wird und dann das niederwertige, also Bit 0 bis Bit 3. Die unteren Datenleitungen des LCDs, die beim Lesezyklus Ausgänge sind, lässt man offen (siehe Datasheets, z. B. vom KS0070).

Der 4-Bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-Bit-Modus. 6 bzw. 7 Pins (eines Portes) reichen aus.

Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' benötigt.

* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Beim Schreiben gilt: ist RS Low, dann wird das ankommende Byte als Befehl interpretiert; Ist RS high, wird das Byte auf dem LCD angezeigt (genauer: ins Data-Register geschrieben, kann auch für den CG bestimmt sein).
* '''RW''' legt fest, ob geschrieben oder gelesen werden soll. High bedeutet lesen, low bedeutet schreiben. Wenn man RW auf lesen einstellt und RS auf Befehl, dann kann man das '''Busy-Flag''' an DB7 lesen, das anzeigt, ob das LCD den vorhergehenden Befehl fertig verarbeitet hat. Ist RS auf Daten eingestellt, dann kann man z. B. den Inhalt des Displays lesen - was jedoch nur in den wenigsten Fällen Sinn macht. Deshalb kann man RW dauerhaft auf low lassen (= an GND anschließen), so dass man noch ein IO-Pin am Controller einspart. Der Nachteil ist, dass man dann das Busy-Flag nicht lesen kann, weswegen man nach jedem Befehl ca. 50 µs (beim Return Home 2 ms, beim Clear Display 20 ms) warten sollte, um dem LCD Zeit zum Ausführen des Befehls zu geben. Dummerweise schwankt die Ausführungszeit von Display zu Display und ist auch von der Betriebsspannung abhängig. Für professionellere Sachen also lieber den IO-Pin opfern und Busy abfragen.
* Der '''E''' Anschluss schließlich signalisiert dem LCD, dass die übrigen Datenleitungen jetzt korrekte Pegel angenommen haben und es die gewünschten Daten von den Datenleitungen bzw. Kommandos von den Datenleitungen übernehmen kann. Beim Lesen gibt das Display die Daten / Status so lange aus, wie E high ist. Beim Schreiben übernimmt das Display die Daten mit der fallenden Flanke.

== Anschluss an den Controller ==

Jetzt, da wir wissen, welche Anschlüsse das LCD benötigt, können wir das LCD mit dem Mikrocontroller verbinden:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen.

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
!Pinnummer LCD || Bezeichnung || Anschluss
|-
| align="center" |1 || VSS || GND
|-
| align="center" |2 || VCC || +5 V
|-
| align="center" |3 || VEE || GND oder [[Potentiometer | Poti]]
|-
| align="center" |4 || RS || PD4 am AVR
|-
| align="center" |5 || RW || GND
|-
| align="center" |6 || E || PD5 am AVR
|-
| align="center" |7 || DB0 || nicht angeschlossen
|-
| align="center" |8 || DB1 || nicht angeschlossen
|-
| align="center" |9 || DB2 || nicht angeschlossen
|-
| align="center" |10 || DB3 || nicht angeschlossen
|-
| align="center" |11 || DB4 || PD0 am AVR
|-
| align="center" |12 || DB5 || PD1 am AVR
|-
| align="center" |13 || DB6 || PD2 am AVR
|-
| align="center" |14 || DB7 || PD3 am AVR
|-
| align="center" |15 || A || Vorsicht! Meistens nicht direkt an +5 V abschließbar, sondern nur über einen Vorwiderstand, der an die Daten der Hintergrundbeleuchtung angepasst werden muss.
|-
| align="center" |16 || K || GND
|}
</center>

Ok. Alles ist verbunden. Wenn man jetzt den Strom einschaltet, sollten ein oder zwei schwarze Balken auf dem Display angezeigt werden.

Doch wie bekommt man jetzt die Befehle und Daten in das Display? Dazu muss das LCD initialisiert werden und man muss Befehle (Commands) und seine Daten an das LCD senden. Weil die Initialisierung ein Spezialfall der Übertragung von Befehlen ist, im Folgenden zunächst die Erklärung für die Übertragung von Werten an das LCD.

== Ansteuerung des LCDs im 4-Bit-Modus ==

Um ein Byte zu übertragen, muss man es erstmal in die beiden Nibbles zerlegen, die getrennt übertragen werden. Da das obere Nibble (Bit 4 - Bit 7) als erstes übertragen wird, die 4 Datenleitungen jedoch an die vier unteren Bits des Port D angeschlossen sind, muss man die beiden Nibbles des zu übertragenden Bytes erstmal vertauschen. Der AVR kennt dazu praktischerweise einen eigenen Befehl:

<avrasm>
swap r16 ; vertauscht die beiden Nibbles von r16
</avrasm>

Aus 0b00100101 wird so z. B. 0b01010010.

Jetzt sind die Bits für die erste Phase der Übertragung an der richtigen Stelle. Trotzdem wollen wir das Ergebnis nicht einfach so mit '''out PORTD, r16''' an den Port geben. Um die Hälfte des Bytes, die jetzt nicht an die Datenleitungen des LCDs gegeben wird auf null zu setzen, verwendet man folgenden Befehl:

<avrasm>
andi r16, 0b00001111 ; Nur die vier unteren (mit 1 markierten)
; Bits werden übernommen, alle anderen werden null
</avrasm>

Also: Das obere Nibble wird erst mit dem unteren vertauscht, damit es unten ist. Dann wird das obere (das wir jetzt noch nicht brauchen) auf null gesetzt.

Jetzt müssen wir dem LCD noch mitteilen, ob wir Daten oder Befehle senden wollen. Das machen wir, indem wir das Bit, an dem RS angeschlossen ist (PD4), auf 0 (Befehl senden) oder auf 1 (Daten senden) setzen. Um ein Bit in einem normalen Register zu setzen, gibt es den Befehl sbr (Set Bit in Register). Dieser Befehl unterscheidet sich jedoch von sbi (das nur für IO-Register gilt) dadurch, dass man nicht die Nummer des zu setzenden Bits angibt, sondern eine Bitmaske. Das geht so:

<avrasm>
sbr r16, 0b00010000 ; Bit 4 setzen, alle anderen Bits bleiben gleich
</avrasm>

RS ist an PD4 angeschlossen. Wenn wir r16 an den Port D ausgeben, ist RS jetzt also high und das LCD erwartet Daten anstatt von Befehlen.

Das Ergebnis können wir jetzt endlich direkt an den Port D übergeben:

<avrasm>
out PORTD, r16
</avrasm>

Natürlich muss vorher der Port D auf Ausgang geschaltet werden, indem man 0xFF ins Datenrichtungsregister DDRD schreibt.

Um dem LCD zu signalisieren, dass es das an den Datenleitungen anliegende Nibble übernehmen kann, wird die E-Leitung (Enable, an PD5 angeschlossen) auf high und kurz darauf wieder auf low gesetzt. Ein Puls an dieser Leitung teilt also dem LCD mit, das die restlichen Leitungen jetzt ihren vom Programm gewollten Pegel eingenommen haben und gültig sind.

<avrasm>
sbi PORTD, 5 ; Enable high
nop ; 3 Taktzyklen warten ("nop" = nichts tun)
nop
nop
cbi PORTD, 5 ; Enable wieder low
</avrasm>

Die eine Hälfte des Bytes wäre damit geschafft! Die andere Hälfte kommt direkt hinterher: Alles, was an der obenstehenden Vorgehensweise geändert werden muss, ist, das "swap" (Vertauschen der beiden Nibbles) wegzulassen.

== Initialisierung des Displays ==

Allerdings gibt es noch ein Problem. Wenn ein LCD eingeschaltet wird, dann läuft es zunächst im 8 Bit Modus. Irgendwie muss das Display initialisiert und auf den 4 Bit Modus umgeschaltet werden, und zwar nur mit den 4 zur Verfügung stehenden Datenleitungen. 

Wenn es Probleme gibt, dann meistens an diesem Punkt. Die "kompatiblen" Kontroller sind gelegentlich doch nicht 100% identisch. Es lohnt sich, das Datenblatt (siehe Weblinks im Artikel [[LCD]]) genau zu lesen, in welcher Reihenfolge und mit welchen Abständen (Delays) die Initialisierungbefehle gesendet werden. Eine weitere Hilfe können Ansteuerungsbeispiele in Forenbeiträgen geben z. B.

* [http://www.mikrocontroller.net/topic/79609#664268 (A) KS0066U oder Ähnliche --- LCD Treiber]

=== Initialisierung für 4 Bit Modus ===

Achtung: Im Folgenden sind alle Bytes aus Sicht des LCD-Kontrollers angegeben! Da LCD-seitig nur die Leitungen DB4 - DB7 verwendet werden, ist daher immer nur das höherwertige Nibble gültig. Durch die Art der Verschaltung (DB4 - DB7 wurde auf dem PORT an PD0 bis PD3 angeschlossen) ergibt sich eine Verschiebung, so dass das am Kontroller auszugebende Byte nibblemässig vertauscht ist!

Die Sequenz, aus Sicht des Kontrollers, sieht so aus:

* Nach dem Anlegen der Betriebsspannung muss eine Zeit von mindestens ca. 15ms gewartet werden, um dem LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
* $3 ins Steuerregister schreiben (RS = 0)
* Mindestens 4.1ms warten
* $3 ins Steuerregister schreiben (RS = 0)
* Mindestens 100µs warten
* $3 ins Steuerregister schreiben (RS = 0)
* $2 ins Steuerregister schreiben (RS = 0), dadurch wird auf 4 Bit Daten umgestellt
* Ab jetzt muss für die Übertragung eines Bytes jeweils zuerst das höherwertige Nibble und dann das niederwertige Nibble übertragen werden, wie oben beschrieben
* Mit dem Konfigurier-Befehl $20 das Display konfigurieren (4-Bit, 1 oder 2 Zeilen, 5x7 Format)
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.

Eine Begründung, warum die ersten Befehle dreifach geschickt werden sollen, findet sich [http://www.mikrocontroller.net/topic/158983#1508510 im Forum].

=== Initialisierung für 8 Bit Modus ===

Der Vollständigkeit halber hier noch die notwendige Initialiserungssequenz für den 8 Bit Modus. Da hier die Daten komplett als 1 Byte übertragen werden können, sind einige Klimmzüge wie im 4 Bit Modus nicht notwendig. Begründung für die anfänglichen Wiederholungen siehe oben.

* Nach dem Anlegen der Betriebsspannung muss eine Zeit von mindestens ca. 15ms gewartet werden, um dem LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
* $30 ins Steuerregister schreiben (RS = 0)
* Mindestens 4.1ms warten
* $30 ins Steuerregister schreiben (RS = 0)
* Mindestens 100µs warten
* $30 ins Steuerregister schreiben (RS = 0)
* Mit dem Konfigurier-Befehl 0x30 das Display konfigurieren (8-Bit, 1 oder 2 Zeilen, 5x7 Format)
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.

== Routinen zur LCD-Ansteuerung im 4-Bit-Modus ==

Im Folgenden werden die bisherigen Grundroutinen zur LCD-Ansteuerung im 4-Bit-Modus zusammengefasst und kommentiert. Die darin enthaltenen Symbole (temp1, PORTD,...) müssen in einem dazugehörenden Hauptprogramm definiert werden. Dies wird nächsten Abschnitt ''Anwendung'' weiter erklärt.

<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LCD-Routinen ;;
;; ============ ;;
;; (c)andreas-s@web.de ;;
;; ;;
;; 4bit-Interface ;;
;; DB4-DB7: PD0-PD3 ;;
;; RS: PD4 ;;
;; E: PD5 ;;
;; ;;
;; Takt: 4 MHz ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sendet ein Datenbyte an das LCD
lcd_data:
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<4 ; entspricht 0b00010000 (Anm.1)
out PORTD, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<4 ; entspricht 0b00010000
out PORTD, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command: ; wie lcd_data, nur RS=0
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out PORTD, temp1
rcall lcd_enable
andi temp2, 0b00001111
out PORTD, temp2
rcall lcd_enable
rcall delay50us
ret

; erzeugt den Enable-Puls
;
; Bei höherem Takt (>= 8 MHz) kann es notwendig sein,
; vor dem Enable High 1-2 Wartetakte (nop) einzufügen.
; Siehe dazu http://www.mikrocontroller.net/topic/81974#685882
lcd_enable:
sbi PORTD, 5 ; Enable high
nop ; mindestens 3 Taktzyklen warten
nop
nop
cbi PORTD, 5 ; Enable wieder low
ret ; Und wieder zurück

; Pause nach jeder Übertragung
delay50us: ; 50µs Pause (bei 4 MHz)
ldi temp1, $42
delay50us_:dec temp1
brne delay50us_
ret ; wieder zurück

; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause (bei 4 MHz)
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück

; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden
lcd_init:
ldi temp3,50
powerupwait:
rcall delay5ms
dec temp3
brne powerupwait
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet
out PORTD, temp1 ; werden zur Initialisierung
rcall lcd_enable ; 1
rcall delay5ms
rcall lcd_enable ; 2
rcall delay5ms
rcall lcd_enable ; und 3!
rcall delay5ms
ldi temp1, 0b00000010 ; 4bit-Modus einstellen
out PORTD, temp1
rcall lcd_enable
rcall delay5ms
ldi temp1, 0b00101000 ; 4Bit / 2 Zeilen / 5x8
rcall lcd_command
ldi temp1, 0b00001100 ; Display ein / Cursor aus / kein Blinken
rcall lcd_command
ldi temp1, 0b00000100 ; inkrement / kein Scrollen
rcall lcd_command
ret

; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret

; Sendet den Befehl: Cursor Home
lcd_home:
ldi temp1, 0b00000010 ; Cursor Home
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Anm.1: Siehe [[Bitmanipulation]]

Weitere Funktionen (wie z. B. Cursorposition verändern) sollten mit Hilfe der [[AVR-Tutorial:_LCD#Welche_Befehle_versteht_das_LCD.3F|Befehlscodeliste]] nicht schwer zu realisieren sein. Einfach den Code in temp laden, lcd_command aufrufen und ggf. eine Pause einfügen. 
Natürlich kann man die LCD-Ansteuerung auch an einen anderen Port des Mikrocontrollers "verschieben": Wenn das LCD z. B. an Port B angeschlossen ist, dann reicht es, im Programm alle "PORTD" durch "PORTB" und "DDRD" durch "DDRB" zu ersetzen. 
Wer eine höhere Taktfrequenz als 4 MHz verwendet, der sollte daran denken, die Dauer der Verzögerungsschleifen anzupassen.

==Anwendung==

Ein Programm, das diese Routinen zur Anzeige von Text verwendet, kann z. B. so aussehen (die Datei lcd-routines.asm muss sich im gleichen Verzeichnis befinden). Nach der Initialisierung wird zuerst der Displayinhalt gelöscht. Um dem LCD ein Zeichen zu schicken, lädt man es in temp1 und ruft die Routine "lcd_data" auf. Das folgende Beispiel zeigt das Wort "Test" auf dem LCD an.

[http://www.mikrocontroller.net/sourcecode/tutorial/lcd-test.asm Download lcd-test.asm]

<avrasm>
.include "m8def.inc"

; .def definiert ein Synonym (Namen) für ein µC Register
.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse
out SPL, temp1
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse
out SPH, temp1

ldi temp1, 0xFF ; Port D = Ausgang
out DDRD, temp1

rcall lcd_init ; Display initialisieren
rcall lcd_clear ; Display löschen

ldi temp1, 'T' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 'e' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 's' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 't' ; Zeichen anzeigen
rcall lcd_data

loop:
rjmp loop

.include "lcd-routines.asm" ; LCD-Routinen werden hier eingefügt
</avrasm>

Für längere Texte ist die Methode, jedes Zeichen einzeln in das Register zu laden und "lcd_data" aufzurufen natürlich nicht sehr praktisch. Dazu später aber mehr.

Bisher wurden in Register immer irgendwelche Zahlenwerte geladen, aber in diesem Programm kommt plötzlich die Anweisung
<avrasm>
ldi temp1, 'T'
</avrasm>
vor. Wie ist diese zu verstehen? Passiert hier etwas grundlegend anderes als beim Laden einer Zahl in ein Register?

Die Antwort darauf lautet: Nein. Auch hier wird letztendlich nur eine Zahl in ein Register geladen. Der Schlüssel zum Verständnis beruht darauf, dass zum LCD, so wie zu allen Ausgabegeräten, für die Ausgabe von Texten immer nur Zahlen übertragen werden, sog. Codes. Zum Beispiel könnte man vereinbaren, dass ein LCD, wenn es den Ausgabecode 65 erhält, ein 'A' anzeigt, bei einem Ausgabecode von 66 ein 'B' usw. Naturgemäß gibt es daher viele verschiedene Code-Buchstaben Zuordnungen. Damit hier etwas Ordnung in das potentielle Chaos kommt, hat man sich bereits in der Steinzeit der Programmierung auf bestimmte Codetabellen geeinigt, von denen die verbreitetste sicherlich die ASCII-Zuordnung ist.

==ASCII==

ASCII steht für ''American Standard Code for Information Interchange'' und ist ein standardisierter Code zur Zeichenumsetzung. Die Codetabelle sieht hexadezimal dabei wie folgt aus:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ||x0||x1||x2||x3||x4||x5||x6||x7||x8||x9||xA||xB||xC||xD||xE||xF
|-
!style="background-color:#ffddcc"| 0x
|NUL||SOH||STX||ETX||EOT||ENQ||ACK||BEL||BS||HT||LF||VT||FF||CR||SO||SI
|-
!style="background-color:#ffddcc"| 1x
|DLE||DC1||DC2||DC3||DC4||NAK||SYN||ETB||CAN||EM||SUB||ESC||FS||GS||RS||US
|-
!style="background-color:#ffddcc"| 2x
|SP||!||"||#||$||%||&||'||(||)||*||+||,||-||.||/
|-
!style="background-color:#ffddcc"| 3x
|0||1||2||3||4||5||6||7||8||9||:||;||<||=||>||?
|-
!style="background-color:#ffddcc"| 4x
|@||A||B||C||D||E||F||G||H||I||J||K||L||M||N||O
|-
!style="background-color:#ffddcc"| 5x
|P||Q||R||S||T||U||V||W||X||Y||Z||[||\||]||^||_
|-
!style="background-color:#ffddcc"| 6x
|`||a||b||c||d||e||f||g||h||i||j||k||l||m||n||o
|-
!style="background-color:#ffddcc"| 7x
|p||q||r||s||t||u||v||w||x||y||z||{|| | ||}||~||DEL
|}
</center>

Die ersten beiden Zeilen enthalten die Codes für einige Steuerzeichen, ihre vollständige Beschreibung würde hier zu weit führen. Das Zeichen '''SP''' steht für ein ''Space'', also ein Leerzeichen. '''BS''' steht für ''Backspace'', also ein Zeichen zurück. '''DEL''' steht für ''Delete'', also das Löschen eines Zeichens. '''CR''' steht für ''Carriage Return'', also wörtlich: der Wagenrücklauf (einer Schreibmaschine), während '''LF''' für ''Line feed'', also einen Zeilenvorschub steht.

Der Assembler kennt diese Codetabelle und ersetzt die Zeile

<avrasm>
ldi temp1, 'T'
</avrasm>

durch

<avrasm>
ldi temp1, $54
</avrasm>

was letztendlich auch der Lesbarkeit des Programmes zugute kommt. Funktional besteht kein Unterschied zwischen den beiden Anweisungen. Beide bewirken, dass das Register temp1 mit dem Bitmuster 01010100 ( = hexadezimal 54, = dezimal 84 oder eben der ASCII Code für '''T''') geladen wird.

Das LCD wiederrum kennt diese Code-Tabelle ebenfalls und wenn es über den Datenbus die Codezahl $54 zur Anzeige empfängt, dann schreibt es ein '''T''' an die aktuelle Cursorposition. Genauer gesagt, weiss das LCD nichts von einem '''T'''. Es sieht einfach in seinen internen Tabellen nach, welche Pixel beim Empfang der Codezahl $54 auf schwarz zu setzen sind. 'Zufällig' sind das genau jene Pixel, die für uns Menschen ein '''T''' ergeben.

==Welche Befehle versteht das LCD?==

Auf dem LCD arbeitet ein Controller vom Typ HD44780. Dieser Kontroller versteht eine Reihe von Befehlen, die allesamt mittels lcd_command gesendet werden können. Ein Kommando ist dabei nichts anderes als ein Befehlsbyte, in dem die verschiedenen Bits verschiedene Bedeutungen haben:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Bitwert || Bedeutung
|-
|align="center" | 0
||dieses Bit muss 0 sein
|-
|align="center" | 1
||dieses Bit muss 1 sein
|-
|align="center" | x
||der Zustand dieses Bits ist egal
|-
|align="center" | sonstige Buchstaben
||das Bit muss je nach gewünschter Funktionalität gesetzt werden. Die mögliche Funktionalität des jeweiligen Bits geht aus der Befehlsbeschreibung hervor.
|}
</center>

Beispiel: Das Kommando 'ON/OFF Control' soll benutzt werden, um das Display einzuschalten, der Cursor soll eingeschaltet werden und der Cursor soll blinken.
Das Befehlsbyte ist so aufgebaut:
0b00001dcb
Aus der Befehlsbeschreibung entnimmt man:
* Display ein bedeutet, dass an der Bitposition d eine 1 stehen muss. 
* Cursor ein bedeutet, dass an der Bitposition c ein 1 stehen muss. 
* Cursor blinken bedeutet, dass an der Bitposition b eine 1 stehen muss. 
Das dafür zu übertragende Befehlsbyte hat also die Gestalt 0b00001111 oder in hexadezimaler Schreibweise $0F.

===Clear display: 0b00000001===

Die Anzeige wird gelöscht und der Ausgabecursor kehrt an die Home Position (links, erste Zeile) zurück.

Ausführungszeit: 1.64ms

===Cursor home: 0b0000001x===

Der Cursor kehrt an die Home Position (links, erste Zeile) zurück. Ein verschobenes Display wird auf die Grundeinstellung zurückgesetzt.

Ausführungszeit: 40µs bis 1.64ms

===Entry mode: 0b000001is===

Legt die Cursor Richtung sowie eine mögliche Verschiebung des Displays fest
* i = 1, Cursorposition bei Ausgabe eines Zeichens erhöhen
* i = 0, Cursorposition bei Ausgabe eines Zeichens vermindern
* s = 1, Display wird gescrollt, wenn der Cursor das Ende/Anfang, je nach Einstellung von i, erreicht hat.

Ausführungszeit: 40µs

===On/off control: 0b00001dcb===

Display insgesamt ein/ausschalten; den Cursor ein/ausschalten; den Cursor auf blinken schalten/blinken aus. Wenn das Display ausgeschaltet wird, geht der Inhalt des Displays nicht verloren. Der vorher angezeigte Text wird nach wiedereinschalten erneut angezeigt.
Ist der Cursor eingeschaltet, aber Blinken ausgeschaltet, so wird der Cursor als Cursorzeile in Pixelzeile 8 dargestellt. Ist Blinken eingeschaltet, wird der Cursor als blinkendes ausgefülltes Rechteck dargestellt, welches abwechselnd mit dem Buchstaben an dieser Stelle angezeigt wird.

* d = 0, Display aus
* d = 1, Display ein
* c = 0, Cursor aus
* c = 1, Cursor ein
* b = 0, Cursor blinken aus
* b = 1, Cursor blinken ein

Ausführungszeit: 40µs

===Cursor/Scrollen: 0b0001srxx===

Bewegt den Cursor oder scrollt das Display um eine Position entweder nach rechts oder nach links.

* s = 1, Display scrollen
* s = 0, Cursor bewegen
* r = 1, nach rechts
* r = 0, nach links

Ausführungszeit: 40µs

===Konfiguration: 0b001dnfxx===

Einstellen der Interface Art, Modus, Font
* d = 0, 4-Bit Interface
* d = 1, 8-Bit Interface
* n = 0, 1 zeilig
* n = 1, 2 zeilig
* f = 0, 5x7 Pixel
* f = 1, 5x11 Pixel

Ausführungszeit: 40µs

===Character RAM Address Set: 0b01aaaaaa===

Mit diesem Kommando werden maximal 8 selbst definierte Zeichen definiert. Dazu wird der Character RAM Zeiger auf den Anfang des Character Generator (CG) RAM gesetzt und das Zeichen durch die Ausgabe von 8 Byte definiert. Der Adresszeiger wird nach Ausgabe jeder Pixelspalte (8 Bit) vom LCD selbst erhöht. Nach Beendigung der Zeichendefinition muss die Schreibposition explizit mit dem Kommando "Display RAM Address Set" wieder in den DD-RAM Bereich gesetzt werden.

aaaaaa 6-bit CG RAM Adresse

Ausführungszeit: 40µs

===Display RAM Address Set: 0b1aaaaaaa===

Den Cursor neu positionieren. Display Data (DD) Ram ist vom Character Generator (CG) Ram unabhängig. Der Adresszeiger wird bei Ausgabe eines Zeichens ins DD Ram automatisch erhöht. Das Display verhält sich so, als ob eine Zeile immer aus 40 logischen Zeichen besteht, von der, je nach konkretem Displaytyp (16 Zeichen, 20 Zeichen) immer nur ein Teil sichtbar ist.

aaaaaaa 7-bit DD RAM Adresse. Auf 2-zeiligen Displays (und den meisten 16x1 Displays), kann die Adressangabe wie folgt interpretiert werden:

1laaaaaa
* l = Zeilennummer (0 oder 1)
* a = 6-Bit Spaltennummer

--------------------------------
DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
--- --- --- --- --- --- --- ---
1 A A A A A A A

Setzt die DDRAM Adresse:

Wenn N = 0 (1 line display)
AAAAAAA = "00h" - "4Fh"

Wenn N = 1 (2 line display) ((1x16))
AAAAAAA = "00h" - "27h" Zeile 1. (0x80)
AAAAAAA = "40h" - "67h" Zeile 2. (0xC0)

Ausführungszeit: 40µs

==Einschub: Code aufräumen==

Es wird Zeit, sich einmal etwas kritisch mit den bisher geschriebenen Funktionen auseinander zu setzen.

===Portnamen aus dem Code herausziehen===

Wenn wir die LCD-Funktionen einmal genauer betrachten, dann fällt sofort auf, dass über die Funktionen verstreut immer wieder das '''PORTD''' sowie einzelne Zahlen für die Pins an diesem Port auftauchen. Wenn das LCD an einem anderen Port betrieben werden soll, oder sich die Pin-Belegung ändert, dann muss an all diesen Stellen eine Anpassung vorgenommen werden. Dabei darf keine einzige Stelle übersehen werden, ansonsten würden die LCD-Funktionen nicht oder nicht vollständig funktionieren.

Eine Möglichkeit, dem vorzubeugen, ist es, diese immer gleichbleibenden Dinge an den Anfang der LCD-Funktionen vorzuziehen. Anstelle von PORTD wird dann im Code ein anderer Name benutzt, den man frei vergeben kann. Dem Assembler wird nur noch mitgeteilt, das dieser Name für PORTD steht. Muss das LCD an einen anderen Port angeschlossen werden, so wird nur diese Zurodnung geändert und der Assembler passt dann im restlichen Code alle davon abhängigen Anweisungen an:

<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LCD-Routinen ;;
;; ============ ;;
;; (c)andreas-s@web.de ;;
;; ;;
;; 4bit-Interface ;;
;; DB4-DB7: PD0-PD3 ;;
;; RS: PD4 ;;
;; E: PD5 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; .equ definiert ein Symbol und dessen Wert
.equ LCD_PORT = PORTD
.equ LCD_DDR = DDRD
.equ PIN_E = 5
.equ PIN_RS = 4

;sendet ein Datenbyte an das LCD
lcd_data:
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD

lcd_command: ; wie lcd_data, nur RS=0
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out LCD_PORT, temp1
rcall lcd_enable
andi temp2, 0b00001111
out LCD_PORT, temp2
rcall lcd_enable
rcall delay50us
ret

; erzeugt den Enable-Puls
lcd_enable:
sbi LCD_PORT, PIN_E ; Enable high
nop ; 3 Taktzyklen warten
nop
nop
cbi LCD_PORT, PIN_E ; Enable wieder low
ret ; Und wieder zurück

; Pause nach jeder Übertragung
delay50us: ; 50µs Pause
ldi temp1, $42
delay50us_:dec temp1
brne delay50us_
ret ; wieder zurück

; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück

; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden
lcd_init:
ldi temp1, 0xFF ; alle Pins am Ausgabeport auf Ausgang
out LCD_DDR, temp1

ldi temp3,6
powerupwait:
rcall delay5ms
dec temp3
brne powerupwait
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet
out LCD_PORT, temp1 ; werden zur Initialisierung
rcall lcd_enable ; 1
rcall delay5ms
rcall lcd_enable ; 2
rcall delay5ms
rcall lcd_enable ; und 3!
rcall delay5ms
ldi temp1, 0b00000010 ; 4bit-Modus einstellen
out LCD_PORT, temp1
rcall lcd_enable
rcall delay5ms
ldi temp1, 0b00101000 ; 4 Bit, 2 Zeilen
rcall lcd_command
ldi temp1, 0b00001100 ; Display on, Cursor off
rcall lcd_command
ldi temp1, 0b00000100 ; endlich fertig
rcall lcd_command
ret

; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret

; Sendet den Befehl: Cursor Home
lcd_home:
ldi temp1, 0b00000010 ; Cursor Home
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Mittels '''.equ''' werden mit dem Assembler Textersetzungen vereinbart. Der Assembler ersetzt alle Vorkomnisse des Quelltextes durch den zu ersetzenden Text. Dadurch ist es z. B. möglich, alle Vorkommnisse von '''PORTD''' durch '''LCD_PORT''' auszutauschen. Wird das LCD an einen anderen Port, z. B. '''PORTB''' gelegt, dann genügt es, die Zeilen
<avrasm>
.equ LCD_PORT = PORTD
.equ LCD_DDR = DDRD
</avrasm>
durch
<avrasm>
.equ LCD_PORT = PORTB
.equ LCD_DDR = DDRB
</avrasm>
zu ersetzen. Der Assembler sorgt dann dafür, dass diese Portänderung an den relevanten Stellen im Code über die Textersetzungen einfließt. Selbiges natürlich mit der Pin-Zuordnung.

===Registerbenutzung===

Bei diesen Funktionen mussten einige Register des Prozessors benutzt werden, um darin Zwischenergebnisse zu speichern bzw. zu bearbeiten.

Beachtet werden muss dabei natürlich, dass es zu keinen Überschneidungen kommt. Solange nur jede Funktion jeweils für sich betrachtet wird, ist das kein Problem. In 20 oder 30 Code-Zeilen kann man gut verfolgen, welches Register wofür benutzt wird. Schwieriger wird es, wenn Funktionen wiederum andere Funktionen aufrufen, die ihrerseits wieder Funktionen aufrufen usw. Jede dieser Funktionen benutzt einige Register und mit zunehmender Programmgröße wird es immer schwieriger, zu verfolgen, welches Register zu welchem Zeitpunkt wofür benutzt wird.

Speziell bei Basisfunktionen wie diesen LCD-Funktionen, ist es daher oft ratsam, dafür zu sorgen, dass jede Funktion die Register wieder in dem Zustand hinterlässt, indem sie sie auch vorgefunden hat. Wir benötigen dazu wieder den Stack, auf dem die Registerinhalte bei Betreten einer Funktion zwischengespeichert werden und von dem die Register bei Verlassen einer Funktion wiederhergestellt werden.

Nehmen wir die Funktion
<avrasm>
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Diese Funktion verändert das Register temp1. Um das Register abzusichern, schreiben wir die Funktion um:

<avrasm>
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
push temp1 ; temp1 auf dem Stack sichern
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
pop temp1 ; temp1 vom Stack wiederherstellen
ret
</avrasm>

Am besten hält man sich an die Regel: Jede Funktion ist dafür zuständig, die Register zu sichern und wieder herzustellen, die sie auch selbst verändert. '''lcd_clear''' ruft die Funktionen '''lcd_command''' und '''delay5ms''' auf. Wenn diese Funktionen selbst wieder Register verändern (und das tun sie), so ist es die Aufgabe dieser Funktionen, sich um die Sicherung und das Wiederherstellen der entsprechenden Register zu kümmern. '''lcd_clear''' sollte sich nicht darum kümmern müssen. Auf diese Weise ist das Schlimmste, das einem passieren kann, dass ein paar Register unnütz gesichert und wiederhergestellt werden. Das kostet zwar etwas Rechenzeit und etwas Speicherplatz auf dem Stack, ist aber immer noch besser als das andere Extrem: Nach einem Funktionsaufruf haben einige Register nicht mehr den Wert, den sie haben sollten, und das Programm rechnet mit falschen Zahlen weiter.

===Lass den Assembler rechnen===
Betrachtet man den Code genauer, so fallen einige konstante Zahlenwerte auf (Das vorangestellte $ kennzeichnet die Zahl als Hexadezimalzahl):

<avrasm>
delay50us: ; 50µs Pause
ldi temp1, $42
delay50us_:
dec temp1
brne delay50us_
ret ; wieder zurück
</avrasm>

Der Code benötigt eine Warteschleife, die mindestens 50µs dauert. Die beiden Befehle innerhalb der Schleife benötigen 3 Takte: 1 Takt für den '''dec''' und der '''brne''' benötigt 2 Takte, wenn die Bedingung zutrifft, der Branch also genommen wird. Bei 4 Mhz werden also 4000000 / 3 * 50 / 1000000 = 66.6 Durchläufe durch die Schleife benötigt, um eine Verzögerungszeit von 50µs (0.000050 Sekunden) zu erreichen, hexadezimal ausgedrückt: $42.

Der springende Punkt ist: Bei anderen Taktfrequenzen müsste man nun jedesmal diese Berechnung machen und den entsprechenden Zahlenwert einsetzen. Das kann aber der Assembler genausogut erledigen. Am Anfang des Codes wird ein Eintrag definiert, der die Taktfrequenz festlegt. Traditionell heißt dieser Eintrag XTAL:

<avrasm>
.equ XTAL = 4000000

...

delay50us: ; 50µs Pause
ldi temp1, ( XTAL * 50 / 3 ) / 1000000
delay50us_:
dec temp1
brne delay50us_
ret ; wieder zurück
</avrasm>

An einer anderen Codestelle gibt es weitere derartige magische Zahlen:

<avrasm>
; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück
</avrasm>

Was geht hier vor?
Die innere Schleife benötigt wieder 3 Takte pro Durchlauf. Bei $C9 = 201 Durchläufen werden also 201 * 3 = 603 Takte verbraucht. In der äußeren Schleife werden pro Durchlauf alo 1 + 603 + 1 + 2 = 607 Takte verbraucht. Da die äußere Schleife $21 = 33 mal wiederholt wird, werden 20031 Takte verbraucht. Bei 4Mhz benötigt der Prozessor 20031 / 4000000 = 0.005007 Sekunden, also 5 ms.
Wird der Wiederholwert für die innere Schleife bei $C9 belassen, so werden 4000000 / 607 * 5 / 1000 Wiederholungen der äusseren Schleife benötigt. Auch diese Berechnung kann wieder der Assembler übernehmen:

<avrasm>
; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, ( XTAL * 5 / 607 ) / 1000
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück
</avrasm>

Ein kleines Problem kann bei der Verwendung dieses Verfahrens entstehen: Bei hohen Taktfrequenzen und großen Wartezeiten kann der berechnete Wert größer als 255 werden und man bekommt die Fehlermeldung "Operand(s) out of range" beim Assemblieren. Dieser Fall tritt zum Beispiel für obige Konstruktion bei einer Taktfrequenz von 16 MHz ein (genauer gesagt ab 15,3 MHz), während darunter XTAL beliebig geändert werden kann. Als einfachste Lösung bietet es sich an, die Zahl der Takte pro Schleifendurchlauf durch das Einfügen von '''nop''' zu erhöhen und die Berechnungsvorschrift anzupassen.

== Ausgabe eines konstanten Textes ==

Weiter oben wurde schon einmal ein Text ausgegeben. Dies geschah durch Ausgabe von einzelnen Zeichen. Das können wir auch anders machen. Wir können den Text im Speicher ablegen und eine Funktion schreiben, die die einzelnen Zeichen aus dem Speicher liest und aus gibt. Dabei stellt sich Frage: Woher 'weiß' die Funktion eigentlich, wie lang der Text ist? Die Antwort darauf lautet: Sie kann es nicht wissen. Wir müssen irgendwelche Vereinbarungen treffen, woran die Funktion erkennen kann, dass der Text zu Ende ist. Im Wesentlichen werden dazu 2 Methoden benutzt:
* Der Text enthält ein spezielles Zeichen, welches das Ende des Textes markiert
* Wir speichern nicht nur den Text selbst, sondern auch die Länge des Textes
Mit einer der beiden Methoden ist es der Textausgabefunktion dann ein Leichtes, den Text vollständig auszugeben.

Wir werden uns im Weiteren dafür entscheiden, ein spezielles Zeichen, eine 0 (den Wert 0, nicht das Zeichen '0'), dafür zu benutzen. Die Ausgabefunktionen werden dann etwas einfacher, als wenn bei der Ausgabe die Anzahl der bereits ausgegebenen Zeichen mitgezählt werden muss.

Den Text selbst speichern wir im Flash-Speicher, also dort, wo auch das Programm gespeichert ist:

<avrasm>
; Einen konstanten Text aus dem Flash Speicher
; ausgeben. Der Text wird mit einer 0 beendet
lcd_flash_string:
push temp1
push ZH
push ZL

lcd_flash_string_1:
lpm temp1, Z+
cpi temp1, 0
breq lcd_flash_string_2
rcall lcd_data
rjmp lcd_flash_string_1

lcd_flash_string_2:
pop ZL
pop ZH
pop temp1
ret
</avrasm>

Diese Funktion benutzt den Befehl '''lpm''', um das jeweils nächste Zeichen aus dem Flash Speicher in ein Register zur Weiterverarbeitung zu laden. Dazu wird der sog. '''Z-Pointer''' benutzt. So nennt man das Registerpaar '''R30''' und '''R31'''. Nach jedem Ladevorgang wird dabei durch den Befehl
<avrasm>
lpm temp1, Z+
</avrasm>
dieser Z-Pointer um 1 erhöht. Mittels '''cpi''' wird das in das Register '''temp1''' geladene Zeichen mit 0 verglichen. '''cpi''' vergleicht die beiden Zahlen und merkt sich das Ergebnis in einem speziellen Register in Form von Status Bits. '''cpi''' zieht dabei ganz einfach die beiden Zahlen voneinander ab. Sind sie gleich, so kommt da als Ergebnis 0 heraus und '''cpi''' setzt daher konsequenter Weise das Zero-Flag, das anzeigt, dass die vorhergegangene Operation eine 0 als Ergebnis hatte.'''breq''' wertet diese Status-Bits aus. Wenn die vorhergegangene Operation ein 0-Ergebnis hatte, das Zero-Flag also gesetzt ist, dann wird ein Sprung zum angegebenen Label durchgeführt. In Summe bewirkt also die Sequenz
<avrasm>
cpi temp1, 0
breq lcd_flash_string_2
</avrasm>
dass das gelesene Zeichen mit 0 verglichen wird und falls das gelesene
Zeichen tatsächlich 0 war, an der Stelle lcd_flash_string_2 weiter gemacht wird. Im anderen Fall wird die bereits geschriebene Funktion '''lcd_data''' aufgerufen, welche das Zeichen ausgibt. '''lcd_data''' erwartet dabei das Zeichen im Register '''temp1''', genau in dem Register, in welches wir vorher mittels '''lpm''' das Zeichen geladen hatten.

Das verwendende Programm sieht dann so aus:

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse
out SPL, temp1
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse
out SPH, temp1

rcall lcd_init ; Display initialisieren
rcall lcd_clear ; Display löschen

ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden

rcall lcd_flash_string ; Unterprogramm gibt String aus der
; durch den Z-Pointer adressiert wird
loop:
rjmp loop

text:
.db "Test",0 ; Stringkonstante, durch eine 0
; abgeschlossen

.include "lcd-routines.asm" ; LCD Funktionen
</avrasm>

Genaueres über die Verwendung unterschiedlicher Speicher findet sich im Kapitel [[AVR-Tutorial:_Speicher|Speicher]]

==Zahlen ausgeben==
Um Zahlen, die beispielsweise in einem Register gespeichert sind, ausgeben zu können, ist es notwendig sich eine Textrepräsentierung der Zahl zu generieren. Die Zahl 123 wird also in den Text "123" umgewandelt welcher dann ausgegeben wird. Aus praktischen Gründen wird allerdings der Text nicht vollständig generiert (man müsste ihn ja irgendwo zwischenspeichern) sondern die einzelnen Buchstaben werden sofort ausgegeben, sobald sie bekannt sind.

===Dezimal ausgeben===
Das Prinzip der Umwandlung ist einfach. Um herauszufinden wieviele Hunderter in der Zahl 123 enthalten sind, genügt es in einer Schleife immer wieder 100 von der Zahl abzuziehen und mitzuzählen wie oft dies gelang, bevor das Ergebnis negativ wurde. In diesem Fall lautet die Antwort: 1 mal, denn 123 - 100 macht 23. Versucht man erneut 100 anzuziehen, so ergibt sich eine negative Zahl.
Also muss eine '1' ausgeben werden. Die verbleibenden 23 werden weiter behandelt, indem festgestellt wird wieviele Zehner darin enthalten sind. Auch hier wiederum: In einer Schleife solange 10 abziehen, bis das Ergebnis negativ wurde. Konkret geht das 2 mal gut, also muss das nächste auszugebende Zeichen ein '2' sein. Damit verbleiben noch die Einer, welche direkt in das entsprechende Zeichen umgewandelt werden können. In Summe hat man also an das Display die Zeichen '1' '2' '3' ausgegeben.

<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine
;
lcd_number:
push temp1 ; die Funktion verändert temp1 und temp2,
push temp2 ; also sichern wir den Inhalt, um ihn am Ende
; wieder herstellen zu können

mov temp2, temp1 ; das Register temp1 frei machen
; abzählen wieviele Hunderter
; in der Zahl enthalten sind
;** Hunderter **
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen
lcd_number_1:
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten
; Durchlauf eine '0' in temp1)
subi temp2, 100 ; 100 abziehen
brcc lcd_number_1 ; ist dadurch kein Unterlauf entstanden?
; nein, dann zurück zu lcd_number_1
subi temp2, -100 ; 100 wieder dazuzählen, da die
; vorherhgehende Schleife 100 zuviel
; abgezogen hat
rcall lcd_data ; die Hunderterstelle ausgeben

;** Zehner **
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen
lcd_number_2:
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten
; Durchlauf eine '0' in temp1)
subi temp2, 10 ; 10 abziehen
brcc lcd_number_2 ; ist dadurch kein Unterlauf enstanden?
; nein, dann zurück zu lcd_number_2
subi temp2, -10 ; 10 wieder dazuzählen, da die
; vorherhgehende Schleife 10 zuviel
; abgezogen hat
rcall lcd_data ; die Zehnerstelle ausgeben

;** Einer **
ldi temp1, '0' ; die Zahl in temp2 ist jetzt im Bereich
add temp1, temp2 ; 0 bis 9. Einfach nur den ASCII Code für
rcall lcd_data ; '0' dazu addieren und wir erhalten dierekt
; den ASCII Code für die Ziffer

pop temp2 ; den gesicherten Inhalt von temp2 und temp1
pop temp1 ; wieder herstellen
ret ; und zurück
</avrasm>

Beachte: Diese Funktion benutzt wiederrum die Funktion '''lcd_data'''. Anders als bei den bisherigen Aufrufen ist '''lcd_number''' aber darauf angewiesen, dass '''lcd_data''' das Register '''temp2''' unangetastet lässt. Falls sie es noch nicht getan haben, dann ist das jetzt die perfekte Gelegenheit, '''lcd_data''' mit den entsprechenden '''push''' und '''pop''' Befehlen zu versehen. Sie sollten dies unbedingt zur Übung selbst machen. Am Ende muß die Funktion dann wie diese hier aussehen:

<avrasm>
;sendet ein Datenbyte an das LCD
lcd_data:
push temp2
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
pop temp2
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command: ; wie lcd_data, nur ohne RS zu setzen
push temp2
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out LCD_PORT, temp1
rcall lcd_enable
andi temp2, 0b00001111
out LCD_PORT, temp2
rcall lcd_enable
rcall delay50us
pop temp2
ret
</avrasm>

Kurz zur Funktionsweise der Funktion '''lcd_number''': Die Zahl in einem Register bewegt sich im Wertebereich 0 bis 255. Um herauszufinden, wie die Hunderterstelle lautet, zieht die Funktion einfach in einer Schleife immer wieder 100 von der Schleife ab, bis bei der Subtraktion ein Unterlauf, angezeigt durch das Setzen des Carry-Bits bei der Subtraktion, entsteht. Die Anzahl wird im Register '''temp1''' mitgezählt. Da dieses Register mit dem ASCII Code von '0' initialisiert wurde, und dieser ASCII Code bei jedem Schleifendurchlauf um 1 erhöht wird, können wir das Register '''temp1''' direkt zur Ausgabe des Zeichens für die Hunderterstelle durch die Funktion '''lcd_data''' benutzen. Völlig analog funktioniert auch die Ausgabe der Zehnerstelle.

===Unterdrückung von führenden Nullen===

Diese Funktion gibt jede Zahl im Register '''temp1''' immer mit 3 Stellen aus. Führende Nullen werden nicht unterdrückt. Möchte man dies ändern, so ist das ganz leicht möglich: Vor Ausgabe der Hunderterstelle muss lediglich überprüft werden, ob die Entsprechende Ausgabe eine '0' wäre. Ist sie das, so wird die Ausgabe übersprungen. Ist es allerdings eine Zahl 1..9, so muss sie der Zehner Stelle signalisieren, daß eine Prüfung auf eine '0' nicht stattfinden darf. Und dazu wird das T-Flag im SREG genutzt. Lediglich in der Einerstelle wird jede Ziffer wie errechnet ausgegeben.

<avrasm>
...
; die Hunderterstelle ausgeben, wenn
; sie nicht '0' ist
clt ; T-Flag löschen
cpi temp1, '0'
breq lcd_number_1a
rcall lcd_data ; die Hunderterstelle ausgeben
set ; T-Flag im SREG setzen da 100er Stelle eine
; 1..9 war

lcd_number_1a:
...

...
brts lcd_number_2a ; Test auf '0' überspringen, da 100er eine
; 1..9 war (unbedingt anzeigen
; auch wenn der Zehner eine '0' ist)
cpi temp1, '0' ; ansonsten Test auf '0'
breq lcd_number_2b
lcd_number_2a:
rcall lcd_data
lcd_number_2b:
...

</avrasm>

Das Verfahren, die einzelnen Stellen durch Subtraktion zu bestimmen, ist bei kleinen Zahlen eine durchaus gängige Alternative. Vor allem dann, wenn keine hardwaremäßige Unterstützung für Multiplikation und Division zur Verfügung steht. Ansonsten könnte man die die einzelnen Ziffern auch durch Division bestimmen. Das Prinzip ist folgendes (beispielhaft an der Zahl 52783 gezeigt)

<pre>
52783 / 10 -> 5278
52783 - 5278 * 10 -> 3

5278 / 10 -> 527
5278 - 527 * 10 -> 8

527 / 10 -> 52
527 - 52 * 10 -> 7

52 / 10 -> 5
52 - 5 * 10 -> 2

5 / 10 -> 0
5 - 0 * 10 -> 5
</pre>

Das Prinzip ist also die Restbildung bei einer fortgesetzten Division durch 10, wobei die einzelnen Ziffern in umgekehrter Reihenfolge ihrer Wertigkeit entstehen. Dadurch hat man aber ein Problem: Damit die Zeichen in der richtigen Reihenfolge ausgegeben werden können, muß man sie meistens zwischenspeichern um sie in der richtigen Reihenfole ausgeben zu können. Wird die Zahl in einem Feld von immer gleicher Größe ausgegeben, dann kann man auch die Zahl von rechts nach links ausgeben (bei einem LCD ist das möglich).

===Hexadezimal ausgeben===

Zu guter letzt hier noch eine Funktion, die eine Zahl aus dem Register '''temp1''' in hexadezimaler Form ausgibt. Die Funktion weist keine Besonderheiten auf und sollte unmittelbar verständlich sein.

<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen hexadezimal ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine
;
lcd_number_hex:
swap temp1
rcall lcd_number_hex_digit
swap temp1

lcd_number_hex_digit:
push temp1

andi temp1, $0F
cpi temp1, 10
brlt lcd_number_hex_digit_1
subi temp1, -( 'A' - '9' - 1 ) ; es wird subi mit negativer
; Konstante verwendet,
; weil es kein addi gibt
lcd_number_hex_digit_1:
subi temp1, -'0' ; ditto
rcall lcd_data

pop temp1
ret
</avrasm>

===Binär ausgeben===
Um die Sache komplett zu machen; Hier eine Routine mit der man eine 8 Bit-Zahl binär auf das LC-Display ausgeben kann:
<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen binär ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine

; eine Zahl aus dem Register temp1 binär ausgeben
lcd_number_bit:
push temp1 ; temp1 gesichert
push temp2
push temp3

mov temp2, temp1;

ldi temp3, 8; ; 8 Bits werden ausgelesen
lcd_number_loop:
dec temp3;
rol temp2; ; Datenbits ins Carry geschoben ...
brcc lcd_number_bit_carryset_0;
brcs lcd_number_bit_carryset_1;
rjmp lcd_number_loop;

lcd_number_bit_carryset_0:
ldi temp1, '0' ; Bit low ausgeben
rcall lcd_data
tst temp3;
breq lcd_number_ende;
rjmp lcd_number_loop;

lcd_number_bit_carryset_1:
ldi temp1, '1' ; Bit high ausgeben
rcall lcd_data
tst temp3;
breq lcd_number_ende;
rjmp lcd_number_loop;

lcd_number_ende:
pop temp3
pop temp2
pop temp1
ret
</avrasm>

===Eine 16-Bit Zahl aus einem Registerpärchen ausgeben===

Um eine 16 Bit Zahl auszugeben wird wieder das bewährte Schema benutzt die einzelnen Stellen durch Subtraktion abzuzählen. Da es sich hierbei allerdings um eine 16 Bit Zahl handelt, müssen die Subtraktionen als 16-Bit Arithmetik ausgeführt werden.

<avrasm>
;**********************************************************************
;
; Eine 16 Bit Zahl ohne Vorzeichen ausgeben
;
; Übergabe: Zahl im Register temp2 (low Byte) / temp3 (high Byte)
; veränderte Register: keine
;
lcd_number16:
push temp1
push temp2
push temp3

; ** Zehntausender **
ldi temp1, '0'-1
lcd_number1:
inc temp1
subi temp2, low(10000)
sbci temp3, high(10000)
brcc lcd_number1
subi temp2, low(-10000)
sbci temp3, high(-10000)
rcall lcd_data

; ** Tausender **
ldi temp1, '0'-1
lcd_number2:
inc temp1
subi temp2, low(1000)
sbci temp3, high(1000)
brcc lcd_number2
subi temp2, low(-1000)
sbci temp3, high(-1000)
rcall lcd_data

; ** Hunderter **
ldi temp1, '0'-1
lcd_number3:
inc temp1
subi temp2, low(100)
sbci temp3, high(100)
brcc lcd_number3
subi temp2, -100 ; + 100 High-Byte nicht mehr erforderlich
rcall lcd_data

; ** Zehner **
ldi temp1, '0'-1
lcd_number4:
inc temp1
subi temp2, 10
brcc lcd_number4
subi temp2, -10
rcall lcd_data

; ** Einer **
ldi temp1, '0'
add temp1, temp2
rcall lcd_data

; ** Stack aufräumen **
pop temp3
pop temp2
pop temp1

ret
</avrasm>

===Eine BCD Zahl ausgeben===

<avrasm>
;**********************************************************************
;
; Übergabe: BCD Zahl in temp1
; veränderte Register: keine
;
lcd_bcd:
push temp2

mov temp2, temp1 ; temp1 sichern
swap temp1 ; oberes mit unterem Nibble tauschen
andi temp1, 0b00001111 ; und "oberes" ausmaskieren
subi temp1, -0x30 ; in ASCII umrechnen
rcall lcd_data ; und ausgeben
mov temp1, temp2 ; ... danach unteres
andi temp1, 0b00001111
subi temp1, -0x30
rcall lcd_data
mov temp1, temp2 ; temp1 rekonstruieren

pop temp2
ret
</avrasm>

== Benutzerdefinierte Zeichen ==
[[Bild:LCD_Character_Grid.png | framed | right| Zeichenraster für 1 Zeichen]]

Das LCD erlaubt für spezielle Zeichen, welche sich nicht im Zeichensatz finden, eigene Zeichen zu definieren. Dazu werden die ersten 8 ASCII Codes reserviert, auf denen sich laut ASCII Tabelle spezielle Steuerzeichen befinden, die normalerweise keine sichtbare Anzeige hervorrufen sondern zur Steuerung von angeschlossenen Geräten dienen. Da diese Zeichen auf einem LCD keine Rolle spielen, können diese Zeichen benutzt werden um sich selbst Sonderzeichen zu erzeugen, die für die jeweilige Anwendung massgeschneidert sind.

Das LCD stellt für jedes Zeichen eine 8*5 Matrix zur Verfügung. Um sich selbst massgeschneiderte Zeichen zu erstellen, ist es am einfachsten sich zunächst auf einem Stück karriertem Papier zu erstellen.

[[Bild:BellCharacter.png | framed | right| Zeichenraster für ein Glockensymbol]]

In diesem Raster markiert man sich dann diejenigen Pixel, die im fertigen Zeichen dunkel erscheinen sollen. Als Beispiel sei hier ein Glockensymbol gezeichnet, welches in einer Telefonapplikation zb als Kennzeichnung für einen Anruf dienen könnte.

Eine Reihe in diesem Zeichen repräsentiert ein an das LCD zu übergebendes Byte, wobei nur die letzten 5 Bits relevant sind. Gesetzte Pixel stellen ein 1 Bit dar, nicht gesetzte Pixel sind ein 0-Bit. Das niedrigstwertige Bit einer Reihe befindet sich rechts. Auf diese Art wird jede Spalte in eine Binärzahl übersetzt, und 8 Bytes repräsentieren ein komplettes Zeichen. Am Beispiel des Glockensymboles: Die 8 Bytes, welches das Symbol repräsentiern, lauten: 0x00, 0x04, 0x0A, 0x0A, 0x0A, 0x1F, 0x04, 0x00,

Dem LCD wird die neue Definition übertragen, indem man dem LCD die 'Schreibposition' mittels des Kommandos ''Character RAM Address Set'' in den Zeichensatzgenerator verschiebt. Danach werden die 8 Bytes ganz normal als Daten ausgegeben, die das LCD damit in seine Zeichensatztabelle schreibt.

Durch die Wahl der Speicheradresse definiert man, welches Zeichen (0 bis 7) man eigentlich durch eine eigene Definition ersetzen will.
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ASCII Code || Zeichensatzadresse
|-
| 0 || 0x00
|-
| 1 || 0x08
|-
| 2 || 0x10
|-
| 3 || 0x18
|-
| 4 || 0x20
|-
| 5 || 0x28
|-
| 6 || 0x30
|-
| 7 || 0x38
|}

Nach erfolgter Definition des Zeichens, muss die Schreibposition wieder explizit in den DDRAM-Bereich gesetzt werden.
Danach kann ein entsprechendes Zeichen mit dem definierten ASCII Code ausgegeben werden, wobei das LCD die von uns definierte Pixelform zur Anzeige benutzt.

Zuerst müssen natürlich erstmal die Zeichen definiert werden.
Dieses geschieht einmalig durch den Aufruf der Routine "lcd_load_user_chars"
unmittelbar nach der Initialisierung des LCD-Displays.

<avrasm>
.
.
rcall lcd_init ; Display initialisieren
rcall lcd_load_user_chars ; User Zeichen in das Display laden
rcall lcd_clear ; Display löschen
.
.
</avrasm>

Durch diesen Aufruf werden die im Flash definierten Zeichen in den
GC-Ram übertragen. Diese Zeichen werden ab Adresse 0 im GC-Ram
gespeichert und sind danach wie jedes andere Zeichen nutzbar.

<avrasm>
.
.
ldi temp1, 0 ; Ausgabe des User-Char "A"
rcall lcd_data
ldi temp1, 6 ; Ausgabe des User-Char "G"
rcall lcd_data
ldi temp1, 5 ; Ausgabe des User-Char "E"
rcall lcd_data
ldi temp1, 4 ; Ausgabe des User-Char "M"
rcall lcd_data
ldi temp1, 3 ; Ausgabe des User-Char "-"
rcall lcd_data
ldi temp1, 2 ; Ausgabe des User-Char "R"
rcall lcd_data
ldi temp1, 1 ; Ausgabe des User-Char "V"
rcall lcd_data
ldi temp1, 0 ; Ausgabe des User-Char "A"
rcall lcd_data
.
.
</avrasm>

Jetzt sollte der Schriftzug "AVR-MEGA"
verkehrt herum (180 Grad gedreht) erscheinen.

Es fehlt natürlich noch die Laderoutine:

<avrasm>
;**********************************************************************
;
; Lädt User Zeichen in den GC-Ram des LCD bis Tabellenende (0xFF)
; gelesen wird. (max. 8 Zeichen können geladen werden)
;
; Übergabe: -
; veränderte Register: temp1, temp2, temp3, zh, zl
; Bemerkung: ist einmalig nach lcd_init aufzurufen
;

lcd_load_user_chars:
ldi zl, LOW (ldc_user_char * 2) ; Adresse der Zeichentabelle
ldi zh, HIGH(ldc_user_char * 2) ; in den Z-Pointer laden
clr temp3 ; aktuelles Zeichen = 0

lcd_load_user_chars_2:
clr temp2 ; Linienzähler = 0

lcd_load_user_chars_1:
ldi temp1, 0b01000000 ; Kommando: 0b01aaalll
add temp1, temp3 ; + akt. Zeichen (aaa)
add temp1, temp2 ; + akt. Linie (lll)
rcall lcd_command ; Kommando schreiben

lpm temp1, Z+ ; Zeichenline laden
rcall lcd_data ; ... und ausgeben

ldi temp1, 0b01001000 ; Kommando: 0b01aa1lll
add temp1, temp3 ; + akt. Zeichen (aaa)
add temp1, temp2 ; + akt. Linie (lll)
rcall lcd_command

lpm temp1, Z+ ; Zeichenline laden
rcall lcd_data ; ... und ausgeben

inc temp2 ; Linienzähler + 1
cpi temp2, 8 ; 8 Linien fertig?
brne lcd_load_user_chars_1 ; nein, dann nächste Linie

subi temp3, -0x10 ; zwei Zeichen weiter (addi 0x10)
lpm temp1, Z ; nächste Linie laden
cpi temp1, 0xFF ; Tabellenende erreicht?
brne lcd_load_user_chars_2 ; nein, dann die nächsten
; zwei Zeichen
ret
</avrasm>

... und die Zeichendefinition:

<avrasm>
ldc_user_char:
; Zeichen
; 0 1
.db 0b10001, 0b00100 ; @ @ , @
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b11111, 0b10001 ; @@@@@ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b01110, 0b10001 ; @@@ , @ @
.db 0b00000, 0b00000 ; ,

; Zeichen
; 2 3
.db 0b10001, 0b00000 ; @ @ ,
.db 0b01001, 0b00000 ; @ @ ,
.db 0b00101, 0b00000 ; @ @ ,
.db 0b11111, 0b11111 ; @@@@@ , @@@@@
.db 0b10001, 0b00000 ; @ @ ,
.db 0b10001, 0b00000 ; @ @ ,
.db 0b01111, 0b00000 ; @@@@ ,
.db 0b00000, 0b00000 ; ,

; Zeichen
; 4 5
.db 0b10001, 0b11111 ; @ @ , @@@@@
.db 0b10001, 0b00001 ; @ @ , @
.db 0b10001, 0b00001 ; @ @ , @
.db 0b10001, 0b01111 ; @ @ , @@@@
.db 0b10101, 0b00001 ; @ @ @ , @
.db 0b11011, 0b00001 ; @@ @@ , @
.db 0b10001, 0b11111 ; @ @ , @@@@@
.db 0b00000, 0b00000 ; ,

; Zeichen
; 6 7
.db 0b11110, 0b11111 ; @@@@ , @@@@@
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b10001, 0b00100 ; @ @ , @
.db 0b11101, 0b01110 ; @@@ @ , @@@
.db 0b00001, 0b00100 ; @ , @
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b01110, 0b11111 ; @@@ , @@@@@
.db 0b00000, 0b00000 ; ,

; End of Tab
.db 0xFF, 0xFF
</avrasm>

==Der überarbeitete, komplette Code==

Hier also die komplett überarbeitete Version der LCD Funktionen.

Die für die Benutzung relevanten Funktionen
* '''lcd_init'''
* '''lcd_clear'''
* '''lcd_home'''
* '''lcd_data'''
* '''lcd_command'''
* '''lcd_flash_string'''
* '''lcd_number'''
* '''lcd_number_hex'''
sind so ausgeführt, dass sie kein Register (ausser dem Statusregister '''SREG''') verändern. Die bei manchen Funktionen notwendige Argumente werden immer im Register '''temp1''' übergeben, wobei '''temp1''' vom Usercode definiert werden muss.

[[Media:lcd-routines.asm|Download lcd-routines.asm]]

----

{{Navigation_zurückhochvor|
zurücktext=Stack|
zurücklink=AVR-Tutorial: Stack|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Interrupts|
vorlink=AVR-Tutorial: Interrupts}}

[[Category:AVR-Tutorial]]
[[Category:LCD]]

AVR-Tutorial: LCD

2011-12-16T16:26:34Z

Klaus2m5: /* Benutzerdefinierte Zeichen */

Kaum ein elektronisches Gerät kommt heutzutage noch ohne ein LCD daher. Ist doch auch praktisch, Informationen im Klartext anzeigen zu können, ohne irgendwelche LEDs blinken zu lassen. Kein Wunder also, dass die häufigste Frage in Mikrocontroller-Foren ist: "Wie kann ich ein LCD anschließen?"

==Das LCD und sein Controller==

Die meisten Text-LCDs verwenden den Controller [[HD44780|'''HD44780''']] oder einen kompatiblen (z. B. KS0070) und haben 14 oder 16 Pins. 
Die Pinbelegung ist meist (Ausnahme z. B. TC1602E (Pollin 120420): VDD und VSS vertauscht) folgendermaßen:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen!

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Pin # || Bezeichnung || Funktion
|-
|align="center" | 1
|align="center" | VSS (selten: VDD)
|| GND (selten: +5 V)
|-
|align="center" | 2
|align="center" | VDD (selten: VSS)
|| +5 V (selten: GND)
|-
|align="center" | 3
|align="center" | VEE, V0, V5
|| Kontrastspannung (-5 V / 0 V bis 5 V)
|-
|align="center" | 4
|align="center" | RS
|| Register Select (0=Befehl/Status 1=Daten)
|-
|align="center" | 5
|align="center" | RW
|| 1=Read 0=Write
|-
|align="center" | 6
|align="center" | E
|| 0=Disable 1=Enable
|-
|align="center" | 7
|align="center" | DB0
|| Datenbit 0
|-
|align="center" | 8
|align="center" | DB1
|| Datenbit 1
|-
|align="center" | 9
|align="center" | DB2
|| Datenbit 2
|-
|align="center" | 10
|align="center" | DB3
|| Datenbit 3
|-
|align="center" | 11
|align="center" | DB4
|| Datenbit 4
|-
|align="center" | 12
|align="center" | DB5
|| Datenbit 5
|-
|align="center" | 13
|align="center" | DB6
|| Datenbit 6
|-
|align="center" | 14
|align="center" | DB7
|| Datenbit 7
|-
|align="center" | 15
|align="center" | A
|| LED-Beleuchtung, meist Anode
|-
|align="center" | 16
|align="center" | K
|| LED-Beleuchtung, meist Kathode
|-
|}
</center>

Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist das Pin1-Pad eckig oder daneben eine kleine 1 auf der LCD-Platine, ansonsten im Datenblatt nachschauen.

Bei der DIL-Version (2x7, 2x8 Kontakte) auch darauf achten, auf welcher Platinen-Seite der Stecker montiert wird: auf der falschen (meist hinteren) Seite sind dann die Flachbandleitungen 1 und 2, 3 und 4 usw. vertauscht. Das kann man kompensieren, indem man es auf der anderen Kabelseite genauso permutiert oder es auf dem Layout bewusst so legt (Stecker auf der Bottom-Seite plazieren). Man kann es NICHT kompensieren, indem man das Flachbandkabel auf der anderen Seite in den Stecker führt.

Bei LCDs mit 16-poligem Anschluss sind die beiden letzten Pins für die Hintergrundbeleuchtung reserviert. Hier unbedingt das Datenblatt zu Rate ziehen. Die beiden Anschlüsse sind je nach Hersteller verdreht beschaltet. Falls kein Datenblatt vorliegt, kann man mit einem Durchgangsprüfer feststellen, welcher Anschluss mit Masse (GND) verbunden ist.

VSS wird ganz einfach an GND angeschlossen und VCC=VDD an +5 V. VEE = V0 = V5 kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte, muss man ein 10kΩ-Potentiometer zwischen GND und 5 V schalten, mit dem Schleifer an VEE. Meist kann man den +5 V-Anschluss am Poti weglassen, da im Display ein Pull-up-Widerstand ist:

[[Bild:LCD_Vee.gif|framed|center| Gewinnung der Kontrastspannung]]

Wenn der Kontrast zu schwach sein sollte (z.B. bei tiefen Temperaturen), kann man anstelle von GND eine negative Spannung ans Kontrast-Poti legen. Diese kann bis -5 V gehen und kann leicht aus einem Timerpin des µC, einem Widerstand, zwei Dioden und zwei Kondensatoren erzeugt werden. So wird auch ein digital einstellbarer Kontrast mittels PWM ermöglicht.

Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-Bit-''' und den '''4-Bit-'''Modus.
* Für den '''8-Bit-Modus''' werden (wie der Name schon sagt) alle acht Datenleitungen zur Ansteuerung verwendet, somit kann durch einen Zugriff immer ein ganzes Byte übertragen werden.
* Der '''4-Bit-Modus''' verwendet nur die oberen vier Datenleitungen ('''DB4-DB7'''). Um ein Byte zu übertragen, braucht man somit zwei Zugriffe, wobei zuerst das höherwertige '''"Nibble"''' (= 4 Bits), also Bit 4 bis Bit 7 übertragen wird und dann das niederwertige, also Bit 0 bis Bit 3. Die unteren Datenleitungen des LCDs, die beim Lesezyklus Ausgänge sind, lässt man offen (siehe Datasheets, z. B. vom KS0070).

Der 4-Bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-Bit-Modus. 6 bzw. 7 Pins (eines Portes) reichen aus.

Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' benötigt.

* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Beim Schreiben gilt: ist RS Low, dann wird das ankommende Byte als Befehl interpretiert; Ist RS high, wird das Byte auf dem LCD angezeigt (genauer: ins Data-Register geschrieben, kann auch für den CG bestimmt sein).
* '''RW''' legt fest, ob geschrieben oder gelesen werden soll. High bedeutet lesen, low bedeutet schreiben. Wenn man RW auf lesen einstellt und RS auf Befehl, dann kann man das '''Busy-Flag''' an DB7 lesen, das anzeigt, ob das LCD den vorhergehenden Befehl fertig verarbeitet hat. Ist RS auf Daten eingestellt, dann kann man z. B. den Inhalt des Displays lesen - was jedoch nur in den wenigsten Fällen Sinn macht. Deshalb kann man RW dauerhaft auf low lassen (= an GND anschließen), so dass man noch ein IO-Pin am Controller einspart. Der Nachteil ist, dass man dann das Busy-Flag nicht lesen kann, weswegen man nach jedem Befehl ca. 50 µs (beim Return Home 2 ms, beim Clear Display 20 ms) warten sollte, um dem LCD Zeit zum Ausführen des Befehls zu geben. Dummerweise schwankt die Ausführungszeit von Display zu Display und ist auch von der Betriebsspannung abhängig. Für professionellere Sachen also lieber den IO-Pin opfern und Busy abfragen.
* Der '''E''' Anschluss schließlich signalisiert dem LCD, dass die übrigen Datenleitungen jetzt korrekte Pegel angenommen haben und es die gewünschten Daten von den Datenleitungen bzw. Kommandos von den Datenleitungen übernehmen kann. Beim Lesen gibt das Display die Daten / Status so lange aus, wie E high ist. Beim Schreiben übernimmt das Display die Daten mit der fallenden Flanke.

== Anschluss an den Controller ==

Jetzt, da wir wissen, welche Anschlüsse das LCD benötigt, können wir das LCD mit dem Mikrocontroller verbinden:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen.

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
!Pinnummer LCD || Bezeichnung || Anschluss
|-
| align="center" |1 || VSS || GND
|-
| align="center" |2 || VCC || +5 V
|-
| align="center" |3 || VEE || GND oder [[Potentiometer | Poti]]
|-
| align="center" |4 || RS || PD4 am AVR
|-
| align="center" |5 || RW || GND
|-
| align="center" |6 || E || PD5 am AVR
|-
| align="center" |7 || DB0 || nicht angeschlossen
|-
| align="center" |8 || DB1 || nicht angeschlossen
|-
| align="center" |9 || DB2 || nicht angeschlossen
|-
| align="center" |10 || DB3 || nicht angeschlossen
|-
| align="center" |11 || DB4 || PD0 am AVR
|-
| align="center" |12 || DB5 || PD1 am AVR
|-
| align="center" |13 || DB6 || PD2 am AVR
|-
| align="center" |14 || DB7 || PD3 am AVR
|-
| align="center" |15 || A || Vorsicht! Meistens nicht direkt an +5 V abschließbar, sondern nur über einen Vorwiderstand, der an die Daten der Hintergrundbeleuchtung angepasst werden muss.
|-
| align="center" |16 || K || GND
|}
</center>

Ok. Alles ist verbunden. Wenn man jetzt den Strom einschaltet, sollten ein oder zwei schwarze Balken auf dem Display angezeigt werden.

Doch wie bekommt man jetzt die Befehle und Daten in das Display? Dazu muss das LCD initialisiert werden und man muss Befehle (Commands) und seine Daten an das LCD senden. Weil die Initialisierung ein Spezialfall der Übertragung von Befehlen ist, im Folgenden zunächst die Erklärung für die Übertragung von Werten an das LCD.

== Ansteuerung des LCDs im 4-Bit-Modus ==

Um ein Byte zu übertragen, muss man es erstmal in die beiden Nibbles zerlegen, die getrennt übertragen werden. Da das obere Nibble (Bit 4 - Bit 7) als erstes übertragen wird, die 4 Datenleitungen jedoch an die vier unteren Bits des Port D angeschlossen sind, muss man die beiden Nibbles des zu übertragenden Bytes erstmal vertauschen. Der AVR kennt dazu praktischerweise einen eigenen Befehl:

<avrasm>
swap r16 ; vertauscht die beiden Nibbles von r16
</avrasm>

Aus 0b00100101 wird so z. B. 0b01010010.

Jetzt sind die Bits für die erste Phase der Übertragung an der richtigen Stelle. Trotzdem wollen wir das Ergebnis nicht einfach so mit '''out PORTD, r16''' an den Port geben. Um die Hälfte des Bytes, die jetzt nicht an die Datenleitungen des LCDs gegeben wird auf null zu setzen, verwendet man folgenden Befehl:

<avrasm>
andi r16, 0b00001111 ; Nur die vier unteren (mit 1 markierten)
; Bits werden übernommen, alle anderen werden null
</avrasm>

Also: Das obere Nibble wird erst mit dem unteren vertauscht, damit es unten ist. Dann wird das obere (das wir jetzt noch nicht brauchen) auf null gesetzt.

Jetzt müssen wir dem LCD noch mitteilen, ob wir Daten oder Befehle senden wollen. Das machen wir, indem wir das Bit, an dem RS angeschlossen ist (PD4), auf 0 (Befehl senden) oder auf 1 (Daten senden) setzen. Um ein Bit in einem normalen Register zu setzen, gibt es den Befehl sbr (Set Bit in Register). Dieser Befehl unterscheidet sich jedoch von sbi (das nur für IO-Register gilt) dadurch, dass man nicht die Nummer des zu setzenden Bits angibt, sondern eine Bitmaske. Das geht so:

<avrasm>
sbr r16, 0b00010000 ; Bit 4 setzen, alle anderen Bits bleiben gleich
</avrasm>

RS ist an PD4 angeschlossen. Wenn wir r16 an den Port D ausgeben, ist RS jetzt also high und das LCD erwartet Daten anstatt von Befehlen.

Das Ergebnis können wir jetzt endlich direkt an den Port D übergeben:

<avrasm>
out PORTD, r16
</avrasm>

Natürlich muss vorher der Port D auf Ausgang geschaltet werden, indem man 0xFF ins Datenrichtungsregister DDRD schreibt.

Um dem LCD zu signalisieren, dass es das an den Datenleitungen anliegende Nibble übernehmen kann, wird die E-Leitung (Enable, an PD5 angeschlossen) auf high und kurz darauf wieder auf low gesetzt. Ein Puls an dieser Leitung teilt also dem LCD mit, das die restlichen Leitungen jetzt ihren vom Programm gewollten Pegel eingenommen haben und gültig sind.

<avrasm>
sbi PORTD, 5 ; Enable high
nop ; 3 Taktzyklen warten ("nop" = nichts tun)
nop
nop
cbi PORTD, 5 ; Enable wieder low
</avrasm>

Die eine Hälfte des Bytes wäre damit geschafft! Die andere Hälfte kommt direkt hinterher: Alles, was an der obenstehenden Vorgehensweise geändert werden muss, ist, das "swap" (Vertauschen der beiden Nibbles) wegzulassen.

== Initialisierung des Displays ==

Allerdings gibt es noch ein Problem. Wenn ein LCD eingeschaltet wird, dann läuft es zunächst im 8 Bit Modus. Irgendwie muss das Display initialisiert und auf den 4 Bit Modus umgeschaltet werden, und zwar nur mit den 4 zur Verfügung stehenden Datenleitungen. 

Wenn es Probleme gibt, dann meistens an diesem Punkt. Die "kompatiblen" Kontroller sind gelegentlich doch nicht 100% identisch. Es lohnt sich, das Datenblatt (siehe Weblinks im Artikel [[LCD]]) genau zu lesen, in welcher Reihenfolge und mit welchen Abständen (Delays) die Initialisierungbefehle gesendet werden. Eine weitere Hilfe können Ansteuerungsbeispiele in Forenbeiträgen geben z. B.

* [http://www.mikrocontroller.net/topic/79609#664268 (A) KS0066U oder Ähnliche --- LCD Treiber]

=== Initialisierung für 4 Bit Modus ===

Achtung: Im Folgenden sind alle Bytes aus Sicht des LCD-Kontrollers angegeben! Da LCD-seitig nur die Leitungen DB4 - DB7 verwendet werden, ist daher immer nur das höherwertige Nibble gültig. Durch die Art der Verschaltung (DB4 - DB7 wurde auf dem PORT an PD0 bis PD3 angeschlossen) ergibt sich eine Verschiebung, so dass das am Kontroller auszugebende Byte nibblemässig vertauscht ist!

Die Sequenz, aus Sicht des Kontrollers, sieht so aus:

* Nach dem Anlegen der Betriebsspannung muss eine Zeit von mindestens ca. 15ms gewartet werden, um dem LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
* $3 ins Steuerregister schreiben (RS = 0)
* Mindestens 4.1ms warten
* $3 ins Steuerregister schreiben (RS = 0)
* Mindestens 100µs warten
* $3 ins Steuerregister schreiben (RS = 0)
* $2 ins Steuerregister schreiben (RS = 0), dadurch wird auf 4 Bit Daten umgestellt
* Ab jetzt muss für die Übertragung eines Bytes jeweils zuerst das höherwertige Nibble und dann das niederwertige Nibble übertragen werden, wie oben beschrieben
* Mit dem Konfigurier-Befehl $20 das Display konfigurieren (4-Bit, 1 oder 2 Zeilen, 5x7 Format)
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.

Eine Begründung, warum die ersten Befehle dreifach geschickt werden sollen, findet sich [http://www.mikrocontroller.net/topic/158983#1508510 im Forum].

=== Initialisierung für 8 Bit Modus ===

Der Vollständigkeit halber hier noch die notwendige Initialiserungssequenz für den 8 Bit Modus. Da hier die Daten komplett als 1 Byte übertragen werden können, sind einige Klimmzüge wie im 4 Bit Modus nicht notwendig. Begründung für die anfänglichen Wiederholungen siehe oben.

* Nach dem Anlegen der Betriebsspannung muss eine Zeit von mindestens ca. 15ms gewartet werden, um dem LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
* $30 ins Steuerregister schreiben (RS = 0)
* Mindestens 4.1ms warten
* $30 ins Steuerregister schreiben (RS = 0)
* Mindestens 100µs warten
* $30 ins Steuerregister schreiben (RS = 0)
* Mit dem Konfigurier-Befehl 0x30 das Display konfigurieren (8-Bit, 1 oder 2 Zeilen, 5x7 Format)
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.

== Routinen zur LCD-Ansteuerung im 4-Bit-Modus ==

Im Folgenden werden die bisherigen Grundroutinen zur LCD-Ansteuerung im 4-Bit-Modus zusammengefasst und kommentiert. Die darin enthaltenen Symbole (temp1, PORTD,...) müssen in einem dazugehörenden Hauptprogramm definiert werden. Dies wird nächsten Abschnitt ''Anwendung'' weiter erklärt.

<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LCD-Routinen ;;
;; ============ ;;
;; (c)andreas-s@web.de ;;
;; ;;
;; 4bit-Interface ;;
;; DB4-DB7: PD0-PD3 ;;
;; RS: PD4 ;;
;; E: PD5 ;;
;; ;;
;; Takt: 4 MHz ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sendet ein Datenbyte an das LCD
lcd_data:
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<4 ; entspricht 0b00010000 (Anm.1)
out PORTD, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<4 ; entspricht 0b00010000
out PORTD, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command: ; wie lcd_data, nur RS=0
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out PORTD, temp1
rcall lcd_enable
andi temp2, 0b00001111
out PORTD, temp2
rcall lcd_enable
rcall delay50us
ret

; erzeugt den Enable-Puls
;
; Bei höherem Takt (>= 8 MHz) kann es notwendig sein,
; vor dem Enable High 1-2 Wartetakte (nop) einzufügen.
; Siehe dazu http://www.mikrocontroller.net/topic/81974#685882
lcd_enable:
sbi PORTD, 5 ; Enable high
nop ; mindestens 3 Taktzyklen warten
nop
nop
cbi PORTD, 5 ; Enable wieder low
ret ; Und wieder zurück

; Pause nach jeder Übertragung
delay50us: ; 50µs Pause (bei 4 MHz)
ldi temp1, $42
delay50us_:dec temp1
brne delay50us_
ret ; wieder zurück

; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause (bei 4 MHz)
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück

; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden
lcd_init:
ldi temp3,50
powerupwait:
rcall delay5ms
dec temp3
brne powerupwait
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet
out PORTD, temp1 ; werden zur Initialisierung
rcall lcd_enable ; 1
rcall delay5ms
rcall lcd_enable ; 2
rcall delay5ms
rcall lcd_enable ; und 3!
rcall delay5ms
ldi temp1, 0b00000010 ; 4bit-Modus einstellen
out PORTD, temp1
rcall lcd_enable
rcall delay5ms
ldi temp1, 0b00101000 ; 4Bit / 2 Zeilen / 5x8
rcall lcd_command
ldi temp1, 0b00001100 ; Display ein / Cursor aus / kein Blinken
rcall lcd_command
ldi temp1, 0b00000100 ; inkrement / kein Scrollen
rcall lcd_command
ret

; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret

; Sendet den Befehl: Cursor Home
lcd_home:
ldi temp1, 0b00000010 ; Cursor Home
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Anm.1: Siehe [[Bitmanipulation]]

Weitere Funktionen (wie z. B. Cursorposition verändern) sollten mit Hilfe der [[AVR-Tutorial:_LCD#Welche_Befehle_versteht_das_LCD.3F|Befehlscodeliste]] nicht schwer zu realisieren sein. Einfach den Code in temp laden, lcd_command aufrufen und ggf. eine Pause einfügen. 
Natürlich kann man die LCD-Ansteuerung auch an einen anderen Port des Mikrocontrollers "verschieben": Wenn das LCD z. B. an Port B angeschlossen ist, dann reicht es, im Programm alle "PORTD" durch "PORTB" und "DDRD" durch "DDRB" zu ersetzen. 
Wer eine höhere Taktfrequenz als 4 MHz verwendet, der sollte daran denken, die Dauer der Verzögerungsschleifen anzupassen.

==Anwendung==

Ein Programm, das diese Routinen zur Anzeige von Text verwendet, kann z. B. so aussehen (die Datei lcd-routines.asm muss sich im gleichen Verzeichnis befinden). Nach der Initialisierung wird zuerst der Displayinhalt gelöscht. Um dem LCD ein Zeichen zu schicken, lädt man es in temp1 und ruft die Routine "lcd_data" auf. Das folgende Beispiel zeigt das Wort "Test" auf dem LCD an.

[http://www.mikrocontroller.net/sourcecode/tutorial/lcd-test.asm Download lcd-test.asm]

<avrasm>
.include "m8def.inc"

; .def definiert ein Synonym (Namen) für ein µC Register
.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse
out SPL, temp1
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse
out SPH, temp1

ldi temp1, 0xFF ; Port D = Ausgang
out DDRD, temp1

rcall lcd_init ; Display initialisieren
rcall lcd_clear ; Display löschen

ldi temp1, 'T' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 'e' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 's' ; Zeichen anzeigen
rcall lcd_data

ldi temp1, 't' ; Zeichen anzeigen
rcall lcd_data

loop:
rjmp loop

.include "lcd-routines.asm" ; LCD-Routinen werden hier eingefügt
</avrasm>

Für längere Texte ist die Methode, jedes Zeichen einzeln in das Register zu laden und "lcd_data" aufzurufen natürlich nicht sehr praktisch. Dazu später aber mehr.

Bisher wurden in Register immer irgendwelche Zahlenwerte geladen, aber in diesem Programm kommt plötzlich die Anweisung
<avrasm>
ldi temp1, 'T'
</avrasm>
vor. Wie ist diese zu verstehen? Passiert hier etwas grundlegend anderes als beim Laden einer Zahl in ein Register?

Die Antwort darauf lautet: Nein. Auch hier wird letztendlich nur eine Zahl in ein Register geladen. Der Schlüssel zum Verständnis beruht darauf, dass zum LCD, so wie zu allen Ausgabegeräten, für die Ausgabe von Texten immer nur Zahlen übertragen werden, sog. Codes. Zum Beispiel könnte man vereinbaren, dass ein LCD, wenn es den Ausgabecode 65 erhält, ein 'A' anzeigt, bei einem Ausgabecode von 66 ein 'B' usw. Naturgemäß gibt es daher viele verschiedene Code-Buchstaben Zuordnungen. Damit hier etwas Ordnung in das potentielle Chaos kommt, hat man sich bereits in der Steinzeit der Programmierung auf bestimmte Codetabellen geeinigt, von denen die verbreitetste sicherlich die ASCII-Zuordnung ist.

==ASCII==

ASCII steht für ''American Standard Code for Information Interchange'' und ist ein standardisierter Code zur Zeichenumsetzung. Die Codetabelle sieht hexadezimal dabei wie folgt aus:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ||x0||x1||x2||x3||x4||x5||x6||x7||x8||x9||xA||xB||xC||xD||xE||xF
|-
!style="background-color:#ffddcc"| 0x
|NUL||SOH||STX||ETX||EOT||ENQ||ACK||BEL||BS||HT||LF||VT||FF||CR||SO||SI
|-
!style="background-color:#ffddcc"| 1x
|DLE||DC1||DC2||DC3||DC4||NAK||SYN||ETB||CAN||EM||SUB||ESC||FS||GS||RS||US
|-
!style="background-color:#ffddcc"| 2x
|SP||!||"||#||$||%||&||'||(||)||*||+||,||-||.||/
|-
!style="background-color:#ffddcc"| 3x
|0||1||2||3||4||5||6||7||8||9||:||;||<||=||>||?
|-
!style="background-color:#ffddcc"| 4x
|@||A||B||C||D||E||F||G||H||I||J||K||L||M||N||O
|-
!style="background-color:#ffddcc"| 5x
|P||Q||R||S||T||U||V||W||X||Y||Z||[||\||]||^||_
|-
!style="background-color:#ffddcc"| 6x
|`||a||b||c||d||e||f||g||h||i||j||k||l||m||n||o
|-
!style="background-color:#ffddcc"| 7x
|p||q||r||s||t||u||v||w||x||y||z||{|| | ||}||~||DEL
|}
</center>

Die ersten beiden Zeilen enthalten die Codes für einige Steuerzeichen, ihre vollständige Beschreibung würde hier zu weit führen. Das Zeichen '''SP''' steht für ein ''Space'', also ein Leerzeichen. '''BS''' steht für ''Backspace'', also ein Zeichen zurück. '''DEL''' steht für ''Delete'', also das Löschen eines Zeichens. '''CR''' steht für ''Carriage Return'', also wörtlich: der Wagenrücklauf (einer Schreibmaschine), während '''LF''' für ''Line feed'', also einen Zeilenvorschub steht.

Der Assembler kennt diese Codetabelle und ersetzt die Zeile

<avrasm>
ldi temp1, 'T'
</avrasm>

durch

<avrasm>
ldi temp1, $54
</avrasm>

was letztendlich auch der Lesbarkeit des Programmes zugute kommt. Funktional besteht kein Unterschied zwischen den beiden Anweisungen. Beide bewirken, dass das Register temp1 mit dem Bitmuster 01010100 ( = hexadezimal 54, = dezimal 84 oder eben der ASCII Code für '''T''') geladen wird.

Das LCD wiederrum kennt diese Code-Tabelle ebenfalls und wenn es über den Datenbus die Codezahl $54 zur Anzeige empfängt, dann schreibt es ein '''T''' an die aktuelle Cursorposition. Genauer gesagt, weiss das LCD nichts von einem '''T'''. Es sieht einfach in seinen internen Tabellen nach, welche Pixel beim Empfang der Codezahl $54 auf schwarz zu setzen sind. 'Zufällig' sind das genau jene Pixel, die für uns Menschen ein '''T''' ergeben.

==Welche Befehle versteht das LCD?==

Auf dem LCD arbeitet ein Controller vom Typ HD44780. Dieser Kontroller versteht eine Reihe von Befehlen, die allesamt mittels lcd_command gesendet werden können. Ein Kommando ist dabei nichts anderes als ein Befehlsbyte, in dem die verschiedenen Bits verschiedene Bedeutungen haben:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Bitwert || Bedeutung
|-
|align="center" | 0
||dieses Bit muss 0 sein
|-
|align="center" | 1
||dieses Bit muss 1 sein
|-
|align="center" | x
||der Zustand dieses Bits ist egal
|-
|align="center" | sonstige Buchstaben
||das Bit muss je nach gewünschter Funktionalität gesetzt werden. Die mögliche Funktionalität des jeweiligen Bits geht aus der Befehlsbeschreibung hervor.
|}
</center>

Beispiel: Das Kommando 'ON/OFF Control' soll benutzt werden, um das Display einzuschalten, der Cursor soll eingeschaltet werden und der Cursor soll blinken.
Das Befehlsbyte ist so aufgebaut:
0b00001dcb
Aus der Befehlsbeschreibung entnimmt man:
* Display ein bedeutet, dass an der Bitposition d eine 1 stehen muss. 
* Cursor ein bedeutet, dass an der Bitposition c ein 1 stehen muss. 
* Cursor blinken bedeutet, dass an der Bitposition b eine 1 stehen muss. 
Das dafür zu übertragende Befehlsbyte hat also die Gestalt 0b00001111 oder in hexadezimaler Schreibweise $0F.

===Clear display: 0b00000001===

Die Anzeige wird gelöscht und der Ausgabecursor kehrt an die Home Position (links, erste Zeile) zurück.

Ausführungszeit: 1.64ms

===Cursor home: 0b0000001x===

Der Cursor kehrt an die Home Position (links, erste Zeile) zurück. Ein verschobenes Display wird auf die Grundeinstellung zurückgesetzt.

Ausführungszeit: 40µs bis 1.64ms

===Entry mode: 0b000001is===

Legt die Cursor Richtung sowie eine mögliche Verschiebung des Displays fest
* i = 1, Cursorposition bei Ausgabe eines Zeichens erhöhen
* i = 0, Cursorposition bei Ausgabe eines Zeichens vermindern
* s = 1, Display wird gescrollt, wenn der Cursor das Ende/Anfang, je nach Einstellung von i, erreicht hat.

Ausführungszeit: 40µs

===On/off control: 0b00001dcb===

Display insgesamt ein/ausschalten; den Cursor ein/ausschalten; den Cursor auf blinken schalten/blinken aus. Wenn das Display ausgeschaltet wird, geht der Inhalt des Displays nicht verloren. Der vorher angezeigte Text wird nach wiedereinschalten erneut angezeigt.
Ist der Cursor eingeschaltet, aber Blinken ausgeschaltet, so wird der Cursor als Cursorzeile in Pixelzeile 8 dargestellt. Ist Blinken eingeschaltet, wird der Cursor als blinkendes ausgefülltes Rechteck dargestellt, welches abwechselnd mit dem Buchstaben an dieser Stelle angezeigt wird.

* d = 0, Display aus
* d = 1, Display ein
* c = 0, Cursor aus
* c = 1, Cursor ein
* b = 0, Cursor blinken aus
* b = 1, Cursor blinken ein

Ausführungszeit: 40µs

===Cursor/Scrollen: 0b0001srxx===

Bewegt den Cursor oder scrollt das Display um eine Position entweder nach rechts oder nach links.

* s = 1, Display scrollen
* s = 0, Cursor bewegen
* r = 1, nach rechts
* r = 0, nach links

Ausführungszeit: 40µs

===Konfiguration: 0b001dnfxx===

Einstellen der Interface Art, Modus, Font
* d = 0, 4-Bit Interface
* d = 1, 8-Bit Interface
* n = 0, 1 zeilig
* n = 1, 2 zeilig
* f = 0, 5x7 Pixel
* f = 1, 5x11 Pixel

Ausführungszeit: 40µs

===Character RAM Address Set: 0b01aaaaaa===

Mit diesem Kommando werden maximal 8 selbst definierte Zeichen definiert. Dazu wird der Character RAM Zeiger auf den Anfang des Character Generator (CG) RAM gesetzt und das Zeichen durch die Ausgabe von 8 Byte definiert. Der Adresszeiger wird nach Ausgabe jeder Pixelspalte (8 Bit) vom LCD selbst erhöht. Nach Beendigung der Zeichendefinition muss die Schreibposition explizit mit dem Kommando "Display RAM Address Set" wieder in den DD-RAM Bereich gesetzt werden.

aaaaaa 6-bit CG RAM Adresse

Ausführungszeit: 40µs

===Display RAM Address Set: 0b1aaaaaaa===

Den Cursor neu positionieren. Display Data (DD) Ram ist vom Character Generator (CG) Ram unabhängig. Der Adresszeiger wird bei Ausgabe eines Zeichens ins DD Ram automatisch erhöht. Das Display verhält sich so, als ob eine Zeile immer aus 40 logischen Zeichen besteht, von der, je nach konkretem Displaytyp (16 Zeichen, 20 Zeichen) immer nur ein Teil sichtbar ist.

aaaaaaa 7-bit DD RAM Adresse. Auf 2-zeiligen Displays (und den meisten 16x1 Displays), kann die Adressangabe wie folgt interpretiert werden:

1laaaaaa
* l = Zeilennummer (0 oder 1)
* a = 6-Bit Spaltennummer

--------------------------------
DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
--- --- --- --- --- --- --- ---
1 A A A A A A A

Setzt die DDRAM Adresse:

Wenn N = 0 (1 line display)
AAAAAAA = "00h" - "4Fh"

Wenn N = 1 (2 line display) ((1x16))
AAAAAAA = "00h" - "27h" Zeile 1. (0x80)
AAAAAAA = "40h" - "67h" Zeile 2. (0xC0)

Ausführungszeit: 40µs

==Einschub: Code aufräumen==

Es wird Zeit, sich einmal etwas kritisch mit den bisher geschriebenen Funktionen auseinander zu setzen.

===Portnamen aus dem Code herausziehen===

Wenn wir die LCD-Funktionen einmal genauer betrachten, dann fällt sofort auf, dass über die Funktionen verstreut immer wieder das '''PORTD''' sowie einzelne Zahlen für die Pins an diesem Port auftauchen. Wenn das LCD an einem anderen Port betrieben werden soll, oder sich die Pin-Belegung ändert, dann muss an all diesen Stellen eine Anpassung vorgenommen werden. Dabei darf keine einzige Stelle übersehen werden, ansonsten würden die LCD-Funktionen nicht oder nicht vollständig funktionieren.

Eine Möglichkeit, dem vorzubeugen, ist es, diese immer gleichbleibenden Dinge an den Anfang der LCD-Funktionen vorzuziehen. Anstelle von PORTD wird dann im Code ein anderer Name benutzt, den man frei vergeben kann. Dem Assembler wird nur noch mitgeteilt, das dieser Name für PORTD steht. Muss das LCD an einen anderen Port angeschlossen werden, so wird nur diese Zurodnung geändert und der Assembler passt dann im restlichen Code alle davon abhängigen Anweisungen an:

<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LCD-Routinen ;;
;; ============ ;;
;; (c)andreas-s@web.de ;;
;; ;;
;; 4bit-Interface ;;
;; DB4-DB7: PD0-PD3 ;;
;; RS: PD4 ;;
;; E: PD5 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; .equ definiert ein Symbol und dessen Wert
.equ LCD_PORT = PORTD
.equ LCD_DDR = DDRD
.equ PIN_E = 5
.equ PIN_RS = 4

;sendet ein Datenbyte an das LCD
lcd_data:
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD

lcd_command: ; wie lcd_data, nur RS=0
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out LCD_PORT, temp1
rcall lcd_enable
andi temp2, 0b00001111
out LCD_PORT, temp2
rcall lcd_enable
rcall delay50us
ret

; erzeugt den Enable-Puls
lcd_enable:
sbi LCD_PORT, PIN_E ; Enable high
nop ; 3 Taktzyklen warten
nop
nop
cbi LCD_PORT, PIN_E ; Enable wieder low
ret ; Und wieder zurück

; Pause nach jeder Übertragung
delay50us: ; 50µs Pause
ldi temp1, $42
delay50us_:dec temp1
brne delay50us_
ret ; wieder zurück

; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück

; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden
lcd_init:
ldi temp1, 0xFF ; alle Pins am Ausgabeport auf Ausgang
out LCD_DDR, temp1

ldi temp3,6
powerupwait:
rcall delay5ms
dec temp3
brne powerupwait
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet
out LCD_PORT, temp1 ; werden zur Initialisierung
rcall lcd_enable ; 1
rcall delay5ms
rcall lcd_enable ; 2
rcall delay5ms
rcall lcd_enable ; und 3!
rcall delay5ms
ldi temp1, 0b00000010 ; 4bit-Modus einstellen
out LCD_PORT, temp1
rcall lcd_enable
rcall delay5ms
ldi temp1, 0b00101000 ; 4 Bit, 2 Zeilen
rcall lcd_command
ldi temp1, 0b00001100 ; Display on, Cursor off
rcall lcd_command
ldi temp1, 0b00000100 ; endlich fertig
rcall lcd_command
ret

; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret

; Sendet den Befehl: Cursor Home
lcd_home:
ldi temp1, 0b00000010 ; Cursor Home
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Mittels '''.equ''' werden mit dem Assembler Textersetzungen vereinbart. Der Assembler ersetzt alle Vorkomnisse des Quelltextes durch den zu ersetzenden Text. Dadurch ist es z. B. möglich, alle Vorkommnisse von '''PORTD''' durch '''LCD_PORT''' auszutauschen. Wird das LCD an einen anderen Port, z. B. '''PORTB''' gelegt, dann genügt es, die Zeilen
<avrasm>
.equ LCD_PORT = PORTD
.equ LCD_DDR = DDRD
</avrasm>
durch
<avrasm>
.equ LCD_PORT = PORTB
.equ LCD_DDR = DDRB
</avrasm>
zu ersetzen. Der Assembler sorgt dann dafür, dass diese Portänderung an den relevanten Stellen im Code über die Textersetzungen einfließt. Selbiges natürlich mit der Pin-Zuordnung.

===Registerbenutzung===

Bei diesen Funktionen mussten einige Register des Prozessors benutzt werden, um darin Zwischenergebnisse zu speichern bzw. zu bearbeiten.

Beachtet werden muss dabei natürlich, dass es zu keinen Überschneidungen kommt. Solange nur jede Funktion jeweils für sich betrachtet wird, ist das kein Problem. In 20 oder 30 Code-Zeilen kann man gut verfolgen, welches Register wofür benutzt wird. Schwieriger wird es, wenn Funktionen wiederum andere Funktionen aufrufen, die ihrerseits wieder Funktionen aufrufen usw. Jede dieser Funktionen benutzt einige Register und mit zunehmender Programmgröße wird es immer schwieriger, zu verfolgen, welches Register zu welchem Zeitpunkt wofür benutzt wird.

Speziell bei Basisfunktionen wie diesen LCD-Funktionen, ist es daher oft ratsam, dafür zu sorgen, dass jede Funktion die Register wieder in dem Zustand hinterlässt, indem sie sie auch vorgefunden hat. Wir benötigen dazu wieder den Stack, auf dem die Registerinhalte bei Betreten einer Funktion zwischengespeichert werden und von dem die Register bei Verlassen einer Funktion wiederhergestellt werden.

Nehmen wir die Funktion
<avrasm>
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
ret
</avrasm>

Diese Funktion verändert das Register temp1. Um das Register abzusichern, schreiben wir die Funktion um:

<avrasm>
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
push temp1 ; temp1 auf dem Stack sichern
ldi temp1, 0b00000001 ; Display löschen
rcall lcd_command
rcall delay5ms
pop temp1 ; temp1 vom Stack wiederherstellen
ret
</avrasm>

Am besten hält man sich an die Regel: Jede Funktion ist dafür zuständig, die Register zu sichern und wieder herzustellen, die sie auch selbst verändert. '''lcd_clear''' ruft die Funktionen '''lcd_command''' und '''delay5ms''' auf. Wenn diese Funktionen selbst wieder Register verändern (und das tun sie), so ist es die Aufgabe dieser Funktionen, sich um die Sicherung und das Wiederherstellen der entsprechenden Register zu kümmern. '''lcd_clear''' sollte sich nicht darum kümmern müssen. Auf diese Weise ist das Schlimmste, das einem passieren kann, dass ein paar Register unnütz gesichert und wiederhergestellt werden. Das kostet zwar etwas Rechenzeit und etwas Speicherplatz auf dem Stack, ist aber immer noch besser als das andere Extrem: Nach einem Funktionsaufruf haben einige Register nicht mehr den Wert, den sie haben sollten, und das Programm rechnet mit falschen Zahlen weiter.

===Lass den Assembler rechnen===
Betrachtet man den Code genauer, so fallen einige konstante Zahlenwerte auf (Das vorangestellte $ kennzeichnet die Zahl als Hexadezimalzahl):

<avrasm>
delay50us: ; 50µs Pause
ldi temp1, $42
delay50us_:
dec temp1
brne delay50us_
ret ; wieder zurück
</avrasm>

Der Code benötigt eine Warteschleife, die mindestens 50µs dauert. Die beiden Befehle innerhalb der Schleife benötigen 3 Takte: 1 Takt für den '''dec''' und der '''brne''' benötigt 2 Takte, wenn die Bedingung zutrifft, der Branch also genommen wird. Bei 4 Mhz werden also 4000000 / 3 * 50 / 1000000 = 66.6 Durchläufe durch die Schleife benötigt, um eine Verzögerungszeit von 50µs (0.000050 Sekunden) zu erreichen, hexadezimal ausgedrückt: $42.

Der springende Punkt ist: Bei anderen Taktfrequenzen müsste man nun jedesmal diese Berechnung machen und den entsprechenden Zahlenwert einsetzen. Das kann aber der Assembler genausogut erledigen. Am Anfang des Codes wird ein Eintrag definiert, der die Taktfrequenz festlegt. Traditionell heißt dieser Eintrag XTAL:

<avrasm>
.equ XTAL = 4000000

...

delay50us: ; 50µs Pause
ldi temp1, ( XTAL * 50 / 3 ) / 1000000
delay50us_:
dec temp1
brne delay50us_
ret ; wieder zurück
</avrasm>

An einer anderen Codestelle gibt es weitere derartige magische Zahlen:

<avrasm>
; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, $21
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück
</avrasm>

Was geht hier vor?
Die innere Schleife benötigt wieder 3 Takte pro Durchlauf. Bei $C9 = 201 Durchläufen werden also 201 * 3 = 603 Takte verbraucht. In der äußeren Schleife werden pro Durchlauf alo 1 + 603 + 1 + 2 = 607 Takte verbraucht. Da die äußere Schleife $21 = 33 mal wiederholt wird, werden 20031 Takte verbraucht. Bei 4Mhz benötigt der Prozessor 20031 / 4000000 = 0.005007 Sekunden, also 5 ms.
Wird der Wiederholwert für die innere Schleife bei $C9 belassen, so werden 4000000 / 607 * 5 / 1000 Wiederholungen der äusseren Schleife benötigt. Auch diese Berechnung kann wieder der Assembler übernehmen:

<avrasm>
; Längere Pause für manche Befehle
delay5ms: ; 5ms Pause
ldi temp1, ( XTAL * 5 / 607 ) / 1000
WGLOOP0: ldi temp2, $C9
WGLOOP1: dec temp2
brne WGLOOP1
dec temp1
brne WGLOOP0
ret ; wieder zurück
</avrasm>

Ein kleines Problem kann bei der Verwendung dieses Verfahrens entstehen: Bei hohen Taktfrequenzen und großen Wartezeiten kann der berechnete Wert größer als 255 werden und man bekommt die Fehlermeldung "Operand(s) out of range" beim Assemblieren. Dieser Fall tritt zum Beispiel für obige Konstruktion bei einer Taktfrequenz von 16 MHz ein (genauer gesagt ab 15,3 MHz), während darunter XTAL beliebig geändert werden kann. Als einfachste Lösung bietet es sich an, die Zahl der Takte pro Schleifendurchlauf durch das Einfügen von '''nop''' zu erhöhen und die Berechnungsvorschrift anzupassen.

== Ausgabe eines konstanten Textes ==

Weiter oben wurde schon einmal ein Text ausgegeben. Dies geschah durch Ausgabe von einzelnen Zeichen. Das können wir auch anders machen. Wir können den Text im Speicher ablegen und eine Funktion schreiben, die die einzelnen Zeichen aus dem Speicher liest und aus gibt. Dabei stellt sich Frage: Woher 'weiß' die Funktion eigentlich, wie lang der Text ist? Die Antwort darauf lautet: Sie kann es nicht wissen. Wir müssen irgendwelche Vereinbarungen treffen, woran die Funktion erkennen kann, dass der Text zu Ende ist. Im Wesentlichen werden dazu 2 Methoden benutzt:
* Der Text enthält ein spezielles Zeichen, welches das Ende des Textes markiert
* Wir speichern nicht nur den Text selbst, sondern auch die Länge des Textes
Mit einer der beiden Methoden ist es der Textausgabefunktion dann ein Leichtes, den Text vollständig auszugeben.

Wir werden uns im Weiteren dafür entscheiden, ein spezielles Zeichen, eine 0 (den Wert 0, nicht das Zeichen '0'), dafür zu benutzen. Die Ausgabefunktionen werden dann etwas einfacher, als wenn bei der Ausgabe die Anzahl der bereits ausgegebenen Zeichen mitgezählt werden muss.

Den Text selbst speichern wir im Flash-Speicher, also dort, wo auch das Programm gespeichert ist:

<avrasm>
; Einen konstanten Text aus dem Flash Speicher
; ausgeben. Der Text wird mit einer 0 beendet
lcd_flash_string:
push temp1
push ZH
push ZL

lcd_flash_string_1:
lpm temp1, Z+
cpi temp1, 0
breq lcd_flash_string_2
rcall lcd_data
rjmp lcd_flash_string_1

lcd_flash_string_2:
pop ZL
pop ZH
pop temp1
ret
</avrasm>

Diese Funktion benutzt den Befehl '''lpm''', um das jeweils nächste Zeichen aus dem Flash Speicher in ein Register zur Weiterverarbeitung zu laden. Dazu wird der sog. '''Z-Pointer''' benutzt. So nennt man das Registerpaar '''R30''' und '''R31'''. Nach jedem Ladevorgang wird dabei durch den Befehl
<avrasm>
lpm temp1, Z+
</avrasm>
dieser Z-Pointer um 1 erhöht. Mittels '''cpi''' wird das in das Register '''temp1''' geladene Zeichen mit 0 verglichen. '''cpi''' vergleicht die beiden Zahlen und merkt sich das Ergebnis in einem speziellen Register in Form von Status Bits. '''cpi''' zieht dabei ganz einfach die beiden Zahlen voneinander ab. Sind sie gleich, so kommt da als Ergebnis 0 heraus und '''cpi''' setzt daher konsequenter Weise das Zero-Flag, das anzeigt, dass die vorhergegangene Operation eine 0 als Ergebnis hatte.'''breq''' wertet diese Status-Bits aus. Wenn die vorhergegangene Operation ein 0-Ergebnis hatte, das Zero-Flag also gesetzt ist, dann wird ein Sprung zum angegebenen Label durchgeführt. In Summe bewirkt also die Sequenz
<avrasm>
cpi temp1, 0
breq lcd_flash_string_2
</avrasm>
dass das gelesene Zeichen mit 0 verglichen wird und falls das gelesene
Zeichen tatsächlich 0 war, an der Stelle lcd_flash_string_2 weiter gemacht wird. Im anderen Fall wird die bereits geschriebene Funktion '''lcd_data''' aufgerufen, welche das Zeichen ausgibt. '''lcd_data''' erwartet dabei das Zeichen im Register '''temp1''', genau in dem Register, in welches wir vorher mittels '''lpm''' das Zeichen geladen hatten.

Das verwendende Programm sieht dann so aus:

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse
out SPL, temp1
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse
out SPH, temp1

rcall lcd_init ; Display initialisieren
rcall lcd_clear ; Display löschen

ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden

rcall lcd_flash_string ; Unterprogramm gibt String aus der
; durch den Z-Pointer adressiert wird
loop:
rjmp loop

text:
.db "Test",0 ; Stringkonstante, durch eine 0
; abgeschlossen

.include "lcd-routines.asm" ; LCD Funktionen
</avrasm>

Genaueres über die Verwendung unterschiedlicher Speicher findet sich im Kapitel [[AVR-Tutorial:_Speicher|Speicher]]

==Zahlen ausgeben==
Um Zahlen, die beispielsweise in einem Register gespeichert sind, ausgeben zu können, ist es notwendig sich eine Textrepräsentierung der Zahl zu generieren. Die Zahl 123 wird also in den Text "123" umgewandelt welcher dann ausgegeben wird. Aus praktischen Gründen wird allerdings der Text nicht vollständig generiert (man müsste ihn ja irgendwo zwischenspeichern) sondern die einzelnen Buchstaben werden sofort ausgegeben, sobald sie bekannt sind.

===Dezimal ausgeben===
Das Prinzip der Umwandlung ist einfach. Um herauszufinden wieviele Hunderter in der Zahl 123 enthalten sind, genügt es in einer Schleife immer wieder 100 von der Zahl abzuziehen und mitzuzählen wie oft dies gelang, bevor das Ergebnis negativ wurde. In diesem Fall lautet die Antwort: 1 mal, denn 123 - 100 macht 23. Versucht man erneut 100 anzuziehen, so ergibt sich eine negative Zahl.
Also muss eine '1' ausgeben werden. Die verbleibenden 23 werden weiter behandelt, indem festgestellt wird wieviele Zehner darin enthalten sind. Auch hier wiederum: In einer Schleife solange 10 abziehen, bis das Ergebnis negativ wurde. Konkret geht das 2 mal gut, also muss das nächste auszugebende Zeichen ein '2' sein. Damit verbleiben noch die Einer, welche direkt in das entsprechende Zeichen umgewandelt werden können. In Summe hat man also an das Display die Zeichen '1' '2' '3' ausgegeben.

<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine
;
lcd_number:
push temp1 ; die Funktion verändert temp1 und temp2,
push temp2 ; also sichern wir den Inhalt, um ihn am Ende
; wieder herstellen zu können

mov temp2, temp1 ; das Register temp1 frei machen
; abzählen wieviele Hunderter
; in der Zahl enthalten sind
;** Hunderter **
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen
lcd_number_1:
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten
; Durchlauf eine '0' in temp1)
subi temp2, 100 ; 100 abziehen
brcc lcd_number_1 ; ist dadurch kein Unterlauf entstanden?
; nein, dann zurück zu lcd_number_1
subi temp2, -100 ; 100 wieder dazuzählen, da die
; vorherhgehende Schleife 100 zuviel
; abgezogen hat
rcall lcd_data ; die Hunderterstelle ausgeben

;** Zehner **
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen
lcd_number_2:
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten
; Durchlauf eine '0' in temp1)
subi temp2, 10 ; 10 abziehen
brcc lcd_number_2 ; ist dadurch kein Unterlauf enstanden?
; nein, dann zurück zu lcd_number_2
subi temp2, -10 ; 10 wieder dazuzählen, da die
; vorherhgehende Schleife 10 zuviel
; abgezogen hat
rcall lcd_data ; die Zehnerstelle ausgeben

;** Einer **
ldi temp1, '0' ; die Zahl in temp2 ist jetzt im Bereich
add temp1, temp2 ; 0 bis 9. Einfach nur den ASCII Code für
rcall lcd_data ; '0' dazu addieren und wir erhalten dierekt
; den ASCII Code für die Ziffer

pop temp2 ; den gesicherten Inhalt von temp2 und temp1
pop temp1 ; wieder herstellen
ret ; und zurück
</avrasm>

Beachte: Diese Funktion benutzt wiederrum die Funktion '''lcd_data'''. Anders als bei den bisherigen Aufrufen ist '''lcd_number''' aber darauf angewiesen, dass '''lcd_data''' das Register '''temp2''' unangetastet lässt. Falls sie es noch nicht getan haben, dann ist das jetzt die perfekte Gelegenheit, '''lcd_data''' mit den entsprechenden '''push''' und '''pop''' Befehlen zu versehen. Sie sollten dies unbedingt zur Übung selbst machen. Am Ende muß die Funktion dann wie diese hier aussehen:

<avrasm>
;sendet ein Datenbyte an das LCD
lcd_data:
push temp2
mov temp2, temp1 ; "Sicherungskopie" für
; die Übertragung des 2.Nibbles
swap temp1 ; Vertauschen
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp1 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
; 2. Nibble, kein swap da es schon
; an der richtigen stelle ist
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000
out LCD_PORT, temp2 ; ausgeben
rcall lcd_enable ; Enable-Routine aufrufen
rcall delay50us ; Delay-Routine aufrufen
pop temp2
ret ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command: ; wie lcd_data, nur ohne RS zu setzen
push temp2
mov temp2, temp1
swap temp1
andi temp1, 0b00001111
out LCD_PORT, temp1
rcall lcd_enable
andi temp2, 0b00001111
out LCD_PORT, temp2
rcall lcd_enable
rcall delay50us
pop temp2
ret
</avrasm>

Kurz zur Funktionsweise der Funktion '''lcd_number''': Die Zahl in einem Register bewegt sich im Wertebereich 0 bis 255. Um herauszufinden, wie die Hunderterstelle lautet, zieht die Funktion einfach in einer Schleife immer wieder 100 von der Schleife ab, bis bei der Subtraktion ein Unterlauf, angezeigt durch das Setzen des Carry-Bits bei der Subtraktion, entsteht. Die Anzahl wird im Register '''temp1''' mitgezählt. Da dieses Register mit dem ASCII Code von '0' initialisiert wurde, und dieser ASCII Code bei jedem Schleifendurchlauf um 1 erhöht wird, können wir das Register '''temp1''' direkt zur Ausgabe des Zeichens für die Hunderterstelle durch die Funktion '''lcd_data''' benutzen. Völlig analog funktioniert auch die Ausgabe der Zehnerstelle.

===Unterdrückung von führenden Nullen===

Diese Funktion gibt jede Zahl im Register '''temp1''' immer mit 3 Stellen aus. Führende Nullen werden nicht unterdrückt. Möchte man dies ändern, so ist das ganz leicht möglich: Vor Ausgabe der Hunderterstelle muss lediglich überprüft werden, ob die Entsprechende Ausgabe eine '0' wäre. Ist sie das, so wird die Ausgabe übersprungen. Ist es allerdings eine Zahl 1..9, so muss sie der Zehner Stelle signalisieren, daß eine Prüfung auf eine '0' nicht stattfinden darf. Und dazu wird das T-Flag im SREG genutzt. Lediglich in der Einerstelle wird jede Ziffer wie errechnet ausgegeben.

<avrasm>
...
; die Hunderterstelle ausgeben, wenn
; sie nicht '0' ist
clt ; T-Flag löschen
cpi temp1, '0'
breq lcd_number_1a
rcall lcd_data ; die Hunderterstelle ausgeben
set ; T-Flag im SREG setzen da 100er Stelle eine
; 1..9 war

lcd_number_1a:
...

...
brts lcd_number_2a ; Test auf '0' überspringen, da 100er eine
; 1..9 war (unbedingt anzeigen
; auch wenn der Zehner eine '0' ist)
cpi temp1, '0' ; ansonsten Test auf '0'
breq lcd_number_2b
lcd_number_2a:
rcall lcd_data
lcd_number_2b:
...

</avrasm>

Das Verfahren, die einzelnen Stellen durch Subtraktion zu bestimmen, ist bei kleinen Zahlen eine durchaus gängige Alternative. Vor allem dann, wenn keine hardwaremäßige Unterstützung für Multiplikation und Division zur Verfügung steht. Ansonsten könnte man die die einzelnen Ziffern auch durch Division bestimmen. Das Prinzip ist folgendes (beispielhaft an der Zahl 52783 gezeigt)

<pre>
52783 / 10 -> 5278
52783 - 5278 * 10 -> 3

5278 / 10 -> 527
5278 - 527 * 10 -> 8

527 / 10 -> 52
527 - 52 * 10 -> 7

52 / 10 -> 5
52 - 5 * 10 -> 2

5 / 10 -> 0
5 - 0 * 10 -> 5
</pre>

Das Prinzip ist also die Restbildung bei einer fortgesetzten Division durch 10, wobei die einzelnen Ziffern in umgekehrter Reihenfolge ihrer Wertigkeit entstehen. Dadurch hat man aber ein Problem: Damit die Zeichen in der richtigen Reihenfolge ausgegeben werden können, muß man sie meistens zwischenspeichern um sie in der richtigen Reihenfole ausgeben zu können. Wird die Zahl in einem Feld von immer gleicher Größe ausgegeben, dann kann man auch die Zahl von rechts nach links ausgeben (bei einem LCD ist das möglich).

===Hexadezimal ausgeben===

Zu guter letzt hier noch eine Funktion, die eine Zahl aus dem Register '''temp1''' in hexadezimaler Form ausgibt. Die Funktion weist keine Besonderheiten auf und sollte unmittelbar verständlich sein.

<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen hexadezimal ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine
;
lcd_number_hex:
swap temp1
rcall lcd_number_hex_digit
swap temp1

lcd_number_hex_digit:
push temp1

andi temp1, $0F
cpi temp1, 10
brlt lcd_number_hex_digit_1
subi temp1, -( 'A' - '9' - 1 ) ; es wird subi mit negativer
; Konstante verwendet,
; weil es kein addi gibt
lcd_number_hex_digit_1:
subi temp1, -'0' ; ditto
rcall lcd_data

pop temp1
ret
</avrasm>

===Binär ausgeben===
Um die Sache komplett zu machen; Hier eine Routine mit der man eine 8 Bit-Zahl binär auf das LC-Display ausgeben kann:
<avrasm>
;**********************************************************************
;
; Eine 8 Bit Zahl ohne Vorzeichen binär ausgeben
;
; Übergabe: Zahl im Register temp1
; veränderte Register: keine

; eine Zahl aus dem Register temp1 binär ausgeben
lcd_number_bit:
push temp1 ; temp1 gesichert
push temp2
push temp3

mov temp2, temp1;

ldi temp3, 8; ; 8 Bits werden ausgelesen
lcd_number_loop:
dec temp3;
rol temp2; ; Datenbits ins Carry geschoben ...
brcc lcd_number_bit_carryset_0;
brcs lcd_number_bit_carryset_1;
rjmp lcd_number_loop;

lcd_number_bit_carryset_0:
ldi temp1, '0' ; Bit low ausgeben
rcall lcd_data
tst temp3;
breq lcd_number_ende;
rjmp lcd_number_loop;

lcd_number_bit_carryset_1:
ldi temp1, '1' ; Bit high ausgeben
rcall lcd_data
tst temp3;
breq lcd_number_ende;
rjmp lcd_number_loop;

lcd_number_ende:
pop temp3
pop temp2
pop temp1
ret
</avrasm>

===Eine 16-Bit Zahl aus einem Registerpärchen ausgeben===

Um eine 16 Bit Zahl auszugeben wird wieder das bewährte Schema benutzt die einzelnen Stellen durch Subtraktion abzuzählen. Da es sich hierbei allerdings um eine 16 Bit Zahl handelt, müssen die Subtraktionen als 16-Bit Arithmetik ausgeführt werden.

<avrasm>
;**********************************************************************
;
; Eine 16 Bit Zahl ohne Vorzeichen ausgeben
;
; Übergabe: Zahl im Register temp2 (low Byte) / temp3 (high Byte)
; veränderte Register: keine
;
lcd_number16:
push temp1
push temp2
push temp3

; ** Zehntausender **
ldi temp1, '0'-1
lcd_number1:
inc temp1
subi temp2, low(10000)
sbci temp3, high(10000)
brcc lcd_number1
subi temp2, low(-10000)
sbci temp3, high(-10000)
rcall lcd_data

; ** Tausender **
ldi temp1, '0'-1
lcd_number2:
inc temp1
subi temp2, low(1000)
sbci temp3, high(1000)
brcc lcd_number2
subi temp2, low(-1000)
sbci temp3, high(-1000)
rcall lcd_data

; ** Hunderter **
ldi temp1, '0'-1
lcd_number3:
inc temp1
subi temp2, low(100)
sbci temp3, high(100)
brcc lcd_number3
subi temp2, -100 ; + 100 High-Byte nicht mehr erforderlich
rcall lcd_data

; ** Zehner **
ldi temp1, '0'-1
lcd_number4:
inc temp1
subi temp2, 10
brcc lcd_number4
subi temp2, -10
rcall lcd_data

; ** Einer **
ldi temp1, '0'
add temp1, temp2
rcall lcd_data

; ** Stack aufräumen **
pop temp3
pop temp2
pop temp1

ret
</avrasm>

===Eine BCD Zahl ausgeben===

<avrasm>
;**********************************************************************
;
; Übergabe: BCD Zahl in temp1
; veränderte Register: keine
;
lcd_bcd:
push temp2

mov temp2, temp1 ; temp1 sichern
swap temp1 ; oberes mit unterem Nibble tauschen
andi temp1, 0b00001111 ; und "oberes" ausmaskieren
subi temp1, -0x30 ; in ASCII umrechnen
rcall lcd_data ; und ausgeben
mov temp1, temp2 ; ... danach unteres
andi temp1, 0b00001111
subi temp1, -0x30
rcall lcd_data
mov temp1, temp2 ; temp1 rekonstruieren

pop temp2
ret
</avrasm>

== Benutzerdefinierte Zeichen ==
[[Bild:LCD_Character_Grid.png | framed | right| Zeichenraster für 1 Zeichen]]

Das LCD erlaubt für spezielle Zeichen, welche sich nicht im Zeichensatz finden, eigene Zeichen zu definieren. Dazu werden die ersten 8 ASCII Codes reserviert, auf denen sich laut ASCII Tabelle spezielle Steuerzeichen befinden, die normalerweise keine sichtbare Anzeige hervorrufen sondern zur Steuerung von angeschlossenen Geräten dienen. Da diese Zeichen auf einem LCD keine Rolle spielen, können diese Zeichen benutzt werden um sich selbst Sonderzeichen zu erzeugen, die für die jeweilige Anwendung massgeschneidert sind.

Das LCD stellt für jedes Zeichen eine 8*5 Matrix zur Verfügung. Um sich selbst massgeschneiderte Zeichen zu erstellen, ist es am einfachsten sich zunächst auf einem Stück karriertem Papier zu erstellen.

[[Bild:BellCharacter.png | framed | right| Zeichenraster für ein Glockensymbol]]

In diesem Raster markiert man sich dann diejenigen Pixel, die im fertigen Zeichen dunkel erscheinen sollen. Als Beispiel sei hier ein Glockensymbol gezeichnet, welches in einer Telefonapplikation zb als Kennzeichnung für einen Anruf dienen könnte.

Eine Reihe in diesem Zeichen repräsentiert ein an das LCD zu übergebende Byte, wobei nur die letzten 5 Bits relevant sind. Gesetzte Pixel stellen ein 1 Bit dar, nicht gesetzte Pixel sind ein 0-Bit. Das niedrigstwertige Bit einer Reihe befindet sich rechts. Auf diese Art wird jede Spalte in eine Binärzahl übersetzt, und 8 Bytes repräsentieren ein komplettes Zeichen. Am Beispiel des Glockensymboles: Die 8 Bytes, welches das Symbol repräsentiern, lauten: 0x04, 0x0A, 0x0A, 0x0A, 0x1F, 0x04, 0x00, 0x00

Dem LCD wird die neue Definition übertragen, indem man dem LCD die 'Schreibposition' mittels des Kommandos ''Character RAM Address Set'' in den Zeichensatzgenerator verschiebt. Danach werden die 8 Bytes ganz normal als Daten ausgegeben, die das LCD damit in seine Zeichensatztabelle schreibt.

Durch die Wahl der Speicheradresse definiert man, welches Zeichen (0 bis 7) man eigentlich durch eine eigene Definition ersetzen will.
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ASCII Code || Zeichensatzadresse
|-
| 0 || 0x00
|-
| 1 || 0x08
|-
| 2 || 0x10
|-
| 3 || 0x18
|-
| 4 || 0x20
|-
| 5 || 0x28
|-
| 6 || 0x30
|-
| 7 || 0x38
|}

Nach erfolgter Definition des Zeichens, muss die Schreibposition wieder explizit in den DDRAM-Bereich gesetzt werden.
Danach kann ein entsprechendes Zeichen mit dem definierten ASCII Code ausgegeben werden, wobei das LCD die von uns definierte Pixelform zur Anzeige benutzt.

Zuerst müssen natürlich erstmal die Zeichen definiert werden.
Dieses geschieht einmalig durch den Aufruf der Routine "lcd_load_user_chars"
unmittelbar nach der Initialisierung des LCD-Displays.

<avrasm>
.
.
rcall lcd_init ; Display initialisieren
rcall lcd_load_user_chars ; User Zeichen in das Display laden
rcall lcd_clear ; Display löschen
.
.
</avrasm>

Durch diesen Aufruf werden die im Flash definierten Zeichen in den
GC-Ram übertragen. Diese Zeichen werden ab Adresse 0 im GC-Ram
gespeichert und sind danach wie jedes andere Zeichen nutzbar.

<avrasm>
.
.
ldi temp1, 0 ; Ausgabe des User-Char "A"
rcall lcd_data
ldi temp1, 6 ; Ausgabe des User-Char "G"
rcall lcd_data
ldi temp1, 5 ; Ausgabe des User-Char "E"
rcall lcd_data
ldi temp1, 4 ; Ausgabe des User-Char "M"
rcall lcd_data
ldi temp1, 3 ; Ausgabe des User-Char "-"
rcall lcd_data
ldi temp1, 2 ; Ausgabe des User-Char "R"
rcall lcd_data
ldi temp1, 1 ; Ausgabe des User-Char "V"
rcall lcd_data
ldi temp1, 0 ; Ausgabe des User-Char "A"
rcall lcd_data
.
.
</avrasm>

Jetzt sollte der Schriftzug "AVR-MEGA"
verkehrt herum (180 Grad gedreht) erscheinen.

Es fehlt natürlich noch die Laderoutine:

<avrasm>
;**********************************************************************
;
; Lädt User Zeichen in den GC-Ram des LCD bis Tabellenende (0xFF)
; gelesen wird. (max. 8 Zeichen können geladen werden)
;
; Übergabe: -
; veränderte Register: temp1, temp2, temp3, zh, zl
; Bemerkung: ist einmalig nach lcd_init aufzurufen
;

lcd_load_user_chars:
ldi zl, LOW (ldc_user_char * 2) ; Adresse der Zeichentabelle
ldi zh, HIGH(ldc_user_char * 2) ; in den Z-Pointer laden
clr temp3 ; aktuelles Zeichen = 0

lcd_load_user_chars_2:
clr temp2 ; Linienzähler = 0

lcd_load_user_chars_1:
ldi temp1, 0b01000000 ; Kommando: 0b01aaalll
add temp1, temp3 ; + akt. Zeichen (aaa)
add temp1, temp2 ; + akt. Linie (lll)
rcall lcd_command ; Kommando schreiben

lpm temp1, Z+ ; Zeichenline laden
rcall lcd_data ; ... und ausgeben

ldi temp1, 0b01001000 ; Kommando: 0b01aa1lll
add temp1, temp3 ; + akt. Zeichen (aaa)
add temp1, temp2 ; + akt. Linie (lll)
rcall lcd_command

lpm temp1, Z+ ; Zeichenline laden
rcall lcd_data ; ... und ausgeben

inc temp2 ; Linienzähler + 1
cpi temp2, 8 ; 8 Linien fertig?
brne lcd_load_user_chars_1 ; nein, dann nächste Linie

subi temp3, -0x10 ; zwei Zeichen weiter (addi 0x10)
lpm temp1, Z ; nächste Linie laden
cpi temp1, 0xFF ; Tabellenende erreicht?
brne lcd_load_user_chars_2 ; nein, dann die nächsten
; zwei Zeichen
ret
</avrasm>

... und die Zeichendefinition:

<avrasm>
ldc_user_char:
; Zeichen
; 0 1
.db 0b10001, 0b00100 ; @ @ , @
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b11111, 0b10001 ; @@@@@ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b10001, 0b10001 ; @ @ , @ @
.db 0b01110, 0b10001 ; @@@ , @ @
.db 0b00000, 0b00000 ; ,

; Zeichen
; 2 3
.db 0b10001, 0b00000 ; @ @ ,
.db 0b01001, 0b00000 ; @ @ ,
.db 0b00101, 0b00000 ; @ @ ,
.db 0b11111, 0b11111 ; @@@@@ , @@@@@
.db 0b10001, 0b00000 ; @ @ ,
.db 0b10001, 0b00000 ; @ @ ,
.db 0b01111, 0b00000 ; @@@@ ,
.db 0b00000, 0b00000 ; ,

; Zeichen
; 4 5
.db 0b10001, 0b11111 ; @ @ , @@@@@
.db 0b10001, 0b00001 ; @ @ , @
.db 0b10001, 0b00001 ; @ @ , @
.db 0b10001, 0b01111 ; @ @ , @@@@
.db 0b10101, 0b00001 ; @ @ @ , @
.db 0b11011, 0b00001 ; @@ @@ , @
.db 0b10001, 0b11111 ; @ @ , @@@@@
.db 0b00000, 0b00000 ; ,

; Zeichen
; 6 7
.db 0b11110, 0b11111 ; @@@@ , @@@@@
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b10001, 0b00100 ; @ @ , @
.db 0b11101, 0b01110 ; @@@ @ , @@@
.db 0b00001, 0b00100 ; @ , @
.db 0b10001, 0b01010 ; @ @ , @ @
.db 0b01110, 0b11111 ; @@@ , @@@@@
.db 0b00000, 0b00000 ; ,

; End of Tab
.db 0xFF, 0xFF
</avrasm>

==Der überarbeitete, komplette Code==

Hier also die komplett überarbeitete Version der LCD Funktionen.

Die für die Benutzung relevanten Funktionen
* '''lcd_init'''
* '''lcd_clear'''
* '''lcd_home'''
* '''lcd_data'''
* '''lcd_command'''
* '''lcd_flash_string'''
* '''lcd_number'''
* '''lcd_number_hex'''
sind so ausgeführt, dass sie kein Register (ausser dem Statusregister '''SREG''') verändern. Die bei manchen Funktionen notwendige Argumente werden immer im Register '''temp1''' übergeben, wobei '''temp1''' vom Usercode definiert werden muss.

[[Media:lcd-routines.asm|Download lcd-routines.asm]]

----

{{Navigation_zurückhochvor|
zurücktext=Stack|
zurücklink=AVR-Tutorial: Stack|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Interrupts|
vorlink=AVR-Tutorial: Interrupts}}

[[Category:AVR-Tutorial]]
[[Category:LCD]]

Datei:Sam.zip

2010-12-26T09:53:44Z

Klaus2m5: hat eine neue Version von „Datei:Sam.zip“ hochgeladen: added EXITxx

Structured Assembly Macros

Datei:Sam.zip

2010-12-26T09:39:20Z

Klaus2m5: hat eine neue Version von „Datei:Sam.zip“ hochgeladen

Structured Assembly Macros

AVR Assembler Makros

2010-12-26T09:35:00Z

Klaus2m5: /* SAM (Structured Assembly Macros) */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>
== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich. Läuft unter aktuellen Versionen von AVRASM2.

Einige Beispiele:

Verschachteltes If-Then-Else<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als [[Media:sam.zip|Download.]]

AVR Assembler Makros

2010-12-25T18:02:11Z

Klaus2m5: /* SAM (Structured Assembly Macros) */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>
== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich. Läuft unter aktuellen Versionen von AVRASM2.

Einige Beispiele:

Verschachteltes If-Then-Else<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als Download.

[[Datei:sam.zip]]

AVR Assembler Makros

2010-12-25T17:54:11Z

Klaus2m5: /* SAM (Structured Assembly Macros) */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>
== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich.

Einige Beispiele:

Verschachteltes If-Then-Else
<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen
<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop
<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als Download:
[[sam.zip]]

AVR Assembler Makros

2010-12-25T17:52:07Z

Klaus2m5: /* Strukturierte Programmierung */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>
== Strukturierte Programmierung ==

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich.

Einige Beispiele:

Verschachteltes If-Then-Else
<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen
<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop
<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als Download:
[[Datei:sam.zip]]

AVR Assembler Makros

2010-12-25T17:50:15Z

Klaus2m5: /* Strukturierte Programmierung */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>
==== Strukturierte Programmierung ====

===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich.

Einige Beispiele:

Verschachteltes If-Then-Else
<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen
<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop
<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als Download:
[[Datei:sam.zip]]

AVR Assembler Makros

2010-12-25T17:48:01Z

Klaus2m5: /* Verzögerung um X Nanosekunden */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>
====Strukturierte Programmierung====
===SAM (Structured Assembly Macros)===
von Klaus2m5

SAM unterstützt strukturiertes Programmieren durch If-Then-Else und Do-Loop Makros. Beliebige Verschachtelung und Mehrfachbedingungen sind möglich.

Einige Beispiele:

Verschachteltes If-Then-Else
<avrasm>
cpi r16,'a'
ifeq a_chr
cpi r17,'b'
ifeq a_and_b
;...a&b
else a_and_b
;...a&-b
end a_and_b
else a_chr
cpi r17,'c'
ifeq c_but_no_a
;...-a&+c
else c_but_no_a
;...-a&c
end c_but_no_a
end a_chr
</avrasm>

Mehrere und/oder verknüpfte Bedingungen
<avrasm>
cpi zh,high(end_buffer)
ifeq_and end_buffer_reached
cpi zl,low(end_buffer)
ifeq end_buffer_reached
ldi zh,high(buffer) ;wrap buffer
ldi zl,low(buffer)
end end_buffer_reached
ld r0,z+ ;read buffer
</avrasm>

Das Gleiche als Do-Loop
<avrasm>
; reading a buffer until end
; similar to: for z = buffer to end_buffer
ldi zh,high(buffer) ;init buffer pointer
ldi zl,low(buffer)
do read_buf
ld r0,z+
cpi zh,high(end_buffer)
loopne read_buf
cpi zl,low(end_buffer)
loopne read_buf
</avrasm>

Mehr Beispiele und das SAM-include als Download:
[[Datei:sam.zip]]

Hilfe:Bearbeitungshilfe

2010-12-25T17:37:04Z

Klaus2m5: /* Datei/Bild hochladen und einfügen */

== Umfangreiche Hilfe ==
Umfangreiche Hilfe befindet sich auch hier: 
'''[http://de.wikipedia.org/wiki/Hilfe:Bearbeiten de.Wikipedia.org/wiki/Hilfe:Bearbeiten]'''

== Überschriften ==

<pre>
== Überschrift ==
=== Unter-Überschrift ===
==== Unter-Unter-Überschrift ====
...
</pre>

== Formatierung ==
Eine ausführlichere Beschreibung der Gliederungs- und Formatierungsmöglichkeiten findet sich im Wikipedia Online-Lexikon: http://de.wikipedia.org/wiki/Hilfe:Bearbeitungshilfe

{| border="0"
|-
|''kursiv''
|<nowiki>''kursiv''</nowiki>
|-
|'''fett'''
|<nowiki>'''fett'''</nowiki>
|-
|unterstrichen
|<nowiki>unterstrichen</nowiki>
|-
|hochgestellt
|<nowiki>hochgestellt</nowiki>
|-
|tiefgestellt
|<nowiki>tiefgestellt</nowiki>
|}

== Einbinden von Sourcecode ==

<code><nowiki><c>C-Code</c></nowiki></code>

Beispiel:

<c>
int main(void) {
return 0;
}
</c>

<code><nowiki><avrasm>AVR Assembler-Code</avrasm></nowiki></code>

Beispiel:

<avrasm>
; Mach fast nix!
.org 0x0000
Start:
LDI r16, 42
RJMP Start
</avrasm>

<code><nowiki><vhdl>VHDL-Code</vhdl></nowiki></code>

<vhdl>
-- Kommentar in VHDL
process(clk)
begin
if rising_dedge(clk) then
data <= data_in;
end if;
end process;
</vhdl>

<code><nowiki><pre>Sonstige Texte mmit fester Formatierung</pre></nowiki></code>

<pre>
Hallo Welt!
Leerzeichen bleiben, feste Zeichenbreite.
Geht auch für ASCII-Art
</pre>

== Einfügen von Bildern oder Dateien ==

''Hierfür ist [[Spezial:Anmelden|Anmeldung]] erforderlich!''

=== Bild erstellen ===
* Fotos müssen nicht von Hand verkleinert werden, sondern können bis 2 MB groß hochgeladen werden.
* Falls mit einem Vektorzeichenprogramm (z.B. Inkscape) gearbeitet wird, bitte das SVG-Format verwenden (erlaubt nachträgliche Bearbeitung durch andere!)
* Für Zeichnungen/Schaltpläne ist ansonsten das PNG-Format am besten geeignet, JPEG nur für Fotos/Scans verwenden, siehe [[Bildformate]].

=== Datei/Bild hochladen und einfügen ===
# Dort, wo das Bild erscheinen (oder die Datei verlinkt werden) soll, den Code <code><nowiki>[[Bild:AVR-Programmer.png]]</nowiki></code> in den Text einfügen (beliebiger Dateiname, aber mit richtiger Endung!).
# In der Vorschau oder der gespeicherten Seite auf den Platzhalter-Link "Bild:AVR-Programmer.png" klicken. Vorsicht, nicht gespeicherte Änderungen gehen verloren!
# Datei auswählen, ggf. Beschreibung eingeben und hochladen (wird automatisch umbenannt).

=== Größe festlegen ===

Folgender Code skaliert das Bild automatisch auf 200 Pixel Breite: <code><nowiki>[[Bild:AVR-Programmer.png|</nowiki>'''200px'''<nowiki>]]</nowiki></code>

== Tabellen ==

Für eine ausführlichere Liste und Beschreibung möglicher Features sei auf [http://de.wikipedia.org/wiki/Hilfe:Tabellen Wikipedia Hilfe:Tabellen] und [http://de.wikipedia.org/wiki/Hilfe:Tabellen-Referenz Wikipedia Hilfe:Tabellen-Referenz] verwiesen.

{| class="wikitable"
|+ '''Tabellen-Überschrift'''
|-
! Überschrift links || Überschrift rechts
|-
| links oben || rechts oben
|-
| links mitte || rechts mitte
|-
| links unten || rechts unten
|}

<pre>
{| class="wikitable"
|+ '''Tabellen-Überschrift'''
|-
! Überschrift links || Überschrift rechts
|-
| links oben || rechts oben
|-
| links mitte || rechts mitte
|-
| links unten || rechts unten
|}
</pre>

Um sortierbare Tabellen zu erhalten fügt man statt <tt> class="wikitable" </tt> folgendes ein: <tt> class="wikitable sortable" id="tabellexyz" </tt>

== Richtlinien ==

=== Links zu verwandten Artikeln und externen Seiten ===

Für '''interne''' Links zu verwandten Artikeln legt man einen Bereich nach dem folgenden Muster an:

<pre>
== Siehe auch ==
* [[Test]]
* [[Foobar]]
</pre>

Ähnlich bei '''externen''' Links:

<pre>
== Weblinks ==
* http://url1/
* http://url2/
* [http://url3/ Seite 3 hat einen Linktext]
</pre>

=== Link für Nachricht an eine Person/Autor ===

<pre>[http://www.mikrocontroller.net/user/show/Username_aus_Forum Alternativer Text]</pre>

[http://www.mikrocontroller.net/user/show/andreas Alternativer Text]

[[Kategorie:Tipps für Autoren]]

Datei:Sam.zip

2010-12-25T17:28:27Z

Klaus2m5: Structured Assembly Macros

Structured Assembly Macros

Aktiver PS/2 Tastatur Umschalter

2010-08-27T11:59:10Z

Klaus2m5: /* Informationen im Web */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z. B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
* [[Media:keyboard_switch.zip|(Assembler Source, HEX-File, dieses Dokument als PDF)]]

=== Informationen im Web ===
* [http://www.computer-engineering.org PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

[[Kategorie:AVR-Projekte]]
[[Category:Datenübertragung]]

I2C-slave USART

2010-07-10T16:25:15Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Baudrate, I2C-Adresse und Einstellungen zur Flusskontrolle haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.

==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

==Zukünftige Erweiterungen==

10-bit Adressierung

Zusätzliche gemeinsame Adresse (zusammen mit anderen Slaves) zum Abfragen der Daten nach Aktivierung des -Int Signals. Dabei antworten zunächst alle Slaves, die das -Int Signal aktiviert haben, mit ihrer eigenen Adresse. Durch Slave-Bus-Arbitration gewinnt der Slave mit der niedrigsten Adresse. Danach überträgt dieser Slave seine Daten.

[[Kategorie:AVR-Projekte]]
[[Kategorie:I2C]]

I2C-slave USART

2010-02-08T11:33:16Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]
Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Baudrate, I2C-Adresse und Einstellungen zur Flusskontrolle haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.

==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

[[Kategorie:AVR-Projekte]]
[[Kategorie:I2C]]

I2C-slave USART

2010-02-08T11:25:27Z

Klaus2m5: /* Konfiguration */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]
Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Baudrate, I2C-Adresse und Einstellungen zur Flusskontrolle haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.

==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

Datei:I2C-slave USART.png

2010-02-08T11:18:00Z

Klaus2m5:

I2C-slave USART

2010-02-08T11:17:44Z

Klaus2m5: /* Die Schaltung */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==
[[Bild:I2C-slave_USART.png]]
Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.

==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Alle einstellbaren Optionen haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.
==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

I2C-slave USART

2010-02-08T11:12:45Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.
==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Alle einstellbaren Optionen haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.
==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip|I2C-slave_USART.zip]]

I2C-slave USART

2010-02-08T11:08:32Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.
==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Alle einstellbaren Optionen haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.
==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

[[Media:I2C-slave_USART.zip]]

I2C-slave USART

2010-02-08T11:07:13Z

Klaus2m5: /* Download */

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.
==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Alle einstellbaren Optionen haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.
==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.
[[Bild:I2C-slave_USART.zip]]

Datei:I2C-slave USART.zip

2010-02-08T11:06:10Z

Klaus2m5: Anleitung als PDF, Firmware als HEX, EEP und ASM Dateien

Anleitung als PDF, Firmware als HEX, EEP und ASM Dateien

I2C-slave USART

2010-02-08T10:58:52Z

Klaus2m5: Die Seite wurde neu angelegt: „''von Klaus2m5'' ==Übersicht== Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert eine…“

''von Klaus2m5''
==Übersicht==
Ein AVR ATTINY2313 als I2C nach RS232 Konverter. Benutzt USART und USI Hardware des AVR, programmiert in Assembler. Erweitert einen Master um jeweils einen USART, begrenzt nur durch die Anzahl der verfügbaren I2C-Adressen und der Bandbreite des I2C-Bus.

Eine spezielle Anwendung besteht darin, einem beliebigen AVR eine temporäre RS232 Schnittstelle zur Verfügung zu stellen, ohne dass dieser einen Baudratenquartz und Schnittstellenhardware benötigt. Mittels des vorhandenen ISP-Steckers kann I2C-Master Software den USART steuern.
==Die Schaltung==

Ein Platinenlayout existiert nicht, da man diese Schaltung in vielen Variationen, bis hin zur Integration mit einem I2C-Master und mehreren I2C-Slaves, aufbauen kann.
==Grundfunktionen==
* I2C-Slave nach RS232 Konverter
* Jeweils 48 Bytes Empfangs- und Sendepuffer
* Optionale Hardware und/oder Xon/Xoff Flusskontrolle
* Viele Optionen konfigurierbar, ohne neu zu flashen
* Bei I2C-Aktivität leuchtet die LED rot, ansonsten grün
* Wenn -RESET low ist, wird die I2C Schnittstelle inklusive der Pullups abgeschaltet (High-Z)
==Erweiterungen==
Drückt man den Taster an PB2 des AVR, kommt man in den Debug- & Konfigurationsmonitor. Die LED leuchtet dauernd rot und die I2C Schnittstelle ist abgeschaltet (Der Master bekommt ein Nak, wenn er die Slave Adresse anspricht). Der Monitor läuft über RS232 und meldet sich dort mit seinem Prompt „I2R>“. Er bietet die Möglichkeit, den Inhalt von GPRs, I/O-Registern, SRAM und EEPROM auszulesen und zu verändern. Man kann einen Reset auslösen (benutzt den Watchdog) oder einen Call oder Jump zu einer Flash-Adresse machen. Ein einfacher I2C-Sniffer erlaubt die Überwachung des angeschlossenen I2C-Buses. Mit den I2C-Master Funktionen kann man I2C-Slaves testen.
==Konfiguration==
Alle einstellbaren Optionen haben reservierte EEPROM-Adressen und können mit Hilfe der Monitor-Commands E & P leicht geändert werden. Die Änderungen werden nach einem Reset wirksam.
==Anwendungsbeispiel==
Um die Anwendungsmöglichkeiten zu verdeutlichen, befindet sich im Ordner Debugger des Downloads eine Sammlung von „Debug Skeleton *.asm“ Dateien, die an verschiedene AVRs angepasst sind. Diese stellen ein Gerüst für die Anwendungsentwicklung mit I2C-Master Zugriff über die ISP-Schnittstelle auf RS232 Ein-/Ausgabe dar. Sie enthalten einen, dem I2C-Slave USART Debug- und Konfigurationsmonitor ähnlichen Monitor, der unter anderem den Zugriff auf die Speicher und Register des AVR erlaubt.
==Download==
Eine Anleitung mit mehr Details und die Firmware mit Assembler Source befinden sich im Download.

AVR Assembler Makros

2010-01-30T17:05:14Z

Klaus2m5: /* Verzögerung um X Nanosekunden */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Mikrosekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>

AVR Assembler Makros

2010-01-30T16:09:44Z

Klaus2m5: /* Verzögerung um X Nanosekunden */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Dabei werden maximal 4 Instruktionen erzeugt.
Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Millisekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab (exakt bis +1 Takt).

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>

AVR Assembler Makros

2010-01-30T16:00:08Z

Klaus2m5: /* I/O */

[[Category:AVR]]

Hier entsteht eine Sammlung von verschiedenen nützlichen [[Makro|Makros]] für den [[AVR]] [[Assembler]].

=== 16 Bit Konstante in Z-Pointer laden ===

<avrasm>
.MACRO SetZPtr ;(Adresse)
ldi ZL, LOW(@0)
ldi ZH, HIGH(@0)
.ENDMACRO
</avrasm>

Natürlich auch möglich mit X- und Y-Pointer.

==Speicher==
=== 2 Register ohne Zwischenspeicher vertauschen ===
<avrasm>
.MACRO SWAP ;(a, b)
eor @0, @1
eor @1, @0
eor @0, @1
.ENDMACRO
</avrasm>

==Arithmetik==

=== Konstante addieren ===

<avrasm>
.MACRO ADDI ;(a, k)
subi @0, -(@1)
.ENDMACRO
</avrasm>

=== Konstante addieren (16 Bit) ===

<avrasm>
.MACRO ADDIW ;(RdL:RdH, k)
subi @0L, LOW(-@1)
sbci @0H, HIGH(-@1)
.ENDMACRO
</avrasm>
oder (sinnlos)
<avrasm>
.MACRO ADDIW ;(Rd, k)
sbiw @0, (-@1)
.ENDMACRO
</avrasm>
DAS geht auch ohne Makro
<avrasm>
adiw a, b
</avrasm>
SBIW und ADIW sind aber beide auf die Register(paare) R24, R26, R28, R30 beschränkt UND nehmen nur Zahlen <64 an.

==I/O==

Bei grösseren und neueren AVRs sind etliche I/O-Register nicht mit IN/OUT-Befehlen ansprechbar. LDS/STS erreicht zwar alle, ist aber bei kleineren oder älteren ineffizient.

=== Port lesen ===

<avrasm>
.macro input
.if @1 < 0x40
in @0, @1
.else
lds @0, @1
.endif
.endm
</avrasm>

=== Port schreiben ===

<avrasm>
.macro output
.if @0 < 0x40
out @0, @1
.else
sts @0, @1
.endif
.endm
</avrasm>

=== Portbit abfragen ===

Abfrage eines Bits eines I/O-Ports und Sprung wenn 1/0.
Überschreibt u.U. ZL.

Branch if Bit in I/O-Register is Set
<avrasm>
.macro bbis ;port,bit,target
.if @0 < 0x20
sbic @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrc zl, @1
rjmp @2
.else
lds zl, @0
sbrc zl, @1
rjmp @2
.endif
.endm
</avrasm>

Branch if Bit in I/O-Register is Cleared
<avrasm>
.macro bbic ;port,bit,target
.if @0 < 0x20
sbis @0, @1
rjmp @2
.elif @0 < 0x40
in zl, @0
sbrs zl, @1
rjmp @2
.else
lds zl, @0
sbrs zl, @1
rjmp @2
.endif
.endm
</avrasm>
== Delay ==
=== Verzögerung um X Nanosekunden ===
von Klaus2m5

Taktgenaue Verzögerung der Instruktionsausführung durch Angabe der Verzögerungszeit
in Nanosekunden. Taktgenau bedeutet, dass auf die nächste volle Anzahl von Takten
aufgerundet wird. Beispiel: 75ns bei 20MHZ (50ns Taktzeit) bedeutet eine tatsächliche
Verzögerung von 2 Zyklen und entspricht 100ns. Dabei werden maximal 4 Instruktionen
erzeugt.

Die Variable Osc_Hz muss der verwendeten Taktquelle angepasst werden und definiert
die CPU-Taktfrequenz in Hertz.

wait_ns wird mit folgenden Parametern aufgerufen:
1. Verzögerungszeit in Nanosekunden
2. bereits verbrauchte Takte
3. ein Immediate-Register (R16-R31) als Zähler
Bereits verbrauchte Takte werden aus den Instruktionen errechnet, die zwischen
den zu verzögernden Ereignissen liegen. Beispiel:
<avrasm>
sbi porta,0
wait_ns 1000,2,R16
cbi porta,0
</avrasm>
In diesem Fall besteht die Anzahl der verbrauchten Takte lediglich aus den Instruktionen,
die zum Ereignis führen. Am Ende von SBI wird die steigende Flanke, am Ende von CBI
die fallende Flanke des Signals erzeugt. Wenn wir also möglichst exakt eine
Pulsbreite von einer Millisekunde erzeugen wollen, müssen wir die Ausführungszeit
von CBI von unserer Wartezeit abziehen. Die Ausführung von CBI liegt vor dem Ereignis!

Wenn die Verzögerungszeit kleiner als die Anzahl bereits verbrauchter Taktzyklen ist,
wird keine weitere Verzögerung erzeugt. Die maximale Verzögerung ist 767 Takte
entsprechend 38350ns bei 20MHZ. Bei niedrigeren Frequenzen wird eine längere Verzögerung
erreicht, allerdings nimmt dann auch die Genauigkeit der Verzögerung ab.

<avrasm>
;
; wait_ns waittime in ns , cyles already used , waitcount register
;
; cycles already used will be subtracted from the delay
; the waittime resolution is 1 cycle (delay from exact to +1 cycle)
; the maximum delay at 20MHz (50ns/clock) is 38350ns
; waitcount register must specify an immediate register
;
.set Osc_Hz = 7372800 ;7,3728 MHz (Baudrate xtal)
.set cycle_time_ns = (1000000000 / Osc_Hz) ;clock duration
.macro wait_ns
.set cycles = ((@0 + cycle_time_ns - 1) / cycle_time_ns - @1)
.if (cycles > (255 * 3 + 2))
.error "MACRO wait_ns - too many cycles to burn"
.else
.if (cycles > 6)
.set loop_cycles = (cycles / 3)
ldi @2,loop_cycles
dec @2
brne pc-1
.set cycles = (cycles - (loop_cycles * 3))
.endif
.if (cycles > 0)
.if (cycles & 4)
rjmp pc+1
rjmp pc+1
.endif
.if (cycles & 2)
rjmp pc+1
.endif
.if (cycles & 1)
nop
.endif
.endif
.endif
.endmacro
</avrasm>

Datei:Keyboard switch.png

2008-12-04T12:33:13Z

Klaus2m5: hat eine neue Version von „Bild:Keyboard switch.png“ hochgeladen

Aktiver PS/2 Tastatur Umschalter

2008-12-04T12:25:37Z

Klaus2m5: /* Informationen im Web */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
* [[Media:keyboard_switch.zip|(Assembler Source, HEX-File, dieses Dokument als PDF)]]

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

[[Category:Projekte|P]]
[[Category:AVR|P]]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T12:16:34Z

Klaus2m5: /* Download */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
* [[Media:keyboard_switch.zip|(Assembler Source, HEX-File, dieses Dokument als PDF)]]

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T12:07:59Z

Klaus2m5: /* Download */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
[[Media:keyboard_switch.zip]]
(Assembler Source, HEX-File, dieses Dokument als PDF)

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:54:18Z

Klaus2m5: /* Download */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
[[Bild:keyboard_switch.zip]]
(Assembler Source, HEX-File, dieses Dokument als PDF)

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:50:41Z

Klaus2m5: /* Download */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
[[Datei:keyboard_switch.zip]]
(Assembler Source, HEX-File, dieses Dokument als PDF)

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:47:03Z

Klaus2m5: /* Download */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
[[keyboard_switch.zip]]
(Assembler Source, HEX-File, dieses Dokument als PDF)

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Datei:Keyboard switch.zip

2008-12-04T11:46:06Z

Klaus2m5:

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:45:26Z

Klaus2m5: /* Download */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
[[Bild:keyboard_switch.zip]]
(Assembler Source, HEX-File, dieses Dokument als PDF)

=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:34:34Z

Klaus2m5: /* Informationen im Web */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
(Assembler Source, HEX-File, dieses Dokument als PDF)
=== Informationen im Web ===
* [http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]
* [http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:31:52Z

Klaus2m5: /* Initialisierung */

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

=== Timer und Interrupts ===

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.

=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
(Assembler Source, HEX-File, dieses Dokument als PDF)
=== Informationen im Web ===
[http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]

[http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]

Datei:Keyboard switch.png

2008-12-04T11:23:55Z

Klaus2m5: hat eine neue Version von „Bild:Keyboard switch.png“ hochgeladen

Aktiver PS/2 Tastatur Umschalter

2008-12-04T11:14:44Z

Klaus2m5: Die Seite wurde neu angelegt: ''von Klaus2m5'' == Übersicht == Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2 Tastatur an bis zu 4 PCs. An inaktiven PC Ports wird...

''von Klaus2m5''
== Übersicht ==
Ein in Assembler programmierter AVR ATTINY2313 erlaubt den Anschluss einer PS/2
Tastatur an bis zu 4 PCs.

An inaktiven PC Ports wird die Tastatur emuliert und die Parameter der Tastatur
(typematic, Lock LEDs) gespeichert. Das Umschalten der Tastatur erfolgt über
Hotkey (Shift Lock). LEDs und typematic rate werden dabei entsprechend des
ausgewählten PCs an die Tastatur übertragen. Die Anzeige des aktiven PCs
erfolgt durch eine gepulste LED (PC = Anzahl Pulse).
=== Einschränkungen ===
Es werden nur Tastaturen mit Scancode Set 2 unterstützt (XT Tastatur). Soweit
bekannt, verwenden alle aktuellen PCs, Betriebssysteme und PS/2 Tastaturen
diesen Standard.
== Die Schaltung ==
[[Bild:keyboard_switch.png]]
=== Stromversorgung ===
Die Schaltung wird durch die angeschlossenen PCs über Schottky Dioden versorgt.
Schaltung und Tastatur sind versorgt, falls einer der angeschlossenen PCs
eingeschaltet ist oder die Tastatur Schnittstelle durch die Standby Spannung
des PC Netzteils versorgt wird.
=== PC Ports ===
Jeweils 2 Pins des Port B bilden die Clock und Data Anschlüsse für einen PC.
Das benutzte PS/2 Protokoll erfordert eine Open Collector Ansteuerung mit
Pullup Widerständen (1,5k) ähnlich I²C. Ursprünglich hatte ich 10k als Pullup
vorgesehen, mit 1,5m Kabel traten aber Übertragungsfehler auf und das Signal
war deutlich sichtbar beeinträchtigt (Scope).

Um erkennen zu können, ob ein PC auch tatsächlich eingeschaltet ist, erfolgt
die Versorgung der Pullups direkt aus der PC Spannung. Ein Pulldown (10k) nebst
Block Kondensator (100n) pro PC sorgt für definierten low Pegel, falls kein PC
angeschlossen ist.
=== Tastatur Port ===
Die Tastatur ist an Port D3 und D5 angeschlossen. Die Tastatur Clock ist dabei
mit INT1 verbunden, damit die Data Bits mit der fallenden Flanke des Clock
Signals ausgewertet werden können.
=== Status LED ===
Die Status LED wird vom Port D6 angesteuert und signalisiert den im Augenblick
aktiven PC und andere Betriebszustände.
=== Reset ===
Der Reset Taster ist noch ein Überbleibsel aus der Debug Zeit und nicht
zwingend erforderlich. Damals war es äußerst lästig, erst die Stromversorgung
von allen PCs unterbrechen zu müssen, um einen Reset zu erreichen.
=== Freie Ports ===
Einige Ports sind noch frei und wurden während der Entwicklung benutzt oder
sind für zusätzliche Funktionen vorgesehen.
* RS232 (Port D0:1) – zum Überwachen der Tastatur Scancodes und der Emulation. Gleichzeitig ist ein 7,372 MHz Quarz an Port A0:1 erforderlich. Der Schalter „debug“ muss beim Assemblieren der Firmware gesetzt sein

* ISP (MISO, MOSI, SCK, Reset) – falls eigene Experimente geplant sind. Während des Programmiervorgangs dürfen PC3 & PC4 nicht verbunden sein.

* BCD codierte Ausgabe des aktiven PC (Port A0:1) – zur Erweiterung durch einen externen Maus oder VGA Umschalter. Der Schalter „hst_sel_out“ muss beim Assemblieren der Firmware gesetzt sein.

* Maus (Port D2,4) – Erweiterung um einen zusätzlichen Maus Eingang. Zurzeit ohne Funktion. Die Erweiterung auf eine Maus Umschaltung ist von mir nicht geplant und ist wahrscheinlich nur auf einem größeren AVR sinnvoll.
=== Aufbau ===
Ein Layout für eine gedruckte Schaltung existiert nicht. Die Schaltung lässt
sich jedoch leicht auf einer Lochrasterplatine aufbauen.

Die 6-poligen Mini-DIN Buchsen zu den PC Tastatur Ports können durch in der
Mitte auseinander geschnittene, und direkt mit der Platine verlötete PS/2
Stecker/Stecker Kabel ersetzt werden.

Wenn der Schalter für weniger PCs aufgebaut wird, kann die Hardware für diese
PCs entfallen. Es wird jedoch empfohlen, die freien Pins des Port B mit 10k
Pulldowns zu bestücken.

Für eigene Experimente sollte man noch eine externe Stromversorgung, Probe Pins
fürs Scope, einen RS232 Anschluss nebst Quarz und einen ISP Stecker verbauen
(nicht Teil des Schaltplans).
== Die Firmware ==
Das zum Download angebotene ZIP File enthält sowohl den Sourcecode (Assembler)
als auch ein HEX File zum flashen des AVR ohne Debug-Funktion und BCD-Ausgabe
an Port A. Benötigte Fuses:
* 8MHz internal RC Osc mit Startup 14 CK + 65ms (voreingestellt)
* BOD enabled – 2,7V
* CKDIV8 disabled !!!!!!!
* Finger weg vom Rest der Fuses!
=== Status ===
Der momentane Betriebszustand wird durch eine LED dargestellt. Wenn kein
besonderer Betriebszustand vorliegt, Zeigt die Anzahl der Lichtimpulse den
aktiven PC an. Wenn nach dem Drücken einer Taste die Kommunikation zum aktiven
PC nicht möglich ist, z.B. keine Stromversorgung von diesem PC, dann wird dies
durch 2 Sekunden 8Hz Blinken dargestellt.
=== Steuerung ===
Die Umschaltung der Tastatur erfolgt durch Klammergriff. Die Shift-Lock/Caps-
Lock Taste dient dabei als Hotkey. Wird der Hotkey betätigt, dann leuchtet die
LED dauernd bis diese Taste wieder losgelassen wird. Die Zifferntasten 1-4 im
Alpha Block (nicht der Nummern Block) schalten auf den entsprechenden PC.
Selbstverständlich kann man auch noch Caps-Lock erreichen, indem man die [ ^ ]
Taste drückt ([ ~ ] bei englischer Tastatur). Die Tastenkombination kann im
Sourcecode frei gewählt werden. Ein Beispiel ist im Source enthalten. Dabei
werden die Tasten F1-F4 zum Umschalter, Caps-Lock über [Esc] erreicht.

Das Umschalten der Tastatur auf einen PC ohne Versorgungsspannung oder mit
dauerhaft auf low liegendem Data- oder Clock-Signal wird unterdrückt und mit
8Hz Blinken angezeigt.
=== Initialisierung ===
Bei einem Reset durch Einschalten (auch Brown Out) wird der erste PC
eingestellt, der eine Versorgungsspannung zur Verfügung stellt. Die
Initialisierung der Tastatur wird dann dem PC an diesem Port überlassen.

Wird der Reset durch den Reset Pin ausgelöst (durch drücken der Reset Taste),
dann wird die Tastatur durch den AVR initialisiert und die bisherigen
Einstellungen wieder hergestellt.

Timer und Interrupts

Alle internen Funktionen des Tastatur Umschalters benutzen die Timer des AVR.
Beide Timer werden mit einem Prescaler von 8 initialisiert, so dass diese mit
einer Auflösung von 1µs arbeiten (8MHz/8 = 1MHz = 1µs). Natürlich eignet sich
der 16 Bit Timer in diesem Falle für längere Zeiträume (65ms) und der 8 Bit
Timer für eher kurze Zeiträume (256 µs).

So wird die LED mit Hilfe des Timer 1 Overflow Interrupts gesteuert. Dieser
Interrupt wird enabled ausgeführt, da er nicht zu den höchsten Prioritäten des
Umschalters gehört.

Die Kommunikation mit der Tastatur wird durch das Clock-Signal der Tastatur
angestoßen. Diese erzeugt über Portpin D3 mit der fallenden Flanke einen
externen Interrupt über den INT1-Vektor. Laut Spezifikation generiert die
Tastatur eine Clock mit maximal 16,6kHz. Die Daten sind während der low Phase
der Clock gültig, entsprechend 30µs des Clock-Zyklus von 60µS. Daten müssen
also nach 240 AVR Clocks erfasst sein (inklusive aller vorausgehender
Interrupts). Ein 11 Bit Datenframe von der Tastatur erreicht den AVR in minimal
660µs, maximal in 1,1ms (minimum Clock 10kHz). Um verlorene Clocks sicher
erkennen zu können, wird am Anfang eines Frames der Timer 1 Compare A auf Timer
1 + 2ms gesetzt. Läuft der Timer Compare vor Ende des Frames ab, so wird durch
den resultierenden Interrupt ein Fehler Bit im Status Register gesetzt (0x40).
Dies geschieht auch bei Start- und Stop-Bits mit falschem Pegel und bei
falschem Parity (0x80).

Die Kommunikation mit den PC Tastatureingängen erfolgt mit Hilfe des Timer 0
Compare A. Für jede Clock-Phase wird der Compare auf Timer 0 + 30µs gesetzt
(240 AVR Clocks + die eventuell von INT1 benötigten AVR Clocks. Der CLock
Zyklus kann durch verzögerte Auslösung des Compare Interrupts bis auf 50µs
verlängert werden, er wird aber immer mindestens 30 µs lang sein (10kHz-
16,6kHz). Mit dem Versenden eines Frames an einen PC wird für diesen PC ein
Software Timer gestartet, so dass das nächste Frame für diesen PC mindestens
3,5ms warten muss. Dadurch bleibt genügend Zeit für die Kommunikation mit den
anderen PCs, und der PC kann mit Hilfe seines 2ms Timeouts mit Sicherheit
verlorene Clocks erkennen.
=== Hauptprogramm ===
Im Hauptprogramm werden permanent die durch die Tastatur- und PC-Kommunikation
gesetzten Status Register überprüft („looking for work“). Wenn die
Statusregister die maximale Anzahl von Interrupts erreicht haben, war die
Übertragung erfolgreich. Wenn zum Beispiel der Tastatur Interrupt 11 erreicht
hat, ist ein Frame komplett empfangen, und kann an den PC weitergegeben werden.
Wenn ein Frame nicht vollständig übertragen werden konnte, wird dies durch
setzen von Bit 7 oder Bit 6 indiziert. In diesem Fall führt das Hauptprogramm
die Fehlerbehandlung durch (Resend, Resend Request).

Ein Kommando vom aktiven PC wird an die Tastatur weitergegeben. Bei den
inaktiven PCs sorgt eine Emulation für die Antworten. In jedem Falle werden
alle wichtigen Parameter in einem Array gespeichert. Aus diesem Array können
beim Wechsel des aktiven PCs die entsprechenden Parameter an die Tastatur
gesendet werden.

Die Kommunikation mit einem PC erfordert oft das Senden mehrerer Frames
hintereinander und ist deshalb durch einen Sequencer realisiert. Das
Hauptprogramm kann dadurch in den Wartezeiten zwischen den Frames auch mit
anderen PCs kommunizieren, obwohl nur eine Task existiert. Auch für die
Tastatur gibt es einen Sequencer, der nach dem Umschalten des aktiven PCs die
Tastatur enabled und mit den Parametern für diesen PC lädt.
== Quellen ==
=== Download ===
(Assembler Source, HEX-File, dieses Dokument als PDF)
=== Informationen im Web ===
[http://www.computer-engineering.org/index.php?title=Main_Page PS/2 Keyboard Protocol]

[http://www.beyondlogic.org/keyboard/keybrd.htm Interfacing the PCs keyboard]