Viele fertige Routinen sind ja in der Picaxe schon enthalten , nur für ein Display leider bis heute noch nichts.
Etwas verwunderlich , da echte Mikrocontroller solch Routinen schon von je her enthalten haben.

Von daher gibt es 2 Möglichkeiten :

1. man kauft sich ein teures serielles Display
2. man erstellt sich selbst eine Routine

Ein normales LCD-Display 16x2 gibt es ja schon bei Ebay für 3.- bis 5.- Euro.
Zu 99,9% sind alle Displays völlig identisch vom Anschluss als auch von der Programmierung her.

Solch Display läßt sich im sogenannten 8Bit-Modus als auch im 4Bit-Modus programieren.
Beim 8Bit-Modus benötigt man 8 Datenleitungen + RS + Enable = 10 Leitungen.
Beim 4Bit-Modus benötigt man nur 4 Datenleitungen + RS + Enable = 6 Leitungen.

Der 4Bit-Modus hat sich mittlerweile durchgesetzt und wird am häufigsten benutzt.
Einzige Besonderheit dabei ist, das man eben für jeden Befehl zur Ausführung 2x ein 4Bit-Byte senden muss.

Der Trick beim 4Bit-Modus ist , das man die unteren 4 Bits eines Bytes auf Masse setzt und somit diese auf logisch 0 setzt.
Dadurch brauch man nur noch 4 Leitungen für die oberen 4Bits um ein volles Byte zu erhalten.


Um sich die Sache einfach zu halten , insbesondere beim Programmieren einer Routine ,
empfiehlt es sich , zusammenliegende Pins von xx.0 bis xx.5 für das Display zu nehmen.



So ein Display hat im Grunde 2 Modi :

a ) ist der RS-Pin auf Low = Command-Mode
b) ist der RS-Pin auf High = ASCII-Mode

Im Command-Mode werden folgende Aktionen ausgeführt :
- Initialisierung
- Setzen der Cursorposition
- Cursor an/aus
- Cursor blinken oder nicht
- Shiften rechts/links
- Display Clear

Im ASCII-Mode werden ausschließlich nur ASCII-Zeichen gesendet für die Anzeige auf dem Display.

Ein Display kann man also nicht einfach so anschliessen und danach einfach mal ein paar Texte rübersenden.
Solch ein Display hat selbst einige Mikrocontroller auf seiner Platine denen man ja erst einmal mitteilen muß
was man gern möchte.
Dazu macht man am Anfang immer erst eine Initialisierung

Ich denke jetzt die Initialisierung im Detail zu erklären gehört mehr in ein Fortgeschrittenen Tutorial , insofern
hier die Initialisierung ohne groß Kommentar :

FOR b0=1 to 3
  LET PINSb=%00100011:low 5
  LET PINSb=%00100011:low 5
  pause 50
NEXT b0
   
' 4 Bit Modus
LET PINSb=%00100000:low 5
LET PINSb=%00100010:low 5
pause 10
 
' 5x8 Matrix / 2 Reihen
LET PINSb=%00100010:low 5
LET PINSb=%00101000:low 5
pause 10
 
'Display Clear
LET PINSb=%00100000:low 5
LET PINSb=%00100001:low 5
pause 10
 
'Return Home
LET PINSb=%00100000:low 5
LET PINSb=%00100110:low 5
pause 10
 
' Display ON,Cursor OFF, No blinken
LET PINSb=%00100000:low 5
LET PINSb=%00101100:low 5
pause 10
let pinsb=0
 
Return
 
 

Diesen Code , zusammen mit dem Schaltplan für die Anschlussbelegung kann man immer und immer wieder nutzen.


Vielleicht wird dem ein oder anderen aufgefallen sein , das ich ja sagte , das wir "nur" 4 Bits senden ,
jedoch immer das 5. Bit auf 1 gesetzt ist.

Tjaaa , wenn man alles richtig angeschlossen hat, ist ja Bit5 ( Pin xx.5 ) => Enable
Ein Display benötigt immer eine Art Clock-Signal um etwas auszuführen.
Das heißt , wenn ich etwas senden will , muß ich einmal das Bit5 auf High und wieder auf Low setzen.

In der Initialisierung mache ich das Setzen des Bit5 durch Angabe von Let Pins in einem Atemzug.

Anschliessend durch den Befehl : low 5 setze ich das Bit5 wieder auf 0

Damit habe ich also eine Clock ausgelöst und das Display führt den Befehl aus.

Jetzt haben wir also das Display initialisiert, aber das reicht ja noch nicht. :)

Jetzt benötigen wir ja noch eine Routine , die uns ASCII-Zeichen auf´s Display sendet.
Dazu benutzen wir folgende :

SendText:
 
  HighWert=Wert/16
  LowWert=HighWert*16:LowWert=Wert-LowWert
 
  HighWert=HighWert+48
  let pinsb=HighWert:low 5
 
  LowWert=LowWert+48
  let pinsb=LowWert:low 5
 
return
 
 

Was wird hier gemacht ?
Nun, .... nehmen wir an , wir wollen ein 'A' ans Display senden.
Ein 'A' ist ja das ASCII-Zeichen '65'
Da wir ja keine vollen Bytes senden können, müssen wir dieses in 2x 4Bits unterteilen.
Da 4Bits max. eine Zahl von 16 sein kann , ist also der Teilungsfaktor => 16
Also rechnen wir:

65 : 16 = 4 ( HighWert=Wert/16 )

16 x 4 = 64
65 - 64 = 1 (LowWert=HighWert*16 : LowWert=Wert-LowWert )


Da wir ja gesagt haben , das wenn wir ASCII-Zeichen senden wollen ,
wir den Pin RS auf high haben müssen , zudem der Pin Enable auch high sein soll ,
wären das also Bit4 + Bit5 ( 16+32 = 48 ) , und zähle somit auf den ersten Wert,
dem Highwert noch 48 drauf.
( HighWert=HighWert+48 )

Da eine Ausführung ja ein Clock-Signal benötigt ,
wir durch die Addition von 48 den Enable schon auf high gesetzt haben ,
müssen wir den Enable nur noch auf low setzen um den Clock zu vollenden.
( let pinsb=HighWert:low 5 )

Das ganze "Spiel" erfolgt jetzt auch nochmal mit dem LowWert .....
( LowWert=LowWert+48 : let pinsb=LowWert:low 5 )



Das war schon die ganze Routine für das Senden von ASCII-Zeichen. :thumbsup:
Wenn man das einmal verstanden hat , einfacher als Fahrrad fahren.


Was jetzt noch fehlt , das wären ja die Command-Befehle.

Zunächst beschränke ich mich hier auf die Positionierung des Cursors.
Wir können , wenn genug Interesse besteht , später noch auf andere Commands eingehen. ^^

Eigentlich ist bei allen Displays der Befehl für : Cursor 1. Zeile - links und Cursor 2. Zeile - links immer gleich.

Cursor 1. Zeile - links = 128
Cursor 2. Zeile - links= 192

Da dies Commands sind , bleibt der Pin RS auf low.
Es müssen jetzt nur noch die Werte in 2x 4Bits gewandelt werden.

'Cursor 1. Zeile :
LET PINSb=%00100000:low 5
LET PINSb=%00100010:low 5
 
'Cursor 2. Zeile :
LET PINSb=%00101100:low 5
LET PINSb=%00100000:low 5
 
 

|addpics|nqa-h-cf6c.jpg|/addpics|