RN-Wissen.de - Benutzerbeiträge [de]

RN-KeyLCD

2006-08-20T18:28:59Z

Darth Ding: /* Was ist RN-KeyLCD? */

== Was ist RN-KeyLCD?==

[[Bild:knkeylcdfoto1.jpg|right|350px]]
Ein LCD und eine Tastatur ist fast bei allen [[Microcontroller]]-Anwendungen und Robotik-Basteleien von großem Vorteil. Nicht nur bei der späteren Bedienung der Schaltung sondern auch beim Debuggen eigener Controlleranwendungen.
Der Nachteil war immer das ein Standard-LCD als auch eine Matrixtastatur viele Portleitungen belegt. Damit macht dieses Board nun Schluß!
Das Board belegt keinerlei zusätzlichen Port, es kann sowohl über eine RS232 Schnittstelle (PC V24 Norm oder TTL Pegel) als auch [[I2C]]-Bus oder sogar [[RS485]] angesteuert werden. Der Anschluß und die Ansteuerung wird dadurch sehr einfach, nicht nur bei allen RN-Board´s.
Baudraten, [[I2C]]-Slave-Adresse und Betriebsmodus können über das Tastenfeld einfach umgeschaltet werden. Der Modus bleibt auch bei Spannungsausfall erhalten!

Besonders Vorteilhaft ist, dass für Tastatur, die serielle Verbindung und den I2C-Bus intern ein Ringbuffer (Zwischenspeicher) vorgesehen ist. So wird das angeschlossene Hauptboard (z.B. [[RN-Control]] oder anderes Board aber auch PC) bei Ausgaben nicht so stark wie bei herkömmlichen LCD´s gebremst. Auch Tastatureingaben gehen nicht verloren wenn das Hauptboard mal gerade wegen einer Operation nicht genügend Zeit hat um die Tasten schnell genug abzufragen. LCD und Tastatur sind dabei völlig unabhängig über das gleiche Kabel ansteuerbar. Für die Verbindung zum PC oder anderem Mikrocontrollerboard ist nur das übliche 3 poliges RS232 Kabel oder 10 polige I2C Kabel notwendig (siehe unter [[RN-Definitionen]]).

===Leistungsmerkmale und Eigenschaften===

*sehr einfach über verschiedene Anschlüsse ansteuerbar.
*per RS232 Schnittstelle (V24 PC-Pegel) ansteuerbar (also nahezu sowohl über PC als auch alle Boards Max232 etc. z.B. rn-Board Serie)
*per RS232 TTL Pegel ansteuerbar (falls Board kein Max besitzt)
*per I2C-Bus ansteuerbar (Slave ID kann per Tasten gewählt werden)
*per RS485 ansteuerbar (in der derzeitigen Firmware wird jedoch noch kein Netzwerk oder spezielles Protokoll unterstützt). Endwiderstände sind über Jumper aktivierbar.
*Spezieller RS232 RING Modus. In dieser Betriebsart kann das Board quasi in Reihe mit anderen RS232 Boards geschaltet werden. Dazu verfügt RN-KeyLCD sowohl über eine 3 polige RS232 Ein- und eine dreipolige Ausgangsstiftleiste. Auf diese Weise werden kann das Board also zwischen andere Board´s geschaltet werden. Die Daten werden von RN-KeyLCD automatisch weitergeleitet als auch auf dem Display angezeigt. Dies kann nützlich sein wenn man den Datenaustausch anderer Boards beobachten möchte.
*Hex-Mode – alle eingehenden Bytes werden in diesem Mode Hexadezimal angezeigt. Ein sehr hilfreicher Mode wenn man Schnittstellen/Protokolle prüfen will
*LCD-Menü um Einstellungen wie SlaveID, Baudrate, Mode einzustellen
*Wahlweise bei Tastendruck Interrupt am I2C-Bus auslösbar
*RN-KeyLCD kann wahlweise über den [[I2C]]Bus mit Spannung versorgt werden, dadurch ist keine weitere Kabelverbindung notwendig
*Durch eine vorhandene Spannungsstabilisierung kann das Board auch mit Spannungen zwischen 6V und ca. 18V betrieben werden.
*Beleuchtetes Display einfach steckbar (kann jederzeit wieder entnommen werden). Es werden sowohl blaue als auch grün/gelbe Displays unterstützt.
*Display Kontrast regelbar
*Beleuchtung per Software ein- und ausschaltbar um Batteriekapazität zu sparen
*Andere Display können über eine Standard Wannenstecker extern angeschlossen werden (derzeit werden nur 4x20 Zeichen Displays mit KS0073 Controller in der Firmware berücksichtigt)
*Umlaute werden automatisch umgesetzt, so das Ausgaben wie Print "schön" auch richtig auf dem LCD erscheinen.
*Automatisches Scrolling (Text verschiebt sich wenn letzte Zeile und Zeichen erreicht ist)
*Matrix Tastatur nur gesteckt und angeschraubt – jederzeit abnehmbar
*Tastatureingaben werden in Ringbuffern zwischengespeichert. Der Abruf erfolgt als ASCII oder Scancode (gleichzeitig gedrückte Tasten können so ermittelt werden)
*Eingebauter Lautsprecher für Tastenbestätigung
*Wahlweise können Tastenbetätigungen auch automatisch nach jeder Betätigung per RS232 als ASCII-Zeichen versendet werden
*Alle IC´s gesockelt
*Profis können bei Bedarf auch eigene Firmware entwickeln / ISP-Programmierstecker ist vorhanden / Schaltplan ist offengelegt
*Roboternetz kompatible Platine (halbes Euroformat) und Stecker ([[RN-Definitionen]])
*Deutsche Doku mit Beispielen

Alles in allem ein Board das sicher etwas teuerer ist als ein reines LCD-Display, aber die vielfältigen Einsatzmöglichkeiten sorgen dafür das dieses sicher nicht so schnell in einer Ablage verschwindet. Insbesondere die schnelle Anschlussmöglichkeit per RS232 wird ein PC mit [[Terminalprogramm]] oft überflüssig machen.

===RN-KeyLCD - Befehlsübersicht===
Die Ansteuerung von RN-KeyLCD ist recht einfach, jedes Zeichen (Byte) welches per RS232, RS485 oder I2C empfangen wird, erscheint als ASCII-Zeichen auf dem LCD, die Cursorposition wird dabei automatisch eine Stelle weiter gerückt. Ist das Zeilenende erreicht wird die nächste Zeile beschrieben. Wird das letzte Zeichen der letzten Zeile beschrieben, so verschiebt sich automatisch der Bildschirminhalt um eine Zeile nach oben (Autoscolling). Auf diese Weise werden also stets die letzten 4 Zeilen angezeigt.

Natürlich existieren auch einige Befehle um den Cursor an eine gewünschte Position zu setzen, die Anzeige zu löschen oder aber Spezialbefehle um die LED-Beleuchtung ein oder auszuschalten usw. Diese Befehle bestehen aus einer bestimmten Bytefolge oder einem Sondercode. Auch hier ist es egal ob diese Codes per I2C-Bus, RS232 oder RS485 gesendet werden.
Hier ist eine Übersicht der Funktionen in dem aktuellen RN-KeyLCD Betriebsystem V 1.2 (man spricht von "Firmware"). Die Firmware kann jederzeit mit einem ISP-Programmierkabel gegen eine andere ersetzt werden, falls es zum Beispiel ein Update gibt. AVR-Profis können sich sogar eine eigene Firmware erstellen.

;Display löschen:
:Bytefolge (dezimal): 12
:Basic-Beispiel (RS232):
::Print Chr(12)

;Carriage Return CR - Cursor nach links auf Spalte 1 setzen
:Bytefolge (dezimal): 13
:Basic-Beispiel (RS232):
::Print Chr(13)

;Linefeed LF 10 - Cursor eine Zeile tiefer
:Bytefolge (dezimal): 10
:Basic-Beispiel (RS232):
::Print Chr(10)

;Cursor positionieren um an bestimmte Stelle auf dem LCD-Display zu schreiben
:Bytefolge (dezimal): 27 79 x y
:x gibt hier die Spalte 1 bis 20 an
:y gibt die Zeile 1 bis 4 an
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(79);Chr(x);Chr(y)

;Cursor sichtbar/unsichtbar (Standard ist ausgeschalteter Cursor)
:Bytefolge (dezimal): 27 67 x
:x =1 bedeutet Cursor einschalten
:x =0 bedeutet Cursor ausschalten
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(67);Chr(0)

;LCD Beleuchtung ein- und aussschalten
:Bytefolge (dezimal): 27 76 x
:x =1 bedeutet Licht einschalten
:x =0 bedeutet Licht ausschalten
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(76);Chr(0)

;Ein Zeichen aus Tastaturbuffer als Scancode senden
:Durch senden dieses Befehles wird eine Taste die zwischenzeitlich im Tastaturbuffer gespeichert ist, als Scancode (2 Byte) per RS232 zurückgesendet. Der Scancode hat den Vorteil das auch gleichzeitig gedrückte Tasten vom Steuerboard ermittelt werden können.
:Bytefolge (dezimal): 27 120
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(120)

:Nach dem Befehl sendet RN-KeyLCD zuerst das Low und dann das High Byte des Scancodes. Die Bedeutung des Scancodes ist weiter unten erläutert.

;Ein Zeichen aus Tastaturbuffer als ASCII Zeichen senden
Durch senden dieses Befehles wird eine Taste die zwischenzeitlich im Tastaturbuffer gespeichert ist, als Ascii-Zeichen (1 Byte) per RS232 zurückgesendet. Der ASCII-Code hat den Vorteil das nur 1 Byte erforderlich ist und sehr einfach ivom Steuerboard weiterverarbeitet werden kann. Der Nachteil gegenüber dem Scancode besteht darin, das das gleichzeitige drücken von Tasten kein gültiges Zeichen ergeben.
:Bytefolge (dezimal): 27 121
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(121)
:Als Rückgabe wird das ASCII-Zeichen geliefert, das auch auf der Matrixtastatur abgebildet ist. Bei gleichzeitigem Betätigen von mehreren Tasten wird ein "?" gesendet.

;AUTOSEND-Modus - Gedrückte Tasten automatisch nach Tastenbetätigung senden
:Durch diesen Befehl wird ein Modus aktiviert, welcher eine gedrückte Tasten sofort nach der Eingabe per RS232 gesendet. Je nach gewählten Modus (siehe nächsten Befehl TASTENCODE-Modus) wird das Tastaturereignis als 1 Byte ASCII-Code oder als 2 Byte Scancode gesendet.
Die zuvor beschriebenen "Abholbefehle" sind in diesem Fall nicht notwendig bzw. möglich. Dieser Mode bleibt solange aktiviert bis er abgeschaltet wird . Nach einem Reset bzw. Neustart wird er automatisch aktiviert. Im I2C-Modus ist diese Betriebsart nicht möglich, dort wird dieser Mode automatisch ignoriert.
Bytefolge (dezimal): 27 122 x
:x =1 bedeutet Automode aktiv
:x =0 bedeutet Automode ausgeschaltet
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(122);Chr(0)

;TASTENCODE-Modus - Scancode und ASCII-Mode für Autosend und I2C-Abruf umschalten
:Durch diesen Befehl kann man wählen ob die Tastatureingaben im Autosend-Modus (siehe Befehl zuvor) per Ascii-Zeichen oder als 2 Byte Scancode gesendet werden sollen.
Nach dem Einschalten ist generell der ASCII-Modus aktiviert.
Mit diesem Befehl wird gleichzeitig im I2C-Mode die Art des Tastaturzeichenabrufes bestimmt. Per I2C müssen immer zwei Byte abgerufen werden. Im Ascii-Modus befindet sich dann im ertsen Byte das entsprechende ASCII-Zeichen des Tastaturfeldes. Im zweiten Byte steht immer 128!
Im Scancode-Modus steht jedes Bit der beiden Bytes für eine Taste!
:Bytefolge (dezimal): 27 119 x
:x =1 bedeutet Scancode-Modus aktiv
:x =0 bedeutet ASCII Mode aktiv
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(119);Chr(1)

;Tastaturspeicher löschen (alle bisher gedrückten Tasten löschen)
:Bytefolge (dezimal): 27 123
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(123)

;Zeige Copyright und Firmware Version über RS232
:Bytefolge (dezimal): 27 200
:Basic-Beispiel (RS232):
::Print Chr(27);Chr(200)

===Hinweise zum I2C-Modus===
Die Ansteuerung im I2C-Mode ist völlig identisch mit dem RS232-Mode. Wird ein Byte über I2C gesendet, so wird dieses ebenfalls auf dem LCD-Display ausgegeben. Sondercodes werden genau wie oben beschrieben behandelt.
Tastatureingaben werden per I2C allerdings stets über einen Lesebefehl (SlaveID + 1) angefordert, da der I2C-Bus das automatische senden von I2C-Slave Board´s nicht erlaubt.

Gelesen werden aus RN-KeyLcd stets 2 Byte. Je nach Tastencode-Modus (siehe oben) müssen die Bytes unterschiedlich interpretiert werden.
Im ASCII-Modi enthält das erste Byte das aufgedruckte Tastenfeld-Zeichen als ASCII-Code. Das zweite Byte enthält immer den Wert 128 und braucht in diesem Mode nicht weiter beachtet zu werden. Es kann jedoch zur Erkennung des Modus genutzt werden.

Im Scancode-Modus steht jedes Bit der beiden Bytes für eine Taste.

Erläuterung des Scancode:

;Low Byte (erste abgerufene Byte):

{{Registertabelle8Bit|Taste8|Taste7|Taste6|Taste5|Taste4|Taste3|Taste2|Taste1}}

;High Byte (zweite abgerufene Byte)

{{Registertabelle8Bit|ASCII-Mode|-|-|-|-|Taste11|Taste10|Taste9}}

Bit 3 bis 6 = derzeit in der Firmware nicht genutzt / Bit 7 = Steht auf 1, wenn ASCII-Mode aktiviert

Die hier beschriebenen Befehle werden alle außer Kraft gesetzt, wenn RN-KeyLCD per Tasten in den Hex-Mode (siehe nächste Seiten) geschaltet wird.

Erwähnenswert ist noch, dass wegen der verwendeten Matrixtastatur die genauen Tastenkombinationen nur dann ermittelt werden können, wenn einzelne oder ein bzw. zwei Tasten gleichzeitig gedrückt werden. Werden noch mehr Tasten gleichzeitig gedrückt, so gibt es einige Sonderfälle bei bestimmten Tastenkombinationen wo weitere Scancode-Bits gesetzt werden. Dies sollte dann bei der Abfrage berücksichtigt werden.

===RN-KeyLCD Einstellungen===

Einige wichtige Einstellungen sind bei RN-KeyLCD direkt über die vorhandene Matrixtastatur möglich, dazu muss kein Steuerboard oder PC angeschlossen sein.

Direkt nach dem das Board durch einschalten der Betriebsspannung aktiviert wurde, meldet sich dieses mit folgender Einschaltmeldung

[[Bild:rnkeylcdeinstellungen1.gif|center|300px]]

Dies ist im übrigen gleich ein guter Test, falls man das Board selbst aufgebaut hat (Bausatz). Erscheint keine Meldung, dann sollte man Jumper und Spannungsversorgung prüfen.

'''Folgende Funktionen stehen zur Verfügung:'''

====Hardware-RESET mit Grundstellung====
Werden die Tasten 1,4 und 7 gleichzeitig gedrückt, so werden Betriebsmode, I2C-Slave ID, Autosend, Baudrate wieder in die ursprüngliche Grundstellung gebracht und ein RESET ausgelöst.
Das bedeutet das Board befindet sich dann im RS232-Mode mit 9600 Baud, Autosend aktiviert und SlaveID Hex 40 wird vorgegeben. Ein eventueller Hexmode wird auch deaktiviert.
Diese Tastenkombination ist eigentlich nur sehr selten notwendig.

====HEX-Mode Ein- und Ausschalten====
Werden die Tasten 1 und # gleichzeitig gedückt, so schalte man den Hexmode ein. Ist de rHexmode bereits eingeschaltet so führt ein erneutes drücken zur Abschaltung des HEX-Mode.
Im sogenannten Hex-Mode werden alle eingehenden Zeichen (egal in welchem Schnittstellenmodus RS232, RS232RING, I2C, RS485) als Hexadezimalzahl dargestellt. Dies kann sehr hilfreich sein wenn man bestimmte Schnittstellen oder Protokolle überprüfen will.
Im Hexmode werden keine Sonderbefehle ausgeführt damit alle Bytes von 0 bis 255 auch wirklich unverändert dargestellt werden.

====Display löschen====
Durch gleichzeitig drücken der Tasten # und 3 wird das LCD-Display gelöscht, Tastaturbuffer und I2C-Befehlsspeicher gelöscht. Der Cursor wird auf Home-Position gebracht. Dies ist sinnvoll wenn man bestimmte Bytefolgen verfolgen will und etwas Platz und Übersicht braucht, insbesondere im Hex-Mode. Einstellungen werden nicht verändert, auch Autosend-, Scan- oder Hexmode! werden nicht geändert.

====Grundeinstellungen per LCD-Menü====
Durch gleichzeitiges drücken der Tasten 1 und 2 kommt man in ein Menü wo verschiedene Einstellungen gewählt werden können. Siehe nächstes Kapitel.

===LCD-Einstellungsmenü===
Durch gleichzeitiges drücken der Tasten 1 und 2 kommt man in ein Menü wo verschiedene Einstellungen gewählt werden können.

Nach dem drücken der Tasten sieht das Menü in etwa so aus (Slave ID auf Bild stimmt nicht):

[[Bild:rnkeylcdeinstellungen2.jpg|center]]

Mit folgenden Tasten können nun folgende Eigenschaften umgeschaltet werden:

;Taste
Betriebsmodus, also die Schnittstelle die genutzt werden soll
Wählbar ist: RS232 , I2C , RS232 RING , RS485

====Erläuterung der Modi====

;RS232: In diesem Modus werden alles Eingaben und Steuerbefehle über die dreipolige Stiftleiste RS232 erwartet. Wird das IC1 und IC3 aus der Fassung entfernt, so kann das Board auch über die 4 polige Stiftleiste RS232TTL im TTL-Pegel angesteuert werden.
[[Bild:rnkeylcdmoders232.jpg|center]]

;RS232RING: Dies ist eine besondere Betriebsart, hier wird das Board zwar auch über die 3 polige RS232 Schnittstelle angesteuert, jedoch wird ein zweites beliebiges Board ebenfalls per RS232 mit einer zweiten dreipoligen Stiftleiste NEXTRS verbunden. Zudem muss der Jumper JP6 entfernt werden. Alle eingehenden Daten werden wie üblich auf dem Display dargestellt, jedoch zugleich an das zweite angeschlossene RS232 Board weitergegeben. Die Rückgaben des zweiten Boardes werden dann als Rückgabe von RN-KeyLCD ebenfalls zurückgegeben. Dieser Betriebsart erlaubt also die Zwischenschaltung von RN-KeyLCD in bestehende RS232 Verbindungen. Dies kann nützlich sein, wenn man die gesendeten Daten sichtbar verfolgen will.
[[Bild:rnkeylcdmoders232ring.jpg|center]]

;I2C: In diesem Modus erfolgt die Steuerung von RN-KeyLCD komplett über den I2C-Bus. Alle Bytes die über den I2C Bus gesendet werden, werden identisch wie die RS232 Bytes behandelt. Die Standard I2C-Slave ID Vorgabe ist Hex 40 (anders als im Bild gezeigt)
[[Bild:rnkeylcdmodersi2c.jpg|center]]

;RS485: In diesem Modus werden die Daten über eine RS485 Verbindung empfangen und gesendet. Gewöhnlich steht das Board immer im Empfangsmodus- Lediglich bei Abruf von Tastaturereignissen sowie im AUTOSEND-Mode schaltet das Board automatisch ganz kurz auf senden um. Wenn dieser Modus genutzt wird, muss IC1 aus der Fassung entfernt werden und IC3 vorhanden sein.
Ein spezielles RS485 Protokoll wird derzeit nicht unterstützt, daher eignet sich dieser Modus vorwiegend auch zur Kontrolle von RS485 Verbindungen.
[[Bild:rnkeylcdmoders485.jpg|center]]

;Taste 5
Baudrate, also die Übertragunsgeschwindigkeit der RS232 Schnittstelle
Wählbar ist: 300, 2400, 9600, 19200, 38400 Baud

;Taste 6
I2C-Slave ID, also die Slave-Adresse über die RN-KeyLCD angesteuert werden soll. Es kann eine beliebige I2C-Slave ID gewählt werden. Somit kann man auch sehr viele RN-KeyLCD Board´s an einem Bus (I2C Kabel) nutzen und getrennt ansprechen. Zudem ist eine wählbare ID sehr günstig wenn man beispielsweise im Hex-Mode die Sendung an ein anderes I2C-Board kontrollieren will.
Durch die Taste 6 wird die ID immer um 2 erhöht und beginnt dann schließlich wieder bei 2 von vorn. Über die Taste 7 kann man in größeren Schritten umschalten.

;Taste #
Durch drücken dieser Taste werden die Einstellungen fest gespeichert und das Menü verlassen. Die Einstellungen bleiben auch erhalten wenn das Board von der Spannung getrennt wird!
Wurde die SLAVE ID geändert, so wird nach dem Speichern automatisch ein RESET durchgeführt.

===Beispiele wie man RNKeyLCD nutzen kann===

Die Ansteuerung von RN-KeyLCD ist über alle Schnittstellen denkbar einfach. Um das übersichtlich zu demonstrieren hier ein paar kleine Bascom Basic-Programme. Verwendet wurde hier das recht beliebte Board RN-Control, natürlich läßt es sich ähnlich auch mit anderen Board´s oder Programmiersprachen ansteuern.

====So einfach geht’s per RS232====
Bei diesem einfachen RN-Control Beispiel werden die rs232 Anschlüsse von rn-Control und rn-KeyLCD über eine 3 polige Leitung verbunden. Das Board RN-KeyLCD versorgt man daher am besten mit einer externen Spannungsquelle.

<pre>
'###################################################
'rnkeylcd_rs232.bas
'Beispiel: zu RN-KeyLCD
'Das Minimalbeispiel demonstriert wie einfach Texte mit Print
'ausgegeben werden
'
'Autor: Frank
'Anleitung findet man unter http://www.Roboternetz.de im Download Bereich
'oder www.robotikhardware.de
'Weitere Beispiele sind im Roboternetz gerne willkommen!
'##############################################################

' ------------- Hier die üblichen RN-Control Anweisungen --------------
$regfile = "m32def.dat"
$crystal = 16000000 'Quarzfrequenz
$baud = 9600
' ------------- Ende der üblichen RN-Control Anweisungen --------------

Wait 1 'Warte bis LCD bereit, falls gleicheitig Spannung eingeschaltet wird

'Das Hauptprogramm zum Ansteuern von RN-KeyLCD

Print Chr(12); 'Display löschen
Print "Hallo Bastler!"
Print "Wenn dieser Text"
Print "erscheint, dann" '
Print "klappt RS232 Modi" ;

End
</pre>

Wie zu erkennen ist benötigt das Hauptprogramm eigentlich nur 5 Print Befehle um alle 4 LCD-Zeilen zu beschreiben. Ein Treiber ist nicht notwendig. Aus diesem Grund kann das LCD auch an Board´s genutzt werden, die eigentlich für ein Terminalprogramm ausgelegt sind.
Die erste Printzeile sendet das Byte 12. Dieser Sondercode löscht das LCD-Display, siehe Befehlstabelle in der Anleitung weiter vorne.
Zu beachten ist das bei der letzten Zeile ein Semikolon genutzt wird, da ansonsten der Print Befehl noch einen Zeilenvorschub senden würde, was den Display Inhalt um eine Zeile nach oben schieben würde.

Man kann nahezu das gleiche Ergebnis erreichen, wenn man das Hauptprogramm zu einem Befehl zusammenfasst:

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Print Chr(12) ; "Hallo Bastler! Wenn dieser Text erscheint, dann klappt RS232 Modi" ;
End
</pre>

Der Test wird in dem Beispiel fortlaufend ausgegeben, das heißt der Zeilenwechsel erfolgt immer wenn 20 Zeichen erreicht sind. Möchte man jedoch wieder an einer bestimmten Stelle den Zeilenvorschub, so kann man es auch so schreiben:

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD

Print Chr(12) ; "Hallo Bastler!" ; Chr(13) ; Chr(10) ; "Wenn dieser Text" ; Chr(13) ; Chr(10) ;
"erscheint, dann" ; Chr(13) ; Chr(10) ; "klappt Rs232 Modi" ;
End
</pre>

Die erste Form ist diesbezüglich sicher übersichtlicher, es sollte nur zum Verständnis gezeigt werden.

Müssen Daten gezielt an eine bestimmte Stelle auf dem LCD-Display geschrieben werden, so kann man vor den Ausgabecursor (der normalerweise unsichtbar ist) an eine bestimmte Position setzen.
Das nachfolgende Beispiel demonstreirt wie man zum Beispiel zwei Textausgaben an genau definierter Stelle ausgibt:

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Print Chr(12) ; ' LCD löschen
Print Chr(27) ; Chr(79) ; Chr(5) ; Chr(2); 'Cursor in Zeile 2 Spalte 5
Print "Zeile2 Spalte 5" ;
Print Chr(27) ; Chr(79) ; Chr(10) ; Chr(4); 'Cursor in Zeile 4 Spalte 10
Print "Zeile4/S10" ;
End
</pre>

Wie zu erkennen ist, wird der Cursor über Print-Anweisung an eine beliebige Stelle gesetzt. Der anschließende Print Befehl gibt dann genau dort die nächsten Zeichen aus.

Wenn man die Chr()-Codes nicht so sehr mag, dann kann man sich in der jeweiligen Programmiersprache auch sehr einfach ein paar übersichtliche Befehle definieren. Im nächsten Beispiel wurde beispielsweise ein Befehl zur Cursor-Positionierung und zur Bildschirmlöschung definiert. Das Hauptprogramm ist dadurch viel übersichtlicher und zugleich kürzer:

<pre>
'
'###################################################
'rnkeylcd_rs232_test5.bas
'##############################################################

Declare Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Declare Sub Rnlcd_clr()

' ------------- Hier die üblichen RN-Control Anweisungen --------------

$regfile = "m32def.dat"
$hwstack = 32
$framesize = 32
$swstack = 32
$crystal = 16000000 'Quarzfrequenz
$baud = 9600
' ------------- Ende der üblichen RN-Control Anweisungen --------------

Wait 1 'Warte bis LCD bereit, falls gleicheitig Spannung eingeschaltet wird

'Das Hauptprogramm zum Ansteuern von RN-KeyLCD

Rnlcd_clr
Rnlcd_cursor 5 , 2
Print "Zeile2 Spalte 5" ;
Rnlcd_cursor 10 , 4
Print "Zeile4/S10" ;

End

'Die speziellen Befehle für das Board RN.KeyLCD:

Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Print Chr(27) ; Chr(79) ; Chr(spalte) ; Chr(zeile);
End Sub

Sub Rnlcd_clr()
Print Chr(12);
End Sub
</pre>

Die oberen Stack-Anweisungen sind in dem Beispiel eigentlich nicht notwendig, allerdings sollte man sich angewöhnen diese einzufügen sobald man mit Funktionen hantiert. Ansonsten kann es schnell vorkommen das ein zu klein definierter Stack zu Programmfehlern führt.
In dem Beispiel wurden nur 2 LCD-Befehle definiert, man kann natürlich noch eine ganze Reihe eigener Befehle hinzufügen, allerdings reichen diese beiden schon für fast alle Ausgaben aus.

Das nachfolgende Beispiel zeigt wie man zum Beispiel in der Mitte des Display langsam eine hochzählende Zahl sieht:

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Dim I As Word

Rnlcd_clr
Rnlcd_cursor 5 , 2
Print "Zähler:"
Do
Rnlcd_cursor 14 , 2
Print I
I = I + 1
Wait 1
Loop

End
</pre>

Und noch ein letztes Ausgabebeispiel welches das Scrolling zeigt:

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Dim I As Word

Rnlcd_clr
Do
Print
Print "Das ist Zeile : " ; I;
I = I + 1
Wait 1
Loop

End
</pre>

Damit dürfte klar sein wie die Ausgabe funktioniert. Wie man andere Befehle zum Ein- und Ausschalten des Cursors, zum deaktivieren der Beleuchtung usw. sendet, dürfte jetzt auch kein Problem mehr sein.

====Die Tastenabfrage im RS232Modus====

Die Tastenabfrage ist im RS232-Modus ebenfalls sehr einfach. Wie schon aus der Befehlsübersicht zu ersehen ist, gibt es eine ganze Reihe von Möglichkeiten die Tasten abzufragen. Das erste Beispiel demonstriert den AUTOSEND-Mode im ASCII-Format. Dies ist der Modus, der in der Grundeinstellung festgelegt ist. Jedesmal wenn eine Taste gedrückt wird, wird diese per RS232 an das Steuerboard gesendet.
In dem unteren Beispiel werden diese tastenbytes Empfangen und gleich zur Kontrolle auch auf dem LCD ausgegeben.

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Dim Taste As Byte

Rnlcd_clr
Do
If Ischarwaiting() = 1 Then
Taste = Inkey()
Print "Taste: " ; Chr(taste)
End If
Loop

End
</pre>

Drücken Sie nach dem Starten mal beliebige Tasten. Das ganze funktioniert also äußerst einfach. Über eine IF-Anweisung oder Select-Case Befehl könnte man nun den Tasten verschiedene Aufgaben zuweisen, z.B. Roboter vorfahren, rückwärts fahren, staubsaugen oder halt ganz andere Dinge.
Lediglich gleichzeitig gedrückte Tasten sind in diesem Mode nicht möglich, dafür werden automatisch Fragezeichen gesendet.

Der Scanmodus erlaubt aber auch das Betätigen mehrerer gleichzeitiger Tasten denn hier werden immer 2 Byte empfangen, wobei jedes Bit für eine Taste steht:

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Dim Tlow As Byte
Dim Thigh As Byte

Print Chr(27) ; Chr(119) ; Chr(1) 'Tasten Scanmodus aktivieren
Rnlcd_clr
Do
Tlow = Waitkey()
Thigh = Waitkey()
Print "Low: " ; Tlow ; " High:" ; Thigh
Loop

End
</pre>

Das obere Byte schaltet durch einen Print Befehl den Scancode-Modus ein. Anschließend empfängt es den Scancode und gibt beide Bytes auf dem LCD aus. Dies ist recht hilfreich zum Verständnis. Geben Sie das Beispiel mal ein und klicken Sie auch mehrere Tasten gleichzeitig. Die Tastenwerte werden dadurch addiert.

Das nachfolgende Beispiel demonstriert wie man in Bascom Basic die einzelnen Bits abfragt und somit den Tasten bestimmte Aufgaben zuweist. In dem Beispiel wird für jede Taste nur das Wort "Aufgabe x" ausgegeben, jedoch hätte man statt diesem Print-Befehl natürlich auch ein Funktionsaufruf oder ein Gosub Befehl einfügen können.

<pre>
'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Dim Tlow As Byte
Dim Thigh As Byte

Print Chr(27) ; Chr(119) ; Chr(1) 'Tasten Scanmodus aktivieren
Rnlcd_clr
Do
Tlow = Waitkey()
Thigh = Waitkey()

If Tlow.0 = 1 Then Print "Aufgabe 1"
If Tlow.1 = 1 Then Print "Aufgabe 2"
If Tlow.2 = 1 Then Print "Aufgabe 3"
If Tlow.3 = 1 Then Print "Aufgabe 4"
If Tlow.4 = 1 Then Print "Aufgabe 5"
If Tlow.5 = 1 Then Print "Aufgabe 6"
If Tlow.6 = 1 Then Print "Aufgabe 7"
If Tlow.7 = 1 Then Print "Aufgabe 8"

If Thigh.0 = 1 Then Print "Aufgabe 9"
If Thigh.1 = 1 Then Print "Aufgabe 10"
If Thigh.2 = 1 Then Print "Aufgabe 11"
If Thigh.3 = 1 Then Print "Aufgabe 12"
Loop

End
</pre>

Das besondere bei dieser Abfrage ist, das durch gleichzeitiges betätigen von Tasten auch quasi gleichzeitig mehrere Aufgaben ausgeführt werden.

Bislang haben wir nur gesehen wie Tasten im AUTOSEND-Modus abgefragt werden. Wie schon erläutert sendet RN-KeyLCD iin diesem Modi automatisch die Tasten direkt nach der Eingabe. Es gibt aber Aufgaben bei denen das Hauptboard nicht genügend Zeit hat um ständig die Tasten abzufragen, somit gingen in dieser Betriebsart eventuell Tasten verloren. Für diesen Zweck gibt es auch eine Möglichkeit bei der Tasten in RN-KeyLCD zwischengespeichert werden. Die Tasten können dann nacheinander vom Hauptboard abgerufen werden, sobald dafür Zeit ist. Für diesen Zweck haben wir im nachfolgenden Beispiel gleich eine spezielle Funktion definiert welche die beiden Scancode-Bytes abruft und zu einer WORD Variable zusammenfügt. Diese Methode erleichtert die Weiterverabeitung des Scancodes, denn für jede Taste ist ein Bit der WORD Variablen zuständig.

<pre>
'###################################################
'rnkeylcd_rs232_test11.bas
'##############################################################

Declare Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Declare Sub Rnlcd_clr()
Declare Function Rnlcd_getscan() As Word

' ------------- Hier die üblichen RN-Control Anweisungen --------------

$regfile = "m32def.dat"
$hwstack = 32
$framesize = 32
$swstack = 32
$crystal = 16000000 'Quarzfrequenz
$baud = 9600
' ------------- Ende der üblichen RN-Control Anweisungen --------------

Wait 1 'Warte bis LCD bereit, falls gleicheitig Spannung eingeschaltet wird

'Das Hauptprogramm zum Ansteuern von RN-KeyLCD
Dim Taste As Word
Print Chr(27) ; Chr(122) ; Chr(0); 'Autosend deaktivieren
Print Chr(27) ; Chr(119) ; Chr(1); 'Tasten Scanmodus aktivieren
Rnlcd_clr
Do
Taste = Rnlcd_getscan()
If Taste <> 0 Then
Print "Taste: " ; Taste
End If
Wait 3 ' 3 Sekunden Pause um Zwischenspeicher zu demonstrieren
Loop

End

'Die speziellen Befehle für das Board RN.KeyLCD:

Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Print Chr(27) ; Chr(79) ; Chr(spalte) ; Chr(zeile);
End Sub

Sub Rnlcd_clr()
Print Chr(12);
End Sub

'Scancode als Word abfragen
Function Rnlcd_getscan() As Word
Local Tlow As Byte
Local Thigh As Byte
Local Temp As Byte

'Diese erste Schleife löscht nur RS232 Buffer
Do
Temp = Inkey()
Loop Until Ischarwaiting() = 0

Print Chr(27) ; Chr(120); 'Befehl damit RN-KeyLCD Taste auf Speicher sendet
Tlow = Waitkey()
Thigh = Waitkey()
Rnlcd_getscan = Thigh * 256
Rnlcd_getscan = Rnlcd_getscan + Tlow
End Function

</pre>

Im Hauptprogramm wurde im oberen Beispiel extra ein 3 Sekunden Wait-Befehl eingefügt bevor die nächste Taste abgerufen wird. Wenn Sie nun schnell hintereinander Tasten auf dem Tastenfaed drücken, werden diese Tasten automatisch zwischengespeichert und nacheinander vom Hauptboard abgerufen. Es geht also nix verloren, alle Tastenwerte werden nacheinander auf dem LCD ausgegeben

Es gibt noch eine andere Funktion bei der man statt dem Scancode auch den ASCII-Code gezielt abrufen kann. Auch dort werden alle Tasten in einem Zwischenspeicher (Ringbuffer) abgelegt, die vorgehensweise ist sehr ähnlich, ein Beispiel dazu erübrigt sich daher sicherlich.

====Anmerkung====
Die Betriebsmodi RS485 und RS232Ring funktionieren auf die gleiche Weise wie der zuvor beschriebene RS232 Mode, die Beispiele können somit übernommen werden. Allerdings werden im RS232Ring-Mode die Tasten an das eingeschleifte Board weitergesendet und können nicht vom Hauptboard empfangen werden. Der RS232RING-Mode ist also vorwiegend zur Überwachung gedacht.

===Die Ansteuerung per I2C-Bus===

Obwohl die Ansteuerung von den Befehlen her betrachtet, per I2C-Bus kaum anders ist, gestaltet sich die Text-Ausgabe doch etwas anders weil halt für den I2C-Bus kein "print" Befehl exestiert. Man muss also die Bytes und Strings entweder mit den herkömmlichen I2C-Befehlen an das Board senden, oder bastelt sich ein paar kleine Hilfsroutinen. Die Hilfsroutinen könnte man dann später sehr einfach mit einem include-Befehl in eigene Programme integrieren. Der besseren Übersicht wegen verwenden wir in den hier gezeigten Beispielen keinen Include-Befehl.

Hier ein Beispiel mit den herkömmlichen I2C-Befehlen in Bascom-Basic:

<pre>
'###################################################
'rnkeylcd_i2c_test1.bas
'Beispiel: zu RN-KeyLCD
'LCD und Matrixtastaturboard RN-KeyLCD wird per I2C angesteuert
'
' Achtung:
' Diese Demo ist mit Bascom Compiler 1.11.7.7 getestet
' Nur ältere Bascom Versionen benötigen eine neue Libary
' http://www.roboternetz.de/phpBB2/viewtopic.php?t=694&start=22
'###################################################
'

' ------------- Hier die üblichen RN-Control Anweisungen --------------
$regfile = "m32def.dat"
$hwstack = 32
$framesize = 32
$swstack = 32

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Config Scl = Portc.0 'Ports fuer IIC-Bus
Config Sda = Portc.1
' ------------- Ende der üblichen RN-Control Anweisungen --------------

'Hauptprogramm

Const Rnkeylcd_slaveid_write = &H40 'I2C SlaveAdresse
Const Rnkeylcd_slaveid_read = &H41

Dim Stemp As String * 100

Wait 1 'Warte bis LCD bereit, falls gleicheitig Spannung eingeschaltet wird
I2cinit

Stemp = Chr(12) 'Löscht LCD
I2csend Rnkeylcd_slaveid_write , Stemp , 1

Stemp = "RN-KeyLCD per I2C"
I2csend Rnkeylcd_slaveid_write , Stemp , 17

End
</pre>

Hier wird einfach eine String-Variable mit dem auszugebenden String oder auch der Befehlssequenz belegt. Der String kann dann bequem mit der Bascom Anweisung I2csend verschickt werden, es muss lediglich die SlaveID und die Länge des Strings mit angegeben werden.

Das das ganze mit ein paar kleinen Funktionen viel bequemer geht, sieht man im nachfolgenden Beispiel. Das Hauptprogramm ist nun viel übersichtlicher. Neben zwei Strings wird nun gleich gezeigt wie man auch eine Variable an einer bestimmten Position ausgibt. Ein Zähler wird im Sekundentakt in der vierten Zeile hochgezählt:

<pre>
'###################################################
'rnkeylcd_i2c_test2.bas
'Beispiel: zu RN-KeyLCD
'LCD und Matrixtastaturboard RN-KeyLCD wird per I2C angesteuert
'
' Achtung:
' Diese Demo ist mit Bascom Compiler 1.11.7.7 getestet
' Nur ältere Bascom Versionen benötigen eine neue Libary
' http://www.roboternetz.de/phpBB2/viewtopic.php?t=694&start=22
'###################################################
'

' ------------- Hier die üblichen RN-Control Anweisungen --------------
$regfile = "m32def.dat"
$hwstack = 32
$framesize = 32
$swstack = 32

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Config Scl = Portc.0 'Ports fuer IIC-Bus
Config Sda = Portc.1
' ------------- Ende der üblichen RN-Control Anweisungen --------------

Declare Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Declare Sub Rnlcd_clr()
Declare Sub Rnlcd(byval Text As String)

Const Rnkeylcd_slaveid_write = &H40 'I2C SlaveAdresse
Const Rnkeylcd_slaveid_read = &H41

'Hauptprogramm
Dim Stemp As String * 100
Dim I As Word
Wait 1 'Warte bis LCD bereit, falls gleicheitig Spannung eingeschaltet wird
I2cinit

Rnlcd_clr

Rnlcd_cursor 4 , 2
Rnlcd "Willkommen im"
Rnlcd_cursor 4 , 3
Rnlcd "Roboternetz"

Do
Rnlcd_cursor 4 , 4
Stemp = "Zähler: " + Str(i)
Rnlcd Stemp
I = I + 1
Wait 1
Loop

End

'--------------------------------------------------------------
'Die speziellen I2C Befehle für das Board RN.KeyLCD:

Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Local Befehle As String * 4

Befehle = Chr(27) + Chr(79) + Chr(spalte) + Chr(zeile)
I2csend Rnkeylcd_slaveid_write , Befehle , 4
End Sub

Sub Rnlcd_clr()
Local Befehle As String * 2

Befehle = Chr(12)
I2csend Rnkeylcd_slaveid_write , Befehle , 1
End Sub

Sub Rnlcd(byval Text As String) 'Eine Art Print Befehl
Local Le As Word
Le = Len(text)
I2csend Rnkeylcd_slaveid_write , Text , Le
End Sub
</pre>

Wie man das LCD nun über I2C-Ansteuert dürfte somit klar sein. Es ist zu empfehlen die unteren LCD-Befehle in eigene Programme zu übernehmen, das erleichtert die Ansteuerung doch erheblich. Man könnte in Bascom auch eine Libary erstellen und dann die Bascom-LCD Befehle nutzen. Allerdings bringt das keine echten Vorteile und würde vermutlich etwas mehr Speicher belegen da dort unnötiger Code enthalten ist.

Der I2C-Bus ist bei RN-KeyLCD mit 100kBit ausgelegt. Ein Ringbuffer sorgt dafür das der I2C-Bus sehr schnell wieder freigegeben wird, somit wird der Bus vom Board kaum belastet.

====Tastaturabfrage per I2C-Bus====

Die Tastaturabfrage per I2C funktioniert ähnlich wie bei der RS232-Schnittstelle mit Abrufbefehl. Per I2C-Bus gibt es keinen AUTOSEND-Befehl, das bedeutet Tasten können nicht automatisch an das Hauptboard gesendet werden, sowas ist generell über I2C nicht möglich.

Daher muss das Hauptboard ab und zu die Tasten durch einen Lesebefehl abfragen. Ein vorhandener Ringspeicher sorgt dafür das keine Tasten verloren gehen, selbst wenn das Hauptboard mal nicht genug Zeit für den Abruf findet.
Es werden immer 2 Bytes abgerufen, egal ob sich das Board im ASCII-Modus oder im Scancode-Modus befindet. Die Bytes müssen nur unterschiedlich interpretiert werden, siehe Befehlsbeschreibung.

In dem nachfolgenden Beispiel haben wir gleich eine Unterfunktion definiert die sowohl im Scan- als auch ASCII-Modus funktioniert. Im ASCII-Modus liefert die Funktion das ASCII-Zeichen und im ScanCode-Modus den Scancode als WORD zurück.
Mit Hilfe der Funktion ist die Tastenabfrage sehr einfach:

<pre>
'###################################################
'rnkeylcd_i2c_test3.bas
'Beispiel: zu RN-KeyLCD
'LCD und Matrixtastaturboard RN-KeyLCD wird per I2C angesteuert
'
' Achtung:
' Diese Demo ist mit Bascom Compiler 1.11.7.7 getestet
' Nur ältere Bascom Versionen benötigen eine neue Libary
' http://www.roboternetz.de/phpBB2/viewtopic.php?t=694&start=22
'###################################################
'

' ------------- Hier die üblichen RN-Control Anweisungen --------------
$regfile = "m32def.dat"
$hwstack = 32
$framesize = 32
$swstack = 32

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Config Scl = Portc.0 'Ports fuer IIC-Bus
Config Sda = Portc.1
' ------------- Ende der üblichen RN-Control Anweisungen --------------

Declare Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Declare Sub Rnlcd_clr()
Declare Sub Rnlcd(byval Text As String)
Declare Sub Rnlcd_cr()
Declare Function Rnlcd_getscan() As Word
Declare Sub Rnlcd_scanmodus(byval Ein As Byte) 'Tastenscanmodus ein und ausschalten

Const Rnkeylcd_slaveid_write = &H40 'I2C SlaveAdresse
Const Rnkeylcd_slaveid_read = &H41

'Hauptprogramm
Dim Stemp As String * 100
Dim Taste As Word

I2cinit

Rnlcd_clr

Rnlcd_scanmodus 1 'Scanmodus ein
Do
Taste = Rnlcd_getscan()
If Taste <> 0 Then
Stemp = "Taste: " + Str(taste)
Rnlcd Stemp
Rnlcd_cr
End If
Waitms 500
Loop

End

'--------------------------------------------------------------
'Die speziellen I2C Befehle für das Board RN.KeyLCD:

Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte) 'Cursor setzen
Local Befehle As String * 4
Befehle = Chr(27) + Chr(79) + Chr(spalte) + Chr(zeile)
I2csend Rnkeylcd_slaveid_write , Befehle , 4
End Sub

Sub Rnlcd_clr() 'LCD löschen
Local Befehle As String * 2
Befehle = Chr(12)
I2csend Rnkeylcd_slaveid_write , Befehle , 1
End Sub

Sub Rnlcd_cr() 'LCD Zeilenvorschub
Local Befehle As String * 2
Befehle = Chr(13) + Chr(10)
I2csend Rnkeylcd_slaveid_write , Befehle , 2
End Sub

Sub Rnlcd(byval Text As String) 'Eine Art Print Befehl
Local Le As Word
Le = Len(text)
I2csend Rnkeylcd_slaveid_write , Text , Le
End Sub

Function Rnlcd_getscan() As Word 'Scancode als Word abfragen
Local Lscan As Byte
Local Hscan As Byte

I2cstart
I2cwbyte Rnkeylcd_slaveid_read
I2crbyte Lscan , Ack
I2crbyte Hscan , Nack
I2cstop

If Hscan.7 = 1 Then 'AScii Modus
Rnlcd_getscan= Lscan
Else
Rnlcd_getscan = Hscan * 256
Rnlcd_getscan = Rnlcd_getscan + Lscan
End If

End Function

Sub Rnlcd_scanmodus(byval Ein As Byte) 'Tastenscanmodus ein und ausschalten
Local Befehle As String * 3
Befehle = Chr(27) + Chr(119) + Chr(ein)
I2csend Rnkeylcd_slaveid_write , Befehle , 3
End Sub

</pre>

=====I2C Bus Interrupt nutzen um Tastatur abzufragen=====
Nach den Roboternetz-Spezifikationen ist Pin 10 des i2C-Steckers für eine Art-Interrupt Leitung reserviert. Diese Leitung wird von angeschlossenen I2C-Bus Teilnehmern genutzt um ein Ereignis zu melden. Die Spezifikation sagt, das diese Leitung auf Low gezogen wird, wenn ein Slave Daten für den Master bereithält.

In dem nachfolgenden Beispiel nutzen wir diese Leitung bei RN-Control aus. Dafür muss lediglich der Jumper INT-Jumper bei RN-Control (siehe JP6 der RN-Control Anleitung) gesteckt werden. Bei RN-KeyLCD muss die bereits vorgesehene Lötbrücke INTMODE durch einen Lötpunkt geschlossen werden. Das war´s, nun kann im RN-Control der Interrupt ausgenutzt werden um auf Tastaturereignisse zu reagieren. Das Beispiel demonstriert es:

<pre>
'###################################################
'rnkeylcd_i2c_test4.bas
'Beispiel: zu RN-KeyLCD
'LCD und Matrixtastaturboard RN-KeyLCD wird per I2C angesteuert
'
' Achtung:
' Diese Demo ist mit Bascom Compiler 1.11.7.7 getestet
' Nur ältere Bascom Versionen benötigen eine neue Libary
' http://www.roboternetz.de/phpBB2/viewtopic.php?t=694&start=22
'###################################################

' ------------- Hier die üblichen RN-Control Anweisungen --------------
$regfile = "m32def.dat"
$hwstack = 62
$framesize = 62
$swstack = 62

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Config Scl = Portc.0 'Ports fuer IIC-Bus
Config Sda = Portc.1
' ------------- Ende der üblichen RN-Control Anweisungen --------------

Declare Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte)
Declare Sub Rnlcd_clr()
Declare Sub Rnlcd(byval Text As String)
Declare Sub Rnlcd_cr()
Declare Function Rnlcd_getscan() As Word
Declare Sub Rnlcd_scanmodus(byval Ein As Byte) 'Tastenscanmodus ein und ausschalten
Declare Sub Rnlcd_clearkeybuffer() 'Löscht Tastaturbuffer

Const Rnkeylcd_slaveid_write = &H40 'I2C SlaveAdresse
Const Rnkeylcd_slaveid_read = &H41

'Hauptprogramm
Config Pinb.2 = Input
Portb.2 = 1 'Pullup ein
Config Int2 = Falling

Dim Stemp As String * 100
Dim Taste As Word

Wait 1 'Warte bis LCD bereit
I2cinit

On Int2 Tasten_interrupt
Enable Int2
Enable Interrupts

Rnlcd_clr
Rnlcd_scanmodus 1 'Scanmodus ein
Rnlcd_clearkeybuffer 'Tastatubuffer löschen, falls noch Tasten drin stecken

Do
'Hier könnte beliebiges Hauptprogramm stehen
Loop

End

Tasten_interrupt:
Taste = Rnlcd_getscan()
If Taste <> 0 Then 'Wurde Taste gedrückt
Stemp = "Taste: " + Str(taste)
Rnlcd Stemp
Rnlcd_cr
End If
Return

'--------------------------------------------------------------
'Einige spezielle I2C.Befehle für RN-KeyLCD als Funktion definiert:

Sub Rnlcd_cursor(byval Spalte As Byte , Byval Zeile As Byte) 'Cursor setzen
Local Befehle As String * 4
Befehle = Chr(27) + Chr(79) + Chr(spalte) + Chr(zeile)
I2csend Rnkeylcd_slaveid_write , Befehle , 4
End Sub

Sub Rnlcd_clr() 'LCD löschen
Local Befehle As String * 2
Befehle = Chr(12)
I2csend Rnkeylcd_slaveid_write , Befehle , 1
End Sub

Sub Rnlcd_cr() 'LCD Zeilenvorschub
Local Befehle As String * 2
Befehle = Chr(13) + Chr(10)
I2csend Rnkeylcd_slaveid_write , Befehle , 2
End Sub

Sub Rnlcd(byval Text As String) 'Eine Art Print Befehl zum Ausgeben von Text
Local Le As Word
Le = Len(text)
I2csend Rnkeylcd_slaveid_write , Text , Le
End Sub

Function Rnlcd_getscan() As Word 'Scancode als Word abfragen
Local Lscan As Byte
Local Hscan As Byte

I2cstart
I2cwbyte Rnkeylcd_slaveid_read
I2crbyte Lscan , Ack
I2crbyte Hscan , Nack
I2cstop

If Hscan.7 = 1 Then 'AScii Modus
Rnlcd_getscan = Lscan
Else
Rnlcd_getscan = Hscan * 256
Rnlcd_getscan = Rnlcd_getscan + Lscan
End If

End Function

Sub Rnlcd_scanmodus(byval Ein As Byte) 'Tastenscanmodus ein und ausschalten
Local Befehle As String * 3
Befehle = Chr(27) + Chr(119) + Chr(ein)
I2csend Rnkeylcd_slaveid_write , Befehle , 3
End Sub

Sub Rnlcd_clearkeybuffer() 'Löscht Tastaturbuffer
Local Befehle As String * 2
Befehle = Chr(27) + Chr(123)
I2csend Rnkeylcd_slaveid_write , Befehle , 2
End Sub

</pre>

Nicht erschrecken wenn das Beispiel auf den ersten Blick etwas lang aussieht. Der Vollständigkeithalber haben wir das ganze Listing mit allen Befehlsdefinitionen abgedruckt. Der eigentliche Hautteil ist ja sehr kurz.
Der Vorteil dieser Abfrage ist, das man im Hauptprogramm quasi garnicht auf die Tastatur achten muss, somit werden auch keinerlei Bytes über den I2C-Bus versendet. Erst wenn eine Taste bei RN-KeyLCD gedrückt wird, wird bei dem Hauptboard (hier rn-control) ein Interrupt ausgelöst. Das Hauptprogramm wird dann kurz unterbrochen um die Taste per I2C-Bus abzuholen, danach wird es wieder weiter ausgeführt. Das ganze geht so schnell das es quasi wirkt als geschehe alles gleichzeitig.
Achten Sie bei dem Beispiel auch darauf das noch etwas höhere Stackwerte notwendig sind, siehe Quellcode!

Verschweigen möchte ich nicht, das dieses Irq-Beispiel so nur wie gewünscht funktioniert wenn nur ein einziges Board am I2C-Bus diese Interrupt Leitung nutzt. Die Interrupt-Leitung kann jedoch auch von mehreren Board´s genutzt werden, in dem Fall muss im Hauptprogramm ab und zu geprüft werden ob noch die Interrupt Leitung auf Low liegt, denn dann könnten schon wieder Tasten vorhanden sein. Ein Interrupt kann dann nämlich aus bleiben wenn mehrere Boards gleichzeitig die Leitung auf Masse ziehen. Aber auch das ist nicht sonderlich schwierig in einem Programm zu berücksichtigen.
Da dieser Fall derzeit kaum auftreten wird, mangels Board´s die diese I2C-Interrupt Leitung nutzen, erspare ich mir ein Beispiel.

=== Aufbau und Anwendung===

Der Aufbau der Schaltung ist durch die vorgefertigte Platine bzw. den Bausatz (über robotikhardware.de, siehe Weblinks beziehbar) eigentlich problemlos auch von Elektronik-Einsteigern zu bewerkstelligen. Durch den Bestückungsdruck und die Bestückungsliste, etwas weiter hinten in dieser Dokumentation, ist der Aufbau unkritisch. Der speziell dafür programmierte Controller ist im Bausatz bereits enthalten! Die Schaltung benötigt in der Regel eine Aufbauzeit von ca. 30 – 45 Minuten.

Dennoch einige Anmerkungen zu eventuellen Hürden:

# Nicht vergessen das in die Fassung wo MEGA8 steht, der oben erwähnte programmierte Spezialchip eingesetzt werden muß. Diesen gibt es fix und fertig programmiert bei robotikhardware.de. Versierte Programmierer/Experten, können natürlich auch ein eigenes Betriebsystem für das Board entwickeln.
# Vor dem Anlegen der Spannung die genaue Bedeutung des Jumpers JP1 beachten. Wenn das Board über den I2C Bus mit Strom versorgt wird, muss Jumper JP1 eingesteckt werden. In diesem fall darf aber keine weitere Spannung an den Schraubklemmen angelegt werden. Bevorzugt man eine Versorgung über die Schraubklemmen, so muß JP1 entfernt werden (außer man will den I2C-Bus mit Strom versorgen)
# Vor dem einstecken des Display´s darauf achten das JP2 nur bei dem grün/gelben Display gesteckt sein darf. Bei dem blauen Display muß dieser Jumper entfernt werden da sonst die Beleuchtung überlastet würde. Beim einstecken des Display darauf achten das dieses in die richtigen Kontakte gesteckt wird. Auf der Platine sitzen 10 polige Buchsenleisten da 9 polige im Fachhandel nicht zu bekommen sind. Da das Display nur 9 Kontakte hat, darf man dieses nicht falsch einsetzen. Anhand der Beschriftung auf der Platine und der Beschriftung der Kontakte kann man die genauen Pinnummern vergleichen. [[Bild:rnkeylcddisplayeinstecken.jpg|right]]
# Auch beim Einstecken des Tastenfeldes drauf achten das dieses in den richtigen Kontakten stecken. Dies ist auf der Platine und im Bestückungsplan gut erkennbar, Die Stifte müssen ganz links in der Buchse stecken. Die unteren beiden Befestigungslöcher des Tastenfeldes sollten mit einem 3 mm Bohrer leicht von 2,5 auf 3mm erweitert werden damit dieses mit 3mm Schrauben und den mitgelieferten Abstandsbolzen verschraubt werden kann.
# Sollte Sie nach dem Einschalten einen kurzen Ton hören aber keine Meldung sehen, dann ist vermutlich der Kontrastregler nicht richtig eingestellt. Drehen sie also solange an dem Poti KONTRAST bis der Text gut lesbar ist.
# Setzen Sie niemals das IC3 und IC1 gleichzeitig ein. Gewöhnlich wird nur IC1 ein MAX232 eingesetzt. Nur wenn der RS485 Modus gebraucht wird, wird IC1 entfernt und in IC-Fassung 3 das IC Max485 eingesetzt. Soll der TTL-Pegel der RS232 genutzt werden, was wohl seltener der Fall sein wird, dann müssen beide IC´s entfernt werden. (Der Max485 gehört eventuell nicht immer zum Lieferumfang eines Bausatzes, da der RS485 Mode relativ selten genutzt wird, gegebenenfalls mitbestellen)
# Es muss in jedem Fall der mitgelieferte 16 Mhz Quarze bestückt werden. Andere Taktraten sind nicht möglich.

Das waren eigentlich schon die besonderen Punkte die zu beachten sind. Ansonsten natürlich sauber mit einem 15 – 25 W Lötkolben alles auf der Unterseite verlöten. Grundkenntnisse beim Löten werden empfohlen.

nach dem Aufbau sollten Sie nochmals alle Lötpunkte kontrollieren. Wenn sich das Board über das LCD meldet als auch einen Pieps beim anlegen der Spannung zu hören ist, dann deutet das darauf hin das alles gut geklappt hat.
In dem Fall können Sie sich dann anhand der vorhergehenden Beispiele mit der Ansteuerung beschäftigen. Sie können das Board auch mit der RS232 des PC´s verbinden, passende Kabel gibt’s zum Beispiel über Robotikhardware.de. Über ein Terminalprogramm (zum Beispiel das eingebaute in Bascom) können Sie dann per PC-Tastatur auf dem LCD schreiben.

[[Bild:rnkeylcdohnetastenfeld.jpg|center|framed|Auf dem oberen Bild ist zu erkennen das IC3 und ganz oben 2 Jumper und eine 5 polige Stiftleiste nicht bestückt ist. Diese Teile sind nur in dem selten benötigten RS485 Modus notwendig und können ansonsten weggelassen werden. Der Widerstand R7 (im Bild bestückt) sollte ebenfalls nicht bestückt werden, er ist eventuell für eine andere Firmware-Version vorgesehen.]]

;Nochmal ganz wichtig: Niemals den I2C-Bus Stecker versehendlich in die daneben liegende ISP-Buchse stecken. Dadurch wird fast immer Ihr Board oder ihr ISP-Dongel beschädigt. Immer genau darauf achten das der I2C-Stecker auch in die I2C-Bus Buchse gesteckt wird. Die Buchsen sind entsprechend beschriftet!

===Erläuterung der Anschlüsse, Kurzschlussbrücken, Jumper===

====Erläuterungen der Jumper und Lötbrücken====

=====JP1=====
Dieser Jumper verbindet die 5V Leitung auf dem I2C-Bus mit der 5V Logik-Spannung. Wenn Sie den Jumper einstecken, dann können Sie das Board komplett über den I2C-Bus mit Strom versorgen. Eine zusätzliche Spannung bzw. zusätzliches Kabel ist dann nicht mehr notwendig.
Versorgen Sie das Board jedoch über die Schraublemmen mit einer Spannung zwischen 6 und 18V, so darf dieser Jumper nicht gesteckt werden, außer sie wollen den I2C-Bus mit 5V Spannung versorgen.

=====JP2=====
Dieser Jumper ändert beim Einstecken den LCD-Vorwiderstand für die Beleuchtung von ca. 28 Ohm auf 8 Ohm. In der Regel wird das grün/gelbe Display von Robotikhardware.de eingesteckt werden, in diesem Fall muss der Jumper gesteckt werden. Wird alternativ ein blaues Display eingesteckt, so muss dieser Jumper unbedingt entfernt werden da ansosnsten die LCD_Beleuchtung dieses Display Schaden nimmt.

=====JP3 und JP4=====
Wenn der RS485 Modus genutzt wird und das Board das letzte Board in einem Netzwerk ist, so kann durch einstecken dieser beiden Jumper ein Endwiderstand aktiviert werden. Dies entspricht der RS485 Norm.

=====JP6=====
Das Board besitzt einen Ringmodus bei dem es praktisch zwischen zwei andere Boards in Reihe geschaltet werden kann. Wenn dieser Ringmodus genutzt werden soll, darf dieser Jumper nicht gesteckt sein und ein zweites Board muss an der Stiftleiste NEXTRS angeschlossen sein.
In allen anderen Fällen muss dieser Jumper gesteckt sein!

=====Lötbrücke I2CBATT=====
Hier handelt es sich um eine Lötbrücke die bei Bedarf mit einem Tropfen Lötzin verbunden werden kann. Durch die Verbindung wird die unstabilisierte Batteriespannung vom I2C-Bus mit der unstabilisierten Eingangsspannung dieses Board´s verbunden. Dadurch kann wahlweise der I2C-Bus zur Stromversorgung des Boards oder das Board zur Stromversorgung des I2C-Busses genutzt werden. Gewöhnlich ist dies nicht notwendig so das diese Lötbücke immer offen bleibt.

=====Lötbücke INTMODE=====
Wenn diese Lötbrücke mit einem Tropfen Lötzinn geschlossen wird, dann kann das Board über den I2C-Bus einen Interrupt auslösen wenn ein Zeichen im Tastaturbuffer landet. Die Leitung wird auf Low gezogen bis alle Zeichen aus dem Tastaturbuffer abgeholt wurden.
Wenn dieser Mode aktiviert wird, ist allerdings der RS485 Modus nicht mehr möglich, dahe rist diese Lötbrücke gewöhnlich offen.

=====Lötbücke INTMODE=====
Wenn diese Lötbrücke mit einem Tropfen Lötzinn geschlossen wird, dann kann man den RS485 – Bus (5 polige Stiftleiste) mit einer unstabilisierten Eingangsspannung verbinden. Gewöhnlich ist das nicht notwendig so das diese Brücke offen bleibt.

====Erläuterungen der Anschlüsse====

=====I2C-Bus=====
Übe diesen I2C-Bus kann das komplette Board angesteuert als auch mit Spannung versorgt werden. Der I2C-Bus hat den Vorteil das mehrere Board´s an dem gleichen Kabel angeschlossen werden. Es können mehrere RN-KeyLCD-Board´s abe rauch ganz verschiedene I2C-Boards sein. Wichtig ist nur das jedes Board eine unterschiedlich Adresse (I2C-Slave ID) besitzt. Die Standard I2C-Slave-ID bei RN-KeyLCD ist Hex 40, diese kann aber per Tastenfeld beliebig verändert werden.
Entsprechend der Roboternetz-Norm wird hier ein 2x5 poliger Stecker angeschlossen. Die Belegung entspricht exakt der von allen Roboternetz-Boards:

Pin 1 SCL (Taktleitung)
Pin 3 SDA (Datenleitung)
Pin 5 +5V (Kann über Jumper I2C5V getrennt werden)
Pin 7 +5V (Kann über Jumper I2C5V getrennt werden)
Pin 9 Batteriespannung Diese Leitung wird jedoch bei RN-Motor nicht benutzt
Pin 2,4,6,8 GND
Pin 10 INT Diese Leitung kann bei Tastaturereignissen einen Interrupt auslösen

=====ISP – IN SYSTEM PROGRAMMING=====
Über diesen Anschluß kann der Controller auf dem Board mit einem Standard ISP-Kabel direkt an einen Parallelport des PC´s angeschlossen und umprogrammiert werden.
Achtung: Dies ist in der Regel nicht notwendig, da ja der Controller bereits programmiert ist. Dieser Anschluß sollte deshalb nur von sehr erfahreneren AVR-Programmierern benutzt werden.
Der Anschluss kann abe rauch genutzt werden um Firmware-Updates einzuspielen, aber natürlich ist dazu auch ein ISP-Adapter notwendig.
Die Belegung des ISP-Anschlusses ist zu dem weit verbreitetet STK200 Programmier Dongle kompatibel. Ein entsprechender Dongle kann man sich entweder selber basteln (siehe Beitrag [[AVR-ISP Programmierkabel]]) oder fertig bestellen (z.B.robotikhardware.de siehe Weblinks).

Pin 1 MOSI
Pin 2 VCC
Pin 3 Nicht belegt
Pin 4 GND
Pin 5 RESET
Pin 6 GND
Pin 7 SCK
Pin 8 GND
Pin 9 MISO
Pin 10 GND

=====LCD2=====
Gewöhnlich nutzt man bei RN-KeyLCD das LCD das direkt auf das Board aufgesteckt wird. In diesem Fall ist dieser Anschluss immer unbelegt. Entfernt man jedoch das LCD aus dem Sockel, so kann hier ein Standard LCD mit 20 Zeichen x 4 Zeilen angeschlossen werden.
Zu beachten ist das die eingebaute Firmware nicht immer alle Display unterstützt, jedoch sollten KS0073 kompatible Displays gewöhnlich kein Problem machen. Beim Anschluss des Display´s darauf achten das man den Beleuchtungsvorwiderstand R6 nach Bedarf anpaßt.

Die Belegung entspricht der 16 poligen Roboternetz-Norm:
Pin 1 GND
Pin 2 5V
Pin 3 Vee Kontrastspannung (0-5V)
Pin 4 RS (CS)
Pin 5 R/W (SID)
Pin 6 Enable (1) (SCLK)
Pin 7 DB0 (SOD)
Pin 8 DB1
Pin 9 DB2
Pin 10 DB3
Pin 11 DB4
Pin 12 DB5
Pin 13 DB6
Pin 14 DB7,MSB
Pin 15 LED – Beleuchtung +
Pin 16 LED – Beleuchtung -

=====POWER=====
Über diese Schraublemme kann das Board mit einer unstabilisierten Gleichspannung von ca. 6 bis 18V versorgen. Bitte unbedingt auf die Polung achten da ansonsten das Board beschädigt werden kann. Plus und Minus ist jedoch auf der Platine deutlich beschriftet.
Beachten Sie auch das das Baord alternativ auch über den I2C-Bus versorgt werden kann, siehe Jumper JP1.

=====RS232 - PC kompatible RS232 Schnittstelle=====
Über ein Adapterkabel kann die serielle Schnittstelle des PC oder eines anderen Board´s (z.B. RN-Control, RN-Mega8, Rnbfra usw.) direkt mit dem Board verbunden werden.
Im RS232 Mode können sehr einfach alle Ausgaben mit Print auf dem LCD ausgegeben werden. Die Baudrate kann über das LCD-Menü eingestellt werden.
Die Belegung entspricht der Roboternetz-Norm und ist kompatibel zum Conrad Roboter CCRP5:

Pin 1 RX
Pin 2 GND
Pin 3 TX

Ein geeignetes Anschlußkabel kann schnell selbst angefertigt werden oder gibt es bei robotikhardware.de bereits fertig

=====NEXTRS=====
Dieser Anschluss hat die gleiche Belegung wie der zuvor beschriebene RS232 Anschluss. Er ist allerdings in Reihe geschaltet. Das bedeutet das alle Daten die über die RS232 Klemme eingehen zunächst vom LCD-Display dargestellt und verarbeitet werden aber zeitgleich auch an das Board weitergeschickt werden das an diesem NXTRS Anschluss hängt. Alle Ausgaben des hier angeschlossenen Board´s werden dann wieder von dem normalen RS232 Anschluss ausgegeben.
Hört sich kompliziert an,ist aber recht einfach, Das LCD-Board wird somit quasi unsichtbar zwischen zei andere Board´s in eine RS232 Leitung gehängt. Dies hat den Vorteil das man die gesendeten Daten überwachen kann, was insbesondere beim Debuggen von Schaltungen hilfreich sein kann.
Dazu muss jedoch noch der RINGMODUS über das Menü aktiviert und der Jumper JP6 entfernt werden. Interessant ist in diesem bezug auch der HEX-Mode von RNKeyLCD (siehe weiter vorne).

=====RS232TTL - RS232 Schnittstelle mit TTL Pegel=====
Dies ist die RS232 Schnittstelle mit TTL-Pegel, also max. 5V Pegel. Hier lassen sich Controllerboards, die keinen Treiberbaustein wie Max232 besitzen, direkt anschließen
Die TTL- Stiftleiste wird nach Roboternetz-Definition immer 4 polig ausgestattet um Verwechslungen mit der Standard RS232 Stiftleiste zu vermeiden. Verbinden Sie niemals eine 4 polige TTL-Stiftleiste mit einer 3 poligen, dies würde den Controller oder PC beschädigen.

Die Belegung entspricht der [[RN-Definitionen]]:

Pin 1 RX
Pin 2 TX
Pin 3 GND
Pin 4 +5V

Ein geeignetes Anschlußkabel kann schnell selbst angefertigt werden.
Wichtig: Wenn die TTL-Buchse benutzt wird, dann müssen Sie sowohl IC1 und IC3 aus der Fassung entfernen

=====RS485=====
Über diese Schnittstelle kann RN-KeyLCD auch über eine [[RS485]] Verbindung angesteuert werden. Dazu muss allerdings der Max485 in IC-Fassung IC3 eingesetzt und der MAX232 aus IC-Fassung IC1 entfernt werden. Zudem muss der [[RS485]] Modus über das Menü aktiviert werden.
Das Board steht immer auf Empfang und schaltet automatisch kurz auf Senden sobalt eine taste im AUTOSEND-Mode gesendet oder per Befehl abgeholt wird. Die Ansteuerung ist somit mit der RS232 Ansteuerung identisch. Ein spezielles Protokoll wird derzeit nicht in der Firmware unterstützt.

Pinbelegung entsprechend der [[RN-Definitionen]]:

Pin 1 Volle Batteriespannung
Pin 2 GND
Pin 3 5V
Pin 4 RS 485 A (kein TTL Pegel)
Pin 5 RS 485 B (kein TTL Pegel)

===Schaltplan===

[[Bild:rnkeylcdschaltplan.gif|center|500px]]

[[Bild:rnkeylcdschaltplan2.gif|center|500px]]

===Bestückungsplan===

Achtung, dieser Bestückungsplan gilt für die Version 1.2 der Platine. Rot markiert ist der Jumper, der bei der üblichen Konfiguration gesetzt sein sollte. Nur im RS232RING Modus muß dieser Jumper entfernt werden.

[[Bild:rnkeylcdbestückungsplan.gif|center|400px]]

===Stückliste===

<pre>
Bauteil Wert Beschreibung
C1 100n Keramik Kondensator
C2 22p 22pF Kondensator
C3 22p 22pF Kondensator
C4 100n Keramik Kondensator
C5 4,7uF Elko
C6 4,7uF Elko
C7 4,7uF Elko
C8 4,7uF Elko
C9 100n Keramik Kondensator
C10 100n Keramik Kondensator
C11 220uF Elko
C12 10uF Elko
C13 100n Keramik Kondensator
C14 100n Keramik Kondensator
I2C Wannenbuchse 10 pol Winkel
IC1 IC-Fassung 16 polig
IC1 MAX232 RS232 Treiber
IC2 7805T Spannungsregler 7805 oder LM2940 CT5
IC3 IC-Fassung 8 polig
IC3 MAX485CPA Treiber Max485
Der Max485 ist nur notwendig wenn auch der RS485
Modus vom Rn-KeyLCD gebraucht wird. Wenn er eingesteckt wird
muss IC1 Max232 entfernt werden und umgekehrt.
ISP Wannenbuchse 10 pol Winkel
JP1 Stiftleiste 2polig
JP2 Stiftleiste 2polig
JP3 Stiftleiste 2polig
JP4 Stiftleiste 2polig
JP6 Stiftleiste 2polig
KEY Matrixtastatur
Tastatur wird in die nachfolgende Buchsenleiste gesteckt
KEY 10 polige Buchsenleiste 2,54 Raster
LCD 20x4 Zeichen LCD Typ EA-DIP204
LCD wird in die nachfolgenden beiden Buchsenleisten gesteckt
LCD 10 polige Buchsenleiste 2,0
LCD 10 polige Buchsenleiste 2,0
LCD2 Wannenbuchse 16pol Winkel
MEGA8 Programmierter Controller RNLK12 nur über robotikhardware erhältlich
NEXTRS Stiftleiste 3 polig
POWER Schraubklemme 2 polig
Q1 16 Mhz Quarz 16 Mhz
R1 10k Metallschichtwiderstand 10k
R2 10k Poti 10k
R3 8 Metallschichtwiderstand 8 Ohm
R4 27 Metallschichtwiderstand 27 Ohm
R5 330 Metallschichtwiderstand 330 Ohm
R6 Widerstand
Dieser Widerstand ist nur notwendig wenn extern ein LCD
mit Beleuchtung angeschlossen wird (der Wert richtet sich
Displaytyp (gewöhnlich um die 10 Ohm)
R7 Diesen Wiederstand nicht einsetzen, er war für andere
Firmware gedacht und wird nicht mehr benötigt
R8 100k Metallschichtwiderstand 100k
R9 1k Widerstand 1K
R10 100k Metallschichtwiderstand 100k
RS232 Stiftleiste 3 polig
RS232TTL Stiftleiste 4 polig
RS485 Stiftleiste 5 polig Winkel
SPEAKER F/CM12P Mini Piezo Lautsprecher
T1 BC338 NPN Transistor BC338-40

2 Stück Abstandsbolzen innen/außen Gewinde 1cm Länge
3 Stück Abstandsbolzen innen/außen Platinenbefestigung
5 Stück Jumper
1 Stück Bedruckte passende Platine

Die Bauteile/LCD/Platine sind auch komplett über robotikhardware.de zu beziehen
</pre>

==Siehe auch==
*[[Bascom]]
*[[RN-Definitionen]]
*[[RN-Control]]
*[[RN-Board FAQ-Seite]]

==Weblinks==
*[http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=222 Ausführlichere Anleitung mit Bestückungsplan / Bauplan und weiteren Hinweisen als PDF-Datei]

{{Platinenservice|http://www.robotikhardware.de}}
{{Bausatzservice|http://www.robotikhardware.de}}

[[Category:Robotikeinstieg]]
[[Category:Praxis]]
[[Category:Elektronik]]
[[Category:Projekte]]
[[Category:Microcontroller]]

Bascom und PWM

2006-05-15T15:14:43Z

Darth Ding: /* Genauere Erklärung: */

== Mit Bascom, PWM-Signale erzeugen ==
(Bezogen auf den Mega8. Aber es gilt in etwa, auch für andere AVR's)

===Grundbegriffe===
'''Puls Weiten Modulation (PWM)'''

Bei der Puls-Weiten-Modulation (PWM) wird ein digitales Ausgangssignal erzeugt, dessen Tastverhältnis moduliert wird.

Das Tastverhältnis gibt das Verhältnis der Länge des eingeschalteten Zustands zur Periodendauer an. Dabei bleiben die Frequenz und der Pegel des Signals immer
gleich!
Es ändert sich nur die Länge von High zu Low.

Dieses Bild zeigt ein Tastverhältnis von 10% und 50 % 

[[Bild:Tastverhältnis.png|center]]

Man könnte das in etwa mit einem Wasserhahn vergleichen, den man z.B. alle Minuten betätigt.
Wenn man ihn in jeder Minute nur kurz aufdreht und dann gleich wieder zumacht,
kommt in Summe nur wenig Wasser raus.
Wenn man ihn aber in jeder dieser Minuten länger offen lässt,
kommt mehr Wasser raus.

Der Rhythmus bleibt immer gleich, aber es ändert sich in Summe die Wassermenge,
die raus kommt.

Mit dem PWM Signal kann man nun tolle Sachen machen.
Zum Beispiel eine LED (oder über einen Transistor auch eine Lampe) an den PWM Ausgang anschliessen und mit der Länge des PWM-Signal’s die Helligkeit der LED verändern.

Oder auch einen Motor in der Geschwindigkeit regeln.

Man kann aber auch dem PWM-Signal einen RC-Filter nachschalten, welches das
PWM-Signal glättet. Dann hat man eine regelbare Gleichspannung, in der das Minimum
dann 0V und das Maximum 5V ist.

Es gibt grundsätzlich zwei Gruppen von PWM-Arten

'''Software PWM und Hardware PWM '''

;'''Software PWM'''
:Vorteile: Man kann diese PWM auf jeden Ausgabe-Pin des AVR anwenden.
:Nachteil: Da die PWM per Software gemacht wird, ist sie eher langsam.

;'''Hardware PWM'''
:Vorteile: Sehr schnell (Maximal die Quarzfrequenz / Periode)
:Nachteile: Man kann nur bestimmte Ausgänge dafür verwenden

Der Mega8 hat nun drei Hardware PWM Ausgänge.
Diese laufen nach Definition der Register/Werte selbstständig ab.
(Darum ist Hardware-PWM auch sehr schnell und belastet die Abarbeitung des Programms nicht.)
Leider sind die Ausgänge aber bestimmten Ausgangs Pin’s fix zugeordnet.
Man kann diese also nicht auf andere Pins legen und muss sich deshalb vorher
Gedanken machen, wie man den Mega8 beschaltet.

Ganz anders beim Software-PWM, das ja rein Softwaremäßig erzeugt wird
und wo man dann das PWM-Signal fast an jeden Pin ausgeben kann.

Für die Hardware-PWM Erzeugung kann man beim Mega8
den Timer1 und den Timer2 verwänden.

Timer1 hat zwei Compare Register und kann dadurch zwei PWM Signale erzeugen.
(Compare A = Pin 15 und Compare B= Pin 16)
Weiters kann man beim Timer1 eine Auflösung von 8, 9 und 10 Bit einstellen.

Timer2 hat nur ein Compare Register (Ausgang am Pin 17), nur 8 Bit
Auflösung und kann auch nur ein PWM erzeugen.

=== PWM-Ablauf: ===

Unteres Bild zeigt den Ablauf für das PWM beim Timer1.
Es kommt zuerst die Frequenz vom Takterzeuger (Quarz), geht über den Prescaler zum Timer.
Beim Timer schaltet das Compare Register je nach seinem eingestellten Wert
 und erzeugt somit das PWM-Signal am Ausgangs-Pin

[[Bild:PWM.png|center]]

===Genauere Erklärung:===

Der Prescaler teilt die Frequenz die vom Quarz kommt!
Bei Teilung 1 geht die vollständige Frequenz zum Timer.
Bei Teilung 8 nur ein Achtel der Quarzfrequenz.
(Also bei 8 MHz Quarz kommen zum Timer dann nur 1 MHz )
Bei Teilung 1024 sind es dann z.B. 8 MHz/1024 = 7,8125kHz

Der Timer ist hier der Zähler für die PWM.
Er zählt mit der Frequenz, die vom Prescaler kommt, einmal von 0 bis
zu der eingestellten Timerauflösung rauf, dann wieder auf 0 zurück.
(dann wieder von 0 auf Timerauflösung u.s.w.)
Einmal rauf und runterzählen, ergibt ein Periode.
Die Periode ist gleich die Ausgangsfrequenz von dem PWM-Signal.
Ausgangsfrequenz = (Quarzfrequenz/Prescale ) /(Timerauflösung*2)

z.B.: Quarz = 8 MHz ; Prescaler = 1 ; Timer = 8 Bit
ergibt: (8000000Hz/1) / (256*2) = 15,625 kHz 

oder: Quarz = 8 MHz ; Prescaler = 8 ; Timer = 10 Bit
ergibt: (8000000Hz/8) / (2048*2) = 244,14 Hz

Mit dem Compare Register definiert man nun das Tastverhältnis!
Überall, wo nun der Timer diese Compare Linie schneidet, schaltet der Ausgang!
Beim raufzählen des Timers auf EIN, beim runterzählen auf AUS.

Als Beispiel ein Tastverhältnis von 20%
[[Bild:Compare205.png|center]]

Als Beispiel ein Tastverhältnis von 80% 
[[Bild:Compare51.png|center]]

Hier sieht man, wie die Signale dann auf einem Oszilloskop ausschauen.
Oben das Signal von Pin15 (Compare A), unten das von Pin 16 (Compare B)
[[Bild:Osci-PWM-kleiner3.GIF|center]]

=== Grundprogramm ===

Hier nun ein Grundprogramm für die Ausgabe von zwei PWM Signalen mit dem Timer1

<pre>
' Hardware PWM mit Timer1

$regfile = "m8def.dat"
$crystal = 4000000

Config Pinb.1 = Output
Config Pinb.2 = Output

Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1

Do
Compare1a = 205
Compare1b = 51
Loop

End
</pre>

''' Erklärung:'''
<pre>
$regfile = "m8def.dat"
$crystal = 8000000
</pre>
Definiert den Mega8 und den 8MHz Quarz

<pre>
Config Pinb.1 = Output
Config Pinb.2 = Output
</pre>
Definiert die zwei Ausgänge von Timer1 auf Ausgabe. 
Pinb.1 = für Compare1a (= Compare A) = Pin 15 
Pinb.2 = für Compare1b (= Compare B) = Pin 16

<pre>
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1
</pre>
;Config Timer1 = Pwm
: Timer1 auf PWM einstellen

;Pwm = 8
:Timer Auflösung = 8 Bit einstellen

;Compare A Pwm = Clear Up:Definiert, wie der Compare A schalten soll. Bei „Clear Up“ schaltet der Ausgang beim erreichen
:des Compare-Wertes zuerst auf High und dann auf Low. Bei „Clear Down“, umgekehrt.

;Compare B Pwm = Clear Up
:Das gleiche noch mal mit Compare B

;Prescale = 1
:Hier wird der Prescaler auf 1 eingestellt.
:(Wert 1 heißt, direkte Frequenz vom Quarz zum Timer.)
:Weitere Teilungen, wie z.B.: 8, 64, 256 und 1024 sind möglich.

<pre>
Compare1a = 205
Compare1b = 51
</pre>
Hier kann man nun die Werte für das Tastverhältnis, in das Register Compare1a
und Compare1b schreiben. Oder man kann auch, satt Compare1a und 1b , die Bezeichnungen
Pwm1a und Pwm1b verwenden. Bascom nimmt beides.

Mit diesem kurzen Programm, hat man nun zwei PWM Signale erzeigt, wo das eine ein Tastverhältnis
von 20% (Compare1a) und das andere von 80 % hat. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Bascom]]
* [[Pwm]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und PWM

2006-05-15T15:12:04Z

Darth Ding: /* Grundbegriffe */

== Mit Bascom, PWM-Signale erzeugen ==
(Bezogen auf den Mega8. Aber es gilt in etwa, auch für andere AVR's)

===Grundbegriffe===
'''Puls Weiten Modulation (PWM)'''

Bei der Puls-Weiten-Modulation (PWM) wird ein digitales Ausgangssignal erzeugt, dessen Tastverhältnis moduliert wird.

Das Tastverhältnis gibt das Verhältnis der Länge des eingeschalteten Zustands zur Periodendauer an. Dabei bleiben die Frequenz und der Pegel des Signals immer
gleich!
Es ändert sich nur die Länge von High zu Low.

Dieses Bild zeigt ein Tastverhältnis von 10% und 50 % 

[[Bild:Tastverhältnis.png|center]]

Man könnte das in etwa mit einem Wasserhahn vergleichen, den man z.B. alle Minuten betätigt.
Wenn man ihn in jeder Minute nur kurz aufdreht und dann gleich wieder zumacht,
kommt in Summe nur wenig Wasser raus.
Wenn man ihn aber in jeder dieser Minuten länger offen lässt,
kommt mehr Wasser raus.

Der Rhythmus bleibt immer gleich, aber es ändert sich in Summe die Wassermenge,
die raus kommt.

Mit dem PWM Signal kann man nun tolle Sachen machen.
Zum Beispiel eine LED (oder über einen Transistor auch eine Lampe) an den PWM Ausgang anschliessen und mit der Länge des PWM-Signal’s die Helligkeit der LED verändern.

Oder auch einen Motor in der Geschwindigkeit regeln.

Man kann aber auch dem PWM-Signal einen RC-Filter nachschalten, welches das
PWM-Signal glättet. Dann hat man eine regelbare Gleichspannung, in der das Minimum
dann 0V und das Maximum 5V ist.

Es gibt grundsätzlich zwei Gruppen von PWM-Arten

'''Software PWM und Hardware PWM '''

;'''Software PWM'''
:Vorteile: Man kann diese PWM auf jeden Ausgabe-Pin des AVR anwenden.
:Nachteil: Da die PWM per Software gemacht wird, ist sie eher langsam.

;'''Hardware PWM'''
:Vorteile: Sehr schnell (Maximal die Quarzfrequenz / Periode)
:Nachteile: Man kann nur bestimmte Ausgänge dafür verwenden

Der Mega8 hat nun drei Hardware PWM Ausgänge.
Diese laufen nach Definition der Register/Werte selbstständig ab.
(Darum ist Hardware-PWM auch sehr schnell und belastet die Abarbeitung des Programms nicht.)
Leider sind die Ausgänge aber bestimmten Ausgangs Pin’s fix zugeordnet.
Man kann diese also nicht auf andere Pins legen und muss sich deshalb vorher
Gedanken machen, wie man den Mega8 beschaltet.

Ganz anders beim Software-PWM, das ja rein Softwaremäßig erzeugt wird
und wo man dann das PWM-Signal fast an jeden Pin ausgeben kann.

Für die Hardware-PWM Erzeugung kann man beim Mega8
den Timer1 und den Timer2 verwänden.

Timer1 hat zwei Compare Register und kann dadurch zwei PWM Signale erzeugen.
(Compare A = Pin 15 und Compare B= Pin 16)
Weiters kann man beim Timer1 eine Auflösung von 8, 9 und 10 Bit einstellen.

Timer2 hat nur ein Compare Register (Ausgang am Pin 17), nur 8 Bit
Auflösung und kann auch nur ein PWM erzeugen.

=== PWM-Ablauf: ===

Unteres Bild zeigt den Ablauf für das PWM beim Timer1.
Es kommt zuerst die Frequenz vom Takterzeuger (Quarz), geht über den Prescaler zum Timer.
Beim Timer schaltet das Compare Register je nach seinem eingestellten Wert
 und erzeugt somit das PWM-Signal am Ausgangs-Pin

[[Bild:PWM.png|center]]

===Genauere Erklärung:===

Der Prescaler, teilt die Frequenz die vom Quarz kommt!
Bei Teilung 1, geht die vollständige Frequenz zum Timer.
Bei Teilung 8, nur ein Achtel der Quarzfrequenz.
(Also bei 8 MHz Quarz kommen zum Timer dann nur 1 MHz )
Bei Teilung 1024 sind es dann z.B. 8 MHz/1024 = 7,8125kHz

Der Timer ist hier der Zähler für das PWM.
Er zählt mit der Frequenz, die vom Prescaler kommt, einmal von 0 bis
zu der eingestellten Timerauflösung rauf, dann wieder auf 0 zurück.
(dann wieder von 0 auf Timerauflösung u.s.w.)
Einmal rauf und runterzählen, ergibt ein Periode.
Die Periode ist gleich die Ausgangsfrequenz von dem PWM-Signal.
Ausgangsfrequenz = (Quarzfrequenz/Prescale ) /(Timerauflösung*2)

z.B.: Quarz = 8 MHz ; Prescaler = 1 ; Timer = 8 Bit
ergibt: (8000000Hz/1) / (256*2) = 15,625 kHz 

oder: Quarz = 8 MHz ; Prescaler = 8 ; Timer = 10 Bit
ergibt: (8000000Hz/8) / (2048*2) = 244,14 Hz

Mit dem Compare Register definiert man nun das Tastverhältnis!
Überall, wo nun der Timer diese Compare Linie schneidet, schaltet der Ausgang!
Beim raufzählen des Timers auf EIN, beim runterzählen auf AUS.

Als Beispiel ein Tastverhältnis von 20%
[[Bild:Compare205.png|center]]

Als Beispiel ein Tastverhältnis von 80% 
[[Bild:Compare51.png|center]]

Hier sieht man, wie die Signale dann auf einem Osciloskop ausschauen.
Oben das Signal von Pin15 (Compare A) , unten das von Pin 16 (Compare B)
[[Bild:Osci-PWM-kleiner3.GIF|center]]

=== Grundprogramm ===

Hier nun ein Grundprogramm für die Ausgabe von zwei PWM Signalen mit dem Timer1

<pre>
' Hardware PWM mit Timer1

$regfile = "m8def.dat"
$crystal = 4000000

Config Pinb.1 = Output
Config Pinb.2 = Output

Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1

Do
Compare1a = 205
Compare1b = 51
Loop

End
</pre>

''' Erklärung:'''
<pre>
$regfile = "m8def.dat"
$crystal = 8000000
</pre>
Definiert den Mega8 und den 8MHz Quarz

<pre>
Config Pinb.1 = Output
Config Pinb.2 = Output
</pre>
Definiert die zwei Ausgänge von Timer1 auf Ausgabe. 
Pinb.1 = für Compare1a (= Compare A) = Pin 15 
Pinb.2 = für Compare1b (= Compare B) = Pin 16

<pre>
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1
</pre>
;Config Timer1 = Pwm
: Timer1 auf PWM einstellen

;Pwm = 8
:Timer Auflösung = 8 Bit einstellen

;Compare A Pwm = Clear Up:Definiert, wie der Compare A schalten soll. Bei „Clear Up“ schaltet der Ausgang beim erreichen
:des Compare-Wertes zuerst auf High und dann auf Low. Bei „Clear Down“, umgekehrt.

;Compare B Pwm = Clear Up
:Das gleiche noch mal mit Compare B

;Prescale = 1
:Hier wird der Prescaler auf 1 eingestellt.
:(Wert 1 heißt, direkte Frequenz vom Quarz zum Timer.)
:Weitere Teilungen, wie z.B.: 8, 64, 256 und 1024 sind möglich.

<pre>
Compare1a = 205
Compare1b = 51
</pre>
Hier kann man nun die Werte für das Tastverhältnis, in das Register Compare1a
und Compare1b schreiben. Oder man kann auch, satt Compare1a und 1b , die Bezeichnungen
Pwm1a und Pwm1b verwenden. Bascom nimmt beides.

Mit diesem kurzen Programm, hat man nun zwei PWM Signale erzeigt, wo das eine ein Tastverhältnis
von 20% (Compare1a) und das andere von 80 % hat. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Bascom]]
* [[Pwm]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und Timer

2006-03-22T21:21:02Z

Darth Ding: /* Timer im 1 Sekunden Takt */

== Bascom Timer (Mega8 und andere) ==

=== Zweck ===
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.

=== Struktur: ===

<pre>
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX
Enable TimerXXX ‘schalte den TimerXXX ein
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX
Enable Interrupts ‘generell Interrupts zulassen

Do
....Hauptprogramm ‘Hauptprogramm
Loop
End

SprungXXX: ‘Unterprogramm von TimerXXX
....Ausführung ‘arbeitet hier etwas ab und springt mit Return
Return ‚ wieder zurück, zum Hauptprogramm
</pre>

Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren.
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)

Dann mit „Enable“ den bestimmten Timer einschalten.
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll,
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.

Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).
8-Bit Timer zählen von 0 bis 255, 16-Bit Timer von 0 bis 65535.

Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde.

Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird.
Sonst kann es sein, dass man den Prozessor damit blockiert.

=== Timer Beispiel: ===
<pre>
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0
Enable Timer0 ‘schalte den Timer0 ein
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0
Enable Interrupts

Do
....Hauptprogramm
Loop
End

Isr_von_Timer0: ‘ISR von Timer0
.....Programm-Code
Return
</pre>

Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird. 
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen). Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 255.
Ab 255 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)

=== Timer im 1 Sekunden Takt ===

Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)

Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-255) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.

Der Timer1 ist ein 16-Bit Timer und kann von 0-65535 zählen.

Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.

Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65535) von meiner gewünschten Zählweite, abziehen. Also 65535-31250 = 34285 .Der Timer muss also schon bei 34285 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34285+31250= 65535 = Überlauf

Hier ein Beispiel mit dem Timer 1.
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.
Man kann in der ISR auch eine Variable hochzählen lassen.
<pre>
$regfile = "m8def.dat" 'für Mega8
$crystal = 8000000 'für 8MHz Quarz

Config Portd = Output 'definiert Portd als Output

Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1
Enable Timer1 'schalte den Timer1 ein
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1
Enable Interrupts
Timer1 = 34285 'Timer1 soll schon von 34285 wegzählen

Do
'....Hauptprogramm
Loop
End

Isr_von_timer1: 'ISR von Timer1
Timer1 = 34285 'Timer1 soll wieder von 34285 wegzählen
Toggle Portd.0 'schaltet Portd.0 im Sekundentakt
'EIN und AUS
'....oder z.B. incr Variable

Return
</pre>

Die Vorgabe (Timer1=34285) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34285 anfangen zu zählen.

Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden.

Man gibt dann ein: Load Timer1 , 31250 

Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.

Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.

Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Timer]]
* [[Bascom]]
* [[Interrupt]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und Timer

2006-03-22T21:20:36Z

Darth Ding: /* Timer im 1 Sekunden Takt */

== Bascom Timer (Mega8 und andere) ==

=== Zweck ===
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.

=== Struktur: ===

<pre>
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX
Enable TimerXXX ‘schalte den TimerXXX ein
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX
Enable Interrupts ‘generell Interrupts zulassen

Do
....Hauptprogramm ‘Hauptprogramm
Loop
End

SprungXXX: ‘Unterprogramm von TimerXXX
....Ausführung ‘arbeitet hier etwas ab und springt mit Return
Return ‚ wieder zurück, zum Hauptprogramm
</pre>

Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren.
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)

Dann mit „Enable“ den bestimmten Timer einschalten.
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll,
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.

Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).
8-Bit Timer zählen von 0 bis 255, 16-Bit Timer von 0 bis 65535.

Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde.

Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird.
Sonst kann es sein, dass man den Prozessor damit blockiert.

=== Timer Beispiel: ===
<pre>
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0
Enable Timer0 ‘schalte den Timer0 ein
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0
Enable Interrupts

Do
....Hauptprogramm
Loop
End

Isr_von_Timer0: ‘ISR von Timer0
.....Programm-Code
Return
</pre>

Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird. 
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen). Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 255.
Ab 255 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)

=== Timer im 1 Sekunden Takt ===

Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)

Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-255) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.

Der Timer1 ist ein 16-Bit Timer und kann von 0-65536 zählen.

Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.

Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65535) von meiner gewünschten Zählweite, abziehen. Also 65535-31250 = 34285 .Der Timer muss also schon bei 34285 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34285+31250= 65535 = Überlauf

Hier ein Beispiel mit dem Timer 1.
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.
Man kann in der ISR auch eine Variable hochzählen lassen.
<pre>
$regfile = "m8def.dat" 'für Mega8
$crystal = 8000000 'für 8MHz Quarz

Config Portd = Output 'definiert Portd als Output

Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1
Enable Timer1 'schalte den Timer1 ein
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1
Enable Interrupts
Timer1 = 34285 'Timer1 soll schon von 34285 wegzählen

Do
'....Hauptprogramm
Loop
End

Isr_von_timer1: 'ISR von Timer1
Timer1 = 34285 'Timer1 soll wieder von 34285 wegzählen
Toggle Portd.0 'schaltet Portd.0 im Sekundentakt
'EIN und AUS
'....oder z.B. incr Variable

Return
</pre>

Die Vorgabe (Timer1=34285) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34285 anfangen zu zählen.

Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden.

Man gibt dann ein: Load Timer1 , 31250 

Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.

Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.

Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Timer]]
* [[Bascom]]
* [[Interrupt]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und Timer

2006-03-22T21:18:45Z

Darth Ding: /* Timer im 1 Sekunden Takt */

== Bascom Timer (Mega8 und andere) ==

=== Zweck ===
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.

=== Struktur: ===

<pre>
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX
Enable TimerXXX ‘schalte den TimerXXX ein
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX
Enable Interrupts ‘generell Interrupts zulassen

Do
....Hauptprogramm ‘Hauptprogramm
Loop
End

SprungXXX: ‘Unterprogramm von TimerXXX
....Ausführung ‘arbeitet hier etwas ab und springt mit Return
Return ‚ wieder zurück, zum Hauptprogramm
</pre>

Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren.
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)

Dann mit „Enable“ den bestimmten Timer einschalten.
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll,
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.

Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).
8-Bit Timer zählen von 0 bis 255, 16-Bit Timer von 0 bis 65535.

Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde.

Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird.
Sonst kann es sein, dass man den Prozessor damit blockiert.

=== Timer Beispiel: ===
<pre>
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0
Enable Timer0 ‘schalte den Timer0 ein
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0
Enable Interrupts

Do
....Hauptprogramm
Loop
End

Isr_von_Timer0: ‘ISR von Timer0
.....Programm-Code
Return
</pre>

Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird. 
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen). Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 255.
Ab 255 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)

=== Timer im 1 Sekunden Takt ===

Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)

Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-255) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.

Der Timer1 ist ein 16-Bit Timer und kann von 0-65536 zählen.

Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.

Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65536) von meiner gewünschten Zählweite, abziehen. Also 65536-31250 = 34286 .Der Timer muss also schon bei 34286 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34286+31250= 65536 = Überlauf

Hier ein Beispiel mit dem Timer 1.
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.
Man kann in der ISR auch eine Variable hochzählen lassen.
<pre>
$regfile = "m8def.dat" 'für Mega8
$crystal = 8000000 'für 8MHz Quarz

Config Portd = Output 'definiert Portd als Output

Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1
Enable Timer1 'schalte den Timer1 ein
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1
Enable Interrupts
Timer1 = 34286 'Timer1 soll schon von 34286 wegzählen

Do
'....Hauptprogramm
Loop
End

Isr_von_timer1: 'ISR von Timer1
Timer1 = 34286 'Timer1 soll wieder von 34286 wegzählen
Toggle Portd.0 'schaltet Portd.0 im Sekundentakt
'EIN und AUS
'....oder z.B. incr Variable

Return
</pre>

Die Vorgabe (Timer1=34286) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34286 anfangen zu zählen.

Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden.

Man gibt dann ein: Load Timer1 , 31250 

Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.

Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.

Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Timer]]
* [[Bascom]]
* [[Interrupt]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und Timer

2006-03-22T21:18:18Z

Darth Ding: /* Timer Beispiel: */

== Bascom Timer (Mega8 und andere) ==

=== Zweck ===
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.

=== Struktur: ===

<pre>
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX
Enable TimerXXX ‘schalte den TimerXXX ein
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX
Enable Interrupts ‘generell Interrupts zulassen

Do
....Hauptprogramm ‘Hauptprogramm
Loop
End

SprungXXX: ‘Unterprogramm von TimerXXX
....Ausführung ‘arbeitet hier etwas ab und springt mit Return
Return ‚ wieder zurück, zum Hauptprogramm
</pre>

Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren.
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)

Dann mit „Enable“ den bestimmten Timer einschalten.
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll,
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.

Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).
8-Bit Timer zählen von 0 bis 255, 16-Bit Timer von 0 bis 65535.

Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde.

Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird.
Sonst kann es sein, dass man den Prozessor damit blockiert.

=== Timer Beispiel: ===
<pre>
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0
Enable Timer0 ‘schalte den Timer0 ein
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0
Enable Interrupts

Do
....Hauptprogramm
Loop
End

Isr_von_Timer0: ‘ISR von Timer0
.....Programm-Code
Return
</pre>

Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird. 
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen). Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 255.
Ab 255 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)

=== Timer im 1 Sekunden Takt ===

Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)

Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-256) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.

Der Timer1 ist ein 16-Bit Timer und kann von 0-65536 zählen.

Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.

Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65536) von meiner gewünschten Zählweite, abziehen. Also 65536-31250 = 34286 .Der Timer muss also schon bei 34286 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34286+31250= 65536 = Überlauf

Hier ein Beispiel mit dem Timer 1.
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.
Man kann in der ISR auch eine Variable hochzählen lassen.
<pre>
$regfile = "m8def.dat" 'für Mega8
$crystal = 8000000 'für 8MHz Quarz

Config Portd = Output 'definiert Portd als Output

Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1
Enable Timer1 'schalte den Timer1 ein
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1
Enable Interrupts
Timer1 = 34286 'Timer1 soll schon von 34286 wegzählen

Do
'....Hauptprogramm
Loop
End

Isr_von_timer1: 'ISR von Timer1
Timer1 = 34286 'Timer1 soll wieder von 34286 wegzählen
Toggle Portd.0 'schaltet Portd.0 im Sekundentakt
'EIN und AUS
'....oder z.B. incr Variable

Return
</pre>

Die Vorgabe (Timer1=34286) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34286 anfangen zu zählen.

Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden.

Man gibt dann ein: Load Timer1 , 31250 

Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.

Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.

Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Timer]]
* [[Bascom]]
* [[Interrupt]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und Timer

2006-03-22T21:17:49Z

Darth Ding: /* Struktur: */

== Bascom Timer (Mega8 und andere) ==

=== Zweck ===
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.

=== Struktur: ===

<pre>
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX
Enable TimerXXX ‘schalte den TimerXXX ein
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX
Enable Interrupts ‘generell Interrupts zulassen

Do
....Hauptprogramm ‘Hauptprogramm
Loop
End

SprungXXX: ‘Unterprogramm von TimerXXX
....Ausführung ‘arbeitet hier etwas ab und springt mit Return
Return ‚ wieder zurück, zum Hauptprogramm
</pre>

Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren.
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)

Dann mit „Enable“ den bestimmten Timer einschalten.
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll,
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.

Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).
8-Bit Timer zählen von 0 bis 255, 16-Bit Timer von 0 bis 65535.

Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde.

Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird.
Sonst kann es sein, dass man den Prozessor damit blockiert.

=== Timer Beispiel: ===
<pre>
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0
Enable Timer0 ‘schalte den Timer0 ein
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0
Enable Interrupts

Do
....Hauptprogramm
Loop
End

Isr_von_Timer0: ‘ISR von Timer0
.....Programm-Code
Return
</pre>

Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird. 
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen). Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 256.
Ab 256 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)

=== Timer im 1 Sekunden Takt ===

Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)

Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-256) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.

Der Timer1 ist ein 16-Bit Timer und kann von 0-65536 zählen.

Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.

Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65536) von meiner gewünschten Zählweite, abziehen. Also 65536-31250 = 34286 .Der Timer muss also schon bei 34286 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34286+31250= 65536 = Überlauf

Hier ein Beispiel mit dem Timer 1.
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.
Man kann in der ISR auch eine Variable hochzählen lassen.
<pre>
$regfile = "m8def.dat" 'für Mega8
$crystal = 8000000 'für 8MHz Quarz

Config Portd = Output 'definiert Portd als Output

Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1
Enable Timer1 'schalte den Timer1 ein
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1
Enable Interrupts
Timer1 = 34286 'Timer1 soll schon von 34286 wegzählen

Do
'....Hauptprogramm
Loop
End

Isr_von_timer1: 'ISR von Timer1
Timer1 = 34286 'Timer1 soll wieder von 34286 wegzählen
Toggle Portd.0 'schaltet Portd.0 im Sekundentakt
'EIN und AUS
'....oder z.B. incr Variable

Return
</pre>

Die Vorgabe (Timer1=34286) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34286 anfangen zu zählen.

Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden.

Man gibt dann ein: Load Timer1 , 31250 

Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.

Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.

Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Timer]]
* [[Bascom]]
* [[Interrupt]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und I2C EEprom

2006-03-19T20:26:01Z

Darth Ding: /* Ansteuern vom I2C EEprom's mit Bascom */

== Ansteuern vom I2C EEproms mit Bascom ==

Der Artikel demonstriert wie man EEPROM Speicherbausteine unter Bascom über den [[I2C]]-Bus anspricht.

=== Struktur: ===

<pre>

'---- schreiben ins EEprom ----------------------------------------
I2cstart 'Start I2C
I2cwbyte Slave Adresse
I2cwbyte Speicheradresse
I2cwbyte Wert
I2cstop 'Stop I2C
Waitms 10 'warte 10ms

'--- lesen vom EEprom --------------------------------------------
I2cstart 'Start I2C
I2cwbyte Slave Adresse
I2cwbyte Speicheradresse

I2cstart 'Start I2C
I2cwbyte Slave Adresse +1 für schreiben
I2crbyte lese Wert
I2cstop 'Stop I2C
</pre>

=== Beispiel für EEprom 24C16 ===
Zum besseren Verständnis werden hier die I2C Befehle untereinander geschrieben.
In einem grösserem Programm empfiehlt es sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/Lesevorgang abwickelt.

'''Beispiel :'''
<pre>
'============I2C EEprom schreiben/lesen ==================================

' =========== Für 24C16 EEprom =====================
' 8MHz Quarz
' LCD auf Port B ,
'
$regfile = "m8def.dat"
$crystal = 8000000

'---Config für LCD -----------------
Config Lcd = 40 * 2
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5
Config Lcdbus = 4
Config Lcdmode = Port
Cursor On

'SDA und SCL definieren
Config Sda = Portd.5
Config Scl = Portd.7

Dim X As Byte
Dim A As Byte
Dim B As Byte
Dim Lesen As Byte

CLS
Do
'---- schreibe in EEprom ----
For A = 1 To 10
Incr X '1 bis Überlauf zählen

I2cstart 'Start I2C
I2cwbyte &HA0 'Sende Slave Adresse
I2cwbyte A 'Sende Speicheradresse
I2cwbyte X 'Sende Wert
I2cstop 'Stop I2C
Waitms 10 'warte 10ms

Locate 1 , 1
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD
Waitms 500
Next A

'--- lesen vom EEprom ----
For B = 1 To 10

I2cstart 'Start I2C
I2cwbyte &HA0 'sende Slave Adresse
I2cwbyte B 'sende Speicheradresse

I2cstart 'Start I2C
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben
I2crbyte Lesen , Nack 'lese Adresse vom EEprom
I2cstop 'Stop I2C

Locate 2 , 1
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte
Waitms 500
Next B

Loop
End
</pre>

Schleife A schreibt den Wert 1-10 in die Speicherstelle 1-10 
Schleife B liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.

=== Beispiel für EEprom 24C256 ===

EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)
Darum muss man den Adressberreich in High und Low Adressbereich trennen.
(Zuerst High-Adressberreich schreiben und dann Low-Adressbereich)

'''Beispiel: ''' 
Wie Beispiel oben, nur mit erweiterten Adressbereich.
<pre>
'============I2C EEprom schreiben/lesen ==================================

' =========== Für 24C256 EEprom =====================
' 8MHz Quarz
' LCD auf Port B ,
'
$regfile = "m8def.dat"
$crystal = 8000000

'---Config für LCD -----------------
Config Lcd = 40 * 2
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5
Config Lcdbus = 4
Config Lcdmode = Port
Cursor On

'SDA und SCL definieren
Config Sda = Portd.5
Config Scl = Portd.7

Dim X As Byte
Dim A As Byte
Dim B As Byte
Dim Lesen As Byte
CLS

Do
'---- schreibe in EEprom ----
For A = 1 To 10
Incr X '1 bis Überlauf zählen

I2cstart 'Start I2C
I2cwbyte &HA0 'Sende Slave Adresse
I2cwbyte 1 'Sende Speicheradresse High
I2cwbyte A 'Sende Speicheradresse LOw
I2cwbyte X 'Sende Wert
I2cstop 'Stop I2C
Waitms 10 'warte 10ms

Locate 1 , 1
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD
Waitms 500
Next A

'--- lesen vom EEprom ----
For B = 1 To 10

I2cstart 'Start I2C
I2cwbyte &HA0 'sende Slave Adresse
I2cwbyte 1 'sende Speicheradresse High
I2cwbyte B 'sende Speicheradresse Low

I2cstart 'Start I2C
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben
I2crbyte Lesen , Nack 'lese Adresse vom EEprom
I2cstop 'Stop I2C

Locate 2 , 1
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte
Waitms 500
Next B

Loop
End
</pre>

=== High/Low Adressbereich mit Overlay leicht ansprechen ===

<pre>
'============I2C EEprom lesen/schreiben ==================================

'===========Für 24C256 EEprom=====================
' 8MHz Quarz
' LCD auf Port B ,

$regfile = "m8def.dat"
$crystal = 8000000

'---Config für LCD -----------------
Config Lcd = 40 * 2
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5
Config Lcdbus = 4
Config Lcdmode = Port
Cursor On

Config Sda = Portd.5 ' I2C-Port festlegen
Config Scl = Portd.7 ' I2C-Port festlegen

Dim X As Byte
Dim A As Word
Dim B As Word
Dim Schreiben As Byte
Dim Lesen As Byte

Dim Adresse As Word At $160 'Die Adresse als Word-Variable
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte

'===================Hauptprogramm===============================================
Do

'----schreiben----
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze
Incr X '1 bis Überlauf

I2cstart 'Start
I2cwbyte &HA0 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse LOW
I2cwbyte X 'Sende Wert
I2cstop 'stop
Waitms 10

Locate 1 , 1
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben
Waitms 500
Next Adresse

'---lesen----
For Adresse = 250 To 260
I2cstart 'Start
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse Low

I2cstart 'Start
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom
I2cstop 'Stop

Locate 2 , 1
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen
Waitms 500
Next Adresse

Loop
End
</pre>

=== Die Sache mit dem Overlay : ===

Dim Adresse As Word At $160

Hier definiere ich die Variable für die Adresse vom I2C-EEprom als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161

Mit:
Dim Low_adresse As Byte At $160 Overlay
Dim High_adresse As Byte At $161 Overlay
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.

"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !

Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.

Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Bascom]]
* [[EEPROM]]
* [[I2C]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom Roboternetz-Thread]
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom Roboternetz-Thread]
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom Roboternetz-Thread]
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661 Roboternetz-Thread]
* http://www.eseo.de/i2c.htm

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bezugsquellen

2006-02-06T16:47:44Z

Darth Ding: /* Sensoren */

{| {{Blaueschmaltabelle}}
|Hier können Bezugsquellen eingetragen werden! Bitte aber pro Eintrag nicht mehr als '''2 bis 3 Zeilen''', ansonsten muss es ein Moderator kürzen! Dieser Artikel soll nicht als Werbeplattform mißbraucht werden, für Werbung gibts andere [[RN-Wissen:Site_support|Möglichkeiten]]. Er soll eine Hilfe für Bastler sein!
Bitte auch keine Bewertungen der Lieferanten vornehmen, das ist Sache der Leser & Bastler indem Sie vergleichen.
|}

==Elektronikbauteile==

;Conrad - http://www.conrad.de: Fast das gesamte Elektronikprogramm

;CSD-Electronic - http://www.csd-electronics.de/: Elektronik

;Distrelec Gruppe - http://www.distrelec.com: Diverse Bauelemente (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, usw.

;Farnell In One - http://de.farnell.com/: elektronische Bauelemente (aktiv, passiv, Microcontroller), Sensoren, Literatur, Entwicklungskits, Kabel, Steckverbinder, Werkstattbedarf. Auch für privat. Sehr schnell.

;Reichelt - http://www.reichelt.de: Diverse Bauelemente (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, Lichttechnik, Messtechnik, Software, Kabel, Steckverbinder, Werkstattbedarf, Werkzeug, Mindestbestellwert: 10 Euro

;RS-Components - http://www.rsonline.de: Bauelemente: (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, Lichttechnik, Messtechnik, Software, Kabel, Steckverbinder, Werkzeug

==Sensoren==

;Robotikhardware - http://www.robotikhardware.de: Drehgeber, Sharp-Entfernungssensoren, Neigungssensoren, Temperatursendoren usw. speziell für Robotik-Bastler

;Micromaus - http://www.micromaus.de: Sharp-Entfernungssensoren, Farbsensoren, Feuchtesensoren, Flexsensoren, Beschleunigungssensoren, Drucksensoren usw.

;Roboter-Teile - http://www.roboter-teile.de/ : Lynxmotion Hexapot, Sensoren, CMU-Cam, AVR, PIC u.v.a.

==Motoren==

;mir-elektronik - http://www.mir-elektronik.de: Schrittmotoren, Endstufen, Bauteile, Literatur und Sonderposten
;Lemo-Solar - http://lemo-solar.de/: Motoren, Getriebe, Elektronik-Bausätze, Sonderposten u.v.a.

==Platinen==

;Multipcb - http://www.multipcb.de: Platinenservice für gewerbliche Kunden

;PCB-Pool - http://pcb-pool.com: Platinenservice für private und gewerbliche Kunden

==Materialien==

;Metall Store - http://www.metallstore.de/: Schrittmotoren, (Kugel-)Lager, diverse Bauelemente aus Alu, VA, Messing, Bronze, Kupfer, Werkzeuge, Spezialschrauben

;Modulor - http://www.modulor.de/: Diverse Materialien Kunststoff, Gummi, Papier, Pappe, Holz, Metall, Textilien, Plexiglas ...

;Igus - http://www.igus.de/: Gleitlager, Lineargleitlager, Kabelschleppen, Gelenklager, Polymergleitlager, Wellen ...

==Roboterboards==
;Robotikhardware - http://www.robotikhardware.de: Spezielle Roboterboards, universelle Microcontrollerboards, Sprachboards, Bausätze, Platinen, Schrittmotoren etc. Berückichtigt [[RN-Definitionen]]

[[Kategorie:Praxis|!]]

Bezugsquellen

2006-02-06T16:47:30Z

Darth Ding: /* Motoren */

{| {{Blaueschmaltabelle}}
|Hier können Bezugsquellen eingetragen werden! Bitte aber pro Eintrag nicht mehr als '''2 bis 3 Zeilen''', ansonsten muss es ein Moderator kürzen! Dieser Artikel soll nicht als Werbeplattform mißbraucht werden, für Werbung gibts andere [[RN-Wissen:Site_support|Möglichkeiten]]. Er soll eine Hilfe für Bastler sein!
Bitte auch keine Bewertungen der Lieferanten vornehmen, das ist Sache der Leser & Bastler indem Sie vergleichen.
|}

==Elektronikbauteile==

;Conrad - http://www.conrad.de: Fast das gesamte Elektronikprogramm

;CSD-Electronic - http://www.csd-electronics.de/: Elektronik

;Distrelec Gruppe - http://www.distrelec.com: Diverse Bauelemente (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, usw.

;Farnell In One - http://de.farnell.com/: elektronische Bauelemente (aktiv, passiv, Microcontroller), Sensoren, Literatur, Entwicklungskits, Kabel, Steckverbinder, Werkstattbedarf. Auch für privat. Sehr schnell.

;Reichelt - http://www.reichelt.de: Diverse Bauelemente (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, Lichttechnik, Messtechnik, Software, Kabel, Steckverbinder, Werkstattbedarf, Werkzeug, Mindestbestellwert: 10 Euro

;RS-Components - http://www.rsonline.de: Bauelemente: (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, Lichttechnik, Messtechnik, Software, Kabel, Steckverbinder, Werkzeug

==Sensoren==

;Robotikhardware - http://www.robotikhardware.de: Drehgeber, Sharp-Entfernungssensoren, Neigungssensoren, Temperatursendoren usw. speziell für Robotik-Bastler

;Micromaus - http://www.micromaus.de: Sharp-Entfernungssensoren, Farbsensoren, Feuchtesensoren, Flexsensoren, Beschleunigungssensoren, Drucksensoren usw.

==Motoren==

;mir-elektronik - http://www.mir-elektronik.de: Schrittmotoren, Endstufen, Bauteile, Literatur und Sonderposten
;Lemo-Solar - http://lemo-solar.de/: Motoren, Getriebe, Elektronik-Bausätze, Sonderposten u.v.a.

==Platinen==

;Multipcb - http://www.multipcb.de: Platinenservice für gewerbliche Kunden

;PCB-Pool - http://pcb-pool.com: Platinenservice für private und gewerbliche Kunden

==Materialien==

;Metall Store - http://www.metallstore.de/: Schrittmotoren, (Kugel-)Lager, diverse Bauelemente aus Alu, VA, Messing, Bronze, Kupfer, Werkzeuge, Spezialschrauben

;Modulor - http://www.modulor.de/: Diverse Materialien Kunststoff, Gummi, Papier, Pappe, Holz, Metall, Textilien, Plexiglas ...

;Igus - http://www.igus.de/: Gleitlager, Lineargleitlager, Kabelschleppen, Gelenklager, Polymergleitlager, Wellen ...

==Roboterboards==
;Robotikhardware - http://www.robotikhardware.de: Spezielle Roboterboards, universelle Microcontrollerboards, Sprachboards, Bausätze, Platinen, Schrittmotoren etc. Berückichtigt [[RN-Definitionen]]

[[Kategorie:Praxis|!]]

Bezugsquellen

2006-02-06T16:47:01Z

Darth Ding: /* Motoren */

{| {{Blaueschmaltabelle}}
|Hier können Bezugsquellen eingetragen werden! Bitte aber pro Eintrag nicht mehr als '''2 bis 3 Zeilen''', ansonsten muss es ein Moderator kürzen! Dieser Artikel soll nicht als Werbeplattform mißbraucht werden, für Werbung gibts andere [[RN-Wissen:Site_support|Möglichkeiten]]. Er soll eine Hilfe für Bastler sein!
Bitte auch keine Bewertungen der Lieferanten vornehmen, das ist Sache der Leser & Bastler indem Sie vergleichen.
|}

==Elektronikbauteile==

;Conrad - http://www.conrad.de: Fast das gesamte Elektronikprogramm

;CSD-Electronic - http://www.csd-electronics.de/: Elektronik

;Distrelec Gruppe - http://www.distrelec.com: Diverse Bauelemente (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, usw.

;Farnell In One - http://de.farnell.com/: elektronische Bauelemente (aktiv, passiv, Microcontroller), Sensoren, Literatur, Entwicklungskits, Kabel, Steckverbinder, Werkstattbedarf. Auch für privat. Sehr schnell.

;Reichelt - http://www.reichelt.de: Diverse Bauelemente (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, Lichttechnik, Messtechnik, Software, Kabel, Steckverbinder, Werkstattbedarf, Werkzeug, Mindestbestellwert: 10 Euro

;RS-Components - http://www.rsonline.de: Bauelemente: (aktiv, passiv, Microcontroller), Literatur, PC-Komponenten, Lichttechnik, Messtechnik, Software, Kabel, Steckverbinder, Werkzeug

==Sensoren==

;Robotikhardware - http://www.robotikhardware.de: Drehgeber, Sharp-Entfernungssensoren, Neigungssensoren, Temperatursendoren usw. speziell für Robotik-Bastler

;Micromaus - http://www.micromaus.de: Sharp-Entfernungssensoren, Farbsensoren, Feuchtesensoren, Flexsensoren, Beschleunigungssensoren, Drucksensoren usw.

==Motoren==

;mir-elektronik - http://www.mir-elektronik.de: Schrittmotoren, Endstufen, Bauteile, Literatur und Sonderposten
;Lemo-Solar - http://lemo-solar.de/: Motoren, Getriebe, Elektronik-Bausätze, Sonderposten u.v.a.
;Roboter-Teile - http://www.roboter-teile.de/ : Lynxmotion Hexapot, Sensoren, CMU-Cam, AVR, PIC u.v.a.

==Platinen==

;Multipcb - http://www.multipcb.de: Platinenservice für gewerbliche Kunden

;PCB-Pool - http://pcb-pool.com: Platinenservice für private und gewerbliche Kunden

==Materialien==

;Metall Store - http://www.metallstore.de/: Schrittmotoren, (Kugel-)Lager, diverse Bauelemente aus Alu, VA, Messing, Bronze, Kupfer, Werkzeuge, Spezialschrauben

;Modulor - http://www.modulor.de/: Diverse Materialien Kunststoff, Gummi, Papier, Pappe, Holz, Metall, Textilien, Plexiglas ...

;Igus - http://www.igus.de/: Gleitlager, Lineargleitlager, Kabelschleppen, Gelenklager, Polymergleitlager, Wellen ...

==Roboterboards==
;Robotikhardware - http://www.robotikhardware.de: Spezielle Roboterboards, universelle Microcontrollerboards, Sprachboards, Bausätze, Platinen, Schrittmotoren etc. Berückichtigt [[RN-Definitionen]]

[[Kategorie:Praxis|!]]

Bascom und PWM

2006-01-24T19:27:14Z

Darth Ding: /* Grundbegriffe */

== Mit Bascom, PWM-Signale erzeugen ==
(Bezogen auf den Mega8. Aber es gilt in etwa, auch für andere AVR's)

===Grundbegriffe===
'''Puls Weiten Modulation (PWM)'''

Bei der Puls-Weiten-Modulation (PWM), wird ein digitales Ausgangssignal erzeugt, dessen Tastverhältnis moduliert wird.

Das Tastverhältnis gibt das Verhältnis der Länge des eingeschalteten Zustands zur Periodendauer an. Dabei bleiben die Frequenz und der Pegel des Signals immer
gleich!
Es ändert sich nur die Länge von High zu Low.

Dieses Bild zeigt ein Tastverhältnis von 10% und 50 % 

[[Bild:Tastverhältnis.png|center]]

Man könnte das in etwa mit einem Wasserhahn vergleichen, den man z.B. alle Minuten betätigt.
Wenn man ihn in jeder Minute nur kurz aufdreht, und dann gleich wieder zumacht,
kommt in Summe nur wenig Wasser raus.
Wenn man ihn aber in jeder dieser Minuten länger offen lässt,
kommt mehr Wasser raus.

Der Rhythmus bleibt immer gleich, aber es ändert sich in Summe die Wassermenge,
die raus kommt.

Mit dem PWM Signal kann man nun tolle Sachen machen.
Zum Beispiel eine LED (oder über einen Transistor auch eine Lampe) an den PWM Ausgang anschliessen und mit der Länge des PWM-Signal’s die Helligkeit der LED verändern.

Oder auch einen Motor in der Geschwindigkeit regeln.

Man kann aber auch dem PWM-Signal einen RC-Filter nachschalten, das das
PWM-Signal glättet. Dann hat man eine regelbare Gleichspannung, in der das Minimum
dann 0V und das Maximum 5V ist.

Es gibt grundsätzlich zwei Gruppen von PWM-Arten

'''Software PWM und Hardware PWM '''

;'''Software PWM'''
:Vorteile: Man kann dieses PWM auf jeden Ausgabe-Pin des AVR anwenden.
:Nachteil: Da das PWM per Software gemacht wird, ist er eher langsam.

;'''Hardware PWM'''
:Vorteile: Sehr schnell (Maximal die Quarzfrequenz / Periode)
:Nachteile: Man kann nur bestimmte Ausgänge dafür verwenden

Der Mega8 hat nun drei Hardware PWM Ausgänge.
Diese laufen nach Definition der Register/Werte selbstständig ab.
(Darum ist Hardware-PWM auch sehr schnell und belastet die Abarbeitung des Programms nicht.)
Leider sind die Ausgänge aber bestimmten Ausgangs Pin’s fix zugeordnet.
Man kann diese also nicht auf andere Pins legen und muss sich deshalb vorher
Gedanken machen, wie man den Mega8 beschaltet.

Ganz anders beim Software-PWM, dass ja rein Software mäßig erzeugt wird
und wo man dann das PWM-Signal fast an jeden Pin ausgeben kann.

Für die Hardware-PWM Erzeugung kann man beim Mega8
den Timer1 und den Timer2 verwänden.

Timer1 hat zwei Compare Register und kann dadurch zwei PWM Signale erzeugen.
(Compare A = Pin 15 und Compare B= Pin 16)
Weiters kann man beim Timer1 eine Auflösung von 8, 9 und 10 Bit einstellen.

Timer2 hat nur ein Compare Register (Ausgang am Pin 17), nur 8 Bit
Auflösung und kann auch nur ein PWM erzeugen.

=== PWM-Ablauf: ===

Unteres Bild zeigt den Ablauf für das PWM beim Timer1.
Es kommt zuerst die Frequenz vom Takterzeuger (Quarz), geht über den Prescaler zum Timer.
Beim Timer schaltet das Compare Register je nach seinem eingestellten Wert
 und erzeugt somit das PWM-Signal am Ausgangs-Pin

[[Bild:PWM.png|center]]

===Genauere Erklärung:===

Der Prescaler, teilt die Frequenz die vom Quarz kommt!
Bei Teilung 1, geht die vollständige Frequenz zum Timer.
Bei Teilung 8, nur ein Achtel der Quarzfrequenz.
(Also bei 8 MHz Quarz kommen zum Timer dann nur 1 MHz )
Bei Teilung 1024 sind es dann z.B. 8 MHz/1024 = 7,8125kHz

Der Timer ist hier der Zähler für das PWM.
Er zählt mit der Frequenz, die vom Prescaler kommt, einmal von 0 bis
zu der eingestellten Timerauflösung rauf, dann wieder auf 0 zurück.
(dann wieder von 0 auf Timerauflösung u.s.w.)
Einmal rauf und runterzählen, ergibt ein Periode.
Die Periode ist gleich die Ausgangsfrequenz von dem PWM-Signal.
Ausgangsfrequenz = (Quarzfrequenz/Prescale ) /(Timerauflösung*2)

z.B.: Quarz = 8 MHz ; Prescaler = 1 ; Timer = 8 Bit
ergibt: (8000000Hz/1) / (256*2) = 15,625 kHz 

oder: Quarz = 8 MHz ; Prescaler = 8 ; Timer = 10 Bit
ergibt: (8000000Hz/8) / (2048*2) = 244,14 Hz

Mit dem Compare Register definiert man nun das Tastverhältnis!
Überall, wo nun der Timer diese Compare Linie schneidet, schaltet der Ausgang!
Beim raufzählen des Timers auf EIN, beim runterzählen auf AUS.

Als Beispiel ein Tastverhältnis von 20%
[[Bild:Compare205.png|center]]

Als Beispiel ein Tastverhältnis von 80% 
[[Bild:Compare51.png|center]]

Hier sieht man, wie die Signale dann auf einem Osciloskop ausschauen.
Oben das Signal von Pin15 (Compare A) , unten das von Pin 16 (Compare B)
[[Bild:Osci-PWM-kleiner3.GIF|center]]

=== Grundprogramm ===

Hier nun ein Grundprogramm für die Ausgabe von zwei PWM Signalen mit dem Timer1

<pre>
' Hardware PWM mit Timer1

$regfile = "m8def.dat"
$crystal = 4000000

Config Pinb.1 = Output
Config Pinb.2 = Output

Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1

Do
Compare1a = 205
Compare1b = 51
Loop

End
</pre>

''' Erklärung:'''
<pre>
$regfile = "m8def.dat"
$crystal = 8000000
</pre>
Definiert den Mega8 und den 8MHz Quarz

<pre>
Config Pinb.1 = Output
Config Pinb.2 = Output
</pre>
Definiert die zwei Ausgänge von Timer1 auf Ausgabe. 
Pinb.1 = für Compare1a (= Compare A) = Pin 15 
Pinb.2 = für Compare1b (= Compare B) = Pin 16

<pre>
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1
</pre>
;Config Timer1 = Pwm
: Timer1 auf PWM einstellen

;Pwm = 8
:Timer Auflösung = 8 Bit einstellen

;Compare A Pwm = Clear Up:Definiert, wie der Compare A schalten soll. Bei „Clear Up“ schaltet der Ausgang beim erreichen
:des Compare-Wertes zuerst auf High und dann auf Low. Bei „Clear Down“, umgekehrt.

;Compare B Pwm = Clear Up
:Das gleiche noch mal mit Compare B

;Prescale = 1
:Hier wird der Prescaler auf 1 eingestellt.
:(Wert 1 heißt, direkte Frequenz vom Quarz zum Timer.)
:Weitere Teilungen, wie z.B.: 8, 64, 256 und 1024 sind möglich.

<pre>
Compare1a = 205
Compare1b = 51
</pre>
Hier kann man nun die Werte für das Tastverhältnis, in das Register Compare1a
und Compare1b schreiben. Oder man kann auch, satt Compare1a und 1b , die Bezeichnungen
Pwm1a und Pwm1b verwenden. Bascom nimmt beides.

Mit diesem kurzen Programm, hat man nun zwei PWM Signale erzeigt, wo das eine ein Tastverhältnis
von 20% (Compare1a) und das andere von 80 % hat. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Siehe auch==
* [[Avr]]
* [[Bascom]]
* [[Pwm]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und LCD's

2006-01-24T13:19:56Z

Darth Ding: /* Anschlussmöglichkeiten des Dispaly */

== Mit Bascom, LCD-Displays ansteuern ==

===LCD Display===

Ein LCD-Display kann man mit wenig Aufwand an einen AVR anschließen. Ein paar Leitungen, ein kleines Programm und schon hat man eine Anzeige für den AVR.

Es gibt unter den Displays zwei große Gruppen.

Die einen sind die Text-Displays (können nur Text und deren Sonderzeichen darstellen), die anderen sind die Grafik-Displays.

Hier geht es um Text- Displays.

====Anschlüsse:====

Die meisten Text-LCD’s haben einen 14 Poligen bzw. einen 16 Poligen Anschluss.
14 Polig ist meist ein LCD ohne Hintergrundbeleuchtung und beim 16 Poligen ist meist der Pin 15 und 16 die Beleuchtung.

Die Anschlüsse vom LCD-Display:

{|{{Blauetabelle}}
|1
|Vss
|GND
|-
|2
|Vcc
|5V
|-
|3
|Vee
|Kontrastspannung (0V bis 5V)
|-
|4
|RS
|Register Select (Befehle/Daten)
|-
|5
|RW
|Read/Write
|-
|6
|E
|Enable
|-
|7
|DB0
|Datenbit 0
|-
|8
|DB1
|Datenbit 1
|-
|9
|DB2
|Datenbit 2
|-
|10
|DB3
|Datenbit 3
|-
|11
|DB4
|Datenbit 4
|-
|12
|DB5
|Datenbit 5
|-
|13
|DB6
|Datenbit 6
|-
|14
|DB7
|Datenbit 7
|-
|15
|Beleuchtung
|GND
|-
|16
|Beleuchtung
|5V über mindestens einen 5 Ohm Widerstand anschließen)
|}

In den meisten Displays wird der Controllerchip HD44780 von Hitachi eingesetzt, oder auch der kompatible Bruder SED1278 von Epson. Auch in Verbindung mit dem Chip HD44100. (Auf der Rückseite vom Display nachschauen) Für alle diese trifft das obige Anschlussbild zu.

Hier ein LCD mit 16 Zeichen mal 2 Zeilen (16*2)
[[Bild:LCD 16 2 Vorderseite.jpg|center]]

Und davon die Rückseite, mit Chip HD44100 und HD44780
[[Bild:LCD_16_2_Rückseite_kleiner.jpg|center]]

Hier ein LCD mit 24 Zeichen in je 2 Zeilen
[[Bild:LCD_24_2_Vorderseite_kleiner.jpg|center]]

Und die Rückseite
[[Bild:LCD_24_2_Rückseite_kleiner.jpg|center]]

==== Anschluss ====
Die Stromversorgung eines LCD sieht so aus:
[[Bild:Stromversorgung.jpg|center]]

Mit dieser Beschaltung kann man schon mal probieren, ob man durch verdrehen des Kontrast-Potie, dunkle Vierecke zu sehen bekommt. Wenn ja, ist bis hier her schon mal alles ok .
Den Kontrast jetzt so einstellen, dass man gerade, diese dunklen Vierecke nicht mehr sieht.

==== Anschlussmöglichkeiten des Dispaly ====

Das Display besitzt neben der Stromversorgung noch die Anschlüsse: RW, RS , E und 8 Datenleitungen.

Es gibt zwei Möglichkeiten, wie man die 8 Datenleitungen des Displays an den AVR anschließen kann. 
Einmal den 8-Bit Modus und einmal den 4-Bit Modus.
Beim 8 Bit Modus schließt man alle 8 Datenleitungen an den AVR und kann in einem Schritt ein Zeichen (=1 Byte )in das Display übertragen.
Oder man macht es im 4 Bit Modus mit nur 4 Datenleitungen und muss dafür 2*4 Bit für ein Zeichen übertragen (4 Bit = ein Nibble)

Der Vorteil: 
Ich erspare mir somit 4 Leitungen des AVR’s und kann sie anderweitig nutzen.

Der Nachteil: 
Ich muss für ein Zeichen nun 2*4 Bit übertragen (= langsamer)

Aber da in diesem Fall die Geschwindigkeit nicht so eine große Rolle spielt und wir lieber 4 Leitungen mehr am AVR haben möchten, schließen wird das Display im 4Bit Modus an.

Anschlussbelegung für das Display im 4-Bit Modus: (Als Beispiel am Port D)

{|{{Blauetabelle}}
|
|Display
|Am AVR
|-
|1
|Vss
|GND
|-
|2
|Vcc
|5V
|-
|3
|Vee
|Poti (siehe oben)
|-
|4
|RS
|PD4 am AVR
|-
|5
|RW
|GND
|-
|6
|E
|PD5 am AVR
|-
|7
|DB0
|GND
|-
|8
|DB1
|GND
|-
|9
|DB2
|GND
|-
|10
|DB3
|GND
|-
|11
|DB4
|PD0 am AVR
|-
|12
|DB5
|PD1 am AVR
|-
|13
|DB6
|PD2 am AVR
|-
|14
|DB7
|PD3 am AVR
|-
|15
|Beleu.
|frei
|-
|16
|Beleu.
|frei
|}

Die vier Datenleitungen vom Display, die wir nicht brauchen, legen wir auf Masse. Zu den vier Datenleitungen brauchen wir noch die Leitungen RS und E. Den Anschluss RW brauchen wir nicht und legen ihn deshalb auch auf Masse.

Wir kommen somit für das Display mit 6 Datenleitungen aus, die wir alle an das Port D (vom Mega 8) anschließen.

=== Das Programm für das LCD ===
<pre>
$regfile = "m8def.dat"
$crystal = 4000000

Config Lcd = 16 * 2
Config Lcdpin = Pin , Db4 = Portd.0 , Db5 = Portd.1 , Db6 = Portd.2 , Db7 = Portd.3 , E = Portd.5 , Rs = Portd.4
Config Lcdbus = 4

Cls
Locate 1 , 1
Lcd "Hallo Welt"
</pre>
Dieses Programm gibt den Text „Hallo Welt“ auf dem Display aus.

'''Erklärung:'''
<pre>
$regfile = "m8def.dat"
$crystal = 4000000
</pre>
Definiert den Mega8 als Prozessor und einen 4 Mhz Quarz.

<pre>
Config Lcd = 16 * 2
</pre>
Definiert das LCD-Display als 16*2 Anzeige.
Sind somit zwei Zeilen mit jeweils 16 Zeichen. 
Folgende weitere Typen von LCD’s könnte man angeben:
16*1 , 16*2 , 16*4 , 20*2 , 20*4 , 40*4

<pre>
Config Lcdpin = Pin , Db4 = Portd.0 , Db5 = Portd.1 , Db6 = Portd.2 , Db7 = Portd.3 , E = Portd.5 , Rs = Portd.4
</pre>
Definiert, wo das Display an den AVR angeschlossen wird. Db4, Db5, Db6....., E , RS sind die Pins vom LCD (siehe Tabelle) 
Portd.0, Portd.1 u.s.w., sind die Port’s vom Mega8 (Port D) 
Heißt also: Die Leitung Db4 vom LCD wird an den Port PD0
angeschlossen (Pin 2 am Mega8) 
Mit diesem Befehl, kann man das LCD auch an andere Pins vom AVR anschließen

<pre>
Config Lcdbus = 4
</pre>
Definiert den 4-Bit Modus für das LCD.
Beim 8-Bit Modus, müsste man statt der 4 eine 8 schreiben.
Der AVR weis dann, wie viele Datenleitungen angeschlossen wurden und wie er den Datentransfer zu dem LCD durchführen muss.

<pre>
Cls
Locate 1 , 1
</pre>
Cls löscht das LCD-Display und Locate 1,1 definiert die nächste Ausgabe mit 1.) Zeile, 1.)Position 
(Locate 2,10 wäre dann ausgabe in Zeile 2 und an zehnter Position )

<pre>
Lcd "Hallo Welt"
</pre>
Mit LCD kann man nun den Text ausgeben. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Weblinks==
* [http://www.sprut.de/electronic/lcd/index.htm#einleitung Sprut]

==Siehe auch==
* [[Avr]]
* [[Bascom]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und LCD's

2006-01-24T13:18:28Z

Darth Ding: /* LCD Display */

== Mit Bascom, LCD-Displays ansteuern ==

===LCD Display===

Ein LCD-Display kann man mit wenig Aufwand an einen AVR anschließen. Ein paar Leitungen, ein kleines Programm und schon hat man eine Anzeige für den AVR.

Es gibt unter den Displays zwei große Gruppen.

Die einen sind die Text-Displays (können nur Text und deren Sonderzeichen darstellen), die anderen sind die Grafik-Displays.

Hier geht es um Text- Displays.

====Anschlüsse:====

Die meisten Text-LCD’s haben einen 14 Poligen bzw. einen 16 Poligen Anschluss.
14 Polig ist meist ein LCD ohne Hintergrundbeleuchtung und beim 16 Poligen ist meist der Pin 15 und 16 die Beleuchtung.

Die Anschlüsse vom LCD-Display:

{|{{Blauetabelle}}
|1
|Vss
|GND
|-
|2
|Vcc
|5V
|-
|3
|Vee
|Kontrastspannung (0V bis 5V)
|-
|4
|RS
|Register Select (Befehle/Daten)
|-
|5
|RW
|Read/Write
|-
|6
|E
|Enable
|-
|7
|DB0
|Datenbit 0
|-
|8
|DB1
|Datenbit 1
|-
|9
|DB2
|Datenbit 2
|-
|10
|DB3
|Datenbit 3
|-
|11
|DB4
|Datenbit 4
|-
|12
|DB5
|Datenbit 5
|-
|13
|DB6
|Datenbit 6
|-
|14
|DB7
|Datenbit 7
|-
|15
|Beleuchtung
|GND
|-
|16
|Beleuchtung
|5V über mindestens einen 5 Ohm Widerstand anschließen)
|}

In den meisten Displays wird der Controllerchip HD44780 von Hitachi eingesetzt, oder auch der kompatible Bruder SED1278 von Epson. Auch in Verbindung mit dem Chip HD44100. (Auf der Rückseite vom Display nachschauen) Für alle diese trifft das obige Anschlussbild zu.

Hier ein LCD mit 16 Zeichen mal 2 Zeilen (16*2)
[[Bild:LCD 16 2 Vorderseite.jpg|center]]

Und davon die Rückseite, mit Chip HD44100 und HD44780
[[Bild:LCD_16_2_Rückseite_kleiner.jpg|center]]

Hier ein LCD mit 24 Zeichen in je 2 Zeilen
[[Bild:LCD_24_2_Vorderseite_kleiner.jpg|center]]

Und die Rückseite
[[Bild:LCD_24_2_Rückseite_kleiner.jpg|center]]

==== Anschluss ====
Die Stromversorgung eines LCD sieht so aus:
[[Bild:Stromversorgung.jpg|center]]

Mit dieser Beschaltung kann man schon mal probieren, ob man durch verdrehen des Kontrast-Potie, dunkle Vierecke zu sehen bekommt. Wenn ja, ist bis hier her schon mal alles ok .
Den Kontrast jetzt so einstellen, dass man gerade, diese dunklen Vierecke nicht mehr sieht.

==== Anschlussmöglichkeiten des Dispaly ====

Das Display besitzt neben der Stromversorgung noch die Anschlüsse: RW, RS , E und 8 Datenleitungen.

Es gibt zwei Möglichkeiten, wie man die 8 Datenleitungen des Displays an den AVR anschließen kann. 
Einmal den 8-Bit Modus und einmal den 4-Bit Modus.
Beim 8 Bit Modus, schließt man alle 8 Datenleitungen an den AVR und kann in einem Schritt, ein Zeichen (=1 Byte )in das Display übertragen.
Oder man macht es im 4 Bit Modus, mit nur 4 Datenleitungen und muss dafür 2*4 Bit für ein Zeichen übertragen (4 Bit = ein Nibble)

Der Vorteil: 
Ich erspare mir somit 4 Leitungen des AVR’s und kann sie anderweitig nutzen.

Der Nachteil: 
Ich muss für ein Zeichen nun 2*4 Bit übertragen (= langsamer)

Aber, da in diesem Fall die Geschwindigkeit nicht so eine große Rolle spielt und wir lieber 4 Leitungen mehr am AVR haben möchten, schließen wird das Display im 4Bit Modus an.

Anschlussbelegung für das Display im 4-Bit Modus: (Als Beispiel am Port D)

{|{{Blauetabelle}}
|
|Display
|Am AVR
|-
|1
|Vss
|GND
|-
|2
|Vcc
|5V
|-
|3
|Vee
|Poti (siehe oben)
|-
|4
|RS
|PD4 am AVR
|-
|5
|RW
|GND
|-
|6
|E
|PD5 am AVR
|-
|7
|DB0
|GND
|-
|8
|DB1
|GND
|-
|9
|DB2
|GND
|-
|10
|DB3
|GND
|-
|11
|DB4
|PD0 am AVR
|-
|12
|DB5
|PD1 am AVR
|-
|13
|DB6
|PD2 am AVR
|-
|14
|DB7
|PD3 am AVR
|-
|15
|Beleu.
|frei
|-
|16
|Beleu.
|frei
|}

Die vier Datenleitungen vom Display, die wir nicht brauchen, legen wir auf Masse. Zu den vier Datenleitungen brauchen wir noch die Leitungen RS und E. Den Anschluss RW brauchen wir nicht und legen ihn deshalb auch auf Masse.

Wir kommen somit für das Display mit 6 Datenleitungen aus, die wir alle an das Port D (vom Mega 8) anschließen.

=== Das Programm für das LCD ===
<pre>
$regfile = "m8def.dat"
$crystal = 4000000

Config Lcd = 16 * 2
Config Lcdpin = Pin , Db4 = Portd.0 , Db5 = Portd.1 , Db6 = Portd.2 , Db7 = Portd.3 , E = Portd.5 , Rs = Portd.4
Config Lcdbus = 4

Cls
Locate 1 , 1
Lcd "Hallo Welt"
</pre>
Dieses Programm gibt den Text „Hallo Welt“ auf dem Display aus.

'''Erklärung:'''
<pre>
$regfile = "m8def.dat"
$crystal = 4000000
</pre>
Definiert den Mega8 als Prozessor und einen 4 Mhz Quarz.

<pre>
Config Lcd = 16 * 2
</pre>
Definiert das LCD-Display als 16*2 Anzeige.
Sind somit zwei Zeilen mit jeweils 16 Zeichen. 
Folgende weitere Typen von LCD’s könnte man angeben:
16*1 , 16*2 , 16*4 , 20*2 , 20*4 , 40*4

<pre>
Config Lcdpin = Pin , Db4 = Portd.0 , Db5 = Portd.1 , Db6 = Portd.2 , Db7 = Portd.3 , E = Portd.5 , Rs = Portd.4
</pre>
Definiert, wo das Display an den AVR angeschlossen wird. Db4, Db5, Db6....., E , RS sind die Pins vom LCD (siehe Tabelle) 
Portd.0, Portd.1 u.s.w., sind die Port’s vom Mega8 (Port D) 
Heißt also: Die Leitung Db4 vom LCD wird an den Port PD0
angeschlossen (Pin 2 am Mega8) 
Mit diesem Befehl, kann man das LCD auch an andere Pins vom AVR anschließen

<pre>
Config Lcdbus = 4
</pre>
Definiert den 4-Bit Modus für das LCD.
Beim 8-Bit Modus, müsste man statt der 4 eine 8 schreiben.
Der AVR weis dann, wie viele Datenleitungen angeschlossen wurden und wie er den Datentransfer zu dem LCD durchführen muss.

<pre>
Cls
Locate 1 , 1
</pre>
Cls löscht das LCD-Display und Locate 1,1 definiert die nächste Ausgabe mit 1.) Zeile, 1.)Position 
(Locate 2,10 wäre dann ausgabe in Zeile 2 und an zehnter Position )

<pre>
Lcd "Hallo Welt"
</pre>
Mit LCD kann man nun den Text ausgeben. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Weblinks==
* [http://www.sprut.de/electronic/lcd/index.htm#einleitung Sprut]

==Siehe auch==
* [[Avr]]
* [[Bascom]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]

Bascom und LCD's

2006-01-24T13:17:04Z

Darth Ding: /* Anschlüsse: */

== Mit Bascom, LCD-Displays ansteuern ==

===LCD Display===

Ein LCD-Display, kann man mit wenig Aufwand an einen AVR anschließen. Ein paar Leitungen, ein kleines Programm und schon hat man eine Anzeige für den AVR.

Es gibt unter den Displays zwei große Gruppen.

Das eine sind die Text-Displays (können nur Text und deren Sonderzeichen darstellen), das andere sind die Grafik-Displays.

Hier geht es um Text- Displays.

====Anschlüsse:====

Die meisten Text-LCD’s haben einen 14 Poligen bzw. einen 16 Poligen Anschluss.
14 Polig ist meist ein LCD ohne Hintergrundbeleuchtung und beim 16 Poligen ist meist der Pin 15 und 16 die Beleuchtung.

Die Anschlüsse vom LCD-Display:

{|{{Blauetabelle}}
|1
|Vss
|GND
|-
|2
|Vcc
|5V
|-
|3
|Vee
|Kontrastspannung (0V bis 5V)
|-
|4
|RS
|Register Select (Befehle/Daten)
|-
|5
|RW
|Read/Write
|-
|6
|E
|Enable
|-
|7
|DB0
|Datenbit 0
|-
|8
|DB1
|Datenbit 1
|-
|9
|DB2
|Datenbit 2
|-
|10
|DB3
|Datenbit 3
|-
|11
|DB4
|Datenbit 4
|-
|12
|DB5
|Datenbit 5
|-
|13
|DB6
|Datenbit 6
|-
|14
|DB7
|Datenbit 7
|-
|15
|Beleuchtung
|GND
|-
|16
|Beleuchtung
|5V über mindestens einen 5 Ohm Widerstand anschließen)
|}

In den meisten Displays wird der Controllerchip HD44780 von Hitachi eingesetzt, oder auch der kompatible Bruder SED1278 von Epson. Auch in Verbindung mit dem Chip HD44100. (Auf der Rückseite vom Display nachschauen) Für alle diese trifft das obige Anschlussbild zu.

Hier ein LCD mit 16 Zeichen mal 2 Zeilen (16*2)
[[Bild:LCD 16 2 Vorderseite.jpg|center]]

Und davon die Rückseite, mit Chip HD44100 und HD44780
[[Bild:LCD_16_2_Rückseite_kleiner.jpg|center]]

Hier ein LCD mit 24 Zeichen in je 2 Zeilen
[[Bild:LCD_24_2_Vorderseite_kleiner.jpg|center]]

Und die Rückseite
[[Bild:LCD_24_2_Rückseite_kleiner.jpg|center]]

==== Anschluss ====
Die Stromversorgung eines LCD sieht so aus:
[[Bild:Stromversorgung.jpg|center]]

Mit dieser Beschaltung kann man schon mal probieren, ob man durch verdrehen des Kontrast-Potie, dunkle Vierecke zu sehen bekommt. Wenn ja, ist bis hier her schon mal alles ok .
Den Kontrast jetzt so einstellen, dass man gerade, diese dunklen Vierecke nicht mehr sieht.

==== Anschlussmöglichkeiten des Dispaly ====

Das Display besitzt neben der Stromversorgung noch die Anschlüsse: RW, RS , E und 8 Datenleitungen.

Es gibt zwei Möglichkeiten, wie man die 8 Datenleitungen des Displays an den AVR anschließen kann. 
Einmal den 8-Bit Modus und einmal den 4-Bit Modus.
Beim 8 Bit Modus, schließt man alle 8 Datenleitungen an den AVR und kann in einem Schritt, ein Zeichen (=1 Byte )in das Display übertragen.
Oder man macht es im 4 Bit Modus, mit nur 4 Datenleitungen und muss dafür 2*4 Bit für ein Zeichen übertragen (4 Bit = ein Nibble)

Der Vorteil: 
Ich erspare mir somit 4 Leitungen des AVR’s und kann sie anderweitig nutzen.

Der Nachteil: 
Ich muss für ein Zeichen nun 2*4 Bit übertragen (= langsamer)

Aber, da in diesem Fall die Geschwindigkeit nicht so eine große Rolle spielt und wir lieber 4 Leitungen mehr am AVR haben möchten, schließen wird das Display im 4Bit Modus an.

Anschlussbelegung für das Display im 4-Bit Modus: (Als Beispiel am Port D)

{|{{Blauetabelle}}
|
|Display
|Am AVR
|-
|1
|Vss
|GND
|-
|2
|Vcc
|5V
|-
|3
|Vee
|Poti (siehe oben)
|-
|4
|RS
|PD4 am AVR
|-
|5
|RW
|GND
|-
|6
|E
|PD5 am AVR
|-
|7
|DB0
|GND
|-
|8
|DB1
|GND
|-
|9
|DB2
|GND
|-
|10
|DB3
|GND
|-
|11
|DB4
|PD0 am AVR
|-
|12
|DB5
|PD1 am AVR
|-
|13
|DB6
|PD2 am AVR
|-
|14
|DB7
|PD3 am AVR
|-
|15
|Beleu.
|frei
|-
|16
|Beleu.
|frei
|}

Die vier Datenleitungen vom Display, die wir nicht brauchen, legen wir auf Masse. Zu den vier Datenleitungen brauchen wir noch die Leitungen RS und E. Den Anschluss RW brauchen wir nicht und legen ihn deshalb auch auf Masse.

Wir kommen somit für das Display, mit 6 Datenleitungen aus, die wir alle an das Port D (vom Mega 8) anschließen.

=== Das Programm für das LCD ===
<pre>
$regfile = "m8def.dat"
$crystal = 4000000

Config Lcd = 16 * 2
Config Lcdpin = Pin , Db4 = Portd.0 , Db5 = Portd.1 , Db6 = Portd.2 , Db7 = Portd.3 , E = Portd.5 , Rs = Portd.4
Config Lcdbus = 4

Cls
Locate 1 , 1
Lcd "Hallo Welt"
</pre>
Dieses Programm gibt den Text „Hallo Welt“ auf dem Display aus.

'''Erklärung:'''
<pre>
$regfile = "m8def.dat"
$crystal = 4000000
</pre>
Definiert den Mega8 als Prozessor und einen 4 Mhz Quarz.

<pre>
Config Lcd = 16 * 2
</pre>
Definiert das LCD-Display als 16*2 Anzeige.
Sind somit zwei Zeilen mit jeweils 16 Zeichen. 
Folgende weitere Typen von LCD’s könnte man angeben:
16*1 , 16*2 , 16*4 , 20*2 , 20*4 , 40*4

<pre>
Config Lcdpin = Pin , Db4 = Portd.0 , Db5 = Portd.1 , Db6 = Portd.2 , Db7 = Portd.3 , E = Portd.5 , Rs = Portd.4
</pre>
Definiert, wo das Display an den AVR angeschlossen wird. Db4, Db5, Db6....., E , RS sind die Pins vom LCD (siehe Tabelle) 
Portd.0, Portd.1 u.s.w., sind die Port’s vom Mega8 (Port D) 
Heißt also: Die Leitung Db4 vom LCD wird an den Port PD0
angeschlossen (Pin 2 am Mega8) 
Mit diesem Befehl, kann man das LCD auch an andere Pins vom AVR anschließen

<pre>
Config Lcdbus = 4
</pre>
Definiert den 4-Bit Modus für das LCD.
Beim 8-Bit Modus, müsste man statt der 4 eine 8 schreiben.
Der AVR weis dann, wie viele Datenleitungen angeschlossen wurden und wie er den Datentransfer zu dem LCD durchführen muss.

<pre>
Cls
Locate 1 , 1
</pre>
Cls löscht das LCD-Display und Locate 1,1 definiert die nächste Ausgabe mit 1.) Zeile, 1.)Position 
(Locate 2,10 wäre dann ausgabe in Zeile 2 und an zehnter Position )

<pre>
Lcd "Hallo Welt"
</pre>
Mit LCD kann man nun den Text ausgeben. :-)

==Autor==
* [[Benutzer:Roberto|Roberto]]

==Weblinks==
* [http://www.sprut.de/electronic/lcd/index.htm#einleitung Sprut]

==Siehe auch==
* [[Avr]]
* [[Bascom]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode Bascom]]