https://www.mikrocontroller.net/api.php?action=feedcontributions&feedformat=atom&user=RotoeMikrocontroller.net - Benutzerbeiträge [de]2026-04-16T06:24:37ZBenutzerbeiträgeMediaWiki 1.39.7https://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=59037Benutzer:Rotoe2011-07-29T13:40:32Z<p>Rotoe: Die Seite wurde geleert.</p>
<hr />
<div></div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=52867Benutzer:Rotoe2010-11-20T19:56:31Z<p>Rotoe: /* Wunschliste */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 19<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (2008)<br />
* Parkzone T-28 Trojan (2008)<br />
* Digitalkamera Casio EX-Z12 (2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
* Bosch SPS CL200 (2009)<br />
<br />
== Wunschliste ==<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=52866Benutzer:Rotoe2010-11-20T19:56:18Z<p>Rotoe: /* Letze Errungenschaften */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 19<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (2008)<br />
* Parkzone T-28 Trojan (2008)<br />
* Digitalkamera Casio EX-Z12 (2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
* Bosch SPS CL200 (2009)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=52865Benutzer:Rotoe2010-11-20T19:55:49Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 19<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (2008)<br />
* Parkzone T-28 Trojan (2008)<br />
* Digitalkamera Casio EX-Z12 (2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
* Bosch SPS CL200 (2009<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=40360Benutzer:Rotoe2009-11-01T16:47:36Z<p>Rotoe: /* Letze Errungenschaften */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 18<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (2008)<br />
* Parkzone T-28 Trojan (2008)<br />
* Digitalkamera Casio EX-Z12 (2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
* Bosch SPS CL200 (2009<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=40359Benutzer:Rotoe2009-11-01T16:46:57Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 18<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (10.10.08)<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=AVR-Tutorial:_Speicher&diff=39617AVR-Tutorial: Speicher2009-10-04T13:35:31Z<p>Rotoe: /* Lesen */</p>
<hr />
<div>== Speichertypen ==<br />
<br />
Die AVR-Mikrocontroller besitzen 3 verschiedene Arten von Speicher: <br />
<br />
<table border="1" class="wikitable"><br />
<tr><br />
<th align="left"></th><br />
<th align="left">Flash</th><br />
<th align="left">EEPROM</th><br />
<th align="left">RAM</th><br />
</tr><br />
<tr><br />
<th align="left">Schreibzyklen</th><br />
<td>&gt;10.000</td><br />
<td>&gt;100.000</td><br />
<td>unbegrenzt</td><br />
</tr><br />
<tr><br />
<th align="left">Lesezyklen</th><br />
<td>unbegrenzt</td><br />
<td>unbegrenzt</td><br />
<td>unbegrenzt</td><br />
</tr><br />
<tr><br />
<th align="left">flüchtig</th><br />
<td>nein</td><br />
<td>nein</td><br />
<td>ja</td><br />
</tr><br />
<tr><br />
<th align="left">Größe beim ATtiny2313</th><br />
<td>2 KB</td><br />
<td>128 Byte</td><br />
<td>128 Byte</td><br />
</tr><br />
<tr><br />
<th align="left">Größe beim ATmega8</th><br />
<td>8 KB</td><br />
<td>512 Byte</td><br />
<td>1 KB</td><br />
</tr><br />
<tr><br />
<th align="left">Größe beim ATmega32</th><br />
<td>32 KB</td><br />
<td>1 KB</td><br />
<td>2 KB</td><br />
</tr><br />
<br />
</table><br />
<br />
=== Flash-ROM ===<br />
<br />
Das [[Speicher#Flash-ROM | '''Flash-ROM''']] der AVRs dient als Programmspeicher. Über den Programmieradapter werden die kompilierten Programme vom PC an den Controller übertragen und im Flash-ROM abgelegt. Bei der Programmausführung wird das ROM [[Digitaltechnik#Word | Wort]] für Wort ausgelesen und ausgeführt. Es lässt sich aber auch zur Speicherung von Daten nutzen (z.B. Texte für ein [[LCD]]). Vom laufenden Programm aus kann man das ROM normalerweise nur lesen, nicht beschreiben. Es kann beliebig oft ausgelesen werden, aber theoretisch nur ~10.000 mal beschrieben werden.<br />
<br />
=== EEPROM ===<br />
<br />
Das [[Speicher#EEPROM |'''EEPROM''']] ist wie das Flash ein nichtflüchtiger Speicher, die Daten bleiben also auch nach dem Ausschalten der Betriebsspannung erhalten. Es kann beliebig oft gelesen und mindestens 100.000 mal beschrieben werden. Bei den AVRs kann man es z.B. als Speicher für Messwerte oder Einstellungen benutzen. <br />
<br />
=== RAM ===<br />
<br />
Das [[Speicher#RAM |'''RAM''']] ist ein flüchtiger Speicher, d.h. die Daten gehen nach dem Ausschalten verloren. Es kann beliebig oft gelesen und beschrieben werden, weshalb es sich zur Speicherung von Variablen eignet für die die Register R0-R31 nicht ausreichen. Daneben dient es als Speicherort für den Stack, auf dem z.B. bei Unterprogrammaufrufen (rcall) die Rücksprungadresse gespeichert wird (siehe [[AVR-Tutorial:_SRAM]]).<br />
<br />
== Anwendung ==<br />
<br />
=== Flash-ROM ===<br />
<br />
Die erste und wichtigste Anwendung des Flash-ROMs kennen wir bereits: Das Speichern von Programmen, die wir nach dem Assemblieren dort hineingeladen haben. Nun sollen aber auch vom laufenden Programm aus Daten ausgelesen werden. <br />
<br />
Um die Daten wieder auszulesen, muss man die Adresse, auf die zugegriffen werden soll, in den '''Z-Pointer''' laden. Der Z-Pointer besteht aus den Registern '''R30''' (Low-Byte) und '''R31''' (High-Byte), daher kann man das Laden einer Konstante wie gewohnt mit dem Befehl '''ldi''' durchführen. Statt R30 und R31 kann man übrigens einfach '''ZL''' und '''ZH''' schreiben, da diese Synonyme bereits in der include-Datei m8def.inc definiert sind. <br />
<br />
Wenn die richtige Adresse erstmal im Z-Pointer steht, geht das eigentliche Laden der Daten ganz einfach mit dem Befehl '''lpm'''. Dieser Befehl, der im Gegensatz zu out, ldi usw. keine Operanden hat, veranlasst das Laden des durch den Z-Pointer addressierte Byte aus dem Programmspeicher in das Register '''R0''', von wo aus man es weiterverarbeiten kann. <br />
<br />
Jetzt muss man nur noch wissen, wie man dem Assembler überhaupt beibringt, dass er die von uns festgelegte Daten im ROM plazieren soll, und wie man dann an die Adresse kommt an der sich diese Daten befinden. Um den Programmspeicher mit Daten zu füllen, gibt es die Direktiven .db und .dw. In der Regel benötigt man nur .db, was folgendermaßen funktioniert: <br />
<br />
<avrasm><br />
daten:<br />
.db 12, 20, 255, 0xFF, 0b10010000<br />
</avrasm><br />
<br />
Direktiven wie .db sind Anweisungen an den Assembler, keine Prozessorbefehle. Von denen kann man sie durch den vorangestellten Punkt unterscheiden. In diesem Fall sagen wir dem Assembler, dass er die angegebenen Bytes nacheinander im Speicher platzieren soll; wenn man die Zeile also assembliert, erhält man eine Hex-Datei, die nur diese Daten enthält.<br />
<br />
Aber was soll das '''daten:''' am Anfang der Zeile? Bis jetzt haben wir Labels nur als Sprungmarken verwendet, um den Befehlen '''rcall''' und '''rjmp''' zu sagen, an welche Stelle im Programm gesprungen werden soll. Würden wir in diesem Fall '''rjmp daten''' im Programm stehen haben, dann würde die Programmausführung zur Stelle '''daten:''' springen, und versuchen die sinnlosen Daten als Befehle zu interpretieren - was mit Sicherheit dazu führt, dass der Controller Amok läuft. <br />
<br />
Statt nach '''daten:''' zu springen, sollten wir die Adresse besser in den Z-Pointer laden. Da der Z-Pointer aus zwei Bytes besteht, brauchen wir dazu zweimal den Befehl '''ldi''': <br />
<br />
<avrasm><br />
ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer<br />
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer<br />
</avrasm><br />
<br />
Wie man sieht, ist das Ganze sehr einfach: Man kann die Labels im Assembler direkt wie Konstanten verwenden. Über die Multiplikation der Adresse mit zwei sollte man sich erst mal keine Gedanken machen: "Das ist einfach so." Wer es genauer wissen will schaut [[AVR-Tutorial:_Mehrfachverzweigung#Z-Pointer_leicht_verst.C3.A4ndlich | hier]] nach.<br />
<br />
Um zu zeigen wie das alles konkret funktioniert, ist das folgende Beispiel nützlich:<br />
<br />
<avrasm> <br />
.include "m8def.inc"<br />
<br />
ldi R16, 0xFF<br />
out DDRB, R16 ; Port B: Ausgang<br />
<br />
ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer<br />
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer<br />
<br />
lpm ; durch Z-Pointer adressiertes Byte<br />
; in R0 laden<br />
out PORTB, R0 ; an PORTB ausgeben<br />
<br />
ende: <br />
rjmp ende ; Endlosschleife<br />
<br />
daten:<br />
.db 0b10101010<br />
</avrasm><br />
<br />
Wenn man dieses Programm assembliert und in den Controller überträgt, dann kann man auf den an Port B angeschlossenen LEDs das mit '''.db 0b10101010''' im Programmspeicher abgelegte Bitmuster sehen. <br />
<br />
Eine häufige Anwendung von '''lpm''' ist das Auslesen von Zeichenketten ("Strings") aus dem Flash-ROM und die Ausgabe an den seriellen Port oder ein LCD. Das folgende Programm gibt in einer Endlosschleife den Text "AVR-Assembler ist ganz einfach", gefolgt von einem Zeilenumbruch, an den UART aus. <br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp = r16<br />
.def temp1 = r17<br />
<br />
.equ CLOCK = 4000000 ; Frequenz des Quarzes<br />
.equ BAUD = 9600 ; Baudrate<br />
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler<br />
<br />
; hier geht das Programmsegment los<br />
<br />
.CSEG <br />
.org 0<br />
ldi r16, low(RAMEND) ; Stackpointer initialisieren<br />
out SPL, r16 <br />
ldi r16, high(RAMEND)<br />
out SPH, r16 <br />
<br />
ldi temp, LOW(UBRRVAL) ; Baudrate einstellen<br />
out UBRRL, temp<br />
ldi temp, HIGH(UBRRVAL)<br />
out UBRRH, temp<br />
<br />
ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit<br />
out UCSRC, temp<br />
sbi UCSRB, TXEN ; TX (Senden) aktivieren<br />
<br />
loop:<br />
ldi ZL, LOW(text*2) ; Adresse des Strings in den<br />
ldi ZH, HIGH(text*2) ; Z-Pointer laden<br />
rcall print ; Funktion print aufrufen<br />
rcall wait ; kleine Pause<br />
rjmp loop ; das Ganze wiederholen<br />
<br />
; kleine Pause<br />
wait:<br />
ldi temp,0<br />
wait_1:<br />
ldi temp1,0<br />
wait_2:<br />
dec temp1<br />
brne wait_2<br />
dec temp<br />
brne wait_1<br />
ret<br />
<br />
; print: sendet die durch den Z-Pointer adressierte Zeichenkette<br />
<br />
print:<br />
lpm ; Erstes Byte des Strings nach R0 lesen<br />
tst R0 ; R0 auf 0 testen<br />
breq print_end ; wenn 0, dann zu print_end<br />
mov r16, r0 ; Inhalt von R0 nach R16 kopieren<br />
rcall sendbyte ; UART-Sendefunktion aufrufen<br />
adiw ZL, 1 ; Adresse des Z-Pointers um 1 erhöhen<br />
rjmp print ; wieder zum Anfang springen<br />
print_end:<br />
ret<br />
<br />
; sendbyte: sendet das Byte aus R16 über das UART<br />
<br />
sendbyte:<br />
sbis UCSRA, UDRE ; warten bis das UART bereit ist<br />
rjmp sendbyte<br />
out UDR, r16<br />
ret<br />
<br />
; Konstanten werden hier im Flash abgelegt<br />
<br />
text:<br />
.db "AVR-Assembler ist ganz einfach",10,13,0 <br />
; Stringkonstante, durch eine 0 abgeschlossen<br />
; die 10 bzw. 13 sind Steuerzeichen für Wagenrücklauf und neue Zeile<br />
</avrasm><br />
<br />
Neuere AVR-Controller besitzen einen erweiterten Befehlssatz. Darunter befindet sich auch der folgende Befehl:<br />
<br />
<avrasm><br />
lpm r16, Z+<br />
</avrasm><br />
<br />
Dieser Befehl liest ein Byte aus dem Flash und speichert es in einem beliebigen Register, hier r16. Danach wird der Zeiger Z um eins erhöht. Für die neuen Controller, wie ATmegas kann das Codebeispiel also so abgeändert werden:<br />
<br />
<avrasm><br />
; print: sendet die durch den Z-Pointer adressierte Zeichenkette<br />
print:<br />
lpm r16, Z+ ; Erstes Byte des Strings nach r16 lesen<br />
tst r16 ; r16 auf 0 testen<br />
breq print_end ; wenn 0, dann zu print_end<br />
rcall sendbyte ; UART-Sendefunktion aufrufen<br />
rjmp print ; wieder zum Anfang springen<br />
print_end:<br />
ret<br />
</avrasm><br />
<br />
Wenn man bei .db einen Text in doppelten Anführungszeichen angibt, werden die Zeichen automatisch in die entsprechenden ASCII-Codes umgerechnet:<br />
<br />
<avrasm><br />
.db "Test", 0 <br />
; ist äquivalent zu<br />
.db 84, 101, 115, 116, 0<br />
</avrasm><br />
<br />
Damit das Programm das Ende der Zeichenkette erkennen kann, wird eine 0 an den Text angehängt. <br />
<br />
Das ist doch schonmal sehr viel praktischer, als jeden Buchstaben einzeln in ein Register zu laden und abzuschicken. Und wenn man statt '''sendbyte''' einfach die Routine '''lcd_data''' aus dem 4. Teil des Tutorials aufruft, dann funktioniert das gleiche sogar mit dem LCD!<br />
<br />
==== Neue Assemblerbefehle ====<br />
<br />
<avrasm><br />
lpm ; Liest das durch den Z-Pointer<br />
; addressierte Byte aus dem Flash-ROM<br />
; in das Register R0 ein. <br />
<br />
lpm [Register], Z ; Macht das gleiche wie lpm, jedoch in<br />
; ein beliebiges Register<br />
<br />
lpm [Register], Z+ ; Erhöht zusätzlich den Z-Zeiger<br />
<br />
tst [Register] ; Prüft, ob Inhalt eines Registers<br />
; gleich 0 ist.<br />
<br />
breq [Label] ; Springt zu [Label], wenn der<br />
; vorhergehende Vergleich wahr ist. <br />
<br />
adiw [Register], [Konstante] ; Addiert eine Konstante zu einem<br />
; Registerpaar. [Register] bezeichnet das<br />
; untere der beiden Register.<br />
; Kann nur auf die Registerpaare<br />
; R25:R24, R27:R26, R29:R28 und R31:R30<br />
; angewendet werden. <br />
</avrasm><br />
<br />
=== EEPROM ===<br />
<br />
==== Lesen ====<br />
<br />
Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse von der gelesen werden soll in das IO-Registerpaar '''EEARH/EEARL''' (EEPROM Address Register) geladen. Da der ATmega8 mehr als 256 Byte EEPROM hat, passt die Adresse nicht in ein einziges 8-Bit-Register, sondern muss in zwei Register aufgeteilt werden: EEARH bekommt das obere Byte der Adresse, EEARL das untere Byte. Dann löst man den Lesevorgang durch das Setzen des Bits '''EERE''' (EEPROM Read Enable) im IO-Register '''EECR''' (EEPROM Control Register) aus. Das gelesene Byte kann sofort aus dem IO-Register '''EEDR''' (EEPROM Data Register) in ein normales CPU-Register kopiert und dort weiterverarbeitet werden.<br />
<br />
Wie auch das Flash-ROM kann man das EEPROM über den ISP-Programmer programmieren. Die Daten, die im EEPROM abgelegt werden sollen, werden wie gewohnt mit .db angegeben; allerdings muss man dem Assembler natürlich sagen, dass es sich hier um Daten für das EEPROM handelt. Das macht man durch die Direktive '''.eseg''', woran der Assembler erkennt, dass alle nun folgenden Daten für das EEPROM bestimmt sind. <br />
<br />
Damit man die Bytes nicht von Hand abzählen muss um die Adresse herauszufinden, kann man auch im EEPROM-Segment wieder Labels einsetzen und diese im Assemblerprogramm wie Konstanten verwenden. <br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
; hier geht die Programmsektion los<br />
.cseg<br />
<br />
ldi r16, low(RAMEND) ; Stackpointer initialisieren<br />
out SPL, r16 <br />
ldi r16, high(RAMEND)<br />
out SPH, r16 <br />
<br />
ldi r16, 0xFF<br />
out DDRB, r16 ; Port B Ausgang<br />
<br />
ldi ZL,low(daten) ; Z-Zeiger laden<br />
ldi ZH,high(daten)<br />
rcall EEPROM_read ; Daten aus EEPROM lesen<br />
out PORTB, r16<br />
<br />
loop: <br />
rjmp loop<br />
<br />
EEPROM_read:<br />
sbic EECR,EEWE ; prüfe ob der vorherige Schreibzugriff<br />
; beendet ist<br />
rjmp EEPROM_read ; nein, nochmal prüfen<br />
<br />
out EEARH, ZH ; Adresse laden<br />
out EEARL, ZL <br />
sbi EECR, EERE ; Lesevorgang aktivieren<br />
in r16, EEDR ; Daten in CPU Register kopieren<br />
ret<br />
<br />
; Daten im EEPROM definieren<br />
.eseg<br />
daten:<br />
.db 0b10101010<br />
</avrasm><br />
<br />
Wenn man dieses Programm assembliert, erhält man außer der .hex-Datei noch eine Datei mit der Endung '''.eep'''. Diese Datei enthält die Daten aus dem EEPROM-Segment (.eseg), und muss zusätzlich zu der hex-Datei in den Controller programmiert werden. <br />
<br />
Das Programm gibt die Binärzahl 0b10101010 an den Port B aus, das heißt jetzt sollte jede zweite LED leuchten.<br />
<br />
Natürlich kann man auch aus dem EEPROM Strings lesen und an den UART senden: <br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp = r16<br />
<br />
.equ CLOCK = 4000000 ; Frequenz des Quarzes<br />
<br />
.equ BAUD = 9600 ; Baudrate<br />
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler<br />
<br />
; hier geht das Programmsegment los<br />
<br />
.CSEG <br />
<br />
; Hauptprogramm<br />
main:<br />
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren<br />
out SPL, temp<br />
ldi temp, HIGH(RAMEND)<br />
out SPH, temp<br />
<br />
ldi temp, LOW(UBRRVAL) ; Baudrate einstellen<br />
out UBRRL, temp<br />
ldi temp, HIGH(UBRRVAL)<br />
out UBRRH, temp<br />
<br />
ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit<br />
out UCSRC, temp<br />
sbi UCSRB, TXEN ; TX (Senden) aktivieren<br />
<br />
ldi ZL, low(text1) ; ersten String senden<br />
ldi ZH, high(text1) ; Z-Pointer laden<br />
rcall EEPROM_print<br />
<br />
ldi ZL, low(text2) ; zweiten String senden<br />
ldi ZH, high(text2) ; Z-Pointer laden<br />
rcall EEPROM_print<br />
<br />
loop: <br />
rjmp loop ; Endlosschleife<br />
<br />
<br />
; EEPROM Lesezugriff auf Strings + UART Ausgabe<br />
<br />
EEPROM_print:<br />
sbic EECR,EEWE ; prüf ob der vorherige Schreibzugriff<br />
; beendet ist<br />
rjmp EEPROM_print ; nein, nochmal prüfen<br />
<br />
out EEARH, ZH ; Adresse laden<br />
out EEARL, ZL<br />
<br />
sbi EECR, EERE ; Lesevorgang aktivieren<br />
in temp, EEDR ; Daten in CPU Register kopieren<br />
tst temp ; auf 0 testen (=Stringende)<br />
breq eep_print_end ; falls 0, Funktion beenden<br />
rcall sendbyte ; ansonsten Byte senden...<br />
adiw ZL,1 ; Adresse um 1 erhöhen...<br />
rjmp EEPROM_print ; und zum Anfang der Funktion<br />
eep_print_end:<br />
ret<br />
<br />
; sendbyte: sendet das Byte aus "data" über den UART<br />
<br />
sendbyte:<br />
sbis UCSRA, UDRE ; warten bis das UART bereit ist<br />
rjmp sendbyte<br />
out UDR, temp<br />
ret<br />
<br />
; hier wird der EEPROM-Inhalt definiert<br />
<br />
.ESEG<br />
<br />
text1:<br />
.db "Strings funktionieren auch ", 0<br />
text2:<br />
.db "im EEPROM",10,13, 0<br />
</avrasm><br />
<br />
==== Schreiben ====<br />
<br />
Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse, auf die geschrieben wird, in das IO-Register '''EEAR''' ('''EE'''PROM '''A'''ddress '''R'''egister) geladen. Dann schreibt man die Daten, welche man auf der im Adressregister abgespeicherten Position ablegen will ins Register '''EEDR''' ('''EE'''PROM '''D'''ata '''R'''egister). Als nächstes setzt man das '''EEMWE''' Bit im EEPROM-Kontrollregister '''EECR''' ('''EE'''PROM '''C'''ontrol '''R'''egister) um den Schreibvorgang vorzubereiten. Nun wird es zeitkritisch - es darf nun keinesfalls ein Interrupt dazwischenfahren - denn man muss innerhalb von 4 Taktzyklen das '''EEWE''' Bit setzen um den Schreibvorgang auszulösen. Um das unter allen Bedingungen sicherzustellen werden die Interrupts kurz gesperrt. Danach startet der Schreibvorgang und läuft automatisch ab. Wenn er beendet ist, wird von der Hardware das '''EEWE''' Bit im Register '''EECR''' wieder gelöscht.<br />
<br />
In diesem Beispiel werden Zeichen per UART und Interrupt empfangen und nacheinander im EEPROM gespeichert. Per Terminalprogramm kann man nun bis zu 512 Zeichen in den EEPROM schreiben. Per Programmieradapter kann man denn EEPROM wieder auslesen und seine gespeicherten Daten anschauen.<br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp = r16<br />
.def sreg_save = r17<br />
<br />
.equ CLOCK = 4000000<br />
<br />
.equ BAUD = 9600<br />
.equ UBRRVAL = CLOCK/(BAUD*16)-1<br />
<br />
; hier geht das Programmsegment los<br />
<br />
.CSEG<br />
.org 0x00<br />
rjmp main<br />
<br />
.org URXCaddr<br />
rjmp int_rxc<br />
<br />
; Hauptprogramm<br />
main:<br />
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren<br />
out SPL, temp<br />
ldi temp, HIGH(RAMEND)<br />
out SPH, temp<br />
<br />
ldi temp, LOW(UBRRVAL) ; Baudrate einstellen<br />
out UBRRL, temp<br />
ldi temp, HIGH(UBRRVAL)<br />
out UBRRH, temp<br />
<br />
<br />
ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit<br />
out UCSRC, temp<br />
<br />
sbi UCSRB, RXCIE ; Interrupt bei Empfang<br />
sbi UCSRB, RXEN ; RX (Empfang) aktivieren<br />
<br />
ldi ZL,low(daten) ; der Z-Zeiger wird hier exclusiv<br />
ldi ZH,high(daten) ; für die Datenadressierung verwendet<br />
<br />
sei ; Interrupts global aktivieren<br />
<br />
loop: <br />
rjmp loop ; Endlosschleife (ABER Interrupts!)<br />
<br />
; Interruptroutine wird ausgeführt,<br />
; sobald ein Byte über den UART empfangen wurde<br />
<br />
int_rxc:<br />
push temp ; temp auf dem Stack sichern<br />
in temp,sreg ; SREG sicher, muss praktisch in jeder<br />
; Interruptroutine gemacht werden<br />
push temp<br />
<br />
in temp, UDR ; empfangenes Byte lesen<br />
rcall EEPROM_write ; Byte im EEPROM speichern<br />
adiw ZL,1 ; Zeiger erhöhen<br />
cpi ZL,low(EEPROMEND+1) ; Vergleiche den Z Zeiger<br />
ldi temp,high(EEPROMEND+1) ; mit der maximalen EEPROM Adresse +1<br />
cpc ZH,temp<br />
brne int_rxc_1 ; wenn ungleich, springen<br />
ldi ZL,low(Daten) ; wenn gleich, Zeiger zurücksetzen<br />
ldi ZH,high(Daten)<br />
int_rxc_1:<br />
<br />
pop temp<br />
out sreg,temp<br />
pop temp ; temp wiederherstellen<br />
reti<br />
<br />
; der eigentliche EEPROM Schreibzugriff<br />
; Adresse in ZL/ZH<br />
; Daten in temp<br />
<br />
EEPROM_write:<br />
sbic EECR, EEWE ; prüfe ob der letzte Schreibvorgang beendet ist<br />
rjmp EEPROM_write ; wenn nein, nochmal prüfen<br />
<br />
out EEARH, ZH ; Adresse schreiben<br />
out EEARL, ZL ; <br />
out EEDR,temp ; Daten schreiben<br />
in sreg_save,sreg ; SREG sichern<br />
cli ; Interrupts sperren, die nächsten<br />
; zwei Befehle dürfen NICHT<br />
; unterbrochen werden<br />
sbi EECR,EEMWE ; Schreiben vorbereiten<br />
sbi EECR,EEWE ; Und los !<br />
out sreg, sreg_save ; SREG wieder herstellen<br />
ret<br />
<br />
; hier wird der EEPROM-Inhalt definiert<br />
.ESEG<br />
<br />
Daten: <br />
.db 0<br />
</avrasm><br />
<br />
=== SRAM ===<br />
<br />
Die Verwendung des SRAM wird in einem anderen Kapitel erklärt: [[AVR-Tutorial: SRAM]]<br />
<br />
== Siehe auch ==<br />
<br />
* [[Adressierung]]<br />
<br />
{{Navigation_zurückhochvor|<br />
zurücktext=UART|<br />
zurücklink=AVR-Tutorial: UART|<br />
hochtext=Inhaltsverzeichnis|<br />
hochlink=AVR-Tutorial|<br />
vortext=Timer|<br />
vorlink=AVR-Tutorial: Timer}}<br />
<br />
[[Category:AVR-Tutorial]]<br />
[[Kategorie:Speicher und Dateisysteme]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=AVR-Tutorial:_LCD&diff=39591AVR-Tutorial: LCD2009-10-03T19:47:48Z<p>Rotoe: /* Benutzerdefinierten Zeichen */</p>
<hr />
<div>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?"<br />
<br />
==Das LCD und sein Controller==<br />
<br />
Die meisten Text-LCDs verwenden den Controller [[HD44780|'''HD44780''']] oder einen kompatiblen (z.B. KS0070) und haben 14 oder 16 Pins. Die Pinbelegung ist praktisch immer gleich: <br />
<br />
<center><br />
{| {{Tabelle}}<br />
|- style="background-color:#ffddcc"<br />
! Pin # || Bezeichnung || Funktion<br />
|-<br />
|align="center" | 1<br />
|align="center" | Vss<br />
|| GND<br />
|-<br />
|align="center" | 2<br />
|align="center" | Vcc<br />
|| 5V<br />
|-<br />
|align="center" | 3<br />
|align="center" | Vee<br />
|| Kontrastspannung (0V bis 5V)<br />
|-<br />
|align="center" | 4<br />
|align="center" | RS<br />
|| Register Select (Befehl/Daten)<br />
|-<br />
|align="center" | 5<br />
|align="center" | RW<br />
|| Read/Write<br />
|-<br />
|align="center" | 6<br />
|align="center" | E<br />
|| Enable<br />
|-<br />
|align="center" | 7<br />
|align="center" | DB0<br />
|| Datenbit 0<br />
|-<br />
|align="center" | 8<br />
|align="center" | DB1<br />
|| Datenbit 1<br />
|-<br />
|align="center" | 9<br />
|align="center" | DB2<br />
|| Datenbit 2<br />
|-<br />
|align="center" | 10<br />
|align="center" | DB3<br />
|| Datenbit 3<br />
|-<br />
|align="center" | 11<br />
|align="center" | DB4<br />
|| Datenbit 4<br />
|-<br />
|align="center" | 12<br />
|align="center" | DB5<br />
|| Datenbit 5<br />
|-<br />
|align="center" | 13<br />
|align="center" | DB6<br />
|| Datenbit 6<br />
|-<br />
|align="center" | 14<br />
|align="center" | DB7<br />
|| Datenbit 7<br />
|-<br />
|align="center" | 15<br />
|align="center" | A<br />
|| LED-Beleuchtung, Anode<br />
|-<br />
|align="center" | 16<br />
|align="center" | K<br />
|| LED-Beleuchtung, Kathode<br />
|}<br />
</center><br />
<br />
Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist neben Pin 1 eine kleine 1 auf der LCD-Platine, ansonsten im Datenblatt nachschauen. <br />
<br />
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.<br />
<br />
Vss wird ganz einfach an GND angeschlossen und Vcc an 5V. Vee kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte muss man ein 10k-Potentiometer zwischen GND und 5V schalten, mit dem Schleifer an Vee: <br />
<br />
[[Bild:LCD_Vee.gif|framed|center| Gewinnung der Kontrastspannung]]<br />
<br />
Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-Bit-''' und den '''4-Bit-'''Modus.<br />
* 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.<br />
* 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).<br />
<br />
Der 4-Bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-Bit-Modus, weshalb hier eine 4-Bit-Ansteuerung verwendet wird.<br />
<br />
Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' benötigt. <br />
<br />
* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Ist RS Low, dann wird das ankommende Byte als Befehl interpretiert. Ist RS high, dann wird das Byte auf dem LCD angezeigt. <br />
* '''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 vorsichtshalber ein paar Mikrosekunden 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.<br />
* 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.<br />
<br />
== Anschluss an den Controller ==<br />
<br />
Jetzt, da wir wissen, welche Anschlüsse das LCD benötigt, können wir das LCD mit dem Mikrocontroller verbinden: <br />
<br />
<center><br />
{| {{Tabelle}}<br />
|- style="background-color:#ffddcc"<br />
!Pinnummer<BR>LCD || Bezeichnung || Anschluss<br />
|-<br />
| align="center" |1 || Vss || GND<br />
|-<br />
| align="center" |2 || Vcc || 5V<br />
|-<br />
| align="center" |3 || Vee || GND oder [[Potentiometer | Poti]] <br />
|-<br />
| align="center" |4 || RS || PD4 am AVR<br />
|-<br />
| align="center" |5 || RW || GND <br />
|-<br />
| align="center" |6 || E || PD5 am AVR<br />
|-<br />
| align="center" |7 || DB0 || nicht angeschlossen <br />
|-<br />
| align="center" |8 || DB1 || nicht angeschlossen<br />
|-<br />
| align="center" |9 || DB2 || nicht angeschlossen<br />
|-<br />
| align="center" |10 || DB3 || nicht angeschlossen<br />
|-<br />
| align="center" |11 || DB4 || PD0 am AVR<br />
|-<br />
| align="center" |12 || DB5 || PD1 am AVR<br />
|-<br />
| align="center" |13 || DB6 || PD2 am AVR<br />
|-<br />
| align="center" |14 || DB7 || PD3 am AVR<br />
|-<br />
| align="center" |15 || A || Vorsicht! Meistens nicht direkt an +5V anschließbar,<BR>nur über einen Vorwiderstand (z.B. 330&Omega;)!<br />
|-<br />
| align="center" |16 || K || GND<br />
|}<br />
</center><br />
<br />
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?<br />
<br />
== Ansteuerung des LCDs im 4-Bit-Modus ==<br />
<br />
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: <br />
<br />
<avrasm><br />
swap r16 ; vertauscht die beiden Nibbles von r16<br />
</avrasm><br />
<br />
Aus 0b00100101 wird so z.B. 0b01010010. <br />
<br />
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: <br />
<br />
<avrasm><br />
andi r16, 0b00001111 ; Nur die vier unteren (mit 1 markierten)<br />
; Bits werden übernommen, alle anderen werden null<br />
</avrasm><br />
<br />
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. <br />
<br />
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: <br />
<br />
<avrasm><br />
sbr r16, 0b00010000 ; Bit 4 setzen, alle anderen Bits bleiben gleich<br />
</avrasm><br />
<br />
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. <br />
<br />
Das Ergebnis können wir jetzt endlich direkt an den Port D übergeben: <br />
<br />
<avrasm><br />
out PORTD, r16<br />
</avrasm><br />
<br />
Natürlich muss vorher der Port D auf Ausgang geschalten werden, indem man 0xFF ins Datenrichtungsregister DDRD schreibt. <br />
<br />
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: <br />
<br />
<avrasm><br />
sbi PORTD, 5 ; Enable high<br />
nop ; 3 Taktzyklen warten ("nop" = nichts tun)<br />
nop<br />
nop<br />
cbi PORTD, 5 ; Enable wieder low<br />
</avrasm><br />
<br />
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.<br />
<br />
== Initialisierung des Displays ==<br />
<br />
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.<br><br />
<br />
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.<br />
<br />
* [http://www.mikrocontroller.net/topic/79609#664268 (A) KS0066U oder Ähnliche --- LCD Treiber]<br />
<br />
=== Initialisierung im 4 Bit Modus ===<br />
<br />
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!<br />
<br />
Die Sequenz, aus Sicht des Kontrollers, sieht so aus:<br />
<br />
* 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<br />
* $3 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 4.1ms warten<br />
* $3 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 100µs warten<br />
* $3 ins Steuerregister schreiben (RS = 0)<br />
* $2 ins Steuerregister schreiben (RS = 0), dadurch wird auf 4 Bit Daten umstellt<br />
* 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<br />
* Mit dem Konfigurier-Befehl $20 das Display konfigurieren (4-Bit, 1 oder 2 Zeilen, 5x7 Format)<br />
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.<br />
<br />
=== Initialisierung im 8 Bit Modus ===<br />
<br />
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.<br />
<br />
* 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<br />
* $30 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 4.1ms warten<br />
* $30 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 100µs warten<br />
* $30 ins Steuerregister schreiben (RS = 0)<br />
* Mit dem Konfigurier-Befehl 0x30 das Display konfigurieren (8-Bit, 1 oder 2 Zeilen, 5x7 Format)<br />
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.<br />
<br />
== Routinen zur LCD-Ansteuerung ==<br />
<br />
Die Routinen zur Kommunikation mit dem LCD sehen also so aus: <br />
<br />
<avrasm><br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
;; LCD-Routinen ;;<br />
;; ============ ;;<br />
;; (c)andreas-s@web.de ;;<br />
;; ;;<br />
;; 4bit-Interface ;;<br />
;; DB4-DB7: PD0-PD3 ;;<br />
;; RS: PD4 ;;<br />
;; E: PD5 ;;<br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
<br />
<br />
<br />
;sendet ein Datenbyte an das LCD<br />
lcd_data:<br />
mov temp2, temp1 ; "Sicherungskopie" für<br />
; die Übertragung des 2.Nibbles<br />
swap temp1 ; Vertauschen<br />
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen<br />
sbr temp1, 1<<4 ; entspricht 0b00010000 (Anm.1)<br />
out PORTD, temp1 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
; 2. Nibble, kein swap da es schon<br />
; an der richtigen stelle ist<br />
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen <br />
sbr temp2, 1<<4 ; entspricht 0b00010000<br />
out PORTD, temp2 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
rcall delay50us ; Delay-Routine aufrufen<br />
ret ; zurück zum Hauptprogramm<br />
<br />
; sendet einen Befehl an das LCD<br />
lcd_command: ; wie lcd_data, nur RS=0<br />
mov temp2, temp1<br />
swap temp1<br />
andi temp1, 0b00001111<br />
out PORTD, temp1<br />
rcall lcd_enable<br />
andi temp2, 0b00001111<br />
out PORTD, temp2<br />
rcall lcd_enable<br />
rcall delay50us<br />
ret<br />
<br />
; erzeugt den Enable-Puls<br />
;<br />
; Bei höherem Takt (>= 8 MHz) kann es notwendig sein, <br />
; vor dem Enable High 1-2 Wartetakte (nop) einzufügen. <br />
; Siehe dazu http://www.mikrocontroller.net/topic/81974#685882<br />
lcd_enable:<br />
sbi PORTD, 5 ; Enable high<br />
nop ; 3 Taktzyklen warten<br />
nop<br />
nop<br />
cbi PORTD, 5 ; Enable wieder low<br />
ret ; Und wieder zurück <br />
<br />
; Pause nach jeder Übertragung<br />
delay50us: ; 50us Pause<br />
ldi temp1, $42<br />
delay50us_:dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
<br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, $21<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
<br />
; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden<br />
lcd_init:<br />
ldi temp3,50<br />
powerupwait:<br />
rcall delay5ms<br />
dec temp3<br />
brne powerupwait<br />
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet<br />
out PORTD, temp1 ; werden zur Initialisierung<br />
rcall lcd_enable ; 1<br />
rcall delay5ms<br />
rcall lcd_enable ; 2<br />
rcall delay5ms<br />
rcall lcd_enable ; und 3!<br />
rcall delay5ms<br />
ldi temp1, 0b00000010 ; 4bit-Modus einstellen<br />
out PORTD, temp1<br />
rcall lcd_enable<br />
rcall delay5ms<br />
ldi temp1, 0b00101000 ; 4Bit / 2 Zeilen / 5x8<br />
rcall lcd_command<br />
ldi temp1, 0b00001100 ; Display ein / Cursor aus / kein Blinken<br />
rcall lcd_command<br />
ldi temp1, 0b00000100 ; inkrement / kein Scrollen<br />
rcall lcd_command<br />
ret<br />
<br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
<br />
; Sendet den Befehl: Cursor Home<br />
lcd_home:<br />
ldi temp1, 0b00000010 ; Cursor Home<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
</avrasm><br />
<br />
Anm.1: Siehe [[Bitmanipulation]]<br />
<br />
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. <br />
<br />
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. <br />
<br />
Wer eine höhere Taktfrequenz als 4 MHz verwendet, der sollte daran denken, die Dauer der Verzögerungsschleifen anzupassen.<br />
<br />
==Anwendung==<br />
<br />
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. <br />
<br />
[http://www.mikrocontroller.net/sourcecode/tutorial/lcd-test.asm Download lcd-test.asm] <br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp1 = r16<br />
.def temp2 = r17<br />
.def temp3 = r18<br />
<br />
<br />
ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse<br />
out SPL, temp1<br />
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse<br />
out SPH, temp1<br />
<br />
ldi temp1, 0xFF ; Port D = Ausgang<br />
out DDRD, temp1<br />
<br />
rcall lcd_init ; Display initialisieren<br />
rcall lcd_clear ; Display löschen<br />
<br />
ldi temp1, 'T' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
ldi temp1, 'e' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
ldi temp1, 's' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
ldi temp1, 't' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
loop:<br />
rjmp loop<br />
<br />
.include "lcd-routines.asm" ; LCD-Routinen werden hier eingefügt<br />
</avrasm><br />
<br />
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.<br />
<br />
Bisher wurden in Register immer irgendwelche Zahlenwerte geladen, aber in diesem Programm kommt plötzlich die Anweisung<br />
<avrasm><br />
ldi temp1, 'T'<br />
</avrasm><br />
vor. Wie ist diese zu verstehen? Passiert hier etwas grundlegend anderes als beim Laden einer Zahl in ein Register?<br />
<br />
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.<br />
<br />
==ASCII==<br />
<br />
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:<br />
<br />
<center><br />
{| {{Tabelle}}<br />
|- style="background-color:#ffddcc"<br />
! ||x0||x1||x2||x3||x4||x5||x6||x7||x8||x9||xA||xB||xC||xD||xE||xF<br />
|-<br />
!style="background-color:#ffddcc"| 0x<br />
|NUL||SOH||STX||ETX||EOT||ENQ||ACK||BEL||BS||HT||LF||VT||FF||CR||SO||SI<br />
|-<br />
!style="background-color:#ffddcc"| 1x<br />
|DLE||DC1||DC2||DC3||DC4||NAK||SYN||ETB||CAN||EM||SUB||ESC||FS||GS||RS||US<br />
|-<br />
!style="background-color:#ffddcc"| 2x<br />
|SP||!||"||#||$||%||&||'||(||)||*||+||,||-||.||/<br />
|-<br />
!style="background-color:#ffddcc"| 3x<br />
|0||1||2||3||4||5||6||7||8||9||:||;||<||=||>||?<br />
|-<br />
!style="background-color:#ffddcc"| 4x<br />
|@||A||B||C||D||E||F||G||H||I||J||K||L||M||N||O<br />
|-<br />
!style="background-color:#ffddcc"| 5x<br />
|P||Q||R||S||T||U||V||W||X||Y||Z||[||\||]||^||_<br />
|-<br />
!style="background-color:#ffddcc"| 6x<br />
|`||a||b||c||d||e||f||g||h||i||j||k||l||m||n||o<br />
|-<br />
!style="background-color:#ffddcc"| 7x<br />
|p||q||r||s||t||u||v||w||x||y||z||{|| &#124; ||}||~||DEL<br />
|}<br />
</center><br />
<br />
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.<br />
<br />
Der Assembler kennt diese Codetabelle und ersetzt die Zeile<br />
<br />
<avrasm><br />
ldi temp1, 'T'<br />
</avrasm><br />
<br />
durch<br />
<br />
<avrasm><br />
ldi temp1, $54<br />
</avrasm><br />
<br />
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.<br />
<br />
<br />
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.<br />
<br />
==Welche Befehle versteht das LCD?==<br />
<br />
Auf dem LCD arbeitet ein Kontroller 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:<br />
<br />
<center><br />
{| {{Tabelle}}<br />
|- style="background-color:#ffddcc"<br />
! Bitwert || Bedeutung<br />
|-<br />
|align="center" | 0<br />
||dieses Bit muss 0 sein<br />
|-<br />
|align="center" | 1<br />
||dieses Bit muss 1 sein<br />
|-<br />
|align="center" | x<br />
||der Zustand dieses Bits ist egal<br />
|-<br />
|align="center" | sonstige Buchstaben<br />
||das Bit muss je nach gewünschter Funktionalität gesetzt werden. Die mögliche Funktionalität des jeweiligen Bits geht aus der Befehlsbeschreibung hervor<br />
|}<br />
</center><br />
<br />
Beispiel: Das Kommando 'ON/OFF Control' soll benutzt werden, um das Display einzuschalten, der Cursor soll eingeschaltet werden und der Cursor soll blinken.<br />
Das Befehlsbyte ist so aufgebaut:<br />
0b00001dcb<br />
Aus der Befehlsbeschreibung entnimmt man:<br />
* Display ein bedeutet, dass an der Bitposition d eine 1 stehen muss.<br><br />
* Cursor ein bedeutet, dass an der Bitposition c ein 1 stehen muss.<br><br />
* Cursor blinken bedeutet, dass an der Bitposition b eine 1 stehen muss.<br><br />
Das dafür zu übertragende Befehlsbyte hat also die Gestalt 0b00001111 oder in hexadezimaler Schreibweise $0F.<br />
<br />
===Clear display: 0b00000001===<br />
<br />
Die Anzeige wird gelöscht und der Ausgabecursor kehrt an die Home Position (links, erste Zeile) zurück.<br />
<br />
Ausführungszeit: 1.64ms<br />
<br />
===Cursor home: 0b0000001x===<br />
<br />
Der Cursor kehrt an die Home Position (links, erste Zeile) zurück. Ein verschobenes Display wird auf die Grundeinstellung zurückgesetzt.<br />
<br />
Ausführungszeit: 40µs bis 1.64ms<br />
<br />
===Entry mode: 0b000001is===<br />
<br />
Legt die Cursor Richtung sowie eine mögliche Verschiebung des Displays fest<br />
* i = 1, Cursorposition bei Ausgabe eines Zeichens erhöhen<br />
* i = 0, Cursorposition bei Ausgabe eines Zeichens vermindern<br />
* s = 1, Display wird gescrollt, wenn der Cursor das Ende/Anfang, je nach Einstellung von i, erreicht hat.<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===On/off control: 0b00001dcb===<br />
<br />
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.<br />
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.<br />
<br />
* d = 0, Display aus<br />
* d = 1, Display ein<br />
* c = 0, Cursor aus<br />
* c = 1, Cursor ein<br />
* b = 0, Cursor blinken aus<br />
* b = 1, Cursor blinken ein<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Cursor/Scrollen: 0b0001srxx===<br />
<br />
Bewegt den Cursor oder scrollt das Display um eine Position entweder nach rechts oder nach links.<br />
<br />
* s = 1, Display scrollen<br />
* s = 0, Cursor bewegen<br />
* r = 1, nach rechts<br />
* r = 0, nach links <br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Konfiguration: 0b001dnfxx===<br />
<br />
Einstellen der Interface Art, Modus, Font<br />
* d = 0, 4-Bit Interface<br />
* d = 1, 8-Bit Interface<br />
* n = 0, 1 zeilig<br />
* n = 1, 2 zeilig<br />
* f = 0, 5x7 Pixel<br />
* f = 1, 5x11 Pixel<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Character RAM Address Set: 0b01aaaaaa===<br />
<br />
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 5 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.<br />
<br />
aaaaaa 6-bit CG RAM Adresse<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Display RAM Address Set: 0b1aaaaaaa===<br />
<br />
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 32 logischen Zeichen besteht, von der, je nach konkretem Displaytyp (16 Zeichen, 20 Zeichen) immer nur ein Teil sichtbar ist.<br />
<br />
aaaaaaa 7-bit DD RAM Adresse. Auf 2-zeiligen Displays (und den meisten 16x1 Displays), kann die Adressangabe wie folgt interpretiert werden:<br />
<br />
1laaaaaa<br />
* l = Zeilennummer (0 oder 1)<br />
* a = 6-Bit Spaltennummer<br />
<br />
--------------------------------<br />
<br />
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0<br />
--- --- --- --- --- --- --- --- --- ---<br />
0 0 1 A A A A A A A <br />
<br />
Setzt die DDRAM Adresse:<br />
<br />
Wenn N = 0 (1 line display)<br />
AAAAAAA = "00h" - "4Fh"<br />
<br />
Wenn N = 1 (2 line display) ((1x16))<br />
AAAAAAA = "00h" - "27h" Zeile 1. (0x80) <br />
AAAAAAA = "40h" - "67h" Zeile 2. (0xC0)<br />
<br />
<br />
Ausführungszeit: 40µs<br />
<br />
==Einschub: Code aufräumen==<br />
<br />
Es wird Zeit, sich einmal etwas kritisch mit den bisher geschriebenen Funktionen auseinander zu setzen.<br />
<br />
<br />
<br />
===Portnamen aus dem Code herausziehen===<br />
<br />
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.<br />
<br />
Eine Möglichkeit, dem vorzubeugen, ist es, diese immer gleichbleibenden Dinge an den Anfang der LCD-Funktionen vorzuziehen:<br />
<br />
<avrasm><br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
;; LCD-Routinen ;;<br />
;; ============ ;;<br />
;; (c)andreas-s@web.de ;;<br />
;; ;;<br />
;; 4bit-Interface ;;<br />
;; DB4-DB7: PD0-PD3 ;;<br />
;; RS: PD4 ;;<br />
;; E: PD5 ;;<br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
<br />
<br />
.equ LCD_PORT = PORTD<br />
.equ LCD_DDR = DDRD<br />
.equ PIN_E = 5<br />
.equ PIN_RS = 4<br />
<br />
;sendet ein Datenbyte an das LCD<br />
lcd_data:<br />
mov temp2, temp1 ; "Sicherungskopie" für<br />
; die Übertragung des 2.Nibbles<br />
swap temp1 ; Vertauschen<br />
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen<br />
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp1 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
; 2. Nibble, kein swap da es schon<br />
; an der richtigen stelle ist<br />
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen <br />
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp2 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
rcall delay50us ; Delay-Routine aufrufen<br />
ret ; zurück zum Hauptprogramm<br />
<br />
<br />
; sendet einen Befehl an das LCD<br />
<br />
lcd_command: ; wie lcd_data, nur RS=0<br />
mov temp2, temp1<br />
swap temp1<br />
andi temp1, 0b00001111<br />
out LCD_PORT, temp1<br />
rcall lcd_enable<br />
andi temp2, 0b00001111<br />
out LCD_PORT, temp2<br />
rcall lcd_enable<br />
rcall delay50us<br />
ret<br />
<br />
; erzeugt den Enable-Puls<br />
lcd_enable:<br />
sbi LCD_PORT, PIN_E ; Enable high<br />
nop ; 3 Taktzyklen warten<br />
nop<br />
nop<br />
cbi LCD_PORT, PIN_E ; Enable wieder low<br />
ret ; Und wieder zurück <br />
<br />
; Pause nach jeder Übertragung<br />
delay50us: ; 50us Pause<br />
ldi temp1, $42<br />
delay50us_:dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
<br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, $21<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
<br />
; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden<br />
lcd_init:<br />
ldi temp1, 0xFF ; alle Pins am Ausgabeport auf Ausgang<br />
out LCD_DDR, temp1<br />
<br />
ldi temp3,6<br />
powerupwait:<br />
rcall delay5ms<br />
dec temp3<br />
brne powerupwait<br />
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet<br />
out LCD_PORT, temp1 ; werden zur Initialisierung<br />
rcall lcd_enable ; 1<br />
rcall delay5ms<br />
rcall lcd_enable ; 2<br />
rcall delay5ms<br />
rcall lcd_enable ; und 3!<br />
rcall delay5ms<br />
ldi temp1, 0b00000010 ; 4bit-Modus einstellen<br />
out LCD_PORT, temp1<br />
rcall lcd_enable<br />
rcall delay5ms<br />
ldi temp1, 0b00101000 ; 4 Bot, 2 Zeilen<br />
rcall lcd_command<br />
ldi temp1, 0b00001100 ; Display on, Cursor off<br />
rcall lcd_command<br />
ldi temp1, 0b00000100 ; endlich fertig<br />
rcall lcd_command<br />
ret<br />
<br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
<br />
; Sendet den Befehl: Cursor Home<br />
lcd_home:<br />
ldi temp1, 0b00000010 ; Cursor Home<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
</avrasm><br />
<br />
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<br />
<avrasm><br />
.equ LCD_PORT = PORTD<br />
.equ LCD_DDR = DDRD<br />
</avrasm><br />
durch<br />
<avrasm><br />
.equ LCD_PORT = PORTB<br />
.equ LCD_DDR = DDRB<br />
</avrasm><br />
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.<br />
<br />
===Registerbenutzung===<br />
<br />
Bei diesen Funktionen mussten einige Register des Prozessors benutzt werden, um darin Zwischenergebnisse zu speichern bzw. zu bearbeiten.<br />
<br />
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.<br />
<br />
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.<br />
<br />
Nehmen wir die Funktion<br />
<avrasm><br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
</avrasm><br />
<br />
Diese Funktion verändert das Register temp1. Um das Register abzusichern, schreiben wir die Funktion um:<br />
<br />
<avrasm><br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
push temp1 ; temp1 auf dem Stack sichern<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
pop temp1 ; temp1 vom Stack wiederherstellen<br />
ret<br />
</avrasm><br />
<br />
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.<br />
<br />
===Lass den Assembler rechnen===<br />
Betrachtet man den Code genauer, so fallen einige konstante Zahlenwerte auf (Das vorangestellte $ kennzeichnet die Zahl als Hexadezimalzahl):<br />
<br />
<avrasm><br />
delay50us: ; 50us Pause<br />
ldi temp1, $42<br />
delay50us_:<br />
dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
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.<br />
<br />
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 <i>XTAL</i>:<br />
<br />
<avrasm><br />
.equ XTAL = 4000000<br />
<br />
...<br />
<br />
delay50us: ; 50us Pause<br />
ldi temp1, ( XTAL * 50 / 3 ) / 1000000<br />
delay50us_:<br />
dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
An einer anderen Codestelle gibt es weitere derartige magische Zahlen:<br />
<br />
<avrasm><br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, $21<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
Was geht hier vor?<br />
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.<br />
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:<br />
<br />
<avrasm><br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, ( XTAL * 5 / 607 ) / 1000<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
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.<br />
<br />
<br />
<br />
== Ausgabe eines konstanten Textes ==<br />
<br />
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 holt und ausgibt. Dabei erhebt sich aber eine Fragestellung: Woher weiß die Funktion eigentlich, wie lange 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:<br />
* Der Text enthält ein spezielles Zeichen, welches das Ende des Textes markiert<br />
* Wir speichern nicht nur den Text selbst, sondern auch die Länge des Textes<br />
Mit einer der beiden Methoden ist es der Textausgabefunktion dann ein Leichtes, den Text vollständig auszugeben.<br />
<br />
Wir werden uns im Weiteren dafür entscheiden, ein spezielles Zeichen, eine 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.<br />
<br />
Den Text selbst speichern wir im Flash-Speicher, also dort, wo auch das Programm gespeichert ist:<br />
<br />
<avrasm><br />
; Einen konstanten Text aus dem Flash Speicher<br />
; ausgeben. Der Text wird mit einer 0 beendet<br />
lcd_flash_string:<br />
push temp1<br />
push ZH<br />
push ZL<br />
<br />
lcd_flash_string_1:<br />
lpm temp1, Z+<br />
cpi temp1, 0<br />
breq lcd_flash_string_2<br />
rcall lcd_data<br />
rjmp lcd_flash_string_1<br />
<br />
lcd_flash_string_2:<br />
pop ZL<br />
pop ZH<br />
pop temp1<br />
ret<br />
</avrasm><br />
<br />
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<br />
<avrasm><br />
lpm temp1, Z+<br />
</avrasm><br />
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<br />
<avrasm><br />
cpi temp1, 0<br />
breq lcd_flash_string_2<br />
</avrasm><br />
dass das gelesene Zeichen mit 0 verglichen wird und falls das gelesene<br />
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.<br />
<br />
Das verwendende Programm sieht dann so aus:<br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp1 = r16<br />
.def temp2 = r17<br />
.def temp3 = r18<br />
<br />
<br />
ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse<br />
out SPL, temp1<br />
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse<br />
out SPH, temp1<br />
<br />
rcall lcd_init ; Display initialisieren<br />
rcall lcd_clear ; Display löschen<br />
<br />
ldi ZL, LOW(text*2) ; Adresse des Strings in den<br />
ldi ZH, HIGH(text*2) ; Z-Pointer laden<br />
<br />
rcall lcd_flash_string ; Unterprogramm gibt String aus der<br />
; durch den Z-Pointer adressiert wird<br />
loop:<br />
rjmp loop<br />
<br />
text:<br />
.db "Test",0 ; Stringkonstante, durch eine 0<br />
; abgeschlossen <br />
<br />
.include "lcd-routines.asm" ; LCD Funktionen<br />
</avrasm><br />
<br />
Genaueres über die Verwendung unterschiedlicher Speicher findet sich im Kapitel [[AVR-Tutorial:_Speicher|Speicher]]<br />
<br />
==Zahlen ausgeben==<br />
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.<br />
<br />
===Dezimal ausgeben===<br />
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.<br />
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.<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 8 Bit Zahl ohne Vorzeichen ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp1<br />
; veränderte Register: keine<br />
;<br />
lcd_number:<br />
push temp1 ; die Funktion verändert temp1 und temp2,<br />
push temp2 ; also sichern wir den Inhalt, um ihn am Ende<br />
; wieder herstellen zu können<br />
<br />
mov temp2, temp1 ; das Register temp1 frei machen<br />
; abzählen wieviele Hunderter<br />
; in der Zahl enthalten sind<br />
;** Hunderter ** <br />
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen<br />
lcd_number_1:<br />
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten<br />
; Durchlauf eine '0' in temp1)<br />
subi temp2, 100 ; 100 abziehen<br />
brcc lcd_number_1 ; ist dadurch kein Unterlauf entstanden?<br />
; nein, dann zurück zu lcd_number_1<br />
subi temp2, -100 ; 100 wieder dazuzählen, da die<br />
; vorherhgehende Schleife 100 zuviel<br />
; abgezogen hat<br />
rcall lcd_data ; die Hunderterstelle ausgeben<br />
<br />
;** Zehner **<br />
ldi temp1, '0'-1 ; temp1 mit ASCII '0'-1 vorladen<br />
lcd_number_2:<br />
inc temp1 ; ASCII erhöhen (somit ist nach dem ersten<br />
; Durchlauf eine '0' in temp1)<br />
subi temp2, 10 ; 10 abziehen<br />
brcc lcd_number_2 ; ist dadurch kein Unterlauf enstanden?<br />
; nein, dann zurück zu lcd_number_2<br />
subi temp2, -10 ; 10 wieder dazuzählen, da die<br />
; vorherhgehende Schleife 10 zuviel<br />
; abgezogen hat<br />
rcall lcd_data ; die Zehnerstelle ausgeben<br />
<br />
;** Einer ** <br />
ldi temp1, '0' ; die Zahl in temp2 ist jetzt im Bereich<br />
add temp1, temp2 ; 0 bis 9. Einfach nur den ASCII Code für<br />
rcall lcd_data ; '0' dazu addieren und wir erhalten dierekt<br />
; den ASCII Code für die Ziffer<br />
<br />
<br />
pop temp2 ; den gesicherten Inhalt von temp2 und temp1<br />
pop temp1 ; wieder herstellen<br />
ret ; und zurück<br />
</avrasm><br />
<br />
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:<br />
<br />
<avrasm><br />
;sendet ein Datenbyte an das LCD<br />
lcd_data:<br />
push temp2<br />
mov temp2, temp1 ; "Sicherungskopie" für<br />
; die Übertragung des 2.Nibbles<br />
swap temp1 ; Vertauschen<br />
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen<br />
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp1 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
; 2. Nibble, kein swap da es schon<br />
; an der richtigen stelle ist<br />
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen <br />
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp2 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
rcall delay50us ; Delay-Routine aufrufen<br />
pop temp2<br />
ret ; zurück zum Hauptprogramm<br />
<br />
; sendet einen Befehl an das LCD<br />
lcd_command: ; wie lcd_data, nur ohne RS zu setzen<br />
push temp2<br />
mov temp2, temp1<br />
swap temp1<br />
andi temp1, 0b00001111<br />
out LCD_PORT, temp1<br />
rcall lcd_enable<br />
andi temp2, 0b00001111<br />
out LCD_PORT, temp2<br />
rcall lcd_enable<br />
rcall delay50us<br />
pop temp2<br />
ret<br />
</avrasm><br />
<br />
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.<br />
<br />
===Unterdrückung von führenden Nullen===<br />
<br />
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.<br />
<br />
<avrasm><br />
...<br />
; die Hunderterstelle ausgeben, wenn<br />
; sie nicht '0' ist<br />
clt ; T-Flag löschen<br />
cpi temp1, '0'<br />
breq lcd_number_1a<br />
rcall lcd_data ; die Hunderterstelle ausgeben<br />
set ; T-Flag im SREG setzen da 100er Stelle eine<br />
; 1..9 war<br />
<br />
lcd_number_1a:<br />
...<br />
<br />
...<br />
brts lcd_number_2a ; Test auf '0' überspringen, da 100er eine<br />
; 1..9 war (unbedingt anzeigen<br />
; auch wenn der Zehner eine '0' ist)<br />
cpi temp1, '0' ; ansonsten Test auf '0'<br />
breq lcd_number_2b<br />
lcd_number_2a: <br />
rcall lcd_data<br />
lcd_number_2b:<br />
...<br />
<br />
</avrasm><br />
<br />
<br />
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)<br />
<br />
<pre><br />
52783 / 10 -> 5278<br />
52783 - 5278 * 10 -> 3<br />
<br />
5278 / 10 -> 527<br />
5278 - 527 * 10 -> 8<br />
<br />
527 / 10 -> 52<br />
527 - 52 * 10 -> 7<br />
<br />
52 / 10 -> 5<br />
52 - 5 * 10 -> 2<br />
<br />
5 / 10 -> 0<br />
5 - 0 * 10 -> 5<br />
</pre><br />
<br />
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).<br />
<br />
===Hexadezimal ausgeben===<br />
<br />
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.<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 8 Bit Zahl ohne Vorzeichen hexadezimal ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp1<br />
; veränderte Register: keine<br />
;<br />
lcd_number_hex:<br />
swap temp1<br />
rcall lcd_number_hex_digit<br />
swap temp1<br />
<br />
lcd_number_hex_digit:<br />
push temp1<br />
<br />
andi temp1, $0F<br />
cpi temp1, 10<br />
brlt lcd_number_hex_digit_1<br />
subi temp1, -( 'A' - '9' - 1 ) ; es wird subi mit negativer Konstante verwendet, weil es kein addi gibt<br />
lcd_number_hex_digit_1:<br />
subi temp1, -'0' ; ditto<br />
rcall lcd_data<br />
<br />
pop temp1<br />
ret<br />
</avrasm><br />
<br />
===Binär ausgeben===<br />
Um die Sache komplett zu machen; Hier eine Routine mit der man eine 8 Bit-Zahl binär auf das LC-Display ausgeben kann:<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 8 Bit Zahl ohne Vorzeichen binär ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp1<br />
; veränderte Register: keine<br />
<br />
; eine Zahl aus dem Register temp1 binär ausgeben<br />
lcd_number_bit:<br />
push temp1 ; temp1 gesichert<br />
push temp2<br />
push temp3<br />
<br />
mov temp2, temp1;<br />
<br />
ldi temp3, 8; ; 8 Bits werden ausgelesen<br />
lcd_number_loop: <br />
dec temp3;<br />
rol temp2; ; Datenbits ins Carry geschoben ...<br />
brcc lcd_number_bit_carryset_0; <br />
brcs lcd_number_bit_carryset_1;<br />
rjmp lcd_number_loop;<br />
<br />
lcd_number_bit_carryset_0: <br />
ldi temp1, '0' ; Bit low ausgeben<br />
rcall lcd_data<br />
tst temp3;<br />
breq lcd_number_ende;<br />
rjmp lcd_number_loop;<br />
<br />
lcd_number_bit_carryset_1:<br />
ldi temp1, '1' ; Bit high ausgeben<br />
rcall lcd_data<br />
tst temp3;<br />
breq lcd_number_ende;<br />
rjmp lcd_number_loop;<br />
<br />
lcd_number_ende:<br />
pop temp3<br />
pop temp2<br />
pop temp1<br />
ret<br />
</avrasm><br />
<br />
===Eine 16-Bit Zahl aus einem Registerpärchen ausgeben===<br />
<br />
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.<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 16 Bit Zahl ohne Vorzeichen ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp2 (low Byte) / temp3 (high Byte)<br />
; veränderte Register: keine<br />
;<br />
lcd_number16:<br />
push temp1<br />
push temp2<br />
push temp3<br />
<br />
; ** Zehntausender **<br />
ldi temp1, '0'-1<br />
lcd_number1:<br />
inc temp1<br />
subi temp2, low(10000)<br />
sbci temp3, high(10000)<br />
brcc lcd_number1<br />
subi temp2, low(-10000)<br />
sbci temp3, high(-10000)<br />
rcall lcd_data<br />
<br />
; ** Tausender **<br />
ldi temp1, '0'-1<br />
lcd_number2:<br />
inc temp1<br />
subi temp2, low(1000)<br />
sbci temp3, high(1000)<br />
brcc lcd_number2<br />
subi temp2, low(-1000)<br />
sbci temp3, high(-1000)<br />
rcall lcd_data<br />
<br />
; ** Hunderter **<br />
ldi temp1, '0'-1<br />
lcd_number3:<br />
inc temp1<br />
subi temp2, low(100)<br />
sbci temp3, high(100)<br />
brcc lcd_number3<br />
subi temp2, -100 ; + 100 High-Byte nicht mehr erforderlich<br />
rcall lcd_data<br />
<br />
; ** Zehner **<br />
ldi temp1, '0'-1<br />
lcd_number4:<br />
inc temp1<br />
subi temp2, 10<br />
brcc lcd_number4<br />
subi temp2, -10<br />
rcall lcd_data<br />
<br />
; ** Einer **<br />
ldi temp1, '0'<br />
add temp1, temp2<br />
rcall lcd_data<br />
<br />
; ** Stack aufräumen **<br />
pop temp3<br />
pop temp2<br />
pop temp1<br />
<br />
ret<br />
</avrasm><br />
<br />
===Eine BCD Zahl ausgeben===<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Übergabe: BCD Zahl in temp1<br />
; veränderte Register: keine<br />
;<br />
lcd_bcd:<br />
push temp2<br />
<br />
mov temp2, temp1 ; temp1 sichern<br />
swap temp1 ; oberes mit unterem Nibble tauschen<br />
andi temp1, 0b00001111 ; und "oberes" ausmaskieren<br />
subi temp1, -0x30 ; in ASCII umrechnen<br />
rcall lcd_data ; und ausgeben<br />
mov temp1, temp2 ; ... danach unteres<br />
andi temp1, 0b00001111<br />
subi temp1, -0x30<br />
rcall lcd_data<br />
mov temp1, temp2 ; temp1 rekonstruieren<br />
<br />
pop temp2<br />
ret <br />
</avrasm><br />
<br />
== Benutzerdefinierten Zeichen ==<br />
[[Bild:LCD_Character_Grid.png | framed | right| Zeichenraster für 1 Zeichen]]<br />
<br />
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 benutz werden um sich selbst Sonderzeichen zu erzeugen, die für die jeweilige Anwendung massgeschneidert sind.<br />
<br />
Das LCD stellt für jedes Zeichen eine 5*8 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.<br />
<br />
[[Bild:BellCharacter.png | framed | right| Zeichenraster für ein Glockensymbol]]<br />
<br />
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.<br />
<br />
Eine Spalte in diesem Zeichen repräsentiert ein an das LCD zu übergebende Byte. Gesetzte Pixel stellen ein 1 Bit dar, nicht gesetzte Pixel sind ein 0-Bit. Das niedrigstwertige Bit einer Spalte befindet sich unten. Auf diese Art wird jede Spalte in eine Binärzahl übersetzt, und 5 Bytes repräsentieren ein komplettes Zeichen. Am Beispiel des Glockensymboles: Die 5 Bytes, welches das Symbol repräsentiern, lauten: 0x04 0x3C 0x46 0x3C 0x04<br />
<br />
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 5 Bytes ganz normal als Daten ausgegeben, die das LCD damit in seine Zeichensatztabelle schreibt.<br />
<br />
Durch die Wahl der Speicheradresse definiert man, welches Zeichen (0 bis 7) man eigentlich durch eine eigene Definition ersetzen will.<br />
{| {{Tabelle}}<br />
|- style="background-color:#ffddcc"<br />
! ASCII Code || Zeichensatzadresse<br />
|-<br />
| 0 || 0x00<br />
|-<br />
| 1 || 0x05<br />
|-<br />
| 2 || 0x0A<br />
|-<br />
| 3 || 0x0F<br />
|-<br />
| 4 || 0x14<br />
|-<br />
| 5 || 0x19<br />
|-<br />
| 6 || 0x1E<br />
|-<br />
| 7 || 0x23<br />
|}<br />
<br />
Nach erfolgter Definition des Zeichens, muss die Schreibposition wieder explizit in den DDRAM-Bereich gesetzt werden.<br />
Danach kann ein entsprechendes Zeichen mit dem definierten ASCII Code ausgegeben werden, wobei das LCD die von uns definierte Pixelform zur Anzeige benutzt.<br />
<br />
Zuerst müssen natürlich erstmal die Zeichen definiert werden.<br />
Dieses geschieht einmalig durch den Aufruf der Routine "lcd_load_user_chars"<br />
unmittelbar nach der Initialisierung des LCD-Displays.<br />
<br />
<avrasm><br />
.<br />
.<br />
rcall lcd_init ; Display initialisieren<br />
rcall lcd_load_user_chars ; User Zeichen in das Display laden<br />
rcall lcd_clear ; Display löschen<br />
.<br />
.<br />
</avrasm><br />
<br />
Durch diesen Aufruf werden die im Flash definierten Zeichen in den<br />
GC-Ram übertragen. Diese Zeichen werden ab Adresse 0 im GC-Ram<br />
gespeichert und sind danach wie jedes andere Zeichen nutzbar.<br />
<br />
<avrasm><br />
.<br />
.<br />
ldi temp1, 0 ; Ausgabe des User-Char "A"<br />
rcall lcd_data<br />
ldi temp1, 6 ; Ausgabe des User-Char "G"<br />
rcall lcd_data<br />
ldi temp1, 5 ; Ausgabe des User-Char "E"<br />
rcall lcd_data<br />
ldi temp1, 4 ; Ausgabe des User-Char "M"<br />
rcall lcd_data<br />
ldi temp1, 3 ; Ausgabe des User-Char "-"<br />
rcall lcd_data<br />
ldi temp1, 2 ; Ausgabe des User-Char "R"<br />
rcall lcd_data<br />
ldi temp1, 1 ; Ausgabe des User-Char "V"<br />
rcall lcd_data<br />
ldi temp1, 0 ; Ausgabe des User-Char "A"<br />
rcall lcd_data<br />
.<br />
.<br />
</avrasm><br />
<br />
Jetzt sollte der Schriftzug "AVR-MEGA"<br />
verkehrt herum (180 Grad gedreht) erscheinen.<br />
<br />
Es fehlt natürlich noch die Laderoutine:<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Lädt User Zeichen in den GC-Ram des LCD bis Tabellenende (0xFF)<br />
; gelesen wird. (max. 8 Zeichen können geladen werden)<br />
;<br />
; Übergabe: - <br />
; veränderte Register: temp1, temp2, temp3, zh, zl<br />
; Bemerkung: ist einmalig nach lcd_init aufzurufen<br />
; <br />
<br />
lcd_load_user_chars:<br />
ldi zl, LOW (ldc_user_char * 2) ; Adresse der Zeichentabelle<br />
ldi zh, HIGH(ldc_user_char * 2) ; in den Z-Pointer laden<br />
clr temp3 ; aktuelles Zeichen = 0 <br />
<br />
lcd_load_user_chars_2:<br />
clr temp2 ; Linienzähler = 0<br />
<br />
lcd_load_user_chars_1:<br />
ldi temp1, 0b01000000 ; Kommando: 0b01aaalll<br />
add temp1, temp3 ; + akt. Zeichen (aaa)<br />
add temp1, temp2 ; + akt. Linie (lll)<br />
rcall lcd_command ; Kommando schreiben<br />
<br />
lpm temp1, Z+ ; Zeichenline laden <br />
rcall lcd_data ; ... und ausgeben<br />
<br />
ldi temp1, 0b01001000 ; Kommando: 0b01aa1lll <br />
add temp1, temp3 ; + akt. Zeichen (aaa) <br />
add temp1, temp2 ; + akt. Linie (lll)<br />
rcall lcd_command<br />
<br />
lpm temp1, Z+ ; Zeichenline laden<br />
rcall lcd_data ; ... und ausgeben <br />
<br />
inc temp2 ; Linienzähler + 1<br />
cpi temp2, 8 ; 8 Linien fertig?<br />
brne lcd_load_user_chars_1 ; nein, dann nächste Linie <br />
<br />
subi temp3, -0x10 ; zwei Zeichen weiter (addi 0x10)<br />
lpm temp1, Z ; nächste Linie laden<br />
cpi temp1, 0xFF ; Tabellenende erreicht? <br />
brne lcd_load_user_chars_2 ; nein, dann die nächsten<br />
; zwei Zeichen<br />
ret<br />
</avrasm><br />
<br />
... und die Zeichendefinition:<br />
<br />
<avrasm><br />
ldc_user_char:<br />
; Zeichen <br />
; 0 1<br />
.db 0b10001, 0b00100 ; @ @ , @<br />
.db 0b10001, 0b01010 ; @ @ , @ @<br />
.db 0b11111, 0b10001 ; @@@@@ , @ @<br />
.db 0b10001, 0b10001 ; @ @ , @ @<br />
.db 0b10001, 0b10001 ; @ @ , @ @<br />
.db 0b10001, 0b10001 ; @ @ , @ @<br />
.db 0b01110, 0b10001 ; @@@ , @ @<br />
.db 0b00000, 0b00000 ; , <br />
<br />
; Zeichen<br />
; 2 3<br />
.db 0b10001, 0b00000 ; @ @ , <br />
.db 0b01001, 0b00000 ; @ @ , <br />
.db 0b00101, 0b00000 ; @ @ , <br />
.db 0b11111, 0b11111 ; @@@@@ , @@@@@ <br />
.db 0b10001, 0b00000 ; @ @ , <br />
.db 0b10001, 0b00000 ; @ @ , <br />
.db 0b01111, 0b00000 ; @@@@ , <br />
.db 0b00000, 0b00000 ; , <br />
<br />
; Zeichen<br />
; 4 5<br />
.db 0b10001, 0b11111 ; @ @ , @@@@@ <br />
.db 0b10001, 0b00001 ; @ @ , @<br />
.db 0b10001, 0b00001 ; @ @ , @<br />
.db 0b10001, 0b01111 ; @ @ , @@@@ <br />
.db 0b10101, 0b00001 ; @ @ @ , @<br />
.db 0b11011, 0b00001 ; @@ @@ , @<br />
.db 0b10001, 0b11111 ; @ @ , @@@@@<br />
.db 0b00000, 0b00000 ; , <br />
<br />
; Zeichen<br />
; 6 7<br />
.db 0b11110, 0b11111 ; @@@@ , @@@@@ <br />
.db 0b10001, 0b01010 ; @ @ , @ @ <br />
.db 0b10001, 0b00100 ; @ @ , @<br />
.db 0b11101, 0b01110 ; @@@ @ , @@@<br />
.db 0b00001, 0b00100 ; @ , @<br />
.db 0b10001, 0b01010 ; @ @ , @ @<br />
.db 0b01110, 0b11111 ; @@@ , @@@@@<br />
.db 0b00000, 0b00000 ; , <br />
<br />
; End of Tab<br />
.db 0xFF, 0xFF<br />
</avrasm><br />
<br />
==Der überarbeitete, komplette Code==<br />
<br />
Hier also die komplett überarbeitete Version der LCD Funktionen.<br />
<br />
Die für die Benutzung relevanten Funktionen<br />
* '''lcd_init'''<br />
* '''lcd_clear'''<br />
* '''lcd_home'''<br />
* '''lcd_data'''<br />
* '''lcd_command'''<br />
* '''lcd_flash_string'''<br />
* '''lcd_number'''<br />
* '''lcd_number_hex'''<br />
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.<br />
<br />
[[Media:lcd-routines.asm|Download lcd-routines.asm]]<br />
<br />
{{Navigation_zurückhochvor|<br />
zurücktext=Stack|<br />
zurücklink=AVR-Tutorial: Stack|<br />
hochtext=Inhaltsverzeichnis|<br />
hochlink=AVR-Tutorial|<br />
vortext=Interrupts|<br />
vorlink=AVR-Tutorial: Interrupts}}<br />
<br />
[[Category:AVR-Tutorial]]<br />
[[Category:LCD]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=36241Benutzer:Rotoe2009-05-21T17:30:38Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (10.10.08)<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Wanderkiste&diff=34097Wanderkiste2009-01-31T16:22:17Z<p>Rotoe: /* Kiste Venus */</p>
<hr />
<div>== Worum geht es? ==<br />
<br />
Die '''Große Wanderkiste elektronischer Bauteile''' erklärt Andreas Jakob in [http://www.mikrocontroller.net/topic/118816#1070509] so:<br />
<br />
Hallo Leute,<br />
<br />
durch diesen Beitrag :<br />
<br />
[http://www.mikrocontroller.net/topic/118752#1070168|Beitrag "Bauteile zu verschenken"]<br />
<br />
bin ich auf die Idee gekommen, auch in Deutschland so ein Wanderkistenprojekt zu starten.<br />
<br />
http://hackaday.com/2008/06/27/the-great-internet-migratory-box-of-electronics-junk/<br />
<br />
Das Konzept :<br />
<br />
Jeder kann sich in einer Liste eintragen, und erhält dann irgendwann die '''Wanderkiste''' vom aktuellen Besitzer zugesandt. Du nimmst dir aus der Kiste raus, was du möchtest, und legst im Gegenzug einige Dinge hinein, die du nicht mehr benötigst, die aber für andere nützlich sein könnten. Dann suchst du dir aus der aktuellen Liste jemand aus, und sendest die Kiste weiter an ihn.<br />
<br />
So bekommt man für das Porto für ein Paket (z.B. bei Hermes 5.90€ für bis zu 25 KG) ein Überraschungspaket, und wird seine nicht mehr benötigten Bauteile, Platinen, Motoren, Lautsprecher, Geräte, Ausschlachtplatinen etc. etc. wirklich sinnvoll los. <br />
<br />
Im Paket gibt es ein Büchlein, das seinen Lebensweg dokumentiert. Jeder macht ein Foto, wie er die Kiste erhalten hat, und schreibt einen Eintrag in ein Weblog, wann er Sie an wen weitergeschickt hat.<br />
<br />
== Die RuleZ ==<br />
<br />
Sind im Konzept ganz gut erklärt. Wenn es Ergänzungen gibt, kommen die hierhin. <br />
<br />
Auf den Punkt gebracht :<br />
<br />
Für alles was ich mir aus der Kiste rausnehme, lege ich etwas <br />
gleichwertig nützliches wieder hinein.<br />
+<br />
<br />
Die aktuelle Entwicklung und Gedanken zur Wanderkiste kann man im Forum [http://www.mikrocontroller.net/topic/118816] verfolgen und aktiv diskutieren. <br />
<br />
Knackig kurze Vorschläge, Anmerkungen usw. zu den RuleZ können auch auf [[Diskussion:Wanderkiste]] gemacht werden.<br />
<br />
== Ich will mitmachen! ==<br />
<br />
''Ich finde die Idee klasse und hoffentlich trägt mich einer in die Empfängerliste ein. Meine Kontaktdaten sind:''<br />
<br />
* '''Username oder Email (ggf. Link zu eigenen Elektronikprojekten)'''<br />
* hier Anhängen...<br />
* Username:<br />
[http://www.mikrocontroller.net/user/show/agentbsik Agentbsik],<br />
[http://www.mikrocontroller.net/user/show/cowz cowz], [http://www.mikrocontroller.net/user/show/djacme djacme], [http://www.mikrocontroller.net/user/show/stefan stefan], [http://www.mikrocontroller.net/user/show/biertrinker biertrinker], [http://www.mikrocontroller.net/user/show/theborg0815 Theborg0815]([http://www.grautier.com/ Grautier]), [http://www.mikrocontroller.net/user/show/Hotty Hotty] <br />
([http://www.avrprojekte.de/ Hottys Projekte]),<br />
[http://www.mikrocontroller.net/user/show/nitram nitram],<br />
[http://www.mikrocontroller.net/user/show/bastelator bastelator] ([http://www.bastelator.de/ Bastelators Basteleien]),<br />
[http://www.mikrocontroller.net/user/show/dr-robotnik dr-robotnik],<br />
[http://www.mikrocontroller.net/user/show/rotoe rotoe],<br />
[http://www.mikrocontroller.net/user/show/roquema roquema]<br />
([http://www.ematronik.de.vu/ Ematronik]),<br />
[http://www.mikrocontroller.net/user/show/matthias00 matthias00],<br />
[http://www.mikrocontroller.net/user/show/Lafkaschar Lafkaschar],<br />
[http://www.mikrocontroller.net/user/show/Easter Easter],<br />
[http://www.mikrocontroller.net/user/show/toybaer toybaer],<br />
[http://www.mikrocontroller.net/user/show/toybaer Esko],<br />
[http://www.mikrocontroller.net/user/show/maesto Maesto],<br />
[http://www.mikrocontroller.net/user/show/andrer AndreR],<br />
[http://www.mikrocontroller.net/user/show/Cyno Cyno],<br />
[http://www.mikrocontroller.net/user/show/Warteschleife Warteschleife],<br />
[http://www.mikrocontroller.net/user/show/fabs fabs],<br />
[http://www.mikrocontroller.net/user/show/derelektroniker derelektroniker],[http://www.mikrocontroller.net/user/show/Pyro-Mike Pyro-Mike],<br />
[http://www.mikrocontroller.net/user/show/juliano julian],<br />
[http://www.mikrocontroller.net/user/show/Benedikt Benedikt],<br />
[http://www.mikrocontroller.net/user/show/johanness johanness],<br />
[http://www.mikrocontroller.net/user/show/netdieter netdieter],<br />
[http://www.mikrocontroller.net/user/show/form form],<br />
[http://www.mikrocontroller.net/user/show/crazor crazor],<br />
[http://www.mikrocontroller.net/user/show/iller iller],<br />
[http://www.mikrocontroller.net/user/show/tien Tien],<br />
[http://www.mikrocontroller.net/user/show/hansilein hansilein], <br />
[http://www.mikrocontroller.net/user/show/bastelwastel015 bastelwastel015 (b-heeger_AT_t-online.de)],<br />
[http://www.mikrocontroller.net/user/show/fr4 fr4],<br />
[http://www.mikrocontroller.net/user/show/Suelzle-frank Suelzle-frank]<br />
<br />
== Karte ==<br />
<br />
<googlemap version="0.9" lat="53.354135" lon="10.634766" type="map" zoom="5"><br />
6#B2758BC5<br />
49.77812, 9.983752<br />
52.23558, 8.169402, Kiste Merkur<br />
</googlemap><br />
== Fotos, Berichte, Links, ... zur Wanderkiste ==<br />
<br />
=== Kiste Merkur ===<br />
<br />
Wer diese Kiste haben möchte sollte sich bewusst sein, dass diese<br />
sehr schwer ist (10-15 KG) !<br />
<br />
12.12.2008 - Ist fertig gepackt und wird am 13.12 an Dr. Robotnik<br />
gesandt. Er wird sie mit einer seiner Kisten durchmischen,<br />
um einen besseren Mix zu erhalten.<br />
<br />
13.12.2008 - Kiste wurde versandt, Trackingnummer wurde dem Empfänger mitgeteilt.<br />
<br />
20.12.2008 - Kiste endlich in Gerbrunn angekommen. Ich hab schon einige feine Sachen gefunden mit denen ich was anfangen kann. Werde berichten. dr-robotnik<br />
<br />
21.12.2008 - Ich habe jetzt einige Sachen herausgenommen und andere dafür hineingetan. Hier eine Übersicht:<br />
<br />
'''Herausgenommen habe ich'''<br />
<br />
[[Bild:vorher.jpg|thumb|180px|right|Was dr-robotnik aus Kiste Merkur entnommen hat]]<br />
<br />
- ein altes EGA Display (vermutlich aus einer Kasse ?)<br />
<br />
- einen kleinen Ringkerntrafo 2x12V (darüber freue ich mich am meißten,<br />
werde daraus ein kleines Doppelnetzteil bauen freu)<br />
<br />
- eine Biegehilfe für axial bedrahtete Bauteile<br />
<br />
- einen kleinen Alu-Kühlkörper (wird auch fürs Netzteil verwendet)<br />
<br />
- zwei ältere ISA Grafikkarten (daraus will ich den DAC rausholen, wird<br />
verwendet für einen einfachen Testbildgenerator, an dem ich zur Zeit<br />
bastle)<br />
<br />
- eine kleine Prototypen-Platine mit MAX232 Beschaltung (einfach toll!)<br />
<br />
- einen alten Gameboy (mal sehen, was daraus wird, vieleicht ein kleiner<br />
Logic Analyzer ?)<br />
<br />
- Einen BlueTooth Adapter für Drucker mit Centronics-Schnittstelle<br />
(Hoffentlich funktioniert er, mein neues Notebook hat keine parallele<br />
Schnittstelle mehr, so kann ich wieder meinen LaserJet in Betrieb<br />
nehmen)<br />
<br />
- Einige LSTTL Bausteine die ich gut gebrauchen kann<br />
<br />
- 10 Stk. kleine Taster mit Kappen<br />
<br />
- Einige Transistoren, ältere Typen<br />
<br />
- 5 Stk. Zenerdioden<br />
<br />
- 2 5Watt Widerstände<br />
<br />
- Einige Kondensatoren<br />
<br />
- Außerdem habe ich ein großes Stück Steckschaum gegen mehrere kleine<br />
getauscht.<br />
<br />
'''Hineingelegt habe ich'''<br />
<br />
<br />
[[Bild:nachher.jpg|thumb|180px|right|Was dr-robotnik in Kiste Merkur hineingelegt hat]]<br />
<br />
- 2 Große Platinen aus einer Industriesteuerung (definitiv defekt, aber<br />
mit vielen netten Bauteilen zum ausschlachten u.A. viele solid state<br />
relais)<br />
<br />
- 2 große Lüfter aus einem Beamer<br />
<br />
- Eine schöne unbenutzte SMD-Prototypenplatine mit Lötstopplack<br />
<br />
- Ein TFT-Display aus einem Notebook<br />
<br />
- Ein kleiner Alu-Kühlkörper<br />
<br />
- Ein Antrieb aus einem Flachbettscanner mit Schrittmotor<br />
<br />
- Einige verschiedene Schrittmotoren<br />
<br />
- Noch ein kleiner Lüfter<br />
<br />
- Mehrere Si-Dioden und jede Menge 9,1V Zener<br />
<br />
- Einige verschiedene Transistoren<br />
<br />
- Eine kleine zweistellige Siebensegmentanzeige, rot<br />
<br />
- Drei Hub- äh.. Zugmagneten (wie heißen die Dinger richtig?)<br />
<br />
- Zwei 16Bit ADCs von Burr Brown und ein Sample/Hold-Baustein von<br />
ANALOGIC<br />
<br />
- Ein kleines Gehäuse mit eingefräster Durchführung für Flachbandkabel<br />
(vieleicht brauchbar für einen kleinen PC-Logic Analyzer?)<br />
<br />
- Einige Abblock-Kerkos<br />
<br />
- Eine Drehpotentiometer-Skala zum aufkleben auf die Frontplatte<br />
<br />
- Einige Steckverbinder und BNC-Buchsen<br />
<br />
- Eine Hand voll verschiedene Quarze<br />
<br />
- Zwei Hartmetallbohrer (ich glaube 0,3mm hab aber nicht nachgemessen)<br />
<br />
- und ein Modellbau-Tipps Buch von Proxxon<br />
<br />
<br />
22.12.2008 Die Kiste geht weiter an Tim Hotfilter (Hotty) nach Bissendorf<br />
<br />
<br />
Ist am 24.12 Bei mir (Tim Hotfilter) angekommen!<br />
<br />
<br />
'''Sachen die ich aus der Kiste nahm: '''<br />
<br />
- ICs, Transistoren, Widerstände und Kondensatoren<br />
<br />
- 3 LCDs<br />
<br />
- Schrittmotoren<br />
<br />
- SMD Adapterplatienen<br />
<br />
- vieles Mehr<br />
<br />
<br />
<br />
'''Sachen die ich in die Kiste tat:'''<br />
<br />
- Etliche Platienen (6 Eurokarten aus einen Ansagegerät, LED-Matrix aus einem Bus, Steuerung aus einem Bus (viele Taster mit beleuchtung + LCD) etc...)<br />
<br />
- 1 LCD (2x24 sehr große Zeichen 9mm)<br />
<br />
- 1 SLM1608 LED-Matrix Modul (RG 16x16)<br />
<br />
- Kondensatoren und Kühlkörper<br />
<br />
<br />
[[Bild:Venus1a.jpg|thumb|180px|right|Wanderkiste Venus (CD-Spindel zum <br />
Grössenvergleich)]]<br />
<br />
<br />
29.12.08 Weiter geschickt an Sascha Berkenkamp (Delmenhorst)<br />
<br />
=== Kiste Venus ===<br />
<br />
Wer diese Kiste haben möchte sollte sich bewusst sein, dass diese<br />
sehr schwer ist (<br />
'''derzeit über 20 KG''' ) !<br />
<br />
12.12.2008 - Ist fertig gepackt, und wird am 13.12. an Stefan versandt.<br />
<br />
[[Bild:Venus1b.jpg|thumb|180px|right|Wanderkiste Venus offen]]<br />
13.12.2008 - Kiste wurde versandt, Trackingnummer wurde dem Empfänger mitgeteilt.<br />
<br />
15 kg Kiste angekommen. [[Benutzer:Stefan|Stefan]] 18:17, 17. Dez. 2008 (CET). Die Kiste wiegt jetzt 16.5 kg und ist seit heute auf dem Weg zu bastelator (Dirk). [[Benutzer:Stefan|Stefan]] 14:44, 20. Dez. 2008 (CET). Infos zum <br />
[http://www.mikrocontroller.net/topic/118816#1106912 DIGISOUND F/SK 44GB] in der Kiste.<br />
<br />
16,5kg-Kiste ist angekommen [[Benutzer:Bastelator|Bastelator]]. Auf den ersten Blick gigantisch! Weitere Neuigkeiten folgen, wenn die komplette Sichtung erfolgt ist. 21:12, 23. Dez. 2008 (CET)<br />
<br />
05.01.2009, 10:16:51 - Die Kiste ist bei mir ([http://www.mikrocontroller.net/user/show/Benedikt Benedikt]) angekommen. Ich hoffe nur ich bekomme alle meine Sachen in die Kiste rein, die ist ja schon randvoll.<br />
[[Bild:Venus4.jpg|thumb|180px|right|Foto der Wanderkiste Venus wie sie [http://www.mikrocontroller.net/user/show/Benedikt Benedikt] verlassen hat]]<br />
Die Kiste geht diese Woche noch zu nitram. Momentanes Gewicht: etwa 19kg.<br />
<br />
10.01.2009 Die Kiste ist bei mir (nitram) angekommen!!! :-)<br />
Allerdings liege ich derzeit mit einer Grippe im Bett...<br />
Sobald es mir besser geht, geht die Kiste wieder auf Reise...<br />
<br />
16.01.2009 Die Kiste ist ist neu gepackt (mehr geht jetzt nicht mehr rein) und geht auf Reise zum "derelektroniker"<br />
<br />
19.01.2009 Kiste ist bei mit (derelektroniker) angekommen und wird nun an Robin Tönniges (rotoe) verschickt. Aktuell hat sie ein Gewicht von etwas über 20 Kilo.<br />
<br />
26.01.2009 Ich (rotoe) habe die Kiste Venus jetzt gezweiteilt weil es einfach zu voll wurde. Ich taufe die neue Kiste Pluto und werde jetzt beide Kisten weiterschicken. Habe schon zwei Leute angeschrieben. Wenn sie die Kisten haben möchten werde ich das hier schreiben.<br />
<br />
30.01.2009 Kiste ist nach Ema Tronik (roquema) unterwegs. Als Entschädigung fürs lange Warten ist die Kiste jetzt um ein STK500 erweitert worden.<br />
<br />
[[Bild:Venus5.jpg|thumb|180px|right|Foto der Wanderkiste Venus wie sie [http://www.mikrocontroller.net/user/show/derelektroniker derelektroniker] verlassen hat]]<br />
<br />
=== Kiste Erde ===<br />
<br />
<br />
[[Bild:kisteErde.jpg|thumb|180px|right|Wanderkiste Erde, wie sie dr-robotnik verlassen hat]]<br />
<br />
Die Kiste Erde wurde von Dr. Robotnik eingerichtet und befüllt. Sie ist auf dem Weg zu User [http://www.mikrocontroller.net/user/show/toybaer toybaer].<br />
<br />
- die Kiste kam am 13.12. in Hameln an.<br />
<br />
- mit Urlaubsbeginn konnte endlich Plünderung und Auffüllen erfolgen, die Erde macht sich zwichen den Tagen auf den Weg nach Esslingen (juliano)<br />
<br />
- Angekommen (kurz vor Silvester 08/09)<br />
<br />
- am 13.01.09 in Wetter (Ruhr) angekommen<br />
<br />
=== Kiste Mars ===<br />
<br />
Wird nächste Woche von Dr. Robotnik gepackt und ist demnächst unterwegs zu User [http://www.mikrocontroller.net/user/show/esko Esko]<br />
<br />
=== Kiste NINA ===<br />
<br />
Die Wanderkiste '''Codename NINA''' Ist ursprünglich gedacht für User aus dem Roboternetz. Sie wird von [http://www.mikrocontroller.net/user/show/theborg0815 theborg0815] betreut. Die Webseite zum Eintragen als Empfänger und zur Dokumentation befindet sich auf http://www.grautier.com/wiki/doku.php?id=wanderkiste. Dort gibt es auch das 1. Foto des Inhalts einer solchen Kiste!<br />
<br />
== Weblinks ==<br />
<br />
* [http://www.evilmadscientist.com/article.php/junkbox Evil Mad Scientist Laboratories]<br />
* [http://www.avrprojekte.de/index.php?site=wanderkiste Wanderkistenseite von Hotty] <br />
* '''[[Wanderkiste.at]]''' ist die entsprechende Seite für die '''Wanderkiste in Österreich'''.<br />
* [http://www.mikrocontroller.net/articles/Spezial:Suche?ns2=1&search=&searchx=Suche Suche im Wiki nach Benutzer]<br />
<br />
[[Category:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Wanderkiste&diff=34096Wanderkiste2009-01-31T16:22:03Z<p>Rotoe: /* Kiste Venus */</p>
<hr />
<div>== Worum geht es? ==<br />
<br />
Die '''Große Wanderkiste elektronischer Bauteile''' erklärt Andreas Jakob in [http://www.mikrocontroller.net/topic/118816#1070509] so:<br />
<br />
Hallo Leute,<br />
<br />
durch diesen Beitrag :<br />
<br />
[http://www.mikrocontroller.net/topic/118752#1070168|Beitrag "Bauteile zu verschenken"]<br />
<br />
bin ich auf die Idee gekommen, auch in Deutschland so ein Wanderkistenprojekt zu starten.<br />
<br />
http://hackaday.com/2008/06/27/the-great-internet-migratory-box-of-electronics-junk/<br />
<br />
Das Konzept :<br />
<br />
Jeder kann sich in einer Liste eintragen, und erhält dann irgendwann die '''Wanderkiste''' vom aktuellen Besitzer zugesandt. Du nimmst dir aus der Kiste raus, was du möchtest, und legst im Gegenzug einige Dinge hinein, die du nicht mehr benötigst, die aber für andere nützlich sein könnten. Dann suchst du dir aus der aktuellen Liste jemand aus, und sendest die Kiste weiter an ihn.<br />
<br />
So bekommt man für das Porto für ein Paket (z.B. bei Hermes 5.90€ für bis zu 25 KG) ein Überraschungspaket, und wird seine nicht mehr benötigten Bauteile, Platinen, Motoren, Lautsprecher, Geräte, Ausschlachtplatinen etc. etc. wirklich sinnvoll los. <br />
<br />
Im Paket gibt es ein Büchlein, das seinen Lebensweg dokumentiert. Jeder macht ein Foto, wie er die Kiste erhalten hat, und schreibt einen Eintrag in ein Weblog, wann er Sie an wen weitergeschickt hat.<br />
<br />
== Die RuleZ ==<br />
<br />
Sind im Konzept ganz gut erklärt. Wenn es Ergänzungen gibt, kommen die hierhin. <br />
<br />
Auf den Punkt gebracht :<br />
<br />
Für alles was ich mir aus der Kiste rausnehme, lege ich etwas <br />
gleichwertig nützliches wieder hinein.<br />
+<br />
<br />
Die aktuelle Entwicklung und Gedanken zur Wanderkiste kann man im Forum [http://www.mikrocontroller.net/topic/118816] verfolgen und aktiv diskutieren. <br />
<br />
Knackig kurze Vorschläge, Anmerkungen usw. zu den RuleZ können auch auf [[Diskussion:Wanderkiste]] gemacht werden.<br />
<br />
== Ich will mitmachen! ==<br />
<br />
''Ich finde die Idee klasse und hoffentlich trägt mich einer in die Empfängerliste ein. Meine Kontaktdaten sind:''<br />
<br />
* '''Username oder Email (ggf. Link zu eigenen Elektronikprojekten)'''<br />
* hier Anhängen...<br />
* Username:<br />
[http://www.mikrocontroller.net/user/show/agentbsik Agentbsik],<br />
[http://www.mikrocontroller.net/user/show/cowz cowz], [http://www.mikrocontroller.net/user/show/djacme djacme], [http://www.mikrocontroller.net/user/show/stefan stefan], [http://www.mikrocontroller.net/user/show/biertrinker biertrinker], [http://www.mikrocontroller.net/user/show/theborg0815 Theborg0815]([http://www.grautier.com/ Grautier]), [http://www.mikrocontroller.net/user/show/Hotty Hotty] <br />
([http://www.avrprojekte.de/ Hottys Projekte]),<br />
[http://www.mikrocontroller.net/user/show/nitram nitram],<br />
[http://www.mikrocontroller.net/user/show/bastelator bastelator] ([http://www.bastelator.de/ Bastelators Basteleien]),<br />
[http://www.mikrocontroller.net/user/show/dr-robotnik dr-robotnik],<br />
[http://www.mikrocontroller.net/user/show/rotoe rotoe],<br />
[http://www.mikrocontroller.net/user/show/roquema roquema]<br />
([http://www.ematronik.de.vu/ Ematronik]),<br />
[http://www.mikrocontroller.net/user/show/matthias00 matthias00],<br />
[http://www.mikrocontroller.net/user/show/Lafkaschar Lafkaschar],<br />
[http://www.mikrocontroller.net/user/show/Easter Easter],<br />
[http://www.mikrocontroller.net/user/show/toybaer toybaer],<br />
[http://www.mikrocontroller.net/user/show/toybaer Esko],<br />
[http://www.mikrocontroller.net/user/show/maesto Maesto],<br />
[http://www.mikrocontroller.net/user/show/andrer AndreR],<br />
[http://www.mikrocontroller.net/user/show/Cyno Cyno],<br />
[http://www.mikrocontroller.net/user/show/Warteschleife Warteschleife],<br />
[http://www.mikrocontroller.net/user/show/fabs fabs],<br />
[http://www.mikrocontroller.net/user/show/derelektroniker derelektroniker],[http://www.mikrocontroller.net/user/show/Pyro-Mike Pyro-Mike],<br />
[http://www.mikrocontroller.net/user/show/juliano julian],<br />
[http://www.mikrocontroller.net/user/show/Benedikt Benedikt],<br />
[http://www.mikrocontroller.net/user/show/johanness johanness],<br />
[http://www.mikrocontroller.net/user/show/netdieter netdieter],<br />
[http://www.mikrocontroller.net/user/show/form form],<br />
[http://www.mikrocontroller.net/user/show/crazor crazor],<br />
[http://www.mikrocontroller.net/user/show/iller iller],<br />
[http://www.mikrocontroller.net/user/show/tien Tien],<br />
[http://www.mikrocontroller.net/user/show/hansilein hansilein], <br />
[http://www.mikrocontroller.net/user/show/bastelwastel015 bastelwastel015 (b-heeger_AT_t-online.de)],<br />
[http://www.mikrocontroller.net/user/show/fr4 fr4],<br />
[http://www.mikrocontroller.net/user/show/Suelzle-frank Suelzle-frank]<br />
<br />
== Karte ==<br />
<br />
<googlemap version="0.9" lat="53.354135" lon="10.634766" type="map" zoom="5"><br />
6#B2758BC5<br />
49.77812, 9.983752<br />
52.23558, 8.169402, Kiste Merkur<br />
</googlemap><br />
== Fotos, Berichte, Links, ... zur Wanderkiste ==<br />
<br />
=== Kiste Merkur ===<br />
<br />
Wer diese Kiste haben möchte sollte sich bewusst sein, dass diese<br />
sehr schwer ist (10-15 KG) !<br />
<br />
12.12.2008 - Ist fertig gepackt und wird am 13.12 an Dr. Robotnik<br />
gesandt. Er wird sie mit einer seiner Kisten durchmischen,<br />
um einen besseren Mix zu erhalten.<br />
<br />
13.12.2008 - Kiste wurde versandt, Trackingnummer wurde dem Empfänger mitgeteilt.<br />
<br />
20.12.2008 - Kiste endlich in Gerbrunn angekommen. Ich hab schon einige feine Sachen gefunden mit denen ich was anfangen kann. Werde berichten. dr-robotnik<br />
<br />
21.12.2008 - Ich habe jetzt einige Sachen herausgenommen und andere dafür hineingetan. Hier eine Übersicht:<br />
<br />
'''Herausgenommen habe ich'''<br />
<br />
[[Bild:vorher.jpg|thumb|180px|right|Was dr-robotnik aus Kiste Merkur entnommen hat]]<br />
<br />
- ein altes EGA Display (vermutlich aus einer Kasse ?)<br />
<br />
- einen kleinen Ringkerntrafo 2x12V (darüber freue ich mich am meißten,<br />
werde daraus ein kleines Doppelnetzteil bauen freu)<br />
<br />
- eine Biegehilfe für axial bedrahtete Bauteile<br />
<br />
- einen kleinen Alu-Kühlkörper (wird auch fürs Netzteil verwendet)<br />
<br />
- zwei ältere ISA Grafikkarten (daraus will ich den DAC rausholen, wird<br />
verwendet für einen einfachen Testbildgenerator, an dem ich zur Zeit<br />
bastle)<br />
<br />
- eine kleine Prototypen-Platine mit MAX232 Beschaltung (einfach toll!)<br />
<br />
- einen alten Gameboy (mal sehen, was daraus wird, vieleicht ein kleiner<br />
Logic Analyzer ?)<br />
<br />
- Einen BlueTooth Adapter für Drucker mit Centronics-Schnittstelle<br />
(Hoffentlich funktioniert er, mein neues Notebook hat keine parallele<br />
Schnittstelle mehr, so kann ich wieder meinen LaserJet in Betrieb<br />
nehmen)<br />
<br />
- Einige LSTTL Bausteine die ich gut gebrauchen kann<br />
<br />
- 10 Stk. kleine Taster mit Kappen<br />
<br />
- Einige Transistoren, ältere Typen<br />
<br />
- 5 Stk. Zenerdioden<br />
<br />
- 2 5Watt Widerstände<br />
<br />
- Einige Kondensatoren<br />
<br />
- Außerdem habe ich ein großes Stück Steckschaum gegen mehrere kleine<br />
getauscht.<br />
<br />
'''Hineingelegt habe ich'''<br />
<br />
<br />
[[Bild:nachher.jpg|thumb|180px|right|Was dr-robotnik in Kiste Merkur hineingelegt hat]]<br />
<br />
- 2 Große Platinen aus einer Industriesteuerung (definitiv defekt, aber<br />
mit vielen netten Bauteilen zum ausschlachten u.A. viele solid state<br />
relais)<br />
<br />
- 2 große Lüfter aus einem Beamer<br />
<br />
- Eine schöne unbenutzte SMD-Prototypenplatine mit Lötstopplack<br />
<br />
- Ein TFT-Display aus einem Notebook<br />
<br />
- Ein kleiner Alu-Kühlkörper<br />
<br />
- Ein Antrieb aus einem Flachbettscanner mit Schrittmotor<br />
<br />
- Einige verschiedene Schrittmotoren<br />
<br />
- Noch ein kleiner Lüfter<br />
<br />
- Mehrere Si-Dioden und jede Menge 9,1V Zener<br />
<br />
- Einige verschiedene Transistoren<br />
<br />
- Eine kleine zweistellige Siebensegmentanzeige, rot<br />
<br />
- Drei Hub- äh.. Zugmagneten (wie heißen die Dinger richtig?)<br />
<br />
- Zwei 16Bit ADCs von Burr Brown und ein Sample/Hold-Baustein von<br />
ANALOGIC<br />
<br />
- Ein kleines Gehäuse mit eingefräster Durchführung für Flachbandkabel<br />
(vieleicht brauchbar für einen kleinen PC-Logic Analyzer?)<br />
<br />
- Einige Abblock-Kerkos<br />
<br />
- Eine Drehpotentiometer-Skala zum aufkleben auf die Frontplatte<br />
<br />
- Einige Steckverbinder und BNC-Buchsen<br />
<br />
- Eine Hand voll verschiedene Quarze<br />
<br />
- Zwei Hartmetallbohrer (ich glaube 0,3mm hab aber nicht nachgemessen)<br />
<br />
- und ein Modellbau-Tipps Buch von Proxxon<br />
<br />
<br />
22.12.2008 Die Kiste geht weiter an Tim Hotfilter (Hotty) nach Bissendorf<br />
<br />
<br />
Ist am 24.12 Bei mir (Tim Hotfilter) angekommen!<br />
<br />
<br />
'''Sachen die ich aus der Kiste nahm: '''<br />
<br />
- ICs, Transistoren, Widerstände und Kondensatoren<br />
<br />
- 3 LCDs<br />
<br />
- Schrittmotoren<br />
<br />
- SMD Adapterplatienen<br />
<br />
- vieles Mehr<br />
<br />
<br />
<br />
'''Sachen die ich in die Kiste tat:'''<br />
<br />
- Etliche Platienen (6 Eurokarten aus einen Ansagegerät, LED-Matrix aus einem Bus, Steuerung aus einem Bus (viele Taster mit beleuchtung + LCD) etc...)<br />
<br />
- 1 LCD (2x24 sehr große Zeichen 9mm)<br />
<br />
- 1 SLM1608 LED-Matrix Modul (RG 16x16)<br />
<br />
- Kondensatoren und Kühlkörper<br />
<br />
<br />
[[Bild:Venus1a.jpg|thumb|180px|right|Wanderkiste Venus (CD-Spindel zum <br />
Grössenvergleich)]]<br />
<br />
<br />
29.12.08 Weiter geschickt an Sascha Berkenkamp (Delmenhorst)<br />
<br />
=== Kiste Venus ===<br />
<br />
Wer diese Kiste haben möchte sollte sich bewusst sein, dass diese<br />
sehr schwer ist (<br />
'''derzeit über 20 KG''' ) !<br />
<br />
12.12.2008 - Ist fertig gepackt, und wird am 13.12. an Stefan versandt.<br />
<br />
[[Bild:Venus1b.jpg|thumb|180px|right|Wanderkiste Venus offen]]<br />
13.12.2008 - Kiste wurde versandt, Trackingnummer wurde dem Empfänger mitgeteilt.<br />
<br />
15 kg Kiste angekommen. [[Benutzer:Stefan|Stefan]] 18:17, 17. Dez. 2008 (CET). Die Kiste wiegt jetzt 16.5 kg und ist seit heute auf dem Weg zu bastelator (Dirk). [[Benutzer:Stefan|Stefan]] 14:44, 20. Dez. 2008 (CET). Infos zum <br />
[http://www.mikrocontroller.net/topic/118816#1106912 DIGISOUND F/SK 44GB] in der Kiste.<br />
<br />
16,5kg-Kiste ist angekommen [[Benutzer:Bastelator|Bastelator]]. Auf den ersten Blick gigantisch! Weitere Neuigkeiten folgen, wenn die komplette Sichtung erfolgt ist. 21:12, 23. Dez. 2008 (CET)<br />
<br />
05.01.2009, 10:16:51 - Die Kiste ist bei mir ([http://www.mikrocontroller.net/user/show/Benedikt Benedikt]) angekommen. Ich hoffe nur ich bekomme alle meine Sachen in die Kiste rein, die ist ja schon randvoll.<br />
[[Bild:Venus4.jpg|thumb|180px|right|Foto der Wanderkiste Venus wie sie [http://www.mikrocontroller.net/user/show/Benedikt Benedikt] verlassen hat]]<br />
Die Kiste geht diese Woche noch zu nitram. Momentanes Gewicht: etwa 19kg.<br />
<br />
10.01.2009 Die Kiste ist bei mir (nitram) angekommen!!! :-)<br />
Allerdings liege ich derzeit mit einer Grippe im Bett...<br />
Sobald es mir besser geht, geht die Kiste wieder auf Reise...<br />
<br />
16.01.2009 Die Kiste ist ist neu gepackt (mehr geht jetzt nicht mehr rein) und geht auf Reise zum "derelektroniker"<br />
<br />
19.01.2009 Kiste ist bei mit (derelektroniker) angekommen und wird nun an Robin Tönniges (rotoe) verschickt. Aktuell hat sie ein Gewicht von etwas über 20 Kilo.<br />
<br />
26.01.2009 Ich (rotoe) habe die Kiste Venus jetzt gezweiteilt weil es einfach zu voll wurde. Ich taufe die neue Kiste Pluto und werde jetzt beide Kisten weiterschicken. Habe schon zwei Leute angeschrieben. Wenn sie die Kisten haben möchten werde ich das hier schreiben.<br />
<br />
30.01.2009 Kiste ist nach Ema Tronik (roquema) unterwegs. Als ENtschädigung fürs lange Warten ist die Kiste jetzt um ein STK500 erweitert worden.<br />
<br />
[[Bild:Venus5.jpg|thumb|180px|right|Foto der Wanderkiste Venus wie sie [http://www.mikrocontroller.net/user/show/derelektroniker derelektroniker] verlassen hat]]<br />
<br />
=== Kiste Erde ===<br />
<br />
<br />
[[Bild:kisteErde.jpg|thumb|180px|right|Wanderkiste Erde, wie sie dr-robotnik verlassen hat]]<br />
<br />
Die Kiste Erde wurde von Dr. Robotnik eingerichtet und befüllt. Sie ist auf dem Weg zu User [http://www.mikrocontroller.net/user/show/toybaer toybaer].<br />
<br />
- die Kiste kam am 13.12. in Hameln an.<br />
<br />
- mit Urlaubsbeginn konnte endlich Plünderung und Auffüllen erfolgen, die Erde macht sich zwichen den Tagen auf den Weg nach Esslingen (juliano)<br />
<br />
- Angekommen (kurz vor Silvester 08/09)<br />
<br />
- am 13.01.09 in Wetter (Ruhr) angekommen<br />
<br />
=== Kiste Mars ===<br />
<br />
Wird nächste Woche von Dr. Robotnik gepackt und ist demnächst unterwegs zu User [http://www.mikrocontroller.net/user/show/esko Esko]<br />
<br />
=== Kiste NINA ===<br />
<br />
Die Wanderkiste '''Codename NINA''' Ist ursprünglich gedacht für User aus dem Roboternetz. Sie wird von [http://www.mikrocontroller.net/user/show/theborg0815 theborg0815] betreut. Die Webseite zum Eintragen als Empfänger und zur Dokumentation befindet sich auf http://www.grautier.com/wiki/doku.php?id=wanderkiste. Dort gibt es auch das 1. Foto des Inhalts einer solchen Kiste!<br />
<br />
== Weblinks ==<br />
<br />
* [http://www.evilmadscientist.com/article.php/junkbox Evil Mad Scientist Laboratories]<br />
* [http://www.avrprojekte.de/index.php?site=wanderkiste Wanderkistenseite von Hotty] <br />
* '''[[Wanderkiste.at]]''' ist die entsprechende Seite für die '''Wanderkiste in Österreich'''.<br />
* [http://www.mikrocontroller.net/articles/Spezial:Suche?ns2=1&search=&searchx=Suche Suche im Wiki nach Benutzer]<br />
<br />
[[Category:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Wanderkiste&diff=33995Wanderkiste2009-01-27T16:34:21Z<p>Rotoe: /* Kiste Venus */</p>
<hr />
<div>== Worum geht es? ==<br />
<br />
Die '''Große Wanderkiste elektronischer Bauteile''' erklärt Andreas Jakob in [http://www.mikrocontroller.net/topic/118816#1070509] so:<br />
<br />
Hallo Leute,<br />
<br />
durch diesen Beitrag :<br />
<br />
[http://www.mikrocontroller.net/topic/118752#1070168|Beitrag "Bauteile zu verschenken"]<br />
<br />
bin ich auf die Idee gekommen, auch in Deutschland so ein Wanderkistenprojekt zu starten.<br />
<br />
http://hackaday.com/2008/06/27/the-great-internet-migratory-box-of-electronics-junk/<br />
<br />
Das Konzept :<br />
<br />
Jeder kann sich in einer Liste eintragen, und erhält dann irgendwann die '''Wanderkiste''' vom aktuellen Besitzer zugesandt. Du nimmst dir aus der Kiste raus, was du möchtest, und legst im Gegenzug einige Dinge hinein, die du nicht mehr benötigst, die aber für andere nützlich sein könnten. Dann suchst du dir aus der aktuellen Liste jemand aus, und sendest die Kiste weiter an ihn.<br />
<br />
So bekommt man für das Porto für ein Paket (z.B. bei Hermes 5.90€ für bis zu 25 KG) ein Überraschungspaket, und wird seine nicht mehr benötigten Bauteile, Platinen, Motoren, Lautsprecher, Geräte, Ausschlachtplatinen etc. etc. wirklich sinnvoll los. <br />
<br />
Im Paket gibt es ein Büchlein, das seinen Lebensweg dokumentiert. Jeder macht ein Foto, wie er die Kiste erhalten hat, und schreibt einen Eintrag in ein Weblog, wann er Sie an wen weitergeschickt hat.<br />
<br />
== Die RuleZ ==<br />
<br />
Sind im Konzept ganz gut erklärt. Wenn es Ergänzungen gibt, kommen die hierhin. <br />
<br />
Auf den Punkt gebracht :<br />
<br />
Für alles was ich mir aus der Kiste rausnehme, lege ich etwas <br />
gleichwertig nützliches wieder hinein.<br />
+<br />
<br />
Die aktuelle Entwicklung und Gedanken zur Wanderkiste kann man im Forum [http://www.mikrocontroller.net/topic/118816] verfolgen und aktiv diskutieren. <br />
<br />
Knackig kurze Vorschläge, Anmerkungen usw. zu den RuleZ können auch auf [[Diskussion:Wanderkiste]] gemacht werden.<br />
<br />
== Ich will mitmachen! ==<br />
<br />
''Ich finde die Idee klasse und hoffentlich trägt mich einer in die Empfängerliste ein. Meine Kontaktdaten sind:''<br />
<br />
* '''Username oder Email (ggf. Link zu eigenen Elektronikprojekten)'''<br />
* hier Anhängen...<br />
* Username:<br />
[http://www.mikrocontroller.net/user/show/agentbsik Agentbsik],<br />
[http://www.mikrocontroller.net/user/show/cowz cowz], [http://www.mikrocontroller.net/user/show/djacme djacme], [http://www.mikrocontroller.net/user/show/stefan stefan], [http://www.mikrocontroller.net/user/show/biertrinker biertrinker], [http://www.mikrocontroller.net/user/show/theborg0815 Theborg0815]([http://www.grautier.com/ Grautier]), [http://www.mikrocontroller.net/user/show/Hotty Hotty] <br />
([http://www.avrprojekte.de/ Hottys Projekte]),<br />
[http://www.mikrocontroller.net/user/show/nitram nitram],<br />
[http://www.mikrocontroller.net/user/show/bastelator bastelator] ([http://www.bastelator.de/ Bastelators Basteleien]),<br />
[http://www.mikrocontroller.net/user/show/dr-robotnik dr-robotnik],<br />
[http://www.mikrocontroller.net/user/show/rotoe rotoe],<br />
[http://www.mikrocontroller.net/user/show/roquema roquema]<br />
([http://www.ematronik.de.vu/ Ematronik]),<br />
[http://www.mikrocontroller.net/user/show/matthias00 matthias00],<br />
[http://www.mikrocontroller.net/user/show/Lafkaschar Lafkaschar],<br />
[http://www.mikrocontroller.net/user/show/Easter Easter],<br />
[http://www.mikrocontroller.net/user/show/toybaer toybaer],<br />
[http://www.mikrocontroller.net/user/show/toybaer Esko],<br />
[http://www.mikrocontroller.net/user/show/maesto Maesto],<br />
[http://www.mikrocontroller.net/user/show/andrer AndreR],<br />
[http://www.mikrocontroller.net/user/show/Cyno Cyno],<br />
[http://www.mikrocontroller.net/user/show/Warteschleife Warteschleife],<br />
[http://www.mikrocontroller.net/user/show/fabs fabs],<br />
[http://www.mikrocontroller.net/user/show/derelektroniker derelektroniker],[http://www.mikrocontroller.net/user/show/Pyro-Mike Pyro-Mike],<br />
[http://www.mikrocontroller.net/user/show/juliano julian],<br />
[http://www.mikrocontroller.net/user/show/Benedikt Benedikt],<br />
[http://www.mikrocontroller.net/user/show/johanness johanness],<br />
[http://www.mikrocontroller.net/user/show/netdieter netdieter],<br />
[http://www.mikrocontroller.net/user/show/form form],<br />
[http://www.mikrocontroller.net/user/show/crazor crazor],<br />
[http://www.mikrocontroller.net/user/show/iller iller],<br />
[http://www.mikrocontroller.net/user/show/tien Tien],<br />
[http://www.mikrocontroller.net/user/show/hansilein hansilein], <br />
[http://www.mikrocontroller.net/user/show/bastelwastel015 bastelwastel015 (b-heeger_AT_t-online.de)],<br />
[http://www.mikrocontroller.net/user/show/fr4 fr4],<br />
[http://www.mikrocontroller.net/user/show/Suelzle-frank Suelzle-frank]<br />
<br />
== Karte ==<br />
<br />
<googlemap version="0.9" lat="53.354135" lon="10.634766" type="map" zoom="5"><br />
6#B2758BC5<br />
49.77812, 9.983752<br />
52.23558, 8.169402, Kiste Merkur<br />
</googlemap><br />
== Fotos, Berichte, Links, ... zur Wanderkiste ==<br />
<br />
=== Kiste Merkur ===<br />
<br />
Wer diese Kiste haben möchte sollte sich bewusst sein, dass diese<br />
sehr schwer ist (10-15 KG) !<br />
<br />
12.12.2008 - Ist fertig gepackt und wird am 13.12 an Dr. Robotnik<br />
gesandt. Er wird sie mit einer seiner Kisten durchmischen,<br />
um einen besseren Mix zu erhalten.<br />
<br />
13.12.2008 - Kiste wurde versandt, Trackingnummer wurde dem Empfänger mitgeteilt.<br />
<br />
20.12.2008 - Kiste endlich in Gerbrunn angekommen. Ich hab schon einige feine Sachen gefunden mit denen ich was anfangen kann. Werde berichten. dr-robotnik<br />
<br />
21.12.2008 - Ich habe jetzt einige Sachen herausgenommen und andere dafür hineingetan. Hier eine Übersicht:<br />
<br />
'''Herausgenommen habe ich'''<br />
<br />
[[Bild:vorher.jpg|thumb|180px|right|Was dr-robotnik aus Kiste Merkur entnommen hat]]<br />
<br />
- ein altes EGA Display (vermutlich aus einer Kasse ?)<br />
<br />
- einen kleinen Ringkerntrafo 2x12V (darüber freue ich mich am meißten,<br />
werde daraus ein kleines Doppelnetzteil bauen freu)<br />
<br />
- eine Biegehilfe für axial bedrahtete Bauteile<br />
<br />
- einen kleinen Alu-Kühlkörper (wird auch fürs Netzteil verwendet)<br />
<br />
- zwei ältere ISA Grafikkarten (daraus will ich den DAC rausholen, wird<br />
verwendet für einen einfachen Testbildgenerator, an dem ich zur Zeit<br />
bastle)<br />
<br />
- eine kleine Prototypen-Platine mit MAX232 Beschaltung (einfach toll!)<br />
<br />
- einen alten Gameboy (mal sehen, was daraus wird, vieleicht ein kleiner<br />
Logic Analyzer ?)<br />
<br />
- Einen BlueTooth Adapter für Drucker mit Centronics-Schnittstelle<br />
(Hoffentlich funktioniert er, mein neues Notebook hat keine parallele<br />
Schnittstelle mehr, so kann ich wieder meinen LaserJet in Betrieb<br />
nehmen)<br />
<br />
- Einige LSTTL Bausteine die ich gut gebrauchen kann<br />
<br />
- 10 Stk. kleine Taster mit Kappen<br />
<br />
- Einige Transistoren, ältere Typen<br />
<br />
- 5 Stk. Zenerdioden<br />
<br />
- 2 5Watt Widerstände<br />
<br />
- Einige Kondensatoren<br />
<br />
- Außerdem habe ich ein großes Stück Steckschaum gegen mehrere kleine<br />
getauscht.<br />
<br />
'''Hineingelegt habe ich'''<br />
<br />
<br />
[[Bild:nachher.jpg|thumb|180px|right|Was dr-robotnik in Kiste Merkur hineingelegt hat]]<br />
<br />
- 2 Große Platinen aus einer Industriesteuerung (definitiv defekt, aber<br />
mit vielen netten Bauteilen zum ausschlachten u.A. viele solid state<br />
relais)<br />
<br />
- 2 große Lüfter aus einem Beamer<br />
<br />
- Eine schöne unbenutzte SMD-Prototypenplatine mit Lötstopplack<br />
<br />
- Ein TFT-Display aus einem Notebook<br />
<br />
- Ein kleiner Alu-Kühlkörper<br />
<br />
- Ein Antrieb aus einem Flachbettscanner mit Schrittmotor<br />
<br />
- Einige verschiedene Schrittmotoren<br />
<br />
- Noch ein kleiner Lüfter<br />
<br />
- Mehrere Si-Dioden und jede Menge 9,1V Zener<br />
<br />
- Einige verschiedene Transistoren<br />
<br />
- Eine kleine zweistellige Siebensegmentanzeige, rot<br />
<br />
- Drei Hub- äh.. Zugmagneten (wie heißen die Dinger richtig?)<br />
<br />
- Zwei 16Bit ADCs von Burr Brown und ein Sample/Hold-Baustein von<br />
ANALOGIC<br />
<br />
- Ein kleines Gehäuse mit eingefräster Durchführung für Flachbandkabel<br />
(vieleicht brauchbar für einen kleinen PC-Logic Analyzer?)<br />
<br />
- Einige Abblock-Kerkos<br />
<br />
- Eine Drehpotentiometer-Skala zum aufkleben auf die Frontplatte<br />
<br />
- Einige Steckverbinder und BNC-Buchsen<br />
<br />
- Eine Hand voll verschiedene Quarze<br />
<br />
- Zwei Hartmetallbohrer (ich glaube 0,3mm hab aber nicht nachgemessen)<br />
<br />
- und ein Modellbau-Tipps Buch von Proxxon<br />
<br />
<br />
22.12.2008 Die Kiste geht weiter an Tim Hotfilter (Hotty) nach Bissendorf<br />
<br />
<br />
Ist am 24.12 Bei mir (Tim Hotfilter) angekommen!<br />
<br />
<br />
'''Sachen die ich aus der Kiste nahm: '''<br />
<br />
- ICs, Transistoren, Widerstände und Kondensatoren<br />
<br />
- 3 LCDs<br />
<br />
- Schrittmotoren<br />
<br />
- SMD Adapterplatienen<br />
<br />
- vieles Mehr<br />
<br />
<br />
<br />
'''Sachen die ich in die Kiste tat:'''<br />
<br />
- Etliche Platienen (6 Eurokarten aus einen Ansagegerät, LED-Matrix aus einem Bus, Steuerung aus einem Bus (viele Taster mit beleuchtung + LCD) etc...)<br />
<br />
- 1 LCD (2x24 sehr große Zeichen 9mm)<br />
<br />
- 1 SLM1608 LED-Matrix Modul (RG 16x16)<br />
<br />
- Kondensatoren und Kühlkörper<br />
<br />
<br />
[[Bild:Venus1a.jpg|thumb|180px|right|Wanderkiste Venus (CD-Spindel zum <br />
Grössenvergleich)]]<br />
<br />
<br />
29.12.08 Weiter geschickt an Sascha Berkenkamp (Delmenhorst)<br />
<br />
=== Kiste Venus ===<br />
<br />
Wer diese Kiste haben möchte sollte sich bewusst sein, dass diese<br />
sehr schwer ist (<br />
'''derzeit über 20 KG''' ) !<br />
<br />
12.12.2008 - Ist fertig gepackt, und wird am 13.12. an Stefan versandt.<br />
<br />
[[Bild:Venus1b.jpg|thumb|180px|right|Wanderkiste Venus offen]]<br />
13.12.2008 - Kiste wurde versandt, Trackingnummer wurde dem Empfänger mitgeteilt.<br />
<br />
15 kg Kiste angekommen. [[Benutzer:Stefan|Stefan]] 18:17, 17. Dez. 2008 (CET). Die Kiste wiegt jetzt 16.5 kg und ist seit heute auf dem Weg zu bastelator (Dirk). [[Benutzer:Stefan|Stefan]] 14:44, 20. Dez. 2008 (CET). Infos zum <br />
[http://www.mikrocontroller.net/topic/118816#1106912 DIGISOUND F/SK 44GB] in der Kiste.<br />
<br />
16,5kg-Kiste ist angekommen [[Benutzer:Bastelator|Bastelator]]. Auf den ersten Blick gigantisch! Weitere Neuigkeiten folgen, wenn die komplette Sichtung erfolgt ist. 21:12, 23. Dez. 2008 (CET)<br />
<br />
05.01.2009, 10:16:51 - Die Kiste ist bei mir ([http://www.mikrocontroller.net/user/show/Benedikt Benedikt]) angekommen. Ich hoffe nur ich bekomme alle meine Sachen in die Kiste rein, die ist ja schon randvoll.<br />
[[Bild:Venus4.jpg|thumb|180px|right|Foto der Wanderkiste Venus wie sie [http://www.mikrocontroller.net/user/show/Benedikt Benedikt] verlassen hat]]<br />
Die Kiste geht diese Woche noch zu nitram. Momentanes Gewicht: etwa 19kg.<br />
<br />
10.01.2009 Die Kiste ist bei mir (nitram) angekommen!!! :-)<br />
Allerdings liege ich derzeit mit einer Grippe im Bett...<br />
Sobald es mir besser geht, geht die Kiste wieder auf Reise...<br />
<br />
16.01.2009 Die Kiste ist ist neu gepackt (mehr geht jetzt nicht mehr rein) und geht auf Reise zum "derelektroniker"<br />
<br />
19.01.2009 Kiste ist bei mit (derelektroniker) angekommen und wird nun an Robin Tönniges (rotoe) verschickt. Aktuell hat sie ein Gewicht von etwas über 20 Kilo.<br />
<br />
26.01.2009 Ich (rotoe) habe die Kiste Venus jetzt gezweiteilt weil es einfach zu voll wurde. Ich taufe die neue Kiste Pluto und werde jetzt beide Kisten weiterschicken. Habe schon zwei Leute angeschrieben. Wenn sie die Kisten haben möchten werde ich das hier schreiben.<br />
<br />
[[Bild:Venus5.jpg|thumb|180px|right|Foto der Wanderkiste Venus wie sie [http://www.mikrocontroller.net/user/show/derelektroniker derelektroniker] verlassen hat]]<br />
<br />
=== Kiste Erde ===<br />
<br />
<br />
[[Bild:kisteErde.jpg|thumb|180px|right|Wanderkiste Erde, wie sie dr-robotnik verlassen hat]]<br />
<br />
Die Kiste Erde wurde von Dr. Robotnik eingerichtet und befüllt. Sie ist auf dem Weg zu User [http://www.mikrocontroller.net/user/show/toybaer toybaer].<br />
<br />
- die Kiste kam am 13.12. in Hameln an.<br />
<br />
- mit Urlaubsbeginn konnte endlich Plünderung und Auffüllen erfolgen, die Erde macht sich zwichen den Tagen auf den Weg nach Esslingen (juliano)<br />
<br />
- Angekommen (kurz vor Silvester 08/09)<br />
<br />
- am 13.01.09 in Wetter (Ruhr) angekommen<br />
<br />
=== Kiste Mars ===<br />
<br />
Wird nächste Woche von Dr. Robotnik gepackt und ist demnächst unterwegs zu User [http://www.mikrocontroller.net/user/show/esko Esko]<br />
<br />
=== Kiste NINA ===<br />
<br />
Die Wanderkiste '''Codename NINA''' Ist ursprünglich gedacht für User aus dem Roboternetz. Sie wird von [http://www.mikrocontroller.net/user/show/theborg0815 theborg0815] betreut. Die Webseite zum Eintragen als Empfänger und zur Dokumentation befindet sich auf http://www.grautier.com/wiki/doku.php?id=wanderkiste. Dort gibt es auch das 1. Foto des Inhalts einer solchen Kiste!<br />
<br />
== Weblinks ==<br />
<br />
* [http://www.evilmadscientist.com/article.php/junkbox Evil Mad Scientist Laboratories]<br />
* [http://www.avrprojekte.de/index.php?site=wanderkiste Wanderkistenseite von Hotty] <br />
* '''[[Wanderkiste.at]]''' ist die entsprechende Seite für die '''Wanderkiste in Österreich'''.<br />
* [http://www.mikrocontroller.net/articles/Spezial:Suche?ns2=1&search=&searchx=Suche Suche im Wiki nach Benutzer]<br />
<br />
[[Category:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Wanderkiste&diff=32984Wanderkiste2008-12-07T10:47:54Z<p>Rotoe: /* Ich will mitmachen! */</p>
<hr />
<div>== Worum geht es? ==<br />
<br />
Die '''Große Wanderkiste elektronischer Bauteile''' erklärt Andreas Jakob in [http://www.mikrocontroller.net/topic/118816#1070509] so:<br />
<br />
Hallo Leute,<br />
<br />
durch diesen Beitrag :<br />
<br />
[http://www.mikrocontroller.net/topic/118752#1070168|Beitrag "Bauteile zu verschenken"]<br />
<br />
bin ich auf die Idee gekommen, auch in Deutschland so ein Wanderkistenprojekt zu starten.<br />
<br />
http://hackaday.com/2008/06/27/the-great-internet-migratory-box-of-electronics-junk/<br />
<br />
Das Konzept :<br />
<br />
Jeder kann sich in einer Liste eintragen, und erhält dann irgendwann die '''Wanderkiste''' vom aktuellen Besitzer zugesandt. Du nimmst dir aus der Kiste raus, was du möchtest, und legst im Gegenzug einige Dinge hinein, die du nicht mehr benötigst, die aber für andere nützlich sein könnten. Dann suchst du dir aus der aktuellen Liste jemand aus, und sendest die Kiste weiter an ihn.<br />
<br />
So bekommt man für das Porto für ein Paket (z.B. bei Hermes 5.90€ für bis zu 25 KG) ein Überraschungspaket, und wird seine nicht mehr benötigten Bauteile, Platinen, Motoren, Lautsprecher, Geräte, Ausschlachtplatinen etc. etc. wirklich sinnvoll los. <br />
<br />
Im Paket gibt es ein Büchlein, das seinen Lebensweg dokumentiert. Jeder macht ein Foto, wie er die Kiste erhalten hat, und schreibt einen Eintrag in ein Weblog, wann er Sie an wen weitergeschickt hat.<br />
<br />
== Die RuleZ ==<br />
<br />
Sind im Konzept ganz gut erklärt. Wenn es Ergänzungen gibt, kommen die hierhin. Die aktuelle Entwicklung und Gedanken zur Wanderkiste kann man auf [http://www.mikrocontroller.net/topic/118816#1070509] verfolgen und aktiv mitdiskutieren.<br />
<br />
== Ich will mitmachen! ==<br />
<br />
''Ich finde die Idee klasse und hoffentlich trägt mich einer in die Empfängerliste ein. Meine Kontaktdaten sind:''<br />
<br />
* '''Username oder Email - Datum - ggf. Link zu eigenen Elektronikprojekten'''<br />
* hier Anhängen...<br />
* Username:<br />
[http://www.mikrocontroller.net/user/show/cowz cowz], [http://www.mikrocontroller.net/user/show/djacme djacme], [http://www.mikrocontroller.net/user/show/stefan stefan], [http://www.mikrocontroller.net/user/show/biertrinker biertrinker], [http://www.mikrocontroller.net/user/show/theborg0815 Theborg0815], [http://www.mikrocontroller.net/user/show/Hotty Hotty] <br />
([http://www.avrprojekte.de/ Hottys Projekte]),<br />
[http://www.mikrocontroller.net/user/show/nitram nitram],<br />
[http://www.mikrocontroller.net/user/show/bastelator bastelator] ([http://www.bastelator.de/ Bastelators Basteleien]),<br />
[http://www.mikrocontroller.net/user/show/dr-robotnik dr-robotnik],<br />
[http://www.mikrocontroller.net/user/show/rotoe rotoe],<br />
<br />
== Fotos, Berichte, Links, ... zur Wanderkiste ==<br />
<br />
=== Kiste 1 ===<br />
<br />
...to be continued<br />
<br />
=== Kiste 2 ===<br />
<br />
...to be continued</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Wanderkiste&diff=32983Wanderkiste2008-12-07T10:47:37Z<p>Rotoe: /* Ich will mitmachen! */</p>
<hr />
<div>== Worum geht es? ==<br />
<br />
Die '''Große Wanderkiste elektronischer Bauteile''' erklärt Andreas Jakob in [http://www.mikrocontroller.net/topic/118816#1070509] so:<br />
<br />
Hallo Leute,<br />
<br />
durch diesen Beitrag :<br />
<br />
[http://www.mikrocontroller.net/topic/118752#1070168|Beitrag "Bauteile zu verschenken"]<br />
<br />
bin ich auf die Idee gekommen, auch in Deutschland so ein Wanderkistenprojekt zu starten.<br />
<br />
http://hackaday.com/2008/06/27/the-great-internet-migratory-box-of-electronics-junk/<br />
<br />
Das Konzept :<br />
<br />
Jeder kann sich in einer Liste eintragen, und erhält dann irgendwann die '''Wanderkiste''' vom aktuellen Besitzer zugesandt. Du nimmst dir aus der Kiste raus, was du möchtest, und legst im Gegenzug einige Dinge hinein, die du nicht mehr benötigst, die aber für andere nützlich sein könnten. Dann suchst du dir aus der aktuellen Liste jemand aus, und sendest die Kiste weiter an ihn.<br />
<br />
So bekommt man für das Porto für ein Paket (z.B. bei Hermes 5.90€ für bis zu 25 KG) ein Überraschungspaket, und wird seine nicht mehr benötigten Bauteile, Platinen, Motoren, Lautsprecher, Geräte, Ausschlachtplatinen etc. etc. wirklich sinnvoll los. <br />
<br />
Im Paket gibt es ein Büchlein, das seinen Lebensweg dokumentiert. Jeder macht ein Foto, wie er die Kiste erhalten hat, und schreibt einen Eintrag in ein Weblog, wann er Sie an wen weitergeschickt hat.<br />
<br />
== Die RuleZ ==<br />
<br />
Sind im Konzept ganz gut erklärt. Wenn es Ergänzungen gibt, kommen die hierhin. Die aktuelle Entwicklung und Gedanken zur Wanderkiste kann man auf [http://www.mikrocontroller.net/topic/118816#1070509] verfolgen und aktiv mitdiskutieren.<br />
<br />
== Ich will mitmachen! ==<br />
<br />
''Ich finde die Idee klasse und hoffentlich trägt mich einer in die Empfängerliste ein. Meine Kontaktdaten sind:''<br />
<br />
* '''Username oder Email - Datum - ggf. Link zu eigenen Elektronikprojekten'''<br />
* hier Anhängen...<br />
* Username:<br />
[http://www.mikrocontroller.net/user/show/cowz cowz], [http://www.mikrocontroller.net/user/show/djacme djacme], [http://www.mikrocontroller.net/user/show/stefan stefan], [http://www.mikrocontroller.net/user/show/biertrinker biertrinker], [http://www.mikrocontroller.net/user/show/theborg0815 Theborg0815], [http://www.mikrocontroller.net/user/show/Hotty Hotty] <br />
([http://www.avrprojekte.de/ Hottys Projekte]),<br />
[http://www.mikrocontroller.net/user/show/nitram nitram],<br />
[http://www.mikrocontroller.net/user/show/bastelator bastelator] ([http://www.bastelator.de/ Bastelators Basteleien]),<br />
[http://www.mikrocontroller.net/user/show/dr-robotnik dr-robotnik],<br />
[http://www.mikrocontroller.net/user/show/rotoe],<br />
<br />
== Fotos, Berichte, Links, ... zur Wanderkiste ==<br />
<br />
=== Kiste 1 ===<br />
<br />
...to be continued<br />
<br />
=== Kiste 2 ===<br />
<br />
...to be continued</div>Rotoehttps://www.mikrocontroller.net/index.php?title=AVR-Tutorial:_Timer&diff=32286AVR-Tutorial: Timer2008-10-31T08:39:35Z<p>Rotoe: /* Wie schnell schaltet denn jetzt der Port? */</p>
<hr />
<div>Timer sind eines der Hauptarbeitspferde in unserem Mikrocontroller. Mit ihrer Hilfe ist es möglich, in regelmäßigen Zeitabständen Aktionen zu veranlassen. Aber Timer können noch mehr!<br />
* Timer können mit einem externen Pin hochgezählt werden<br />
* Es gibt Möglichkeiten, bei bestimmten Zählerständen einen Interrupt auslösen zu lassen<br />
* Timer können aber auch völlig selbstständig Signale an einem Ausgabepin erzeugen<br />
* ...<br />
<br />
Aber der Reihe nach.<br />
<br />
==Was ist ein Timer?==<br />
<br />
Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert fortlaufend um 1 erhöht (oder erniedrigt) wird (statt <i>um 1 erhöhen</i> sagt man auch '''inkrementieren''', und das Gegenstück, '''dekrementieren''', bedeutet <i>um 1 erniedrigen</i>). Anstatt also Befehle im Programm vorzusehen, die regelmäßig ausgeführt werden und ein Register inkrementieren, erledigt dies der Mikrocontroller ganz von alleine. Dazu ist es möglich, den Timer mit dem Systemtakt zu verbinden und so die Genauigkeit des Quarzes auszunutzen, um ein Register regelmässig und vor allen Dingen unabhängig vom restlichen Programmfluss (!) hochzählen zu lassen.<br />
<br />
Davon alleine hätte man aber noch keinen großen Gewinn. Nützlich wird das Ganze erst dann, wenn man bei bestimmten Zählerständen eine Aktion ausführen lassen kann. Einer der 'bestimmten Zählerstände' ist zum Beispiel der '''Overflow'''. Das Zählregister eines Timers kann natürlich nicht beliebig lange inkrementiert werden – z. B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 2<sup>8</sup> – 1 = 255. Beim nächsten Inkrementierschritt tritt ein Überlauf (engl. Overflow) auf, der den Timerstand wieder zu 0 werden lässt. Und hier liegt der springende Punkt. Wir können uns nämlich an diesen Overflow "anhängen" und den Controller so konfigurieren, dass beim Auftreten des Timer-Overflows ein Interrupt ausgelöst wird.<br />
<br />
==Der Vorteiler (Prescaler)==<br />
<br />
Wenn also der Quarzoszillator mit 4 MHz schwingt, dann würde auch der Timer 4 Millionen mal in der Sekunde erhöht werden. Da der Timer jedes Mal von 0 bis 255 zählt, bevor ein Overflow auftritt, heist das auch, dass in einer Sekunde 4000000 / 256 = 15625 Overflows vorkommen. Ganz schön schnell! Nur: Oft ist das nicht sinnvoll. Um diese Raten zu verzögern, gibt es den Vorteiler, oder auf Englisch, Prescaler. Er kann auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden. Seine Aufgabe ist es, den Systemtakt um den angegebenen Faktor zu teilen. Steht der Vorteiler also auf 1024, so wird nur bei jedem 1024-ten Impuls vom Systemtakt das Timerregister um 1 erhöht. Entsprechend weniger häufig kommen dann natürlich die Overflows. Der Systemtakt sei wieder 4000000. Dann wird der Timer in 1 Sekunde 4000000 / 1024 = 3906.25 mal erhöht. Da der Timer wieder jedesmal bis 255 zählen muss bis ein Overflow auftritt, bedeutet dies, dass in 1 Sekunde 3906.25 / 256 = 15.25 Overflows auftreten.<br />
<br />
Systemtakt: 4Mhz<br />
<br />
Vorteiler Overflows/Sekunde Zeit zwischen<br />
2 Overflows [s]<br />
<br />
1 15625 0.000064<br />
8 1953.125 0.000512<br />
64 244.1406 0.004096<br />
256 61.0351 0.016384<br />
1024 15.2587 0.065536<br />
<br />
==Erste Tests==<br />
<br />
Ein Programm, das einen Timer Overflow in Aktion zeigt, könnte z.B. so aussehen:<br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp = r16<br />
.def leds = r17<br />
<br />
.org 0x0000<br />
rjmp main ; Reset Handler<br />
.org OVF0addr<br />
rjmp timer0_overflow ; Timer Overflow Handler<br />
<br />
main:<br />
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren<br />
out SPL, temp<br />
ldi temp, HIGH(RAMEND)<br />
out SPH, temp<br />
<br />
ldi temp, 0xFF ; Port B auf Ausgang<br />
out DDRB, temp<br />
<br />
ldi leds, 0xFF<br />
<br />
ldi temp, 0b00000001 ; CS00 setzen: Teiler 1<br />
out TCCR0, temp<br />
<br />
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow<br />
out TIMSK, temp<br />
<br />
sei<br />
<br />
loop: rjmp loop<br />
<br />
timer0_overflow: ; Timer 0 Overflow Handler<br />
out PORTB, leds<br />
com leds<br />
reti<br />
</avrasm><br />
<br />
Das Programm beginnt mit der [[AVR-Tutorial:_Interrupts|Interrupt-Vektoren-Tabelle]]. Dort ist an der Adresse <i>OVF0Addr</i> ein Sprung zur Marke <i>timer0_overflow</i> eingetragen. Wenn also ein Overflow Interrupt vom Timer 0 auftritt, so wird dieser Interrupt durch den '''rjmp''' weitergeleitet an die Stelle <i>timer0_overflow</i>.<br />
<br />
Das Hauptprogramm beginnt ganz normal mit der Belegung des Stackpointers. Danach wird der Port B auf Ausgang geschaltet, wir wollen hier wieder die LED anschliessen.<br />
<br />
Durch Beschreiben von TCCR0 mit dem Bitmuster 0b00000001 wird der Vorteiler auf 1 gesetzt. Für die ersten Versuche empfiehlt es sich, das Programm mit dem AVR-Studio zunächst zu simulieren. Würden wir einen größeren Vorteiler benutzen, so müsste man ziemlich oft mittels F11 einen simulierten Schritt ausführen, um eine Änderung im Timerregister zu erreichen.<br />
<br />
Die nächsten Anweisungen setzen im TIMSK Register das TOIE0 Bit. Sinn der Sache ist es, dem Timer zu erlauben, bei Erreichen eines Overflow einen Interrupt auszulösen.<br />
<br />
Zum Schluss noch die Interrupts generell mittels '''sei''' freigeben. Dieser Schritt ist obligatorisch. Im Mikrocontroller können viele Quellen einen Interrupt auslösen. Daraus folgt: Für jede mögliche Quelle muss festgelegt werden, ob sie einen Interrupt erzeugen darf oder nicht. Die Oberhoheit hat aber das globale Interrupt Flag. Mit ihm können alle Interrupts, egal von welcher Quelle sie kommen, unterdrückt werden.<br />
<br />
Damit ist die Initialisierung beendet und das Hauptprogramm kann sich schlafen legen. Die '''loop: rjmp loop''' Schleife macht genau dieses.<br />
<br />
Tritt nun ein Overflow am Timer auf, so wird über den Umweg über die Interrupt Vektor Tabelle der Programmteil <i>timer0_overflow</i> angesprungen. Dieser gibt einfach nur den Inhalt des Registers leds am Port B aus. Danach wird das leds Register mit einer '''com''' Operation negiert, so dass aus allen 0 Bits eine 1 wird und umgekehrt. Die Overflow Behandlung ist damit beendet und mittels '''reti''' wird der Interrupt Handler wieder verlassen.<br />
<br />
==Simulation im AVR-Studio==<br />
<br />
Es lohnt sich, den ganzen Vorgang im AVR-Studio simulieren zu lassen. Dazu am besten in der linken I/O View Ansicht die Einträge für PORTB und TIMER_COUNTER_0 öffnen. Wird mittels F11 durch das Programm gegangen, so sieht man, dass ab dem Moment, ab dem der Vorteiler auf 1 gesetzt wird, der Timer 0 im TCNT0 Register zu zählen anfängt. Mit jedem Druck auf F11 erhöht sich der Zählerstand. Irgendwann ist dann die Endlosschleife loop erreicht. Drücken Sie weiterhin F11 und beobachten sie, wie TCNT0 immer höher zählt, bis der Overflow erreicht wird. In dem Moment, in dem der Overflow erreicht wird, wird der Interrupt ausgelöst. Mit dem nächsten F11 landen sie in der Interrupt Vektor Tabelle und von dort geht es weiter zu timer_0_overflow. Weitere Tastendrücke von F11 erledigen dann die Ausgabe auf den Port B, das Invertieren des Registers r17 und der Interrupt ist damit behandelt. Nach dem '''reti''' macht der Microcontroller genau an der Stelle weiter, an der er vom Interrupt unterbrochen wurde. Und der Timer 0 hat in der Zwischenzeit weitergezählt! Nach exakt weiteren 256 Schritten, vom Auftreten des ersten Overflows an gerechnet, wird der nächste Overflow ausgelöst.<br />
<br />
==Wie schnell schaltet denn jetzt der Port?==<br />
<br />
Eine berechtigte Frage. Dazu müssen wir etwas rechnen. Keine Angst, es ist nicht schwer, und wer das Prinzip bisher verstanden hat, der sollte keine Schwierigkeiten haben, die Berechnung nachzuvollziehen.<br />
<br />
Der Quarzoszillator schwingt mit 4 MHz. Das heißt, in 1 Sekunde werden 4000000 Taktzyklen generiert. Durch die Wahl des Vorteilers von 1 bedeutet das auch, dass der Timer 4000000 mal in der Sekunde erhöht wird. Von einem Overflow zum nächsten muss der Timer 256 Zählvorgänge ausführen. Also werden in 1 Sekunde 4000000 / 256 = 15625 Overflows generiert. Bei jedem Overflow schalten wir die LEDs jeweils in den anderen Zustand. D.h die LEDs blinken mit einer Frequenz von 7812.5 Hz. Das ist zuviel als dass wir es noch sehen könnten.<br />
<br />
Was können wir also tun, um diese Blinkfrequenz zu verringern? Im Moment ist unsere einzige Einflussgröße der Vorteiler. Wie sieht die Rechnung aus, wenn wir einen Vorteiler von 1024 wählen?<br />
<br />
Wiederrum: Der Systemtakt sei 4 Mhz. Durch den Vorteiler von 1024 werden daraus 4000000 / 1024 = 3906.25 Pulse pro Sekunde für den Timer. Der zählt wiederum 256 Zustände von einem Overflow zum nächsten. 3906.25 / 256 = 15.2587. Und wiederum: Im Overflow werden die LEDs ja abwechselnd ein und ausgeschaltet, also dividieren wir noch durch 2: 15.2587 / 2 = 7.629. Also knapp 7 Hz. Diese Frequenz müsste man schon mit freiem Auge sehen. Die LEDs werden ziemlich schnell vor sich hin blinken.<br />
<br />
Reicht diese Verzögerung noch immer nicht, dann haben wir 2 Möglichkeiten:<br />
* Entweder wir benutzen einen anderen Timer. Timer 1 beispielsweise ist ein 16 Bit Timer. Der Timer zählt also nicht bis 255 sondern bis 65535. Bei entsprechender Umarbeitung des Programms und einem Vorteiler von 1024 bedeutet das, dass die LEDs einen Ein/Aus Zyklus in 33 Sekunden absolvieren.<br />
* Oder wir schalten die LEDs nicht bei jedem Timer Overflow um. Man könnte zum Beispiel in einem Register bis 7 zählen und nur dann, wenn dieses Register 7 erreicht hat, wird<br />
** das Register wieder auf 0 gesetzt und<br />
** die LEDs umgeschaltet.<br />
<br />
==Timer 0==<br />
<br />
Timer 0 ist ein 8 Bit Timer.<br />
<br />
* Overflow Interrupt<br />
<br />
===TCCR0===<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | CS02 | CS01 | CS00 |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
<i>CS02 - CS00 Clock Select</i><br />
<br />
<table border="0"><br />
<tr><br />
<th align="left">CS02</th><th align="left">CS01</th><th align="left">CS00</th><th align="left">Bedeutung</th><br />
</tr><br />
<tr><br />
<td align="center">0</td><td align="center">0</td><td align="center">0</td><td>keine (Der Timer ist angehalten)</td><br />
</tr><br />
<tr><br />
<td align="center">0</td><td align="center">0</td><td align="center">1</td><td>Vorteiler: 1</td><br />
</tr><br />
<tr><br />
<td align="center">0</td><td align="center">1</td><td align="center">0</td><td>Vorteiler: 8</td><br />
</tr><br />
<tr><br />
<td align="center">0</td><td align="center">1</td><td align="center">1</td><td>Vorteiler: 64</td><br />
</tr><br />
<tr><br />
<td align="center">1</td><td align="center">0</td><td align="center">0</td><td>Vorteiler: 256</td><br />
</tr><br />
<tr><br />
<td align="center">1</td><td align="center">0</td><td align="center">1</td><td>Vorteiler: 1024</td><br />
</tr><br />
<tr><br />
<td align="center">1</td><td align="center">1</td><td align="center">0</td><td>Externer Takt vom Pin T0, fallende Flanke</td><br />
</tr><br />
<tr><br />
<td align="center">1</td><td align="center">1</td><td align="center">1</td><td>Externer Takt vom Pin T0, steigende Flanke</td><br />
</tr><br />
</table><br />
<br />
===TIMSK===<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | TOIE0|<br />
+------+------+------+------+------+------+------+------+<br />
<br />
<i>TOIE0 Timer 0 Overflow Interrupt Enable</i><br />
<br />
Ist dieses Bit gesetzt, so wird beim Auftreten eines<br />
Overflows am Timer ein Interrupt ausgelöst.<br />
<br />
Anstatt der Schreibweise<br />
<avrasm><br />
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow<br />
out TIMSK, temp<br />
</avrasm><br />
ist es besser, die Schreibweise<br />
<avrasm><br />
ldi temp, 1 << TOIE0<br />
out TIMSK, temp<br />
</avrasm><br />
zu wählen, da hier unmittelbar aus dem Ladekommando hervorgeht, welche Bedeutung das gesetzte Bit hat. Die vorher inkludierte m8def.inc definiert dazu alles Notwendige.<br />
<br />
==Timer 1==<br />
<br />
Timer 1 ist ein 16 Bit Timer<br />
<br />
* Overflow Interrupt<br />
* Clear Timer on Compare Match<br />
* Input Capture<br />
* 2 Compare Einheiten<br />
* div. PWM Modi<br />
<br />
===TCCR1B===<br />
+------+------+------+------+------+------+------+------+<br />
| ICNC1| ICES1| | WGM13| WGM12| CS12 | CS11 | CS10 |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
<i>CS12 - CS10 Clock Select</i><br />
<br />
<table border="0"><br />
<tr><br />
<th>CS12</th><th>CS11</th><th>CS10</th><th align="left">Bedeutung</th><br />
</tr><br />
<tr><br />
<td>0</td><td>0</td><td>0</td><td>keine (Der Timer ist angehalten)</td><br />
</tr><br />
<tr><br />
<td>0</td><td>0</td><td>1</td><td>Vorteiler: 1</td><br />
</tr><br />
<tr><br />
<td>0</td><td>1</td><td>0</td><td>Vorteiler: 8</td><br />
</tr><br />
<tr><br />
<td>0</td><td>1</td><td>1</td><td>Vorteiler: 64</td><br />
</tr><br />
<tr><br />
<td>1</td><td>0</td><td>0</td><td>Vorteiler: 256</td><br />
</tr><br />
<tr><br />
<td>1</td><td>0</td><td>1</td><td>Vorteiler: 1024</td><br />
</tr><br />
<tr><br />
<td>1</td><td>1</td><td>0</td><td>Externer Takt vom Pin T1, fallende Flanke</td><br />
</tr><br />
<tr><br />
<td>1</td><td>1</td><td>1</td><td>Externer Takt vom Pin T1, steigende Flanke</td><br />
</tr><br />
</table><br />
<br />
<i>ICES1 Input Capture Edge Select</i><br />
<br />
<i>ICNC1 Input Capture Noise Canceler</i><br />
<br />
===TCCR1A===<br />
+------+------+------+------+------+------+------+------+<br />
|COM1A1|COM1A0|COM1B1|COM1B0|FOC1A |FOC1B |WGM11 |WGM10 |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
===OCR1A===<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
===OCR1B===<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
===ICR1===<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
===TIMSK===<br />
+------+------+------+------+------+------+------+------+<br />
| | |TICIE1|OCIE1A|OCIE1B| TOIE1| | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
<i>TICIE1 Timer 1 Input Capture Interrupt Enable</i><br />
<br />
<i>OCIE1A Timer 1 Output Compare A Match Interrupt Enable</i><br />
<br />
<i>OCIE1B Timer 1 Output Compare B Match Interrupt Enable</i><br />
<br />
<i>TOIE1 Timer 1 Overflow Interrupt Enable</i><br />
<br />
==Timer 2==<br />
Timer 2 ist ein 8 Bit Timer.<br />
<br />
* Overflow Interrupt<br />
* Compare Match Interrupt<br />
* Clear Timer on Compare Match<br />
* Phasen korrekte PWM<br />
<br />
===TCCR2===<br />
+------+------+------+------+------+------+------+------+<br />
| FOC2 | WGM20| COM21| COM20| WGM21| CS22 | CS21 | CS20 |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
<i>CS22 - CS20 Clock Select</i><br />
<br />
<table border="0"><br />
<tr><br />
<th>CS22</th><th>CS21</th><th>CS20</th><th align="left">Bedeutung</th><br />
</tr><br />
<tr><br />
<td>0</td><td>0</td><td>0</td><td>keine (Der Timer ist angehalten)</td><br />
</tr><br />
<tr><br />
<td>0</td><td>0</td><td>1</td><td>Vorteiler: 1</td><br />
</tr><br />
<tr><br />
<td>0</td><td>1</td><td>0</td><td>Vorteiler: 8</td><br />
</tr><br />
<tr><br />
<td>0</td><td>1</td><td>1</td><td>Vorteiler: 32</td><br />
</tr><br />
<tr><br />
<td>1</td><td>0</td><td>0</td><td>Vorteiler: 64</td><br />
</tr><br />
<tr><br />
<td>1</td><td>0</td><td>1</td><td>Vorteiler: 128</td><br />
</tr><br />
<tr><br />
<td>1</td><td>1</td><td>0</td><td>Vorteiler: 256</td><br />
</tr><br />
<tr><br />
<td>1</td><td>1</td><td>1</td><td>Vorteiler: 1024</td><br />
</tr><br />
</table><br />
<br />
===OCR2===<br />
+------+------+------+------+------+------+------+------+<br />
| | | | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
===TIMSK===<br />
+------+------+------+------+------+------+------+------+<br />
| OCIE2| TOIE2| | | | | | |<br />
+------+------+------+------+------+------+------+------+<br />
<br />
<i>OCIE2 Timer 2 Output Compare Interrupt Enable</i><br />
<br />
<i>TOIE2 Timer 2 Overflow Interrupt Enable</i><br />
<br />
==Was geht noch mit einem Timer?==<br />
<br />
Timer sind sehr universelle Microcontroller Bestandteile. Für weitergehende Studien ist es daher unerlässlich, das entsprechende Datenblatt des Microcontrollers zu studieren. Oft ist es z.B. möglich, dass der Timer bei erreichen von bestimmten Zählerständen einen Ausgabepin von sich aus ein-/aus-/umschaltet. Er erledigt dann das, was wir oben noch mit einem Interrupt gemacht haben, eigenständig komplett in Hardware. Bei einigen Timern ist es möglich, damit eine [[PWM]] (Pulsweiten-Modulation) aufzubauen.<br />
<br />
Ein paar der Timermodule lassen sich auch als Counter verwenden. Damit kann man z.B. die Anzahl externer Ereignisse wie Schaltvorgänge eines Inkrementalgebers bestimmen.<br />
<br />
Andere bieten die Möglichkeit, über einen externen Uhrenquarz getaktet zu werden (Anwendung z.B. eine "Echtzeituhr" oder als "Weckfunktion" aus einem<br />
Standby/Powerdownmodus).<br />
<br />
== Weblinks ==<br />
* Timer/Counter und PWM beim ATMega16 Mikrocontroller: http://www.uni-koblenz.de/~physik/informatik/MCU/Timer.pdf <br />
<br />
{{Navigation_zurückhochvor|<br />
zurücktext=Speicher|<br />
zurücklink=AVR-Tutorial: Speicher|<br />
hochtext=Inhaltsverzeichnis|<br />
hochlink=AVR-Tutorial|<br />
vortext=Uhr|<br />
vorlink=AVR-Tutorial: Uhr}}<br />
<br />
[[Category:AVR]][[Category:AVR-Tutorial]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Temperatursensor&diff=32193Temperatursensor2008-10-26T20:48:15Z<p>Rotoe: /* LM75 */</p>
<hr />
<div>Will man mit einem [[Mikrocontroller]] Temperaturen messen, dann braucht man<br />
* einen [[Sensor]], der die Temperatur z.B. in eine Spannung oder einen Strom umwandelt<br />
* einen [[ADC | AD-Wandler]], der das Signal digitalisiert. Der kann auf dem Sensor oder dem Mikrocontroller integriert sein.<br />
<br />
Temperatursensoren gibt es nun in allen möglichen Varianten. Vom temperaturabhängigen [[Widerstand]] bis zum fertig abgeglichenen All-in-one-Bauteil mit digitalem Ausgang. Wie bei allen Sensoren sollte man auch hier genau hinschauen und [[Auflösung und Genauigkeit]] unterscheiden.<br />
<br />
== Analoge Temperatursensoren ==<br />
<br />
=== PT100 ===<br />
<br />
Unter einem PT100 versteht man einen Platinwiderstand, der bei 0°C einen Widerstand von 100 Ohm hat.<br />
Platinwiderstände sind temperaturabhängige Widerstände mit hoher Wiederholgenauigkeit und Konstanz. Wegen der relativ geringen Widerstandsänderung von nur ca. 0,4 Ohm pro Grad ist etwas mehr Schaltungsaufwand erforderlich als bei anderen Sensoren. Genauere Formeln zur Temperaturbestimmung gibt es u.a. bei der [http://de.wikipedia.org/wiki/Pt100 Wikipedia]. Einen Schaltplan findet sich bei der [http://www.heise.de/ct/04/22/236/ c't].<br />
<br />
Die Sensoren gibt es auch mit anderen Widerstandswerten, z.B. mit 1000&Omega; und heißen dann entsprechend PT1000.<br />
<br />
Vorteil:<br />
* genormt<br />
* hohe Linearität<br />
* hohe Wiederholgenauigkeit<br />
* einfach austauschbar<br />
<br />
Nachteil:<br />
* relativ teuer (bei segor.de ab 3,80&euro;)<br />
* brauchen aufwendigere Auswerteschaltung<br />
<br />
Links:<br />
* [http://www.heise.de/ct/04/22/236/ c't-Artikel: Mikrocontroller-Programmierung: Timer, Sensoren und Drehgeber (mit PT100 Schaltung)]<br />
<br />
=== NTC/PTC ===<br />
<br />
NTC und PTC sind temperaturabhängige Widerstände.<br />
<br />
* NTC (engl. '''N'''egative '''T'''emperature '''C'''oefficient, Heißleiter), hat bei hohen Temperaturen seinen niedrigsten Widerstand, z.B. Silizium<br />
* PTC (engl. '''P'''ositive '''T'''emperature '''C'''oefficient, Kaltleiter), hat bei niedrigen Temperaturen seinen geringsten Widerstand, z.B. Glühlampe<br />
<br />
Um den Widerstandswert zu messen schaltet man sie mit einem normalen Widerstand oder einer [[Konstantstromquelle]] in Reihe zu einem [[Spannungsteiler]] und misst den Spannungsabfall. Eine Beispielschaltung findet sich [http://www.mathar.com/msp_thermo1.html hier].<br />
<br />
Vorteil:<br />
* billig (Reichelt 0,29 &euro;)<br />
<br />
Nachteil:<br />
* müssen abgeglichen werden<br />
* brauchen A/D-Wandler<br />
* sind nichtlinear<br />
<br />
Links:<br />
* [http://www.sprut.de/electronic/temeratur/temp.htm Temperaturabhängige Stromquelle und NTC/PTC inclusive Linearisierung]<br />
<br />
=== LMx35 ===<br />
<br />
Eine IC-Familie, die pro Kelvin Temperaturänderung ihre Ausgangsspannung um 10&nbsp;mV ändert. Die ICs gibt es in verschiedenen Genauigkeiten und Temperaturbereichen mit den Bezeichnungen LM135(A), LM235(A) und LM335(A). Der günstigste ist der LM335 mit einem Temperaturbereich von −40 … +100°C.<br />
In verschiedenen Bauformen erhältlich. Beispielschaltungen finden sich im [http://www.national.com/ds.cgi/LM/LM135.pdf Datenblatt] und [http://www.suessbrich.info/elek/elektherm1.html hier]<br />
<br />
Vorteile:<br />
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)<br />
* relativ billig (LM335 bei Reichelt ab 0,50&nbsp;€)<br />
<br />
Nachteile:<br />
* benötigt A/D-Wandler<br />
* bei längerer Anschlussleitung störanfällig<br />
<br />
=== LM334 ===<br />
<br />
Ein IC ähnlich dem LM335 mit dem Unterschied, dass der durch das IC fließende Strom proportional von der Temperatur abhängt. Mit einer einfachen Schaltung aus nur zwei Widerständen kann man dann den Strom in einer Weise wandeln, dass pro Kelvin eine Spannungsänderung von 10mV ausgegeben wird. Da die Strom-Spannungswandlung auf der Platine (und damit nahe am AD-Wandler) stattfindet und die Übertragung des Messwerts durch einen Strom stattfindet, sind Störungen durch Netzbrumm etc. viel geringer als beim LM335<br />
<br />
Vorteile:<br />
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)<br />
* relativ billig ([http://www.reichelt.de/?ARTICLE=10468 Reichelt 0,54 &euro;])<br />
<br />
Nachteile:<br />
* benötigt A/D-Wandler<br />
* Bereich 0°C-70°C<br />
<br />
Ähnliche ICs:<br />
* AD592 (Ausgangsstrom 1µA pro Kelvin, absolute Temperatur) [http://www.reichelt.de/?ARTICLE=3825 Reichelt: 3,75 €], Conrad 174912 8,50 &euro;<br />
<br />
=== SMT160-30 ===<br />
<br />
Ist ein Zwischending zwischen Digital und Analog. Sein Ausgangssignal ist ein digitales PWM-Signal, zu dessen Messung man am besten den Input-Capture-Eingang eines Mikrocontrollers verwendet. Man kann ihn also wie einen analogen Sensor nur indirekt auslesen, anstatt über einen AD-Wandler hier über einen Timer.<br />
<br />
Vorteile:<br />
* Digitales PWM-Signal ist unempfindlich gegen Störeinflüsse<br />
* gibt es in SO8, TO18, TO92 und <b>TO220</b>, gut befestigbar, z.B am Kühlkörper<br />
* linear<br />
* kein Abgleich nötig<br />
<br />
Nachteile (viele):<br />
* benötigt Timer<br />
* jittert extrem, genaue Messungen nur über Mittelung / Filterung möglich<br />
* nicht nur das PWM-Verhältnis, sondern auf die Frequenz ist temp-abhängig (1-4kHz)<br />
* teuer (Farnell 10,90&euro; +16%, Conrad 9,xx&euro; , www.hy-line.de ??).<br />
* TO92 Gehäuse ist günstiger, dafür weniger genau<br />
<br />
Links:<br />
* http://www.hy-line.de/co/sensor-tec/hersteller/smartec/smt-160-30/index.html<br />
<br />
=== Thermoelement ===<br />
<br />
Ein Thermoelement besteht im einfachsten Fall aus zwei ungleichen Metallendrähten, die an einem Punkt miteinander verbunden sind und bei dem die Verbindungsstelle einer anderen Temperatur ausgesetzt ist als die offenen Enden der Drähte. An den offenen Enden der Drähten entsteht eine Spannung (Thermospannung). Dieser Effekt wurde 1821 von Thomas Seebeck entdeckt ([http://de.wikipedia.org/wiki/Seebeck-Effekt Seebeck-Effekt] bei Wikipedia). Eine weitere Anwendung ist der thermoelektrische Generator ("Thermogenerator").<br />
<br />
Vorteil:<br />
* über einen sehr weiten Temperaturbereich einsetzbar<br />
<br />
Nachteil:<br />
* die sehr geringen Temperaturspannungen im Mikrovoltbereich benötigen eine sehr gute Auswertelektronik (guter Analogteil + AD-Wandler).<br />
<br />
Links:<br />
* [http://digital.ni.com/worldwide/germany.nsf/web/all/7A4F02BAEFEC22AC802567F6003E0D6E Temperaturmessung mit Thermoelementen] - Eine Einführung von David Potter (deutsche Überarbeitung: G.Sinkovic) (inkl. Erläuterung der Kaltstellenkompensation)<br />
* [http://www.ipetronik.com/pdf/Newsletter/Ipetronik_NL2_2004_d.pdf Warum Thermoelemente Relativtemperaturen messen! oder Was ist eine Kaltstelle?] - Technische Information von www.ipetronik.com (PDF, 272 KB)<br />
<br />
== Digitale Temperatursensoren ==<br />
<br />
=== DS1621 ===<br />
<br />
Der DS1621 ist Temperatursensor und A/D-Wandler in einem. Er gibt seine Daten per [[I²C]]-[[Bus]] aus. Ein Schaltplan für einen elektronischen Thermometer mit diesem IC findet sich [http://www.myplace.nu/avr/thermo/ hier].<br />
<br />
Vorteile:<br />
* bereits kalibriert<br />
* kein A/D-Wandler nötig<br />
* da I²C ein Bus ist, kann man mehrere DS1621 und andere I²C-Bausteine zusammen anschließen und braucht dafür trotzdem nur zwei I/O-Ports.<br />
* Messbereich -55°C to +125°C <br />
* Genauigkeit +-0,5°<br />
* Auflösung besser 0,01°, wenn man die beiden Zählerregister (Count-Remain und Count-per-C) auswertet<br />
<br />
Nachteile:<br />
* teuer (Segor 5,80&euro;; RS 3,95&euro;; Conrad 4,99&euro;)<br />
* trotzdem die meisten Register [[Speicher#NVRAM | nichtflüchtig]] sind, kann man ihn nicht als Stand-Alone-Thermostat einsetzen, da er erst nach einem Start-Conversion-Befehl zu messen beginnt.<br />
<br />
Nachfolger:<br />
* DS1631, DS1631A (Auto-Start-> Stand-Alone-Thermostat), DS1731<br />
* weitere Stand-Alone-Thermostaten: DS1821, DS1629<br />
<br />
<br />
=== LM75 ===<br />
<br />
Der LM75 ist so ähnlich wie der DS1621, allerdings nur in SMD erhältlich und nicht so genau. Er ist aber öfters mal auf PC-Mainboards zu finden, so dass man beim Schlachten eines solchen günstig an einen Temperatursensor kommen kann. Einen Schaltplan findet man [http://www.mcselec.com/index.php?option=com_docman&task=cat_view&gid=83&limit=1&limitstart=35 hier].<br />
<br />
Vorteile:<br />
* bereits kalibriert<br />
* kein A/D-Wandler nötig<br />
* I²C-Bus Ausgang<br />
* billiger als DS1621 (Reichelt 1,35 &euro;; RS 3V: 3,75&euro;; 5V: 2,72&euro;)<br />
* Auflösung 0,5°<br />
<br />
Nachteile:<br />
* nur im SMD-Gehäuse erhältlich<br />
* relativ ungenau (+-2°), kann man jedoch kalibrieren / kompensieren<br />
<br />
Kompatible Typen:<br />
* AD7415ART<br />
<br />
=== DS18S20 / DS18B20 ===<br />
<br />
Der DS18S20 (Nachfolger des DS1820) und DS18B20 sind scheinbar Temperatursensoren und A/D-Wandler in einem. Wenn man genauer hinschaut, stellt man fest, dass es sich um direktwandelnde Sensoren handelt. Die Temperatur wird ohne Umweg über eine analoge Zwischengröße (Spannung oder Strom) in ein digitales Signal überführt. Die Datenkommunikation erfolgt über ein 1-Wire-Interface, wodurch man am [[Mikrocontroller]] mit nur einen einzigen I/O-Pin auskommen kann. Außerdem beherrschen sie die parasitäre Stromversorgung, d.h. man braucht für Daten und Stromversorgung zusammen nur zwei Leitungen. Der DS18B20 hat 12 Bit Auflösung gegenüber 9 Bit Auflösung beim DS18S20.<br />
<br />
Vorteile:<br />
* bereits kalibriert<br />
* Genauigkeit +-0,5°<br />
* 1-Wire-Ausgang<br />
<br />
Nachteil:<br />
* ziemlich teuer (Reichelt 3,10&euro;)<br />
* bei http://shop.medhost.at/ für 3,24&euro; (2,70&euro;+20%UST) + Versand EU 6&euro;<br />
<br />
Vereinzelte Preise<br />
* DS 1822 ---> 3,50 bei Reichelt<br />
* ---> 5,08 bei Conrad<br />
<br />
<br />
Links:<br />
* [http://chaokhun.kmitl.ac.th/~kswichit/avrthermo/avrthermo.html Ein Schaltplan]<br />
* [http://www.mikrocontroller.net/forum/read-4-27035.html Code zur Ansteuerung]<br />
* [http://pdfserv.maxim-ic.com/en/ds/DS18S20.pdf Datenblatt DS18S20] <br />
* [http://pdfserv.maxim-ic.com/en/ds/DS18B20.pdf Datenblatt DS18B20]<br />
* [http://www.mikrocontroller.net/forum/read-4-248219.html Webserver zur Ansteuerung von bis zu 63 Bausteinen]<br />
<br />
=== DS1921 / DS1922 ===<br />
<br />
Sind wie die DS1821 1-wire-Sensoren mit zusätzlicher Logging-Funktion.<br />
Im iButton-Gehäuse befindet sich eine Lithium-Zelle, eine RTC, CMOS-RAM und der Temp-Sensor. Nach umfangreicher Progammierung startet der Button seine Mission (Aufzeichnung des Temperaturverlaufs).<br />
Gibt es auch mit zusätzlicher Feuchtemessung (DS1923).<br />
<br />
<br />
=== TSic ===<br />
<br />
Die TSic Sensoren werden gleich von 3 Herstellern angeboten (Die Sensoren sind aber alle baugleich):<br />
* ZMD<br />
* IST AG<br />
* Hygrosens<br />
<br />
Die TSic Sensoren geben ihre Temperaturmessdaten automatisch in einem festen Intervall aus. Daher muss der Host nur warten bis die nächsten Messdaten rausgeschickt werden. Die TSic Sensoren die es im freien Handel gibt, geben ihre Messdaten alle 100ms (10Hz) aus. <br />
Zur Übertragung wird das ZACwire Protokoll benutzt. Es handelt sich um eine einfach zwei Byte Übertragung per Manchester-Code. Diese zwei Byte repräsentieren den digital gewandelten Temperaturwert. Im Gegensatz zu Sensoren wie den DS18xxx von Dallas muss dieser Wert aber erst auf einen dezimalen Wert umgerechnet werden. <br />
Die Sensoren kommen mit 3 Pins aus (VCC, GND, Dout).<br />
<br />
Vorteile:<br />
* Bereits kalibriert<br />
* Verschiedene Genauigkeiten lieferbar<br />
* Sehr einfaches Kommunikationsprotokoll<br />
* Geringer Stromverbrauch<br />
* Hochgenau: bis zu +/- 0.1°C<br />
<br />
Nachteil:<br />
* Recht teuer (Conrad: 5,08&euro; für den TSic206)<br />
* Nur ein Sensor an einem I/O nutzbar (Kein Bussystem)<br />
<br />
Achtung! <br />
Die TSic Sensoren gibt es auch als Version mit analog Ausgang. Bei der Typenbezeichnung gibt die 3. Stelle an ob es sich um die analog- oder Digitalversion handelt (1 = analog, 6 = digital). <br />
Der TSic201 ist also analog, wärend der TSic206 ein digitaler ist.<br />
<br />
Links:<br />
* [http://www.mikrocontroller.net/topic/82087 Diskussion mit Beispielcode]<br />
<br /><br />
<br /><br />
<br />
=== SHT1x/SHT7x ===<br />
<br />
Der SHT1x/SHT7x (SHT10, SHT11, SHT15, STH71, SHT75) sind kombinierte Temperatur- und Feuchtesensoren von [http://www.sensirion.com Sensirion]. Sie unterscheiden sich in Bauform und Genauigkeit.<br />
<br />
Vorteile:<br />
* digitale Schnittstelle mit einfacher [[I²C]]-''ähnlicher'' Ansteuerung<br />
* keine Kalibrierung notwendig<br />
* Beispielcode (C, MC51) auf der Sensirion-Seite verfügbar (relativ leicht portierbar)<br />
* interne Heizelemente (Funktionsprüfung, "rauhe" Umgebung)<br />
* Spannungsmonitor ("Battery fail")<br />
<br />
Nachteile:<br />
* kann nicht am [[I²C]] Bus betrieben werden, theoretisch gleiche Clockleitung möglich, fixe Adresse<br />
* relativ teuer (Farnell 18,60&euro;)<br />
<br />
[[Category:Bauteile]]<br />
[[Category:Sensorik]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=31774Benutzer:Rotoe2008-10-10T17:44:40Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT bei K+S<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (10.10.08)<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=31773Benutzer:Rotoe2008-10-10T17:44:25Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung seit 01.09.08 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (10.10.08)<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=31772Benutzer:Rotoe2008-10-10T17:43:23Z<p>Rotoe: /* Wunschliste */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (10.10.08)<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
* Digitales Speicher Oszilloskop<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=31771Benutzer:Rotoe2008-10-10T17:42:50Z<p>Rotoe: </p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* STK600 (10.10.08)<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* Tablet PC<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=30873Benutzer:Rotoe2008-09-05T19:59:10Z<p>Rotoe: /* Bisher gebaute Sachen */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
<br />
== Bisher gebaute Sachen ==<br />
* NiCd/NiMh Ladegerät<br />
* RC-Multitester<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=30872Benutzer:Rotoe2008-09-05T19:58:23Z<p>Rotoe: /* Wunschliste */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=GPS-Maus_Falcom_Navi-S-1&diff=30057GPS-Maus Falcom Navi-S-12008-08-13T14:39:35Z<p>Rotoe: /* Firmwarewiederherstellung nach fehlgeschlagenem Update */</p>
<hr />
<div>Dieser Artikel wird noch ergänzt.<br />
<br />
== Technische Daten ==<br />
{| border="0"<br />
|-<br />
|Chipsatz:<br />
|SiRF2<br />
|-<br />
|Versorgungsspannung:<br />
|5V (3,5 bis 7V)<br />
|-<br />
|Schnittstelle:<br />
|Seriell, 3,3 Volt<br />
|}<br />
<br />
==== Anschlussbelegung ====<br />
Wenn man das angebrachte Kabel abmantelt, findet man vier Adern vor. Die Belegung ist wie folgt:<br />
{| border="0"<br />
|-<br />
|Gelb:<br />
|V<sub>cc</sub><br />
|-<br />
|Grün:<br />
|GND<br />
|-<br />
|Rot:<br />
|TX<br />
|-<br />
|Weiß:<br />
|RX<br />
|}<br />
<br />
== Software ==<br />
Um die Funktion und den Empfang der Module zu testen, ist das Programm SiRFDemo nützlich. Weiterhin kann man mit diesem Programm die Module konfigurieren.<br /> Firmwareupdates können mit dem Programm SiRFflash durchgeführt werden.<br />
<br />
== Standardeinstellungen ==<br />
Nach dem Einschalten werden folgende NMEA-Daten mit 38400 Baud ausgegeben: <br />
<pre><br />
$PSRFTXT,Version: 2.4.13.00-XTrac2.0.1-C3PROD1.0 0000003721 *17<br />
$PSRFTXT,TOW: 0*25<br />
$PSRFTXT,WK: 1255*66<br />
$PSRFTXT,POS: 6378137 0 0*2A<br />
$PSRFTXT,CLK: 96250*25<br />
$PSRFTXT,CHNL: 12*73<br />
$PSRFTXT,Baud rate: 38400 System clock: 24.553MHz*45<br />
</pre><br />
Danach folgen nur noch RMC-Nachrichten.<br />
<br />
== Features ==<br />
=== Schnittstelle ===<br />
Die GPS-Mäuse senden in der Ausgangskonfiguration Daten im SiRF-Binary Protokoll. Man kann die Module aber auch auf NMEA mit beliebigen Baudraten umstellen. Einstellbare Datensätze sind GPRMC, GPGGA, GPGSA, GPGSV, GPGLL, GPVTG und GPMSS. Die Umstellung kann über das Programm SiRFDemo erfolgen. Unter den Einstellungen sind auch die Datensätze User8, User9 und User10 aufgeführt. Beim JP7T versteckt sich hinter User9 der GPZDA-Datensatz.<br />
<br />
=== Power-Management ===<br />
Im Auslieferungszustand, also mit XTrac-Firmware, wird das Advanced Power Management von SiRF unterstützt. Damit sind Positionsraten von 10 bis 180 Sekunden möglich. Weiterhin kann man dem Modul vorgeben, wie viel % der Zeit es eingeschaltet sein soll, und ob die Positionsrate oder der Stromverbrauch Priorität besitzt.<br />
<br />
Die JP7T-Firmware dagegen bietet die Modi Trickle-Power und Push-to-Fix an. In Trickle-Power sind Positionsraten zwischen 1 und 10 Sekunden möglich. Im Modus Push-to-Fix schaltet das Modul sich in einen Energiespar-Modus, Positionsupdates können über den Pin "RESET_N" angefordert werden. Die GPS-Maus muss dazu natürlich aufgebrochen werden, um an das Modul dranzukommen... Laut Datenblatt lohnt sich Push-to-Fix erst ab einer Positionsraten von etwa 600 Sekunden.<br />
<br />
Die Befehle zum Einschalten der Energiespar-Modi sind im Datenblatt beschrieben. SiRFDemo ist dazu ebenfalls in der Lage.<br />
=== PPS-Timing ===<br />
Die XTrac-Firmware unterstützt offenbar keinerlei Timing-Funktionen. Um diese nutzen zu können, muss die JP7T- oder JP7TH-Firmware aufgespielt werden.<br />
==== SiRF Timing Message ====<br />
Kann in SiRFDemo über Action / Set Message Rate eingeschaltet werden. Dort 0x34 PPS Timing auswählen und die Update-Rate auf 1 Sekunde einstellen.<br />
==== GPZDA-Datensatz ====<br />
Kann ausgewählt werden, wenn man das Modul in den NMEA-Modus umschaltet. Verbirgt sich hinter "User9", nachdem man die JP7-T Firmware aufgespielt hat.<br />
<br />
==== 1-PPS-Puls ====<br />
Weiterhin ist beim JP7T der 1-PPS-Puls (1 PulsePerSecond) am GPS-Modul an Pin 29 abgreifbar. Laut Datenblatt hat der 1-PPS-Puls CMOS-Pegel und eine Länge von 100ms. Zeitreferenz ist die positive Flanke. Die Genauigkeit liegt unter 1µs im Vergleich zu einem Referenz PPS Puls.<br />
<br />
[[Bild:1PPSPulse.jpg]]<br />
<br />
== Firmware ==<br />
Die Firmware wird mit dem Programm SiRFflash (Download siehe Weblinks) auf das Modul aufgespielt. Einstellungen: "Baud rate" auf 38400 Baud verringern, "Target boot mode state setting" auf "External", "Programming options" auf "Erase whole chip". Dann per "Browse" die neue Firmware auswählen und mit "Execute" den Update-Prozess starten. Das Flashen funktioniert recht zuverlässig.<br />
=== JP7TX (XTrac) ===<br />
Im Auslieferungszustand befindet sich eine SiRF XTrac-Firmware auf dem Modul. Die Module mit dieser Firmware nennen sich JP7TX, einen Hardware-Unterschied zu JP7T-Modulen gibt es laut Falcom nicht.<br />
==== Erklärung XTrac ====<br />
[http://www.pocketgpsworld.com/xtracornoxtrac.php Hier] findet sich eine gute Erklärung der Unterschiede zwischen XTrac und normaler Firmware.<br />
<br />
Die wichtigsten sind:<br />
* XTrac ist viel empfindlicher<br />
* XTrac ist u.U. etwas langsamer<br />
* XTrac kennt keinen TricklePower-Modus<br />
=== JP7T ===<br />
Weiterhin ist eine Firmware für das JP7T vorhanden. Wenn man die Firmware aufspielt, werden beim ersten Start einige Debug-Meldungen ausgegeben. Teilweise verschwinden die von selbst, man kann sie aber auch über SiRFDemo abschalten. (Action / Set Message Rate, dort 0xFF auswählen, Rate auf 0s stehen lassen und "Send" klicken.) Die TTFF ist beim Cold Start etwas länger. Vereinzelt soll der Empfang damit besser als vorher sein.<br />
=== JP7TH ===<br />
Zusätzlich ist noch eine Firmware für Datenlogger vorhanden, genannt JP7TH. Die Firmware baut auf der des JP7T auf. Ein Handbuch dazu ist unter den Weblinks aufgeführt.<br />
<br />
Ein kleines Tool für die Filtereinstellungen und das Auslesen der gespeicherten GPS Punkte ist hier zu finden (.NET 2.0 ist Vorraussetzung, Programm noch im Alpha Stadium, voll funktionsfähig, aber nicht DAU sicher)<br />
<br />
[http://www.mikrocontroller.net/attachment/38432/Falcom_GPS_Logger_Settings.exe Nur das Programm]<br />
<br />
[http://www.mikrocontroller.net/attachment/38433/Falcom_GPS_Logger_Settings.zip komplett mit Sourcecode]<br />
<br />
=== Firmwarewiederherstellung nach fehlgeschlagenem Update ===<br />
Sollte nach einem Firmwareupdate das Modul nicht mehr reagieren (das Modul gibt weder Daten aus, noch ist es über SiRFFlash ansprechbar), kann man versuchen die Software mittels internen Bootloader des Moduls zu übertragen. Hierzu muss Pin 3 des Moduls (BOOT_SELECT)über einen Pull-Up-Widerstand (z.B. 1k) auf Vcc gezogen werden. Danach kann man mit SiRFFlash und der Einstellung ''Target boot mode state setting'' auf ''Internal'' die neue Firmware an das Modul übertragen (die restlichen Einstellungen sollten wie zuvor beschrieben gesetzt sein).<br />
<br />
== Hardware ==<br />
Im Modul befindet sich eine Patchantenne, darunter eine weitere Platine mit dem GPS-Modul Falcom JP7TX. <br />
<br />
=== Spannungsregler ===<br />
Das Modul wird über einen Linearregler [http://www.datasheetcatalog.org/datasheets/105/187365_DS.pdf MIC5205-3.3BM5] mit 3,3 Volt versorgt. Außerdem befindet sich noch ein kleiner Akku auf der Platine, der als Backup-Versorgung für das SRAM dient. <br />
Der Spannungsregler kann 150mA liefern, das GPS-Modul zieht ca. 60mA. Wenn man also ein Kabel an der 3.3V-Leitung anlötet kann man auch noch die eigene Schaltung damit versorgen. Aufpassen muss man lediglich mit der zulässigen Verlustleistung.<br />
<br />
Laut Datenblatt:<br><br />
<math>\theta_{JA} = 220 K/W</math><br><br />
mit <math>P = (U_{in}-U_{out}) * I</math><br><br />
und einer maximalen Chiptemperatur von 125°C und einer angenommen Umgebungstemperatur von 60°C (Sommer + Eigenerwärumg nach längerem Betrieb)<br><br />
ergibt sich somit folgender Maximalstrom in Abhängigkeit von der Eingangsspannung:<br><br />
<math>I_{max} =\frac{65 K}{220 K/W * (U_{in} - 3.3V)} = 0.3W / (U_{in} - 3.3V)</math><br />
<br />
Wertebeispiele:<br />
* 5V (USB): 174mA begrenzt durch die maximal erlaubten 150mA<br />
* 7V (Mitgelieferter Zigarettenanzünderstecker): 81mA<br />
* 12V: 30mA (zuwenig zum Betrieb des Moduls)<br />
<br />
Alternativ kann man wenn ohnehin 3.3V in der Schaltung zur Verfügung stehen auch einfach den Spannungsregler ausbauen und das Modul direkt mit 3.3V speisen.<br />
<br />
=== Pegelwandler ===<br />
<br />
<br />
Auf der Platine ist noch Platz für einen Pegelwandler; Ob ein Umbau auf RS232 damit funktioniert wurde bisher noch nicht getestet. Vorgesehen ist dafür ein ICL3221. Zum Umbau müssen vermutlich die beiden 0-Ohm-Widerstände entfernt werden, anschließend müssen dann zusätzlich zum IC noch an 5 Stellen 100nF-Kondensatoren eingelötet werden.<br />
<br />
== Weblinks ==<br />
*[http://www.mikrocontroller.net/topic/104240 ursprünglicher µC.net Thread >GPS - Empfänger günstig bei Ebay<]<br />
*[http://www.falcom.de/support/software-tools/sirf/ falcom.de Downloadbereich, SiRFDemo, SiRFflash]<br />
*[http://www.mikrocontroller.net/attachment/37464/komplett_-_aktuell_-_JP7.zip Zip-Archiv mit allen aktuellen Firmwares]<br />
*[http://www.falcom.de/uploads/media/JP7_T_Family_1.04.pdf Datenblatt des verwendeten GPS-Moduls]<br />
*[http://www.falcom.de/uploads/media/JP7-T_family_datalogger_functionality_v1.01.pdf Handbuch zur Datenlogger-Funktionalität]<br />
*[http://www.gpsinformation.org/dale/nmea.htm Verständliche Beschreibung des NMEA-Protokolls]<br />
*[http://gpsd.berlios.de/references.html Links zu jeder Menge nützlicher Dokumente, insbesondere der Protokollbeschreibung von SIRF]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=AVR-Tutorial:_LCD&diff=29879AVR-Tutorial: LCD2008-08-09T17:26:37Z<p>Rotoe: /* Anschluss an den Controller */</p>
<hr />
<div>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?"<br />
<br />
==Das LCD und sein Controller==<br />
<br />
Die meisten Text-LCDs verwenden den Controller [[HD44780|'''HD44780''']] oder einen kompatiblen (z.B. KS0070) und haben 14 oder 16 Pins. Die Pinbelegung ist praktisch immer gleich: <br />
<br />
<table width="0"><br />
<tr><th width="50" align="left">Pin #</th><th width="70" align="left">Bezeichnung</th><th align="left">Funktion</th></tr><br />
<tr><td>'''1'''</td><td>Vss</td><td>GND</td></tr> <br />
<tr><td>'''2'''</td><td>Vcc</td><td>5V</td></tr> <br />
<tr><td>'''3'''</td><td>Vee</td><td>Kontrastspannung (0V bis 5V)</td></tr> <br />
<tr><td>'''4'''</td><td>RS</td><td>Register Select (Befehle/Daten)</td></tr> <br />
<tr><td>'''5'''</td><td>RW</td><td>Read/Write</td></tr> <br />
<tr><td>'''6'''</td><td>E</td><td>Enable</td></tr> <br />
<tr><td>'''7'''</td><td>DB0</td><td>Datenbit 0</td></tr> <br />
<tr><td>'''8'''</td><td>DB1</td><td>Datenbit 1</td></tr> <br />
<tr><td>'''9'''</td><td>DB2</td><td>Datenbit 2</td></tr> <br />
<tr><td>'''10'''</td><td>DB3</td><td>Datenbit 3</td></tr> <br />
<tr><td>'''11'''</td><td>DB4</td><td>Datenbit 4</td></tr> <br />
<tr><td>'''12'''</td><td>DB5</td><td>Datenbit 5</td></tr> <br />
<tr><td>'''13'''</td><td>DB6</td><td>Datenbit 6</td></tr> <br />
<tr><td>'''14'''</td><td>DB7</td><td>Datenbit 7</td></tr> <br />
<tr><td>'''15'''</td><td>A</td><td>LED-Beleuchtung, Anode</td></tr><br />
<tr><td>'''16'''</td><td>K</td><td>LED-Beleuchtung, Kathode</td></tr><br />
</table><br />
<br />
Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist neben Pin 1 eine kleine 1 auf der LCD-Platine, ansonsten im Datenblatt nachschauen. <br />
<br />
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.<br />
<br />
Vss wird ganz einfach an GND angeschlossen und Vcc an 5V. Vee kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte muss man ein 10k-Potentiometer zwischen GND und 5V schalten, mit dem Schleifer an Vee: <br />
<br />
[[Bild:LCD_Vee.gif]]<br />
<br />
Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-Bit-''' und den '''4-Bit-'''Modus.<br />
* 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.<br />
* 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).<br />
<br />
Der 4-Bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-Bit-Modus, weshalb ich mich hier für eine Ansteuerung mit 4 Bit entschieden habe. <br />
<br />
Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' benötigt. <br />
<br />
* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Ist RS Low, dann wird das ankommende Byte als Befehl interpretiert. Ist RS high, dann wird das Byte auf dem LCD angezeigt. <br />
* '''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 vorsichtshalber ein paar Mikrosekunden 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.<br />
* 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.<br />
<br />
== Anschluss an den Controller ==<br />
<br />
Jetzt, da wir wissen, welche Anschlüsse das LCD benötigt, können wir das LCD mit dem Mikrocontroller verbinden: <br />
<br />
{| border="1"<br />
!Pinnummer<BR>LCD || Bezeichnung || Anschluss<br />
|-<br />
| align="center" |1 || Vss || GND<br />
|-<br />
| align="center" |2 || Vcc || 5V<br />
|-<br />
| align="center" |3 || Vee || GND oder [[Potentiometer | Poti]] <br />
|-<br />
| align="center" |4 || RS || PD4 am AVR<br />
|-<br />
| align="center" |5 || RW || GND <br />
|-<br />
| align="center" |6 || E || PD5 am AVR<br />
|-<br />
| align="center" |7 || DB0 || nicht angeschlossen <br />
|-<br />
| align="center" |8 || DB1 || nicht angeschlossen<br />
|-<br />
| align="center" |9 || DB2 || nicht angeschlossen<br />
|-<br />
| align="center" |10 || DB3 || nicht angeschlossen<br />
|-<br />
| align="center" |11 || DB4 || PD0 am AVR<br />
|-<br />
| align="center" |12 || DB5 || PD1 am AVR<br />
|-<br />
| align="center" |13 || DB6 || PD2 am AVR<br />
|-<br />
| align="center" |14 || DB7 || PD3 am AVR<br />
|-<br />
| align="center" |15 || A || Vorsicht! Meistens nicht direkt an +5V anschließbar,<BR>nur über einen Vorwiderstand (z.B. 330&Omega;)!<br />
|-<br />
| align="center" |16 || K || GND<br />
|}<br />
<br />
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?<br />
<br />
== Ansteuerung des LCDs im 4-Bit-Modus ==<br />
<br />
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: <br />
<br />
<avrasm><br />
swap r16 ; vertauscht die beiden Nibbles von r16<br />
</avrasm><br />
<br />
Aus 0b00100101 wird so z.B. 0b01010010. <br />
<br />
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 PORTB, 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: <br />
<br />
<avrasm><br />
andi r16, 0b00001111 ; Nur die vier unteren (mit 1 markierten)<br />
; Bits werden übernommen, alle anderen werden null<br />
</avrasm><br />
<br />
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. <br />
<br />
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: <br />
<br />
<avrasm><br />
sbr r16, 0b00010000 ; Bit 4 setzen, alle anderen Bits bleiben gleich<br />
</avrasm><br />
<br />
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. <br />
<br />
Das Ergebnis können wir jetzt endlich direkt an den Port D übergeben: <br />
<br />
<avrasm><br />
out PORTD, r16<br />
</avrasm><br />
<br />
Natürlich muss vorher der Port D auf Ausgang geschalten werden, indem man 0xFF ins Datenrichtungsregister DDRD schreibt. <br />
<br />
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: <br />
<br />
<avrasm><br />
sbi PORTD, 5 ; Enable high<br />
nop ; 3 Taktzyklen warten ("nop" = nichts tun)<br />
nop<br />
nop<br />
cbi PORTD, 5 ; Enable wieder low<br />
</avrasm><br />
<br />
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.<br />
<br />
== Initialisierung des Displays ==<br />
<br />
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.<br><br />
<br />
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.<br />
<br />
* [http://www.mikrocontroller.net/topic/79609#664268 (A) KS0066U oder Ähnliche --- LCD Treiber]<br />
<br />
=== Initialisierung im 4 Bit Modus ===<br />
<br />
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!<br />
<br />
Die Sequenz, aus Sicht des Kontrollers, sieht so aus:<br />
<br />
* 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<br />
* $3 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 4.1ms warten<br />
* $3 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 100µs warten<br />
* $3 ins Steuerregister schreiben (RS = 0)<br />
* $2 ins Steuerregister schreiben (RS = 0), dadurch wird auf 4 Bit Daten umstellt<br />
* 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<br />
* Mit dem Konfigurier-Befehl $20 das Display konfigurieren (4-Bit, 1 oder 2 Zeilen, 5x7 Format)<br />
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.<br />
<br />
=== Initialisierung im 8 Bit Modus ===<br />
<br />
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.<br />
<br />
* 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<br />
* $30 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 4.1ms warten<br />
* $30 ins Steuerregister schreiben (RS = 0)<br />
* Mindestens 100µs warten<br />
* $30 ins Steuerregister schreiben (RS = 0)<br />
* Mit dem Konfigurier-Befehl 0x30 das Display konfigurieren (8-Bit, 1 oder 2 Zeilen, 5x7 Format)<br />
* Mit den restlichen Konfigurierbefehlen die Konfiguration vervollständigen: Display ein/aus, Cursor ein/aus, etc.<br />
<br />
== Routinen zur LCD-Ansteuerung ==<br />
<br />
Die Routinen zur Kommunikation mit dem LCD sehen also so aus: <br />
<br />
<avrasm><br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
;; LCD-Routinen ;;<br />
;; ============ ;;<br />
;; (c)andreas-s@web.de ;;<br />
;; ;;<br />
;; 4bit-Interface ;;<br />
;; DB4-DB7: PD0-PD3 ;;<br />
;; RS: PD4 ;;<br />
;; E: PD5 ;;<br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
<br />
<br />
<br />
;sendet ein Datenbyte an das LCD<br />
lcd_data:<br />
mov temp2, temp1 ; "Sicherungskopie" für<br />
; die Übertragung des 2.Nibbles<br />
swap temp1 ; Vertauschen<br />
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen<br />
sbr temp1, 1<<4 ; entspricht 0b00010000 (Anm.1)<br />
out PORTD, temp1 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
; 2. Nibble, kein swap da es schon<br />
; an der richtigen stelle ist<br />
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen <br />
sbr temp2, 1<<4 ; entspricht 0b00010000<br />
out PORTD, temp2 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
rcall delay50us ; Delay-Routine aufrufen<br />
ret ; zurück zum Hauptprogramm<br />
<br />
; sendet einen Befehl an das LCD<br />
lcd_command: ; wie lcd_data, nur RS=0<br />
mov temp2, temp1<br />
swap temp1<br />
andi temp1, 0b00001111<br />
out PORTD, temp1<br />
rcall lcd_enable<br />
andi temp2, 0b00001111<br />
out PORTD, temp2<br />
rcall lcd_enable<br />
rcall delay50us<br />
ret<br />
<br />
; erzeugt den Enable-Puls<br />
;<br />
; Bei höherem Takt (>= 8 MHz) kann es notwendig sein, <br />
; vor dem Enable High 1-2 Wartetakte (nop) einzufügen. <br />
; Siehe dazu http://www.mikrocontroller.net/topic/81974#685882<br />
lcd_enable:<br />
sbi PORTD, 5 ; Enable high<br />
nop ; 3 Taktzyklen warten<br />
nop<br />
nop<br />
cbi PORTD, 5 ; Enable wieder low<br />
ret ; Und wieder zurück <br />
<br />
; Pause nach jeder Übertragung<br />
delay50us: ; 50us Pause<br />
ldi temp1, $42<br />
delay50us_:dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
<br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, $21<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
<br />
; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden<br />
lcd_init:<br />
ldi temp3,50<br />
powerupwait:<br />
rcall delay5ms<br />
dec temp3<br />
brne powerupwait<br />
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet<br />
out PORTD, temp1 ; werden zur Initialisierung<br />
rcall lcd_enable ; 1<br />
rcall delay5ms<br />
rcall lcd_enable ; 2<br />
rcall delay5ms<br />
rcall lcd_enable ; und 3!<br />
rcall delay5ms<br />
ldi temp1, 0b00000010 ; 4bit-Modus einstellen<br />
out PORTD, temp1<br />
rcall lcd_enable<br />
rcall delay5ms<br />
ldi temp1, 0b00101000 ; 4Bit / 2 Zeilen / 5x8<br />
rcall lcd_command<br />
ldi temp1, 0b00001100 ; Display ein / Cursor aus / kein Blinken<br />
rcall lcd_command<br />
ldi temp1, 0b00000100 ; inkrement / kein Scrollen<br />
rcall lcd_command<br />
ret<br />
<br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
<br />
; Sendet den Befehl: Cursor Home<br />
lcd_home:<br />
ldi temp1, 0b00000010 ; Cursor Home<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
</avrasm><br />
<br />
Anm.1: Siehe [[Bitmanipulation]]<br />
<br />
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. <br />
<br />
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. <br />
<br />
Wer eine höhere Taktfrequenz als 4 MHz verwendet, der sollte daran denken, die Dauer der Verzögerungsschleifen anzupassen.<br />
<br />
==Anwendung==<br />
<br />
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. <br />
<br />
[http://www.mikrocontroller.net/sourcecode/tutorial/lcd-test.asm Download lcd-test.asm] <br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp1 = r16<br />
.def temp2 = r17<br />
.def temp3 = r18<br />
<br />
<br />
ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse<br />
out SPL, temp1<br />
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse<br />
out SPH, temp1<br />
<br />
ldi temp1, 0xFF ; Port D = Ausgang<br />
out DDRD, temp1<br />
<br />
rcall lcd_init ; Display initialisieren<br />
rcall lcd_clear ; Display löschen<br />
<br />
ldi temp1, 'T' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
ldi temp1, 'e' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
ldi temp1, 's' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
ldi temp1, 't' ; Zeichen anzeigen<br />
rcall lcd_data<br />
<br />
loop:<br />
rjmp loop<br />
<br />
.include "lcd-routines.asm" ; LCD-Routinen werden hier eingefügt<br />
</avrasm><br />
<br />
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.<br />
<br />
Bisher wurden in Register immer irgendwelche Zahlenwerte geladen, aber in diesem Programm kommt plötzlich die Anweisung<br />
<avrasm><br />
ldi temp1, 'T'<br />
</avrasm><br />
vor. Wie ist diese zu verstehen? Passiert hier etwas grundlegend anderes als beim Laden einer Zahl in ein Register?<br />
<br />
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.<br />
<br />
==ASCII==<br />
<br />
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:<br />
<br />
<table><br />
<tr><br />
<th></th><th>.0</th><th>x1</th><th>x2</th><th>x3</th><th>x4</th><th>x5</th><th>x6</th><th>x7</th><th>x8</th><th>x9</th><th>xA</th><th>xB</th><th>xC</th><th>xD</th><th>xE</th><th>xF</th><br><br />
</tr><br />
<tr><br />
<td>'''0x'''</td><td>NUL</td><td>SOH</td><td>STX</td><td>ETX</td><td>EOT</td><td>ENQ</td><td>ACK</td><td>BEL</td><td>BS</td><td>HT</td><td>LF</td><td>VT</td><td>FF</td><td>CR</td><td>SO</td><td>SI</td><br />
</tr><br />
<tr><br />
<td>'''1x'''</td><td>DLE</td><td>DC1</td><td>DC2</td><td>DC3</td><td>DC4</td><td>NAK</td><td>SYN</td><td>ETB</td><td>CAN</td><td>EM</td><td>SUB</td><td>ESC</td><td>FS</td><td>GS</td><td>RS</td><td>US</td><br />
</tr><br />
<tr><br />
<td>'''2x'''</td><td>SP</td><td>!</td><td>"</td><td>#</td><td>$</td><td>%</td><td>&</td><td>'</td><td>(</td><td>)</td><td>*</td><td>+</td><td>,</td><td>-</td><td>.</td><td>/</td><br />
</tr><br />
<tr><br />
<td>'''3x'''</td><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>:</td><td>;</td><td><</td><td>=</td><td>></td><td>?</td><br />
</tr><br />
<tr><br />
<td>'''4x'''</td><td>@</td><td>A</td><td>B</td><td>C</td><td>D</td><td>E</td><td>F</td><td>G</td><td>H</td><td>I</td><td>J</td><td>K</td><td>L</td><td>M</td><td>N</td><td>O</td><br />
</tr><br />
<tr><br />
<td>'''5x'''</td><td>P</td><td>Q</td><td>R</td><td>S</td><td>T</td><td>U</td><td>V</td><td>W</td><td>X</td><td>Y</td><td>Z</td><td>[</td><td>\</td><td>]</td><td>^</td><td>_</td><br />
</tr><br />
<tr><br />
<td>'''6x'''</td><td>`</td><td>a</td><td>b</td><td>c</td><td>d</td><td>e</td><td>f</td><td>g</td><td>h</td><td>i</td><td>j</td><td>k</td><td>l</td><td>m</td><td>n</td><td>o</td><br />
</tr><br />
<tr><br />
<td>'''7x'''</td><td>p</td><td>q</td><td>r</td><td>s</td><td>t</td><td>u</td><td>v</td><td>w</td><td>x</td><td>y</td><td>z</td><td>{</td><td>|</td><td>}</td><td>~</td><td>DEL</td><br />
</tr><br />
</table><br />
<br />
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.<br />
<br />
Der Assembler kennt diese Codetabelle und ersetzt die Zeile<br />
<br />
<avrasm><br />
ldi temp1, 'T'<br />
</avrasm><br />
<br />
durch<br />
<br />
<avrasm><br />
ldi temp1, $54<br />
</avrasm><br />
<br />
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.<br />
<br />
<br />
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.<br />
<br />
==Welche Befehle versteht das LCD?==<br />
<br />
Auf dem LCD arbeitet ein Kontroller 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:<br />
<table><br />
<tr><td>0</td><td>dieses Bit muss 0 sein</td></tr><br />
<tr><td>1</td><td>dieses Bit muss 1 sein</td></tr><br />
<tr><td>x</td><td>der Zustand dieses Bits ist egal</td></tr><br />
<tr><td>sonstige Buchstaben</td><td>das Bit muss je nach gewünschter Funktionalität gesetzt werden. Die mögliche Funktionalität des jeweiligen Bits geht aus der Befehlsbeschreibung hervor</td></tr><br />
</table><br />
<br />
Beispiel: Das Kommando 'ON/OFF Control' soll benutzt werden, um das Display einzuschalten, der Cursor soll eingeschaltet werden und der Cursor soll blinken.<br />
Das Befehlsbyte ist so aufgebaut:<br />
0b00001dcb<br />
Aus der Befehlsbeschreibung entnimmt man:<br />
* Display ein bedeutet, dass an der Bitposition d eine 1 stehen muss.<br><br />
* Cursor ein bedeutet, dass an der Bitposition c ein 1 stehen muss.<br><br />
* Cursor blinken bedeutet, dass an der Bitposition b eine 1 stehen muss.<br><br />
Das dafür zu übertragende Befehlsbyte hat also die Gestalt 0b00001111 oder in hexadezimaler Schreibweise $0F.<br />
<br />
===Clear display: 0b00000001===<br />
<br />
Die Anzeige wird gelöscht und der Ausgabecursor kehrt an die Home Position (links, erste Zeile) zurück.<br />
<br />
Ausführungszeit: 1.64ms<br />
<br />
===Cursor home: 0b0000001x===<br />
<br />
Der Cursor kehrt an die Home Position (links, erste Zeile) zurück. Ein verschobenes Display wird auf die Grundeinstellung zurückgesetzt.<br />
<br />
Ausführungszeit: 40µs bis 1.64ms<br />
<br />
===Entry mode: 0b000001is===<br />
<br />
Legt die Cursor Richtung sowie eine mögliche Verschiebung des Displays fest<br />
* i = 1, Cursorposition bei Ausgabe eines Zeichens erhöhen<br />
* i = 0, Cursorposition bei Ausgabe eines Zeichens vermindern<br />
* s = 1, Display wird gescrollt, wenn der Cursor das Ende/Anfang, je nach Einstellung von i, erreicht hat.<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===On/off control: 0b00001dcb===<br />
<br />
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.<br />
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.<br />
<br />
* d = 0, Display aus<br />
* d = 1, Display ein<br />
* c = 0, Cursor aus<br />
* c = 1, Cursor ein<br />
* b = 0, Cursor blinken aus<br />
* b = 1, Cursor blinken ein<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Cursor/Scrollen: 0b0001srxx===<br />
<br />
Bewegt den Cursor oder scrollt das Display um eine Position entweder nach rechts oder nach links.<br />
<br />
* s = 1, Display scrollen<br />
* s = 0, Cursor bewegen<br />
* r = 1, nach rechts<br />
* r = 0, nach links <br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Konfiguration: 0b001dnfxx===<br />
<br />
Einstellen der Interface Art, Modus, Font<br />
* d = 0, 4-Bit Interface<br />
* d = 1, 8-Bit Interface<br />
* n = 0, 1 zeilig<br />
* n = 1, 2 zeilig<br />
* f = 0, 5x7 Pixel<br />
* f = 1, 5x11 Pixel<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Character RAM Address Set: 0b01aaaaaa===<br />
<br />
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 Pixelzeile (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.<br />
<br />
aaaaaa 6-bit CG RAM Adresse<br />
<br />
Ausführungszeit: 40µs<br />
<br />
===Display RAM Address Set: 0b1aaaaaaa===<br />
<br />
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 32 logischen Zeichen besteht, von der, je nach konkretem Displaytyp (16 Zeichen, 20 Zeichen) immer nur ein Teil sichtbar ist.<br />
<br />
aaaaaaa 7-bit DD RAM Adresse. Auf 2-zeiligen Displays (und den meisten 16x1 Displays), kann die Adressangabe wie folgt interpretiert werden:<br />
<br />
1laaaaaa<br />
* l = Zeilennummer (0 oder 1)<br />
* a = 6-Bit Spaltennummer<br />
<br />
--------------------------------<br />
<br />
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0<br />
--- --- --- --- --- --- --- --- --- ---<br />
0 0 1 A A A A A A A <br />
<br />
Setzt die DDRAM Adresse:<br />
<br />
Wenn N = 0 (1 line display)<br />
AAAAAAA = "00h" - "4Fh"<br />
<br />
Wenn N = 1 (2 line display) ((1x16))<br />
AAAAAAA = "00h" - "27h" Zeile 1. (0x80) <br />
AAAAAAA = "40h" - "67h" Zeile 2. (0xC0)<br />
<br />
<br />
Ausführungszeit: 40µs<br />
<br />
==Einschub: Code aufräumen==<br />
<br />
Es wird Zeit, sich einmal etwas kritisch mit den bisher geschriebenen Funktionen auseinander zu setzen.<br />
<br />
===Portnamen aus dem Code herausziehen===<br />
<br />
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.<br />
<br />
Eine Möglichkeit, dem vorzubeugen, ist es, diese immer gleichbleibenden Dinge an den Anfang der LCD-Funktionen vorzuziehen:<br />
<br />
<avrasm><br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
;; LCD-Routinen ;;<br />
;; ============ ;;<br />
;; (c)andreas-s@web.de ;;<br />
;; ;;<br />
;; 4bit-Interface ;;<br />
;; DB4-DB7: PD0-PD3 ;;<br />
;; RS: PD4 ;;<br />
;; E: PD5 ;;<br />
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<br />
<br />
<br />
.equ LCD_PORT = PORTD<br />
.equ LCD_DDR = DDRD<br />
.equ PIN_E = 5<br />
.equ PIN_RS = 4<br />
<br />
;sendet ein Datenbyte an das LCD<br />
lcd_data:<br />
mov temp2, temp1 ; "Sicherungskopie" für<br />
; die Übertragung des 2.Nibbles<br />
swap temp1 ; Vertauschen<br />
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen<br />
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp1 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
; 2. Nibble, kein swap da es schon<br />
; an der richtigen stelle ist<br />
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen <br />
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp2 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
rcall delay50us ; Delay-Routine aufrufen<br />
ret ; zurück zum Hauptprogramm<br />
<br />
<br />
; sendet einen Befehl an das LCD<br />
<br />
lcd_command: ; wie lcd_data, nur RS=0<br />
mov temp2, temp1<br />
swap temp1<br />
andi temp1, 0b00001111<br />
out LCD_PORT, temp1<br />
rcall lcd_enable<br />
andi temp2, 0b00001111<br />
out LCD_PORT, temp2<br />
rcall lcd_enable<br />
rcall delay50us<br />
ret<br />
<br />
; erzeugt den Enable-Puls<br />
lcd_enable:<br />
sbi LCD_PORT, PIN_E ; Enable high<br />
nop ; 3 Taktzyklen warten<br />
nop<br />
nop<br />
cbi LCD_PORT, PIN_E ; Enable wieder low<br />
ret ; Und wieder zurück <br />
<br />
; Pause nach jeder Übertragung<br />
delay50us: ; 50us Pause<br />
ldi temp1, $42<br />
delay50us_:dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
<br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, $21<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
<br />
; Initialisierung: muss ganz am Anfang des Programms aufgerufen werden<br />
lcd_init:<br />
ldi temp1, 0xFF ; alle Pins am Ausgabeport auf Ausgang<br />
out LCD_DDR, temp1<br />
<br />
ldi temp3,6<br />
powerupwait:<br />
rcall delay5ms<br />
dec temp3<br />
brne powerupwait<br />
ldi temp1, 0b00000011 ; muss 3mal hintereinander gesendet<br />
out LCD_PORT, temp1 ; werden zur Initialisierung<br />
rcall lcd_enable ; 1<br />
rcall delay5ms<br />
rcall lcd_enable ; 2<br />
rcall delay5ms<br />
rcall lcd_enable ; und 3!<br />
rcall delay5ms<br />
ldi temp1, 0b00000010 ; 4bit-Modus einstellen<br />
out LCD_PORT, temp1<br />
rcall lcd_enable<br />
rcall delay5ms<br />
ldi temp1, 0b00101000 ; 4 Bot, 2 Zeilen<br />
rcall lcd_command<br />
ldi temp1, 0b00001100 ; Display on, Cursor off<br />
rcall lcd_command<br />
ldi temp1, 0b00000100 ; endlich fertig<br />
rcall lcd_command<br />
ret<br />
<br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
<br />
; Sendet den Befehl: Cursor Home<br />
lcd_home:<br />
ldi temp1, 0b00000010 ; Cursor Home<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
</avrasm><br />
<br />
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<br />
<avrasm><br />
.equ LCD_PORT = PORTD<br />
.equ LCD_DDR = DDRD<br />
</avrasm><br />
durch<br />
<avrasm><br />
.equ LCD_PORT = PORTB<br />
.equ LCD_DDR = DDRB<br />
</avrasm><br />
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.<br />
<br />
===Registerbenutzung===<br />
<br />
Bei diesen Funktionen mussten einige Register des Prozessors benutzt werden, um darin Zwischenergebnisse zu speichern bzw. zu bearbeiten.<br />
<br />
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.<br />
<br />
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.<br />
<br />
Nehmen wir die Funktion<br />
<avrasm><br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
ret<br />
</avrasm><br />
<br />
Diese Funktion verändert das Register temp1. Um das Register abzusichern, schreiben wir die Funktion um:<br />
<br />
<avrasm><br />
; Sendet den Befehl zur Löschung des Displays<br />
lcd_clear:<br />
push temp1 ; temp1 auf dem Stack sichern<br />
ldi temp1, 0b00000001 ; Display löschen<br />
rcall lcd_command<br />
rcall delay5ms<br />
pop temp1 ; temp1 vom Stack wiederherstellen<br />
ret<br />
</avrasm><br />
<br />
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.<br />
<br />
===Lass den Assembler rechnen===<br />
Betrachtet man den Code genauer, so fallen einige konstante Zahlenwerte auf (Das vorangestellte $ kennzeichnet die Zahl als Hexadezimalzahl):<br />
<br />
<avrasm><br />
delay50us: ; 50us Pause<br />
ldi temp1, $42<br />
delay50us_:<br />
dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
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.<br />
<br />
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 <i>XTAL</i>:<br />
<br />
<avrasm><br />
.equ XTAL = 4000000<br />
<br />
...<br />
<br />
delay50us: ; 50us Pause<br />
ldi temp1, ( XTAL * 50 / 3 ) / 1000000<br />
delay50us_:<br />
dec temp1<br />
brne delay50us_<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
An einer anderen Codestelle gibt es weitere derartige magische Zahlen:<br />
<br />
<avrasm><br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, $21<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
Was geht hier vor?<br />
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.<br />
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:<br />
<br />
<avrasm><br />
; Längere Pause für manche Befehle<br />
delay5ms: ; 5ms Pause<br />
ldi temp1, ( XTAL * 5 / 607 ) / 1000<br />
WGLOOP0: ldi temp2, $C9<br />
WGLOOP1: dec temp2<br />
brne WGLOOP1<br />
dec temp1<br />
brne WGLOOP0<br />
ret ; wieder zurück<br />
</avrasm><br />
<br />
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.<br />
<br />
== Ausgabe eines konstanten Textes ==<br />
<br />
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 holt und ausgibt. Dabei erhebt sich aber eine Fragestellung: Woher weiß die Funktion eigentlich, wie lange 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:<br />
* Der Text enthält ein spezielles Zeichen, welches das Ende des Textes markiert<br />
* Wir speichern nicht nur den Text selbst, sondern auch die Länge des Textes<br />
Mit einer der beiden Methoden ist es der Textausgabefunktion dann ein Leichtes, den Text vollständig auszugeben.<br />
<br />
Wir werden uns im Weiteren dafür entscheiden, ein spezielles Zeichen, eine 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.<br />
<br />
Den Text selbst speichern wir im Flash-Speicher, also dort, wo auch das Programm gespeichert ist:<br />
<br />
<avrasm><br />
; Einen konstanten Text aus dem Flash Speicher<br />
; ausgeben. Der Text wird mit einer 0 beendet<br />
lcd_flash_string:<br />
push temp1<br />
<br />
lcd_flash_string_1:<br />
lpm temp1, Z+<br />
cpi temp1, 0<br />
breq lcd_flash_string_2<br />
rcall lcd_data<br />
rjmp lcd_flash_string_1<br />
<br />
lcd_flash_string_2:<br />
pop temp1<br />
ret<br />
</avrasm><br />
<br />
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<br />
<avrasm><br />
lpm temp1, Z+<br />
</avrasm><br />
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<br />
<avrasm><br />
cpi temp1, 0<br />
breq lcd_flash_string_2<br />
</avrasm><br />
dass das gelesene Zeichen mit 0 verglichen wird und falls das gelesene<br />
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.<br />
<br />
Das verwendende Programm sieht dann so aus:<br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
.def temp1 = r16<br />
.def temp2 = r17<br />
.def temp3 = r18<br />
<br />
<br />
ldi temp1, LOW(RAMEND) ; LOW-Byte der obersten RAM-Adresse<br />
out SPL, temp1<br />
ldi temp1, HIGH(RAMEND) ; HIGH-Byte der obersten RAM-Adresse<br />
out SPH, temp1<br />
<br />
rcall lcd_init ; Display initialisieren<br />
rcall lcd_clear ; Display löschen<br />
<br />
ldi ZL, LOW(text*2) ; Adresse des Strings in den<br />
ldi ZH, HIGH(text*2) ; Z-Pointer laden<br />
<br />
rcall lcd_flash_string ; Unterprogramm gibt String aus der<br />
; durch den Z-Pointer adressiert wird<br />
loop:<br />
rjmp loop<br />
<br />
text:<br />
.db "Test",0 ; Stringkonstante, durch eine 0<br />
; abgeschlossen <br />
<br />
.include "lcd-routines.asm" ; LCD Funktionen<br />
</avrasm><br />
<br />
Genaueres über die Verwendung unterschiedlicher Speicher findet sich im Kapitel [[AVR-Tutorial:_Speicher|Speicher]]<br />
<br />
==Zahlen ausgeben==<br />
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.<br />
<br />
===Dezimal ausgeben===<br />
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.<br />
Also muss eine '1' ausgeben werden. Die verbleibenden 23 werden weiterbehandelt, indem festgestellt wird wieviele Zehner darin enthalten sind. Auch hier wiederrum: In einer Schleife solange 10 abziehen, bis das Ergebnis nagativ 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.<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 8 Bit Zahl ohne Vorzeichen ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp1<br />
; veränderte Register: keine<br />
;<br />
lcd_number:<br />
push temp2 ; die Funktion verändert temp2, also sichern<br />
; wir den Inhalt, um ihn am Ende wieder<br />
; herstellen zu können<br />
<br />
mov temp2, temp1 ; das Register temp1 frei machen<br />
; abzählen wieviele Hunderter<br />
; in der Zahl enthalten sind<br />
ldi temp1, '0'<br />
lcd_number_1:<br />
subi temp2, 100 ; 100 abziehen<br />
brcs lcd_number_2 ; ist dadurch ein Unterlauf entstanden?<br />
inc temp1 ; Nein: 1 Hunderter mehr ...<br />
rjmp lcd_number_1 ; ... und ab zur nächsten Runde<br />
;<br />
; die Hunderterstelle ausgeben<br />
lcd_number_2:<br />
rcall lcd_data<br />
subi temp2, -100 ; 100 wieder dazuzählen, da die<br />
; vorherhgehende Schleife 100 zuviel<br />
; abgezogen hat<br />
<br />
; abzählen wieviele Zehner in<br />
; der Zahl enthalten sind<br />
ldi temp1, '0'<br />
lcd_number_3:<br />
subi temp2, 10 ; 10 abziehen<br />
brcs lcd_number_4 ; ist dadurch ein Unterlauf enstanden?<br />
inc temp1 ; Nein: 1 Zehner mehr ...<br />
rjmp lcd_number_3 ; ... und ab zur nächsten Runde<br />
<br />
; die Zehnerstelle ausgeben<br />
lcd_number_4:<br />
rcall lcd_data<br />
subi temp2, -10 ; 10 wieder dazuzählen, da die<br />
; vorhergehende Schleife 10 zuviel<br />
; abgezogen hat<br />
<br />
; die übrig gebliebenen Einer<br />
; noch ausgeben<br />
ldi temp1, '0' ; die Zahl in temp2 ist jetzt im Bereich<br />
add temp1, temp2 ; 0 bis 9. Einfach nur den ASCII Code für<br />
rcall lcd_data ; '0' dazu addieren und wir erhalten dierekt<br />
; den ASCII Code für die Ziffer<br />
<br />
pop temp2 ; den gesicherten Inhalt von temp2 wieder herstellen<br />
ret ; und zurück<br />
</avrasm><br />
<br />
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:<br />
<br />
<avrasm><br />
;sendet ein Datenbyte an das LCD<br />
lcd_data:<br />
push temp2<br />
mov temp2, temp1 ; "Sicherungskopie" für<br />
; die Übertragung des 2.Nibbles<br />
swap temp1 ; Vertauschen<br />
andi temp1, 0b00001111 ; oberes Nibble auf Null setzen<br />
sbr temp1, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp1 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
; 2. Nibble, kein swap da es schon<br />
; an der richtigen stelle ist<br />
andi temp2, 0b00001111 ; obere Hälfte auf Null setzen <br />
sbr temp2, 1<<PIN_RS ; entspricht 0b00010000<br />
out LCD_PORT, temp2 ; ausgeben<br />
rcall lcd_enable ; Enable-Routine aufrufen<br />
rcall delay50us ; Delay-Routine aufrufen<br />
pop temp2<br />
ret ; zurück zum Hauptprogramm<br />
<br />
; sendet einen Befehl an das LCD<br />
lcd_command: ; wie lcd_data, nur ohne RS zu setzen<br />
push temp2<br />
mov temp2, temp1<br />
swap temp1<br />
andi temp1, 0b00001111<br />
out LCD_PORT, temp1<br />
rcall lcd_enable<br />
andi temp2, 0b00001111<br />
out LCD_PORT, temp2<br />
rcall lcd_enable<br />
rcall delay50us<br />
pop temp2<br />
ret<br />
</avrasm><br />
<br />
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.<br />
<br />
===Unterdrückung von führenden Nullen===<br />
<br />
'''Achtung: Diese Routine ist fehlerhaft'''<br />
<br />
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 bzw. Zehnerstelle muss lediglich überprüft werden, ob die Entsprechende Ausgabe eine '0' wäre. Ist sie das, so wird die Ausgabe übersprungen. Lediglich in der Einerstelle wird jede Ziffer wie errechnet ausgegeben.<br />
<br />
<avrasm><br />
...<br />
; die Hunderterstelle ausgeben, wenn<br />
; sie nicht '0' ist<br />
lcd_number_2:<br />
cpi temp1, '0'<br />
breq lcd_number_2a<br />
rcall lcd_data<br />
lcd_number_2a:<br />
subi temp2, -100 ; 100 wieder dazuzählen, da die<br />
...<br />
<br />
...<br />
; die Zehnerstelle ausgeben, wenn<br />
; sie nicht '0' ist<br />
lcd_number_4:<br />
cpi temp1, '0'<br />
breq lcd_number_4a<br />
rcall lcd_data<br />
lcd_number_4a:<br />
subi temp2, -10 ; 10 wieder dazuzählen, da die<br />
...<br />
</avrasm><br />
<br />
<br />
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)<br />
<br />
<pre><br />
52783 / 10 -> 5278<br />
52783 - 5278 * 10 -> 3<br />
<br />
5278 / 10 -> 527<br />
5278 - 527 * 10 -> 8<br />
<br />
527 / 10 -> 52<br />
527 - 52 * 10 -> 7<br />
<br />
52 / 10 -> 5<br />
52 - 5 * 10 -> 2<br />
<br />
5 / 10 -> 0<br />
5 - 0 * 10 -> 5<br />
</pre><br />
<br />
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).<br />
<br />
===Hexadezimal ausgeben===<br />
<br />
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.<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 8 Bit Zahl ohne Vorzeichen hexadezimal ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp1<br />
; veränderte Register: keine<br />
;<br />
lcd_number_hex:<br />
swap temp1<br />
rcall lcd_number_hex_digit<br />
swap temp1<br />
<br />
lcd_number_hex_digit:<br />
push temp1<br />
<br />
andi temp1, $0F<br />
cpi temp1, 10<br />
brlt lcd_number_hex_digit_1<br />
subi temp1, -( 'A' - '9' - 1 ) ; es wird subi mit negativer Konstante verwendet, weil es kein addi gibt<br />
lcd_number_hex_digit_1:<br />
subi temp1, -'0' ; ditto<br />
rcall lcd_data<br />
<br />
pop temp1<br />
ret<br />
</avrasm><br />
<br />
===Binär ausgeben===<br />
Um die Sache komplett zu machen; Hier eine Routine mit der man eine 8 Bit-Zahl binär auf das LC-Display ausgeben kann:<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 8 Bit Zahl ohne Vorzeichen binär ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp1<br />
; veränderte Register: keine<br />
<br />
; eine Zahl aus dem Register temp1 binär ausgeben<br />
lcd_number_bit:<br />
push temp1 ; temp1 gesichert<br />
in temp1, SREG; <br />
push temp1 ; SREG gesichert<br />
push temp2<br />
push temp3<br />
<br />
mov temp2, temp1; <br />
ldi temp3, 8; ; 8 Bits werden ausgelesen<br />
lcd_number_loop: <br />
dec temp3;<br />
rol temp2; ; Datenbits ins Carry geschoben ...<br />
brcc lcd_number_bit_carryset_0; <br />
brcs lcd_number_bit_carryset_1;<br />
rjmp lcd_number_loop;<br />
<br />
lcd_number_bit_carryset_0: <br />
ldi temp1, '0' ; Bit low ausgeben<br />
rcall lcd_data<br />
tst temp3;<br />
breq lcd_number_ende;<br />
rjmp lcd_number_loop;<br />
<br />
lcd_number_bit_carryset_1:<br />
ldi temp1, '1' ; Bit high ausgeben<br />
rcall lcd_data<br />
tst temp3;<br />
breq lcd_number_ende;<br />
rjmp lcd_number_loop;<br />
<br />
lcd_number_ende:<br />
pop temp3<br />
pop temp2<br />
pop temp1<br />
out SREG, temp1;<br />
pop temp1<br />
ret<br />
</avrasm><br />
<br />
===Eine 16-Bit Zahl aus einem Registerpärchen ausgeben===<br />
<br />
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.<br />
<br />
<avrasm><br />
;**********************************************************************<br />
;<br />
; Eine 16 Bit Zahl ohne Vorzeichen ausgeben<br />
;<br />
; Übergabe: Zahl im Register temp2 (low Byte) / temp3 (high Byte)<br />
; veränderte Register: keine<br />
;<br />
lcd_number16:<br />
push temp1<br />
push temp2<br />
push temp3<br />
<br />
; die Zehntausenderstellen abzählen ...<br />
ldi temp1, '0'<br />
lcd_number0:<br />
subi temp2, low(10000)<br />
sbci temp3, high(10000)<br />
brcs lcd_number1<br />
inc temp1<br />
rjmp lcd_number0<br />
<br />
; .. und ausgeben<br />
lcd_number1:<br />
rcall lcd_data<br />
subi temp2, low(-10000)<br />
sbci temp3, high(-10000)<br />
<br />
; die Tausenderstellen abzählen ...<br />
ldi temp1, '0'<br />
lcd_number2:<br />
subi temp2, low(1000)<br />
sbci temp3, high(1000)<br />
brcs lcd_number3<br />
inc temp1<br />
rjmp lcd_number2<br />
<br />
; ... und ausgeben<br />
lcd_number3:<br />
rcall lcd_data<br />
subi temp2, low(-1000)<br />
sbci temp3, high(-1000)<br />
<br />
; Als nächtes kommt die Hunderterstelle drann<br />
ldi temp1, '0'<br />
lcd_number4:<br />
subi temp2, low(100)<br />
sbci temp3, high(100)<br />
brcs lcd_number5<br />
inc temp1<br />
rjmp lcd_number4<br />
<br />
; und ausgeben<br />
lcd_number5:<br />
rcall lcd_data<br />
subi temp2, -100<br />
<br />
; bleiben noch die Zehner<br />
ldi temp1, '0'<br />
lcd_number6:<br />
subi temp2, 10<br />
brcs lcd_number7<br />
inc temp1<br />
rjmp lcd_number6<br />
<br />
; ausgeben ...<br />
lcd_number7:<br />
rcall lcd_data<br />
subi temp2, -10<br />
<br />
ldi temp1, '0'<br />
add temp1, temp2<br />
rcall lcd_data<br />
<br />
; fertig. Stack wieder aufräumen<br />
pop temp1<br />
pop temp2<br />
pop temp3<br />
<br />
ret<br />
</avrasm><br />
<br />
==Der überarbeitete, komplette Code==<br />
<br />
Hier also die komplett überarbeitete Version der LCD Funktionen.<br />
<br />
Die für die Benutzung relevanten Funktionen<br />
* '''lcd_init'''<br />
* '''lcd_clear'''<br />
* '''lcd_home'''<br />
* '''lcd_data'''<br />
* '''lcd_command'''<br />
* '''lcd_flash_string'''<br />
* '''lcd_number'''<br />
* '''lcd_number_hex'''<br />
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.<br />
<br />
[[Media:lcd-routines.asm|Download lcd-routines.asm]]<br />
<br />
<br />
<br />
{{Navigation_zurückhochvor|<br />
zurücktext=Stack|<br />
zurücklink=AVR-Tutorial: Stack|<br />
hochtext=Inhaltsverzeichnis|<br />
hochlink=AVR-Tutorial|<br />
vortext=Interrupts|<br />
vorlink=AVR-Tutorial: Interrupts}}<br />
<br />
[[Category:AVR]][[Category:AVR-Tutorial]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=AVR-Tutorial:_IO-Grundlagen&diff=29864AVR-Tutorial: IO-Grundlagen2008-08-09T12:28:17Z<p>Rotoe: /* Programmerklärung */</p>
<hr />
<div>== Hardware ==<br />
Für die ersten Versuche braucht man nur ein paar Taster und [[LED]]s an die IO-Ports des AVRs anzuschließen. An '''PB0-PB5''' schließt man 6 LEDs über einen Vorwiderstand von je 1 kΩ gegen Vcc (5V) an. In der Praxis ist es unerheblich, ob der Widerstand vor oder nach der Diode liegt, wichtig ist nur, dass er da ist. Weitere Details zu LEDs und entsprechenden Vorwiderständen findet ihr im Artikel über [[LED]]s und in diesem [http://www.mikrocontroller.net/topic/66109 Thread im Forum].<br />
<br />
http://www.mikrocontroller.net/images/led.gif<br />
<br />
Dass die LEDs an den gleichen Pins wie der ISP-Programmer angeschlossen sind, stört übrigens normalerweise nicht. Falls wider Erwarten deshalb Probleme auftreten sollten, kann man versuchen, den Vorwiderstand der LEDs zu vergrößern.<br />
<br />
An '''PD0-PD3''' kommen 4 Taster mit je einem 10 kΩ Pullup-Widerstand:<br />
<br />
http://www.mikrocontroller.net/images/taster.gif<br />
<br />
Sven Holthaus<br />
<br />
==Zahlensysteme==<br />
Bevor es losgeht, hier noch ein paar Worte zu den verschiedenen Zahlensystemen.<br />
<br />
Binärzahlen werden für den Assembler im Format '''0b00111010''' geschrieben, Hexadezimalzahlen als '''0x7F'''. Umrechnen kann man die Zahlen z.B. mit dem Windows-Rechner. Hier ein paar Beispiele:<br />
<table border="1"><br />
<tr align="center"><th>Dezimal</th><th>Hexadezimal</th><th>Binär</th></tr><br />
<tr align="right"><td>0</td><td>0x00</td><td>0b00000000</td></tr><br />
<tr align="right"><td>1</td><td>0x01</td><td>0b00000001</td></tr><br />
<tr align="right"><td>2</td><td>0x02</td><td>0b00000010</td></tr><br />
<tr align="right"><td>3</td><td>0x03</td><td>0b00000011</td></tr><br />
<tr align="right"><td>4</td><td>0x04</td><td>0b00000100</td></tr><br />
<tr align="right"><td>5</td><td>0x05</td><td>0b00000101</td></tr><br />
<tr align="right"><td>6</td><td>0x06</td><td>0b00000110</td></tr><br />
<tr align="right"><td>7</td><td>0x07</td><td>0b00000111</td></tr><br />
<tr align="right"><td>8</td><td>0x08</td><td>0b00001000</td></tr><br />
<tr align="right"><td>9</td><td>0x09</td><td>0b00001001</td></tr><br />
<tr align="right"><td>10</td><td>0x0A</td><td>0b00001010</td></tr><br />
<tr align="right"><td>11</td><td>0x0B</td><td>0b00001011</td></tr><br />
<tr align="right"><td>12</td><td>0x0C</td><td>0b00001100</td></tr><br />
<tr align="right"><td>13</td><td>0x0D</td><td>0b00001101</td></tr><br />
<tr align="right"><td>14</td><td>0x0E</td><td>0b00001110</td></tr><br />
<tr align="right"><td>15</td><td>0x0F</td><td>0b00001111</td></tr><br />
<tr align="right"><td>100</td><td>0x64</td><td>0b01100100</td></tr><br />
<tr align="right"><td>255</td><td>0xFF</td><td>0b11111111</td></tr><br />
</table><br />
<br />
"0b" und "0x" haben für die Berechnung keine Bedeutung, sie zeigen nur an, dass es sich bei dieser Zahl um eine Binär- bzw. Hexadezimalzahl handelt.<br />
<br />
<font color=FF0000>Wichtig dabei ist es, dass Hexadezimal- bzw. Binärzahlen bzw. Dezimalzahlen nur unterschiedliche Schreibweisen für immer das Gleiche sind: Eine Zahl. Welche Schreibweise bevorzugt wird, hängt auch vom Verwendungszweck ab. Je nachdem kann die eine oder die andere Schreibweise klarer sein.</font><br><br />
<br><br />
<font color=FF0000>Auch noch sehr wichtig: Computer und µCs beginnen immer bei 0 zu zählen, d.h. wenn es 8 Dinge (Bits etc.) gibt hat das erste die Nummer 0, das zweite die Nummer 1, ..., und das letzte (das 8.) die Nummer 7 (!).</font><br />
<br />
== Ausgabe ==<br />
=== Assembler-Sourcecode ===<br />
<br />
Unser erstes Assemblerprogramm, das wir auf dem Controller laufen lassen möchten, sieht so aus:<br />
<br />
<avrasm><br />
.include "m8def.inc" ; Definitionsdatei für den Prozessortyp einbinden<br />
<br />
ldi r16, 0xFF ; lade Arbeitsregister r16 mit der Konstanten 0xFF<br />
out DDRB, r16 ; Inhalt von r16 ins IO-Register DDRB ausgeben<br />
<br />
ldi r16, 0b11111100 ; 0b11111100 in r16 laden<br />
out PORTB, r16 ; r16 ins IO-Register PORTB ausgeben<br />
<br />
ende: rjmp ende ; Sprung zur Marke "ende" -> Endlosschleife<br />
</avrasm><br />
<br />
=== Assemblieren ===<br />
Das Programm muss mit der Endung ".asm" abgespeichert werden, z.B. als "leds.asm". Diese Datei können wir aber noch nicht direkt auf den Controller programmieren. Zuerst müssen wir sie dem Assembler füttern. Bei wavrasm funktioniert das z.B., indem wir ein neues Fenster öffnen, den Programmtext hineinkopieren, speichern und auf "assemble" klicken. Wichtig ist, dass sich die Datei "m8def.inc" (wird beim Atmel-Assembler mitgeliefert) im gleichen Verzeichnis wie die Assembler-Datei befindet. Der Assembler übersetzt die Klartext-Befehle des Assemblercodes in für den Mikrocontroller verständlichen Binärcode und gibt ihn in Form einer sogenannten "Hex-Datei" aus. Diese Datei kann man dann mit der entsprechenden Software direkt in den Controller programmieren. <br />
<br />
<div style="border: 1px solid grey; padding: 1ex;"><br />
<br />
=== Hinweis: Konfigurieren der Taktversorgung des ATmega8 ===<br />
<br />
Beim '''ATmega8''' ist standardmäßig der interne 1 MHz-Oszillator aktiviert; weil dieser für viele Anwendungen (z.B. das UART, siehe späteres Kapitel) aber nicht genau genug ist, soll der Mikrocontroller seinen Takt aus dem angeschlossenen 4 MHz-Quarzoszillator beziehen. Dazu müssen ein paar Einstellungen an den '''Fusebits''' des Controllers vorgenommen werden. Am besten und sichersten geht das mit dem Programm [http://www.myplace.nu/avr/yaap/ yaap]. Wenn man das Programm gestartet hat und der ATmega8 richtig erkannt wurde, wählt man aus den Menüs den Punkt "Lock Bits & Fuses" und klickt zunächst auf "Read Fuses". Das Ergebnis sollte so aussehen: [http://www.mikrocontroller.net/images/atmega8-vorher.png Screenshot]. Nun ändert man die Kreuze so, dass das folgende Bild entsteht: [http://www.mikrocontroller.net/images/atmega8-nachher.png Screenshot] und klickt auf "Write Fuses". Vorsicht, wenn die Einstellungen nicht stimmen, kann es sein, dass die ISP-Programmierung deaktiviert wird und man den AVR somit nicht mehr programmieren kann! Die FuseBits bleiben übrigens nach dem Löschen des Controllers aktiv, müssen also nur ein einziges Mal eingestellt werden. Mehr über die Fuse-Bits findet sich im Artikel [[AVR Fuses]].<br />
</div><br />
<br />
Nach dem Assemblieren sollte eine neue Datei mit dem Namen "leds.hex" oder "leds.rom" vorhanden sein, die man mit yaap, PonyProg oder AVRISP in den Flash-Speicher des Mikrocontrollers laden kann. Wenn alles geklappt hat, leuchten jetzt die ersten beiden angeschlossenen LEDs.<br />
<br />
=== Programmerklärung ===<br />
In der ersten Zeile wird die Datei m8def.inc eingebunden, welche die prozessortypischen Bezeichnungen für die verschiedenen Register definiert. Wenn diese Datei fehlen würde, wüsste der Assembler nicht, was mit "PORTB", "DDRD" usw. gemeint ist. Für jeden AVR-Mikrocontroller gibt es eine eigene derartige Include-Datei, da zwar die Registerbezeichnungen bei allen Controllern mehr oder weniger gleich sind, die Register aber auf unterschiedlichen Controllern unterschiedlich am Chip angeordnet sind und nicht alle Funktionsregister auf allen Prozessoren existieren. Für einen ATmega8 beispielsweise würde die einzubindende Datei m8def.inc heißen. Normalerweise ist also im Namen der Datei der Name des Chips in irgendeiner Form, auch abgekürzt, enthalten. Kennt man den korrekten Namen einmal nicht, so sieht man ganz einfach nach. Alle Include-Dateien wurden von Atmel in einem gemeinsamen Verzeichnis gespeichert. Das Verzeichnis ist bei einer Standardinstallation am PC auf C:\Programme\Atmel\AVR Tools\AvrAssembler\Appnotes\. Einige Include-Dateien heißen<br />
<br />
AT90s2313: 2313def.inc<br />
ATmega8: m8def.inc<br />
ATmega16: m16def.inc<br />
ATmega32: m32def.inc<br />
ATTiny12: tn12def.inc<br />
ATTiny2313: tn2313def.inc<br />
<br />
Um sicher zu gehen, dass man die richtige Include-Datei hat, kann man diese mit einem Texteditor (AVR-Studio oder Notepad) öffnen. Der Name des Prozessors wurde von Atmel immer an den Anfang der Datei geschrieben:<br />
<br />
<avrasm><br />
;***************************************************************************<br />
;* A P P L I C A T I O N N O T E F O R T H E A V R F A M I L Y<br />
;* <br />
;* Number :AVR000<br />
;* File Name :"2313def.inc"<br />
;* Title :Register/Bit Definitions for the AT90S2313<br />
;* Date :99.01.28<br />
;* Version :1.30<br />
;* Support E-Mail :avr@atmel.com<br />
;* Target MCU :AT90S2313<br />
...<br />
</avrasm><br />
<br />
Aber jetzt weiter mit dem selbstgeschriebenen Programm.<br />
<br />
In der 2. Zeile wird mit dem Befehl '''ldi r16, 0xFF''' der Wert 0xFF (entspricht 0b11111111) in das Register r16 geladen (mehr Infos unter [[Adressierung]]). Die AVRs besitzen 32 Arbeitsregister, r0-r31, die als Zwischenspeicher zwischen den I/O-Registern (z.B. DDRB, PORTB, UDR...) und dem RAM genutzt werden. Zu beachten ist außerdem, dass die ersten 16 Register (r0-r15) nicht von jedem Assemblerbefehl genutzt werden können. Ein Register kann man sich als eine Speicherzelle direkt im Mikrocontroller vorstellen. Natürlich besitzt der Controller noch viel mehr Speicherzellen, die werden aber ausschliesslich zum Abspeichern von Daten verwendet. Um diese Daten zu manipulieren, müssen sie zuerst in eines der Register geladen werden. Nur dort ist es möglich, die Daten zu manipulieren und zu verändern. Ein Register ist also vergleichbar mit einer Arbeitsfläche, während der restliche Speicher eher einem Stauraum entspricht. Will man arbeiten, so muss das Werkstück (= die Daten) aus dem Stauraum auf die Arbeitsfläche geholt werden und kann dann dort bearbeitet werden.<br />
<br />
Die Erklärungen nach dem Semicolon sind Kommentare und werden vom Assembler nicht beachtet.<br />
<br />
Der 3. Befehl gibt den Inhalt von r16 (=0xFF) in das Datenrichtungsregister für Port B aus. Das Datenrichtungsregister legt fest, welche Portpins als Ausgang und welche als Eingang genutzt werden. Steht in diesem Register ein Bit auf 0, wird der entsprechende Pin als Eingang konfiguriert, steht es auf 1, ist der Pin ein Ausgang. In diesem Fall sind also alle 6 Pins von Port B Ausgänge. Datenrichtungsregister können ebenfalls nicht direkt beschrieben werden, daher muss man den Umweg über eines der normalen Register r16 - r31 gehen.<br />
<br />
Der nächste Befehl, '''ldi r16, 0b11111100''' lädt den Wert 0b11111100 in das Arbeitsregister r16, der durch den darauffolgenden Befehl '''out PORTB, r16''' in das I/O-Register PORTB (und damit an den Port, an dem die LEDs angeschlossen sind) ausgegeben wird. Eine 1 im PORTB-Register bedeutet, dass an dem entsprechenden Anschluss des Controllers die Spannung 5V anliegt, bei einer 0 sind es 0V (Masse). <br />
<br />
Schließlich wird mit '''rjmp ende''' ein Sprung zur Marke '''ende:''' ausgelöst, also an die gleiche Stelle, wodurch eine Endlosschleife entsteht. Sprungmarken schreibt man gewöhnlich an den Anfang der Zeile, Befehle in die 2. und Kommentare in die 3. Spalte. <br />
<br />
Bei Kopier- und Ladebefehlen (ldi, in, out...) wird immer der 2. Operand in den ersten kopiert:<br />
<br />
<avrasm><br />
ldi r17, 15 ; das Register r17 wird mit der Konstanten 15 geladen<br />
mov r16, r17 ; das Register r16 wird mit dem Inhalt des Registers r17 geladen<br />
out PORTB, r16 ; das IO-Register "PORTB" wird mit dem Inhalt des Registers r16 geladen<br />
in r16, PIND ; das Register 16 wird mit dem Inhalt des IO-Registers "PIND" geladen<br />
</avrasm><br />
<br />
Wer mehr über die Befehle wissen möchte, sollte sich die PDF-Datei [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Instruction Set (1,27 MB)] runterladen (benötigt [http://www.acrobat.com/ Acrobat Reader] oder in der Hilfe von Assembler oder AVR-Studio nachschauen. Achtung: nicht alle Befehle sind auf jedem Controller der AVR-Serie verwendbar! <br />
<br />
Nun sollten die beiden ersten LEDs leuchten, weil die Portpins PB0 und PB1 durch die Ausgabe von 0 (low) auf Masse (0V) gelegt werden und somit ein Strom durch die gegen Vcc (5V) geschalteten LEDs fließen kann. Die 4 anderen LEDs sind aus, da die entsprechenden Pins durch die Ausgabe von 1 (high) auf 5V liegen. <br />
<br />
Warum leuchten die beiden ersten LEDs, wo doch die beiden letzen Bits auf 0 gesetzt sind? Das liegt daran, dass man die Bitzahlen von rechts nach links schreibt. Ganz rechts steht das niedrigstwertige Bit ("LSB", Least Significant Bit), das man als Bit 0 bezeichnet, und ganz links das höchstwertige Bit ("MSB", Most Significant Bit), bzw. Bit 7. Das Prefix "0b" gehört nicht zur Zahl, sondern sagt dem Assembler, dass die nachfolgende Zahl in binärer Form interpretiert werden soll.<br />
<br />
http://www.mikrocontroller.net/images/bits.gif<br />
<br />
Das LSB steht für PB0, und das MSB für PB7... aber PB7 gibt es doch z.B. beim AT90S4433 gar nicht, es geht doch nur bis PB5? Der Grund ist einfach: Am Gehäuse des AT90S4433 gibt es nicht genug Pins für den kompletten Port B, deshalb existieren die beiden obersten Bits nur intern.<br />
<br />
== Eingabe ==<br />
Im folgenden Programm wird Port B als Ausgang und Port D als Eingang verwendet: <br />
<br />
[http://www.mikrocontroller.net/sourcecode/tutorial/leds+buttons.asm Download leds+buttons.asm]<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
ldi r16, 0xFF<br />
out DDRB, r16 ; Alle Pins am Port B durch Ausgabe von 0xFF ins<br />
; Richtungsregister DDRB als Ausgang konfigurieren<br />
ldi r16, 0x00<br />
out DDRD, r16 ; Alle Pins am Port D durch Ausgabe von 0x00 ins<br />
; Richtungsregister DDRD als Eingang konfigurieren<br />
loop:<br />
in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 einlesen<br />
out PORTB, r16 ; Inhalt von r16 an Port B ausgeben<br />
rjmp loop ; Sprung zu "loop:" -> Endlosschleife<br />
</avrasm><br />
<br />
Wenn der Port D als Eingang geschaltet ist, können die anliegenden Daten über das IO-Register '''PIND''' eingelesen werden. Dazu wird der Befehl '''in''' verwendet, der ein IO-Register (in diesem Fall PIND) in ein Arbeitsregister (z.B. r16) kopiert. Danach wird der Inhalt von r16 mit dem Befehl '''out''' an Port B ausgegeben. Dieser Umweg ist notwendig, da man nicht direkt von einem IO-Register in ein anderes kopieren kann. <br />
<br />
'''rjmp loop''' sorgt dafür, dass die Befehle '''in r16, PIND''' und '''out PORTB, r16''' andauernd wiederholt werden, so dass immer die zu den gedrückten Tasten passenden LEDs leuchten.<br />
<br />
=== Stolperfalle bei Matrixtastaturen etc. ===<br />
<br />
'''Vorsicht!''' In bestimmten Situationen kann es passieren, dass scheinbar Pins nicht richtig gelesen werden. <br />
<br />
Speziell bei der Abfrage von Matrixtastaturen kann der Effekt auftreten, dass Tasten scheinbar nicht reagieren. Typische Sequenzen sehen dann so aus.<br />
<br />
<avrasm><br />
ldi r16,0x0F <br />
out DDRD,r16 ; oberes Nibble Eingang, unteres Ausgang<br />
ldi r16,0xFE <br />
out PORTD,r16 ; PD0 auf 0 ziehem, PD4..7 Pull ups aktiv<br />
in r17,PIND ; Pins lesen schlägt hier fehl!<br />
</avrasm><br />
<br />
Warum ist das problematisch? Nun, der AVR ist ein RISC Mikrocontroller, welcher die meisten Befehle in einem Takt ausführt. Gleichzeitig werden aber alle Eingangssignale über FlipFlops abgetastet (synchronisiert), damit sie sauber im AVR zur Verfügung stehen. Dadurch ergibt sich eine Verzögerung (Latenz) von bis zu 1,5 Takten, mit der auf externe Signale reagiert werden kann. Die Erklärung dazu findet man im Datenblatt unter der Überschrift "I/O Ports - Reading the Pin Value". <br />
<br />
Was tun? Wenn der Wert einer Port-Eingabe von einer unmittelbar vorangehenden Port-Ausgabe abhängt, muss man wenigstens einen weiteren Befehl zwischen beiden einfügen, im einfachsten Fall ein NOP.<br />
<br />
<avrasm><br />
ldi r16,0x0F<br />
out DDRD,r16 ; oberes Nibble Eingang, unteres Ausgang<br />
ldi r16,0xFE<br />
out PORTD,r16 ; PD0 auf 0 ziehem, PD4..7 Pull ups aktiv<br />
NOP ; Delay der Synchronisatzions-FlipFlops ausgleichen<br />
in r17,PIND ; Pins lesen ist hier OK.<br />
</avrasm><br />
<br />
Ein weiteres Beispiel für dieses Verhalten bei rasch aufeinanderfolgenden '''OUT''' und '''IN''' Anweisungen ist in einem Forenbeitrag zur [http://www.mikrocontroller.net/topic/88680#753847 Abfrage des Busyflag bei einem LCD] angegeben. Dort spielen allerdings weitere, vom [[LCD]] Controller abhängige Timings eine wesentliche Rolle für den korrekten Programmablauf.<br />
<br />
==Pullup-Widerstand==<br />
Bei der Besprechung der notwendigen Beschaltung der Ports wurde an einen Eingangspin jeweils ein Taster mit einem Widerstand nach Vcc vorgeschlagen. Diesen Widerstand nennt man einen '''Pullup'''-Widerstand. Wenn der Taster geöffnet ist, so ist es seine Aufgabe, den Eingangspegel am Pin auf Vcc zu ziehen. Daher auch der Name: 'pull up' (engl. für hochziehen). Ohne diesen Pullup-Widerstand würde ansonsten der Pin bei geöffnetem Taster in der Luft hängen, also weder mit Vcc noch mit GND verbunden sein. Dieser Zustand ist aber unbedingt zu vermeiden, da bereits elektromagnetische Einstreuungen auf Zuleitungen ausreichen, dem Pin einen Zustand vorzugaukeln, der in Wirklichkeit nicht existiert. Der Pullup-Widerstand sorgt also für einen definierten 1-Pegel bei geöffnetem Taster. Wird der Taster geschlossen, so stellt dieser eine direkte Verbindung zu GND her und der Pegel am Pin fällt auf GND. Durch den Pullup-Widerstand rinnt dann ein kleiner Strom von Vcc nach GND. Da Pullup-Widerstände in der Regel aber relativ hochohmig sind, stört dieser kleine Strom meistens nicht weiter.<br />
<br />
Anstelle eines externen Widerstandes wäre es auch möglich, den Widerstand wegzulassen und stattdessen den in den AVR eingebauten Pullup-Widerstand zu aktivieren. Die Beschaltung eines Tasters vereinfacht sich dann zum einfachst möglichen Fall: Der Taster wird direkt an den Eingangspin des µC angeschlossen und schaltet nach Masse durch:<br />
<br />
[[Bild:Taster2.gif]]<br />
<br />
Das geht allerdings nur dann, wenn der entsprechende Mikroprozessor-Pin auf Eingang geschaltet wurde. Ein Pullup-Widerstand hat nun mal nur bei einem Eingangspin einen Sinn. Bei einem auf Ausgang geschalteten Pin sorgt der Mikroprozessor dafür, dass ein dem Port-Wert entsprechender Spannungspegel ausgegeben wird. Ein Pullup-Widerstand wäre in so einem Fall kontraproduktiv, da der Widerstand versucht, den Pegel am Pin auf Vcc zu ziehen, während eine 0 im Port-Register dafür sorgt, dass der Mikroprozessor versuchen würde, den Pin auf GND zu ziehen.<br />
<br />
Ein Pullup-Widerstand an einem Eingangspin wird durch das '''PORT'''-Register gesteuert. Das '''PORT'''-Register erfüllt also 2 Aufgaben. Bei einem auf Ausgang geschalteten Port steuert es den Pegel an den Ausgangspins. Bei einem auf Eingang geschalteten Port steuert es, ob die internen Pullup-Widerstände aktiviert werden oder nicht. Ein 1-Bit aktiviert den entsprechenden Pullup-Widerstand.<br />
<br />
{| border="1"<br />
! DDRx || PORTx || IO-Pin-Zustand<br />
|-<br />
|align="center" | 0<br />
|align="center" | 0<br />
|| Eingang ohne Pull-Up (Resetzustand)<br />
|-<br />
|align="center" | 0<br />
|align="center" | 1<br />
|| Eingang mit Pull-Up<br />
|-<br />
|align="center" | 1<br />
|align="center" | 0<br />
|| [[Ausgangsstufen_Logik-ICs#Push-Pull | Push-Pull]]-Ausgang auf LOW<br />
|-<br />
|align="center" | 1<br />
|align="center" | 1<br />
|| [[Ausgangsstufen_Logik-ICs#Push-Pull | Push-Pull]]-Ausgang auf HIGH<br />
|}<br />
<br />
<br />
<avrasm><br />
.include "m8def.inc"<br />
<br />
ldi r16, 0xFF<br />
out DDRB, r16 ; Alle Pins am Port B durch Ausgabe von 0xFF ins<br />
; Richtungsregister DDRB als Ausgang konfigurieren<br />
ldi r16, 0x00<br />
out DDRD, r16 ; Alle Pins am Port D durch Ausgabe von 0x00 ins<br />
; Richtungsregister DDRD als Eingang konfigurieren<br />
<br />
ldi r16, 0xFF ; An allen Pins vom Port D die Pullup-Widerstände<br />
out PORTD, r16 ; aktivieren. Dies geht deshalb durch eine Ausgabe<br />
; nach PORTD, da ja der Port auf Eingang gestellt ist.<br />
loop:<br />
in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 einlesen<br />
out PORTB, r16 ; Inhalt von r16 an Port B ausgeben<br />
rjmp loop ; Sprung zu "loop:" -> Endlosschleife<br />
</avrasm><br />
<br />
Werden auf diese Art und Weise die AVR-internen Pullup-Widerstände aktiviert, so sind keine externen Widerstände mehr notwendig und die Beschaltung vereinfacht sich zu einem Taster, der einfach nur den µC-Pin mit GND verbindet.<br />
<br />
==Zugriff auf einzelne Bits==<br />
Man muss nicht immer ein ganzes Register auf einmal einlesen oder mit einem neuen Wert laden. Es gibt auch Befehle, mit denen man einzelne Bits abfragen und ändern kann: <br />
<br />
* Der Befehl '''sbic''' ("skip if bit cleared") überspringt den darauffolgenden Befehl, wenn das angegebene Bit 0 (low) ist.<br />
* '''sbis''' ("skip if bit set") bewirkt das Gleiche, wenn das Bit 1 (high) ist.<br />
* Mit '''cbi''' ("clear bit") wird das angegebene Bit auf 0 gesetzt.<br />
* '''sbi''' ("set bit") bewirkt das Gegenteil.<br />
Achtung: Diese Befehle können nur auf die IO-Register angewandt werden! <br />
<br />
Am besten verstehen kann man das natürlich an einem Beispiel: <br />
<br />
[http://www.mikrocontroller.net/sourcecode/tutorial/bitaccess.asm Download bitaccess.asm]<br />
<avrasm> <br />
.include "m8def.inc"<br />
<br />
ldi r16, 0xFF<br />
out DDRB, r16 ; Port B ist Ausgang<br />
<br />
ldi r16, 0x00<br />
out DDRD, r16 ; Port D ist Eingang<br />
<br />
<br />
ldi r16, 0xFF<br />
out PORTB, r16 ; PORTB auf 0xFF setzen -> alle LEDs aus<br />
<br />
loop: sbic PIND, 0 ; "skip if bit cleared", nächsten Befehl überspringen,<br />
; wenn Bit 0 im IO-Register PIND =0 (Taste 0 gedrückt)<br />
rjmp loop ; Sprung zu "loop:" -> Endlosschleife<br />
<br />
cbi PORTB, 3 ; Bit 3 im IO-Register PORTB auf 0 setzen -> 4. LED an<br />
<br />
ende: rjmp ende ; Endlosschleife<br />
</avrasm><br />
<br />
Dieses Programm wartet so lange in einer Schleife ("loop:"..."rjmp loop"), bis Bit 0 im Register PIND 0 wird, also die erste Taste gedrückt ist. Durch "sbic" wird dann der Sprungbefehl zu "loop:" übersprungen, die Schleife wird also verlassen und das Programm danach fortgesetzt. Ganz am Ende schließlich wird das Programm durch eine leere Endlosschleife praktisch "angehalten", da es ansonsten wieder von vorne beginnen würde.<br />
<br />
==Zusammenfassung der Portregister==<br />
Für jeden Hardwareport gibt es im Mikroprozessor insgesamt 3 Register:<br />
* Das Datenrichtungsregister '''DDRx'''. Es wird verwendet um die Richtung jedes einzelnen Mikroprozessor-Pins festzulegen. Eine 1 an der entsprechenden Bit Position steht für Ausgang, eine 0 steht für Eingang.<br />
* Das Einleseregister '''PINx'''. Es wird verwendet um von einem Mikroprozessor-Pin den aktuellen Zustand einzulesen. Dazu muss das entsprechende Datenrichtungsbit auf Eingang geschaltet sein.<br />
* Das Ausgangsregister '''PORTx'''. Es erfüllt 2 Funktionen, je nachdem wie das zugehörige Datenrichtungsbit geschaltet ist.<br />
** Steht es auf Ausgang, so wird bei einer entsprechenden Zuweisung an das '''PORTx''' Register der entsprechende Mikroprozessor-Pin auf den angegebenen Wert gesetzt.<br />
** Steht es auf Eingang, so beeinflusst das '''PORTx'''-Bit den internen Pullup-Widerstand an diesem Mikroprozessor-Pin. Bei einer 0 wird der Widerstand abgeschaltet, bei einer 1 wird der Widerstand an den Eingangs-Pin zugeschaltet.<br />
* Bei den neueren AVR (wie z.B. ''ATtiny13'', ''ATtiny2313'', ''ATtiny24/44/84'', ''ATtiny25/45/85'', ''ATmega48/88/168'', usw.) kann man als Ausgang konfigurierte Pins toggeln ('''PORTx''' zwischen 0 und 1 „umschalten“), indem man eine 1 an die entsprechende Bit Position des '''PINx''' Register schreibt.<br />
<br />
==Ausgänge benutzen, wenn mehr Strom benötigt wird==<br />
Man kann nicht jeden beliebigen Verbraucher nach dem LED-Vorbild von oben an einen µC anschließen. Die Ausgänge des ATMega8 können nur eine begrenzte Menge Strom liefern, so dass der Chip schnell überfordert ist, wenn eine nachgeschaltete Schaltung mehr Strom benötigt. Die Ausgangstreiber des µC würden in solchen Fällen den Dienst quittieren und durchbrennen.<br />
<br />
Abhilfe schafft in solchen Fällen eine zusätzliche Treiberstufe, die im einfachsten Fall mit einem [[Transistor|Transistor]] als Schalter aufgebaut wird.<br />
<br />
[[Bild:Transi2.gif]]<br />
<br />
Die LED samt zugehörigen Widerständen dienen hier lediglich als Sinnbild für den Verbraucher, der vom µC ein und ausgeschaltet werden soll. Welcher Transistor als Schalter benutzt werden kann, hängt vom Stromverbrauch des Verbrauchers ab. Die Widerstände '''R1''' und '''R2''' werden als '''Basiswiderstände''' der Transistoren bezeichnet. Für ihre Berechnung siehe z.B. [[Basiswiderstand|hier]]. Um eine sichere Störfestigkeit im Resetfall des Mikrocontrollers zu gewähren, sollte man noch einen Pulldown Widerstand zwischen Basis und Emitter schalten oder einen digitalen Transistor (z.B. BCR135) mit integriertem Basis- und Basisemitterwiderstand benutzen.<br />
<br />
Um ein Relais an einen µC Ausgang anzuschließen, siehe [[Relais_mit_Logik_ansteuern|hier]].<br />
<br />
<br />
{{Navigation_zurückhochvor|<br />
zurücktext=Benötigte Ausrüstung|<br />
zurücklink=AVR-Tutorial: Equipment|<br />
hochtext=Inhaltsverzeichnis|<br />
hochlink=AVR-Tutorial|<br />
vortext=logische Operationen|<br />
vorlink=AVR-Tutorial: Logik}}<br />
<br />
[[Category:AVR]][[Category:AVR-Tutorial]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29472Benutzer:Rotoe2008-07-29T18:55:05Z<p>Rotoe: /* Wunschliste */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Fluke 123<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=29414Atmega32 Experimentierplatine2008-07-27T23:42:29Z<p>Rotoe: /* Features */</p>
<hr />
<div>''von [[Benutzer:rotoe|Robin Tönniges]]''<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per N-FET an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin des µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
== Bezugsquellen ==<br />
*2x16 Zeichen Display ([http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MzI1OTc4OTk=&w=OTg4OTk4&ts=20 Pollin])<br />
*Die restlichen Teile ([http://www.reichelt.de Reichelt]) <br />
<br />
<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29271Benutzer:Rotoe2008-07-24T12:50:15Z<p>Rotoe: /* Bisher gebaute Sachen */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* [http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29270Benutzer:Rotoe2008-07-24T12:50:07Z<p>Rotoe: /* Bisher gebaute Sachen */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Experimentierplatine<br />
* ([http://www.mikrocontroller.net/articles/Atmega32_Experimentierplatine ATmega32 Experimentierplatine]) <br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29269Benutzer:Rotoe2008-07-24T12:48:28Z<p>Rotoe: /* Bisher gebaute Sachen */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Testplatine<br />
* ATmega32-Experimentierplatine<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29217Benutzer:Rotoe2008-07-22T14:23:05Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Testplatine<br />
* ATmega32-128 Testplatine<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29216Benutzer:Rotoe2008-07-22T14:22:32Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Beruf: Ex-Schüler ;)<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 478,64 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Testplatine<br />
* ATmega32-128 Testplatine<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29215Benutzer:Rotoe2008-07-22T14:21:45Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Beruf: Ex-Schüler ;)<br/><br />
Ausbildung ab 1.09 als EAT<br/><br />
Montl. Einkommen: 17,50 Euro<br/><br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Testplatine<br />
* ATmega32-128 Testplatine<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Benutzer:Rotoe&diff=29214Benutzer:Rotoe2008-07-22T14:21:03Z<p>Rotoe: /* Persönliche Daten */</p>
<hr />
<div>= Robin Tönniges - ICQ: 216193451=<br />
<br />
== Persönliche Daten ==<br />
Name: Robin Tönniges<br/><br />
Alter: 17<br/><br />
Geburtsdatum: 07.07.1991<br/><br />
Beruf: Schüler<br/><br />
Montl. Einkommen: 17,50 Euro<br/><br />
Berufswunsch: Elektroniker für Automatisierungstechnik<br />
<br />
== Hobby-Werdegang ==<br />
Ich bin seit 2002 begeisterter Hobbyelektroniker und habe mich sei dem<br />
durch das Internet und ein paar gute Bekannte fortgebildet. Unterwegs bin ich auch auf den Modellflug gestoßen was mt meinen Hobby natürlich perfekt harmoniert.<br />
Seit dem habe ich gelernt AVR's in C zu programmieren kenne die wichtigesten Grundlagen, Formeln und el. Bauteile.<br />
<br />
== Vorhaben ==<br />
Ich möchte FPGA's programmieren lernen. Weiß nicht warum. Auf jedefall ist es irgendwie reizvoll. Aber erstmal muss ich AVR-C richtig beherrschen bevor ich was Neues anfange.<br />
<br />
== Letze Errungenschaften ==<br />
* Parkzone T-28 Trojan (06.06.08)<br />
* Digitalkamera Casio EX-Z12 (06.05.2008)<br />
* STK500 (04.04.2008)<br />
* HAMEG HM-605 (2002)<br />
<br />
== Wunschliste ==<br />
* STK600<br />
* Tablet PC<br />
* Digitales Speicheroszi<br />
<br />
== Bisher gebaute Sachen ==<br />
* Akkutester mit einstellbarer Zellenzahl und Grafikdisplay<br />
* LC-Meter<br />
* 1-30V 0-3A Netzteil<br />
* 5W Röhrenoszillator<br />
* ATmega8 Testplatine<br />
* ATmega32-128 Testplatine<br />
* Mini-Multimeter<br />
* PC-Akkutester</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Datei:Layout.pdf&diff=29046Datei:Layout.pdf2008-07-16T12:13:33Z<p>Rotoe: hat eine neue Version von „Bild:Layout.pdf“ hochgeladen</p>
<hr />
<div></div>Rotoehttps://www.mikrocontroller.net/index.php?title=Datei:Layout.pdf&diff=29045Datei:Layout.pdf2008-07-16T12:11:47Z<p>Rotoe: hat eine neue Version von „Bild:Layout.pdf“ hochgeladen</p>
<hr />
<div></div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28955Atmega32 Experimentierplatine2008-07-11T19:01:23Z<p>Rotoe: /* Features */</p>
<hr />
<div>''von [[Benutzer:rotoe|Robin Tönniges]]''<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per N-FET an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
== Bezugsquellen ==<br />
*2x16 Zeichen Display ([http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MzI1OTc4OTk=&w=OTg4OTk4&ts=20 Pollin])<br />
*Die restlichen Teile ([http://www.reichelt.de Reichelt]) <br />
<br />
<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28752Atmega32 Experimentierplatine2008-06-27T16:11:15Z<p>Rotoe: /* Bezugsquellen */</p>
<hr />
<div>''von [[Benutzer:rotoe|Robin Tönniges]]''<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
== Bezugsquellen ==<br />
*2x16 Zeichen Display ([http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MzI1OTc4OTk=&w=OTg4OTk4&ts=20 Pollin])<br />
*Die restlichen Teile ([http://www.reichelt.de Reichelt]) <br />
<br />
<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28732Atmega32 Experimentierplatine2008-06-27T10:46:44Z<p>Rotoe: </p>
<hr />
<div>''von [[Benutzer:rotoe|Robin Tönniges]]''<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
== Bezugsquellen ==<br />
*2x16 Zeichen Display ([http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MzI1OTc4OTk=&w=OTg4OTk4&ts=20 Pollin])<br />
*Die Restlichen Teile ([http://www.reichelt.de Reichelt]) <br />
<br />
<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28709Atmega32 Experimentierplatine2008-06-26T21:38:30Z<p>Rotoe: </p>
<hr />
<div>''von [[Benutzer:rotoe|Robin Tönniges]]''<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28708Atmega32 Experimentierplatine2008-06-26T21:38:13Z<p>Rotoe: </p>
<hr />
<div>''von [[Benutzer:RoToe|Robin Tönniges]]''<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28707Atmega32 Experimentierplatine2008-06-26T21:36:48Z<p>Rotoe: </p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28706Atmega32 Experimentierplatine2008-06-26T21:35:28Z<p>Rotoe: </p>
<hr />
<div>[[Kategorie:Wettbewerb]]<br />
[[Kategorie:Projekte]]<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28704Atmega32 Experimentierplatine2008-06-26T21:27:30Z<p>Rotoe: </p>
<hr />
<div>[[Kategorie:Wettbewerb]]<br />
<br />
Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28703Atmega32 Experimentierplatine2008-06-26T21:27:08Z<p>Rotoe: </p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
“[[Kategorie:Wettbewerb]]”</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28702Atmega32 Experimentierplatine2008-06-26T21:26:49Z<p>Rotoe: </p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]<br />
<br />
<br />
[[Kategorie:Wettbewerb]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28701Atmega32 Experimentierplatine2008-06-26T21:26:21Z<p>Rotoe: /* Features */</p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-20V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28700Atmega32 Experimentierplatine2008-06-26T21:25:54Z<p>Rotoe: </p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Features ==<br />
* Eingangsspannung von 7-15V DC<br />
* 2x16 Zeichen Display an PORTA<br />
* Display kann per Fet an- und ausgeschaltet werden (kann überbrückt werden)<br />
* JTAG Anschluss<br />
* ISP Anschluss<br />
* I2C Anschluss<br />
* 8x LED's an PORTB (abschalt- und umsteckbar mit Klingeldraht)<br />
* 8x Taster an PORTB<br />
* Jeder Pin es µC's ist über eine Buchsenleiste erreichbar<br />
* 2x N-Fets an den PWM Kanälen zum Steuern von Lasten<br />
* Quarz und Lastkapazitäten sind austauschbar<br />
* PC Anschluss über MAX232 und Hardware UART möglich<br />
<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28699Atmega32 Experimentierplatine2008-06-26T21:18:50Z<p>Rotoe: /* Platinenlayout */</p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestückungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]</div>Rotoehttps://www.mikrocontroller.net/index.php?title=Atmega32_Experimentierplatine&diff=28698Atmega32 Experimentierplatine2008-06-26T21:18:40Z<p>Rotoe: /* Platinenlayout */</p>
<hr />
<div>Hier stelle ich meine selbstentwickelte ATmega32-Experimentierplatine vor. Was gleich erwähnt werden sollte ist dass diese Platine auch mit allen anderen Pinkompatiblen Typen funktioniert (warum auch nicht).<br />
<br />
== Schaltplan ==<br />
[[Bild:Pic3.jpg]]<br />
<br />
Der Schaltplan als PDF<br />
[[Media:Atm32_ep.pdf|Download]]<br />
<br />
== Platinenlayout ==<br />
[[Bild:Pic4.jpg]]<br />
<br />
Das Layout als PDF <br />
[[Media:Layout.pdf|Download]]<br />
<br />
Der Bestpckungsplan als PDF <br />
[[Media:Bestck.pdf|Download]]<br />
<br />
== Bilder der fertig bestückten Platine==<br />
=== Die Platine von Vorne ===<br />
[[Bild:Pic1.jpg]]<br />
=== Die Platine von Hinten ===<br />
[[Bild:Pic2.jpg]]</div>Rotoe