Aus RN-Wissen.de
Wechseln zu: Navigation, Suche
Rasenmaehroboter fuer schwierige und grosse Gaerten im Test

K (→‎Hinweise zum I2C-Modus)
K (→‎Beispiele wie man RNKeyLCD nutzen kann)
Zeile 236: Zeile 236:
  
 
===Beispiele wie man RNKeyLCD nutzen kann===
 
===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===
  
 
===Schaltplan===
 
===Schaltplan===

Version vom 15. Dezember 2005, 17:49 Uhr

Baustelle.gif An diesem Artikel arbeitet gerade Mitglied Frank.

Am besten momentan noch keine gravierenden Ergänzungen / Änderungen vornehmen.

Dieser Hinweis verschwindet wenn der Autor soweit ist. Sollte dieser Hinweis länger als drei Tage auf einer Seite sein, bitte beim Autor Frank per PM / Mail oder Forum nachfragen ob er vergessen wurde.

Was ist RN-KeyLCD?

Knkeylcdfoto1.jpg

Ein LCD und eine Tastatur ist fast bei allen Microcontroller-Anwendungen, 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 Vorteilshaft ist das 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 I2CBus 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 Display 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-Modi steht jedes Bit der beiden Bytes für eine Taste.

Erläuterung des Scancode:

Low Byte (erste abgerufene Byte)
Bit: 7 6 5 4 3 2 1 0
Name: Taste8 Taste7 Taste6 Taste5 Taste4 Taste3 Taste2 Taste1
High Byte (zweite abgerufene Byte)
Bit: 7 6 5 4 3 2 1 0
Name: 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 das 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

Datei:Rnkeylcdeinstellungen1.jpg

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):

Rnkeylcdeinstellungen2.jpg

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

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

Erläuterung der Modi:

Datei:Rnkeylcdeinstellungen3.jpg

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.

Datei:Rnkeylcdeinstellungen4.jpg

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.

Datei:Rnkeylcdeinstellungen5.jpg

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)

Datei:Rnkeylcdeinstellungen6.jpg

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.


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. 

'###################################################
'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

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: 

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

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: 

'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

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: 

'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

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: 

'
'###################################################
'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

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: 

'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

Und noch ein letztes Ausgabebeispiel welches das Scrolling zeigt: 

'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

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. 

'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

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: 

'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

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. 

'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

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. 

'###################################################
'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

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: 

'###################################################
'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

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: 

'###################################################
'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


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: 

'###################################################
'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


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: 

'###################################################
'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

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

Schaltplan

Stückliste

Siehe auch

Weblinks

Platinenservice.gif hier Bausatzservice.gif hier

Von „https://rn-wissen.de/wiki/index.php?title=RN-KeyLCD&oldid=3795“

LiFePO4 Speicher Test