LCD-Programmierung/Tastatur-Programmierung

[Willi (Gast)]

Hey Leute

Ich muss als Projekt eine Alarmanlage programmieren. Soweit kam ich noch 
klar aber nun muss ich eine Tastatur, mit Tastern programmieren. Dafür 
soll ein Taster als Speichern definiert werden, einer als Löschen und 
einer als Zurück und einer als Eingabe. Die anderen sollen die Tasten 
1-4 darstellen.. Das ist das kleinste Problem, das dürfte ich auh noch 
einigermaßen hinbekommen.
Das größte Problem ist das Prgrammieren der LCD anzeige, es sollen 
verschiedene Funktionen angezeigt werden und über die Taster dann 
ausgewählt werden. Das Problem ist dass ich überhaupt nicht weiß wie man 
ein LCD-Bildschirm programmiert. Ich habe bisher alles über die LED oder 
7segm-Anzeige gemacht.

Ich wäre froh wenn mir einer von euch einen Link oder einen Code posten 
könnte.

Achja es geht um den Mikroprozessor 80C535 und wir programmieren mit dem 
MCLS-modular.


Dann noch eine andere Frage,
Gibt es ein Programm mit dem man das programmierte Programm simulieren 
kann? dann könnte ich auch noch zu Hause am Programm arbeiten, denn mit 
MCLS kann man nicht simulieren.


Hoffe auf eure Hilfe

mfg Willi

[Arnold (Gast)]

Hallo Willi,

was für ein LCD hast Du (grafisch, Text)? Was für ein Controller ist da 
drauf? Es gibt diverse fertige Lib's im Netz.

Gruß
Arnold

[heinzhorst (Gast)]

Wie gesagt, für LCDs gibt's diverse Librarys im Netz und bei den 
Controllerherstellern. Denke mal bei deiner Anwendung hast es mit einem 
Standard 1x16 oder 2x16 Textdisplay zu tun. Und ein Menü zur Anzeige 
diverser Funktionen auf dem Display realisiert man mit einer 
State-Machine.

[Willi (Gast)]

Es ist eine Text LCD mit 2 Zeilen

Das ist der Code als Demo:

; ***********************************************************
; *    Demoprogramm zur Ansteuerung der Display-Unit 2      *
; *           (MCLS-modular/PSD1-Konfiguration)             *
; * ------------------------------------------------------- *
; *         LCD-UNIT im 4-Bit Modus am PSD1-Modul           *
; *        (HD44780-kompatibler Anzeigecontroller)          *
; * ------------------------------------------------------- *
; *    Display-Unit 2 im 4-Bit Modus am PSD1-Modul          *
; *        (HD44780-kompatibler Anzeigecontroller)          *
; * a) Datensignale                                         *
; *                      DB7 - P1.7                         *
; *                      DB6 - P1.6                         *
; *                      DB5 - P1.5                         *
; *                      DB4 - P1.4                         *
; * b) Steuersignale                                        *
; *       E   - P4.0 ; Enable, 1-0 zur Datenübernahme       *
; *       R/W - P4.1 ; Read/Write, 0 für Schreiben          *
; *                  ; 1 für Lesen                          *
; *       RS  - P4.2 ; Register Select                      *
; *                  ; 0 - Daten sind Befehle               *
; *                  ; 1 - Daten für Display-RAM            *
; ***********************************************************
; *                     HAG 17.10.2000                      *
; ***********************************************************



; Assemblerdirektiven
 CPU    80515
 INCLUDE stddef51


 SEGMENT code
 org    0000h 



; Demoprogramm
; ***********************************************************
Demo_LCD:       
        call    INIT_LCD        ; LCD-Anzeige initialisieren
d01:    call    text_zeile1
        call    wait_lang
        call    text_zeile2
        call    wait_lang
        call    init_lcd
        call    wait_lang
        jmp     d01                                     
; ***********************************************************



; -----------------------------------------------------------
text_zeile1:
        mov     a,#00h+2        ; Cursorposition 1. Zeile
        call    CURSOR_POS
        mov     b,#000h         ; Offset für Text rücksetzen
        mov     dptr,#text1     ; Zeiger auf Textanfang
m00:    mov     a,b             ; Offset nach a
        movc    a,@a+dptr       ; Zuriff auf Textelement
        jz      m01             ; Endekennung erreicht ?
                                ; wenn ja, dann zur Endlosschleife
        call    WRITE_DREG      ; Zeichen ins LCD-Datenregister schreiben
        call    wait_kurz       ; 100us warten
        inc     b               ; Offset +1
        jmp     m00             ; weiter machen
m01:    ret
; -----------------------------------------------------------


; -----------------------------------------------------------
text_zeile2:
        mov     a,#40h          ; Cursorposition 2. Zeile
        call    CURSOR_POS
        mov     b,#000h         ; Offset für Text rücksetzen
        mov     dptr,#text2     ; Zeiger auf Textanfang
m02:    mov     a,b             ; Offset nach a
        movc    a,@a+dptr       ; Zuriff auf Textelement
        jz      m03             ; Endekennung erreicht ?
                                ; wenn ja, dann zur Endlosschleife
        call    WRITE_DREG      ; Zeichen ins LCD-Datenregister schreiben
        call    wait_kurz       ; 100us warten
        inc     b               ; Offset +1
        jmp     m02             ; weiter machen
m03:    ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; Demotexte
text1   db      "MCLS-modular!",00

text2   db      "Demo  LCD-UNIT",00
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                                                         #
; #                 Steuersignalzuordnung                   #
; #                                                         #
; -----------------------------------------------------------

E       equ     P4.0            ; Enable
RW      equ     P4.1            ; Read/Write
RS      equ     P4.2            ; Register Select
; -----------------------------------------------------------




; -----------------------------------------------------------
; #                         INIT_LCD                        #
; #            LCD-Unit initialisieren und löschen          #
; -----------------------------------------------------------
INIT_LCD:
; SW-Reset 
        call    wait_10ms

        mov     a,#00110000b
        call    WRITE_CREG_8BIT ; ins Befehlsreg. schreiben
        call    wait_2ms

        mov     a,#00110000b
        call    WRITE_CREG_8BIT
        call    wait_1ms

        mov     a,#00110000b
        call    WRITE_CREG_8BIT
        call    wait_1ms

; Umschalten auf 4-Bit Modus
        mov     a,#00100000b
        call    WRITE_CREG_8BIT                                 
        call    wait_1ms

        mov     a,#00101000b    ; Funktion Set, 2 Zeilen
                                ; 5*7 Dots
        call    WRITE_CREG_4BIT
        call    wait_1ms

        mov     a,#00001000b    ; Funktion Display off
        call    WRITE_CREG_4BIT
        call    wait_1ms

        mov     a,#00000001b    ; Funktion Display clear
        call    WRITE_CREG_4BIT
        call    wait_1ms

        mov     a,#00000110b    ; Entry Mode
        call    WRITE_CREG_4BIT
        call    wait_1ms

        call    WAIT_FOR_READY
        mov     a,#00001100b    ; Display on
                                ; Cursor off, Blinken off
        call    WRITE_CREG_4BIT
        call    WAIT_FOR_READY

        ret
; -----------------------------------------------------------




; -----------------------------------------------------------
; #                        CURSOR_HOME                      #
; #                 Cursor auf Startposition                #
; -----------------------------------------------------------
CURSOR_HOME:
        mov     a,#00000010b
        call    WRITE_CREG_4BIT
        call    wait_1ms
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                      CURSOR_POS                         #
; #                Cursor positionieren                     #
; #          Adressen für Zeile 1: 00h - 1fh                #
; #          Adressen für Zeile 2: 40h - 4fh                #
; #    Adresse des Zeichens über Akku bereitstellen         #
; -----------------------------------------------------------
CURSOR_POS:
        orl     a,#10000000b    ; Bit 7 setzen
        call    WRITE_CREG_4BIT
        call    wait_1ms
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                    WRITE_CREG_8BIT                      #
; #          Steuerwort zur LCD-Unit (8-Bit Modus)          #
; -----------------------------------------------------------
WRITE_CREG_8BIT:
        push    b
        clr     RS              ; Daten sind Befehlswort
        clr     RW              ; in Display Schreiben
        clr     E               ; erst mal auf 0
        nop

        setb    E               ; E in Grundstellung
        anl     a,#0f0h         ; LT im Steuerwort rücksetzen
        anl     p1,#0fh         ; HT im Port 1 rücksetzen
        orl     p1,a            ; Tetraden zusammenfügen
        clr     E               ; jetzt Übernahmeflanke
        nop

        orl     p1,#0f0h        ; HT Port 1 setzen
        pop     b
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                     WRITE_CREG_4BIT                     #
; #          Steuerwort zur LCD-Unit (4-Bit Modus)          #
; -----------------------------------------------------------
WRITE_CREG_4BIT:
        push    b
        mov     b,a             ; Daten in b puffern
        clr     RS              ; Daten sind Befehlswort
        clr     RW              ; in Display Schreiben
        clr     E               ; erst mal auf 0
        nop

        setb    E               ; E in Grundstellung
        anl     a,#0f0h         ; LT im Steuerwort rücksetzen
        anl     p1,#0fh         ; HT im Port 1 rücksetzen
        orl     p1,a            ; Tetraden zusammenfügen
        clr     E               ; jetzt Übernahmeflanke
        nop

        setb    E
        mov     a,b
        swap    a
        anl     a,#0f0h
        anl     p1,#0fh
        orl     p1,a
        clr     E
        nop

        orl     p1,#0f0h
        pop     b
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                      WAIT_FOR_READY                     #
; #               Warten, bis LCD-UNIT bereit!              #
; -----------------------------------------------------------
WAIT_FOR_READY:
        push    acc
wa0:
        call    READ_CREG
        jb      acc.7,wa0
        pop     acc
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                        READ_CREG                        #
; #              Auslesen des Steuerregisters               #
; -----------------------------------------------------------
READ_CREG:
        push    b
        orl     p1,#0f0h
        clr     RS
        setb    RW
        clr     E
        nop

        setb    E
        nop
        mov     a,p1
        anl     a,#0f0h
        mov     b,a
        clr     E
        nop

        setb    E
        nop
        mov     a,p1
        anl     a,#0f0h
        swap    a
        orl     a,b
        clr     E
        nop

        clr     RW
        pop     b
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #                        WRITE_DREG                       #
; #               Schreiben ins Datenregister               #
; #         ASCII-Zeichencode über Akku bereitstellen       #
; -----------------------------------------------------------
WRITE_DREG:
        push    b
        mov     b,a
        setb    RS
        clr     RW
        clr     E
        nop

        setb    E
        anl     a,#0f0h
        anl     p1,#0fh
        orl     p1,a
        clr     E
        nop

        setb    E
        mov     a,b
        swap    a
        anl     a,#0f0h
        anl     p1,#0fh
        orl     p1,a
        clr     E
        nop

        clr     RS
        nop
        orl     p1,#0f0h
        pop     b
        ret
; -----------------------------------------------------------



; -----------------------------------------------------------
; #            Zeitverzögerungen für LCD_UNIT               #
; -----------------------------------------------------------
; etwa 1 s warten
wait_lang:
        mov     r5,#100
w04:    call    wait_10ms       ; 10ms
        djnz    r5,w04          ; 2us
        ret                     ; 2us

; etwa 100us warten
wait_kurz:
        mov     r6,#48          ; 2us
w00:    djnz    r6,w00          ; 96us
        ret                     ; 2us

wait_1ms:
        mov     r6,#10
w01:    call    wait_kurz
        djnz    r7,w01
        ret

wait_2ms:
        mov     r6,#20
w02:    call    wait_kurz
        djnz    r7,w02
        ret

wait_10ms:
        mov     r6,#98
w03:    call    wait_kurz       ; 100us
        djnz    r7,w03          ; 2us
        ret                     ; 2us
; -----------------------------------------------------------


END

[Willi (Gast)]

Ich muss ein ganzes Menü anzeigen und das hab ich mir so vorgestellt 
dass ich das mit der Tastatur mache indem ich sage dass Taste5 Rauf 
bedeutet und Taste6 Runter, dh dass die erste Zeile durch die zweite 
ersetzt wird und die 2te Zeile durch eine neue ersetzt wird. Genaueres 
kann ich erst sagen wenn ich die Bautteile vor mir liegen habe. dann 
weiß ich auch genau was das für Bautteile sind.

[Karl H. (kbuchegg)]

Hier hast du doch beispielsweise Code, der einen Text ausgibt

; -----------------------------------------------------------
text_zeile1:
        mov     a,#00h+2        ; Cursorposition 1. Zeile
        call    CURSOR_POS
        mov     b,#000h         ; Offset für Text rücksetzen
        mov     dptr,#text1     ; Zeiger auf Textanfang
m00:    mov     a,b             ; Offset nach a
        movc    a,@a+dptr       ; Zuriff auf Textelement
        jz      m01             ; Endekennung erreicht ?
                                ; wenn ja, dann zur Endlosschleife
        call    WRITE_DREG      ; Zeichen ins LCD-Datenregister schreiben
        call    wait_kurz       ; 100us warten
        inc     b               ; Offset +1
        jmp     m00             ; weiter machen
m01:    ret

In dieser Funktion ist der auszugebende Text offenbar so bestimmt, dass 
das dptr die Startadresse des Textes beinhalten soll. Wenn du das also 
aus dem Unterprogramm herausziehst, sollte das schon mal die halbe Miete 
sein

Du hast dann ein Unterprogramm

;
; Voraussetzungen
;    dptr enthält die Startadresse des auszugebenden Textes
;    der Cursor am LCD ist schon an der richtigen Stelle
;
;    veränderte Register: b, a und alles in WRITE_DREG, wait_kurz
;
TEXT_OUT:
        mov     b,#000h         ; Offset für Text rücksetzen
to00:   mov     a,b             ; Offset nach a
        movc    a,@a+dptr       ; Zuriff auf Textelement
        jz      to1             ; Endekennung erreicht ?
                                ; wenn ja, dann Ausgabe beenden
        call    WRITE_DREG      ; Zeichen ins LCD-Datenregister schreiben
        call    wait_kurz       ; 100us warten
        inc     b               ; Offset +1
        jmp     to00            ; weiter machen
to01:   ret

welches du so aufrufen kannst

        mov     dptr,#menu_1
        call    TEXT_OUT
....
     
menu_1   db     "Menupunkt 1",00

und das den Text an der Stelle, an der der Cursor gerade steht ausgibt. 
Also sollte man vorher noch den Cursor am LCD entsprechend 
positionieren.


In deinem Demo ist fast alles enthalten was du brauchst. Lediglich die 
eigentlichen Text Ausgabe Funktionen sind ein wenig ungeschickt gemacht, 
weil sie zuviel machen und sich nicht mehr weiter auf einfachere 
Basisfunktionen, wie zb Textausgabe stützen. Das wäre im Demo so besser 
gewesen, da hätte man dann die eigentliche Textausgabe von dem was 
ausgegeben werden soll besser getrennt gehabt:

; -----------------------------------------------------------
text_zeile1:
        mov     a,#00h+2        ; Cursorposition 1. Zeile
        call    CURSOR_POS
        mov     dptr,#text1     ; Zeiger auf Textanfang
        call    TEXT_OUT        ; Text ausgeben
        ret

; -----------------------------------------------------------
text_zeile2:
        mov     a,#40h          ; Cursorposition 2. Zeile
        call    CURSOR_POS
        mov     dptr,#text2     ; Zeiger auf Textanfang
        call    TEXT_OUT        ; Text ausgeben
        ret

text1   db      "MCLS-modular!",00
text2   db      "Demo  LCD-UNIT",00


;
; Voraussetzungen
;    dptr enthält die Startadresse des auszugebenden Textes
;    der Cursor am LCD ist schon an der richtigen Stelle
;
;    veränderte Register: b, a und alles in WRITE_DREG, wait_kurz
;
TEXT_OUT:
        mov     b,#000h         ; Offset für Text rücksetzen
to00:   mov     a,b             ; Offset nach a
        movc    a,@a+dptr       ; Zuriff auf Textelement
        jz      to1             ; Endekennung erreicht ?
                                ; wenn ja, dann Ausgabe beenden
        call    WRITE_DREG      ; Zeichen ins LCD-Datenregister schreiben
        call    wait_kurz       ; 100us warten
        inc     b               ; Offset +1
        jmp     to00            ; weiter machen
to01:   ret

Allerdings hättest du das selbst auch sehen müssen, wie man eine 
bestimmte Funktionalität (Textausgeben) aus dem Demobeispiel 
herausziehen kann.

[Karl H. (kbuchegg)]

Willi schrieb:
> Ich muss ein ganzes Menü anzeigen und das hab ich mir so vorgestellt
> dass ich das mit der Tastatur mache indem ich sage dass Taste5 Rauf
> bedeutet und Taste6 Runter, dh dass die erste Zeile durch die zweite
> ersetzt wird und die 2te Zeile durch eine neue ersetzt wird.

Der Plan klingt erst mal nicht so schlecht.
Ein Menü ist ja nichts anderes als eine Sammlung von Texten und einem 
Mechanismus, wie man einen davon auswählt. Dazu braucht man eine 
'Variable', die einem sagt, welcher Menüpunkt zur Zeit der wäre, der 
gerade selektiert werden würde, wenn der Benutzer selektiert. Also so 
was wie einen aktiven Menüpunkt. Du kannst zb sagen, dass immer der 
Menüpunkt in der ersten Zeile der ist, der ausgewählt wird, wenn der 
Benutzer 'Enter' drückt.

Bei dir kommt noch dazu, dass du von n-Texten immer nur 2 anzeigen 
kannst.
Quäl dich aber nicht damit herum, Text auf dem LCD umzukopieren. Schreib 
einfach immer alle beiden Texte hin: den gerade aktiven und den nächsten 
(falls es noch einen nächsten gibt). Wenn der Benutzer Rauf oder Runter 
drückt, wird einfach die Variable für den aktiven Menüpunkt um 1 erhöht 
oder erniedrigt und das Unterprogramm aufgerufen, welches den aktiven 
Menüpunkt in die erste Zeile und den jeweils nächsten in die zweite 
Zeile schreibt.

[Willi (Gast)]

Also soweit habe ich die Tastatur jetzt programmiert.

; -------- Declarations required for Assembler ----------

  CPU  80515      ; MC selection (identical with 80C535)

  INCLUDE  stddef51  ; SFR definitions
  INCLUDE  bitfuncs
  SEGMENT  code    ; Program code segment starts here

   ORG    0000H    ; Program code starts at 0000H
   

; -------------------------------------------------------

; ------------------------------------------------------------------
;Setzt alle Werte der Display Unit auf 0
;-------------------------------------------------------------------
Main:      

init:      Mov P1,#11000000B
      SETB  P4.0
      CLR  P4.0
      SETB  P4.0
      
      Mov P1,#11000000B
      SETB  P4.1
      CLR  P4.1
      SETB  P4.1

      Mov P1,#11000000B
      SETB  P4.2
      CLR  P4.2
      SETB  P4.2
    
      Mov P1,#11000000B
      SETB  P4.3
      CLR  P4.3
      SETB  P4.3
      
      Mov 030H,#11000000B
      Mov 040H,#11000000B
      Mov 050H,#11000000B
      Mov 060H,#11000000B


;Schleife die auf Druecken einer Taste wartet
;----------------------------------------------------------------

loop:      JNB  P5.0,NULL
      JNB  P5.1,EINS
      JNB  P5.2,ZWEI
      JNB  P5.3,DREI
      JNB  P5.4,Eingeben
        
      
      SJMP  loop

;Setz D0 von Display auf eingeben Wert ein
;---------------------------------------------------------------
        
Start1:    MOV  060H,050H
      MOV  050H,040H
      MOV  040H,030H
        
      MOV  DPTR,#Tab0
      MOVC  A,@A+DPTR
    
      MOV  030H,A
    
      MOV  P1,030H
      SETB  P4.0
      CLR  P4.0
      SETB  P4.0
    
      MOV  P1,040H
      SETB  P4.1
      CLR  P4.1
      SETB  P4.1

      MOV  P1,050H
      SETB  P4.2
      CLR  P4.2
      SETB  P4.2
    
      MOV  P1,060H
      SETB  P4.3
      CLR  P4.3
      SETB  P4.3

noch_gedrueckt5:  JB   P4.7,noch_gedrueckt5
      sjmp loop
    
    
NULL:      MOV  A,#0
noch_gedrueckt0:  JB   P4.7,noch_gedrueckt0
      SJMP  Start1


EINS:      MOV  A,#1
noch_gedrueckt1:  JB   P4.7,noch_gedrueckt1
      SJMP  Start1


ZWEI:      MOV  A,#2
noch_gedrueckt2:  JB   P4.7,noch_gedrueckt2
      SJMP  Start1


DREI:      MOV  A,#3
noch_gedrueckt3:  JB   P4.7,noch_gedrueckt3
      SJMP  Start1


Eingeben:    Mov R0,030H  
      Mov P1,030H
      
noch_gedrueckt4:  JB   P4.7,noch_gedrueckt4      
      
      SJMP loop      
                  


Tab0:    DB 11000000B  ;Null
    DB 11111001B  ;Eins
    DB 10100100B  ;Zwei
    DB 10110000B  ;Drei

END

Soweit bin ich jetzt bei der Tastatur.
die ersten 4 Tasten sind bereits mit den Zahlen 0-4 belegt und  werden 
mom noch über eine 7segm-Anzeige ausgegeben. Die anderen 4 Tasten sollen 
mit den Befehlen "Enter"; "Löschen/Zurück", "Rauf" und "Runter" belegt 
werden. Damit wàre das Problem eig gelöst, allerdings verstehe ich immer 
noch nicht wie die LCD funktionieren soll, also das mit dem Menü.

[Karl H. (kbuchegg)]

Willi schrieb:

> werden. Damit wàre das Problem eig gelöst, allerdings verstehe ich immer
> noch nicht wie die LCD funktionieren soll,

Was genau verstehst du daran nicht?

Es gibt eine Init Funktion, die das LCD initialisiert, so dass man 
darauf Texte ausgeben kann.
Und es gibt eine Funktion, die einen Text ausgeben kann.

> also das mit dem Menü.

Ein Menü ist auch nur eine Sammlung mehrer Texte, von denen einer einer 
ausgezeichneter ist als alle anderen


Dein Menü ist eine Sammlung von Texten

   Licht ein
   Licht aus
   Ton   ein
   Ton   aus

dazu brauchst du noch eine Variable (in einem Register oder sonstwo), 
die festlegt, welches der aktive Menüpunkt ist. Ich nenn sie mal actMenu

Am Anfang sein actMenu gleich 0

das heisst von den 4 Texten, ist der mit der 0-te der 'aktive'
als Konsequenz davon wird auf deinem 2-zeiligen LCD angezeigt

   Licht ein
   Licht aus

mehr Platz hast du nicht. Um die Texte anzuzeigen, hast du ja schon eine 
Ausgabefunktion. Für den Anfang ist es für dich am einfachsten, wenn 
alle Texte gleich lang sind (gegebenenfalls hinten mit Leerzeichen 
auffüllen). Denn dann kannst du aus der Adresse des ersten Textes 
ausrechnen, an welcher Stelle im Speicher der n-te Text anfängt. Und das 
brauchst du, weildu ja bei einem Wert von 0 in ActMenu den 0-ten und den 
1-ten Text anzeigen musst.

Jetzt kommt der Benutzer und drückt einmal runter
Als Folge davon wird actMenu um 1 erhöht und hat jetzt den Wert 1.
Es geht wieder in die Anzeigefunktion. Die sieht sich das actMenu an und 
weiß daher, dass es jetzt in die 1. Zeile den Text mit der Nummer 1 und 
in die 2te Zeile den Text mit der Nummer 2 ausgeben muss.

Also malt sie aufs LCD

   Licht aus
   Ton   ein

Der Benutzer drückt wieder runter. actMenu wird wieder um 1 erhöht und 
hat jetzt den Wert 2.
Das heisst für die Textausgabefunktion, dass sie von den vorhandenen 
Texten

   Licht ein     ;0
   Licht aus     ;1
   Ton   ein     ;2
   Ton   aus     ;3

den mit der Nummer 2 (weil ja actMenu 2 ist) in die erste Zeile ausgeben 
soll und in die 2. Zeile kommt der mit der Nummer 3. Wieder: mit der 
Textnummer, der bekannten Startadresse des ersten Textes und der Länge 
der Texte (die alle gleich sind) kann man ausrechnen, wo im Speicher der 
Text mit der Nummer 3 anfängt. Und den kann man wiederrum ausgeben.

Auf dem LCD steht dann

  Ton ein
  Ton aus

Sinngemaß drückt jetzt der Benutzer die Taste rauf. actMenu wird um 1 
vermindert und ist wieder 1. Die Funktion die basierend auf actMenu die 
beiden Texte ausgeben soll, gibt daher

  Licht aus
  Ton   ein

aus.

Für deinen Benutzer sieht es so aus, als ob das Menü mit jedem 
Tastendruck um 1 Zeile durchscrollt.

[Willi (Gast)]

Ok ich versuche jetzt das mal zu verstehen und melde mich dann wieder

danke für die antwort

[Willi (Gast)]

Ok das mit der Tabelle habe ich drauf aber ich verstehs immer noch 
nicht, wie sage ich der LCD jetzt dass das so sein muss...
Ich habe noch nie mit LCD gearbeitet und erst seit einem Semester mit 
Mikrokontroller.

Wäre echt froh wenn mir jemand Schritt für Schritt erklären könnte wie 
ich vorgehen muss

[Willi (Gast)]

>dazu brauchst du noch eine Variable (in einem Register oder sonstwo),

>Für den Anfang ist es für dich am einfachsten, wenn
>alle Texte gleich lang sind (gegebenenfalls hinten mit Leerzeichen
>auffüllen). Denn dann kannst du aus der Adresse des ersten Textes
>ausrechnen, an welcher Stelle im Speicher der n-te Text anfängt. Und das
>brauchst du, weildu ja bei einem Wert von 0 in ActMenu den 0-ten und den
>1-ten Text anzeigen musst.


diese Zeilen versteh ich nicht, also wörtlich verteh ich sie schon aber 
ich versteh nicht wie ich das realisieren soll

[Klaus W. (mfgkw)]

Dann sollte das Tutorial doch helfen; mehr wird man dir hier auch nicht 
sagen können - sonst würde es im Tutorial stehen.

[Karl H. (kbuchegg)]

Willi schrieb:
> Ok das mit der Tabelle habe ich drauf aber ich verstehs immer noch
> nicht, wie sage ich der LCD jetzt dass das so sein muss...
> Ich habe noch nie mit LCD gearbeitet und erst seit einem Semester mit
> Mikrokontroller.

Du legst zuviel Augenmerk auf das LCD.
Die Situation eines Menüs wäre auch keine andere, wenn du es auf einem 
PC im Textmodus auf dem Monitor ausgeben willst und nur 2 Anzeigezeilen 
zur Verfügung hast.

Du hast eine Anzeigeeinheit, auf der du Text ausgeben kannst.
Punkt
Da musst du jetzt ein Menü draufpappen
Punkt
Ob das ein LCD ist, oder ein Monitor oder eine Laser-Projektionseinheit 
oder .... spielt keine Rolle. Du hast 2 Anzeigezeilen und mit denen 
musst du klarkommen.

Du kannst in eine AUsgabezeile einen Text schreiben.
Gut
Du kannst in die andere Ausgabezeile einen Text schreiben
Auch gut

Ein Menü besteht auch nur aus Texten, die zum richtigen Zeitpunkt in die 
richtige Ausgabezeile geschrieben werden.


Du scheinst da in der Vorstellung zu leben, dass Menüs irgendwie etwas 
besonderes wären. Nein! Das sind sie nicht.
Menüs sind (in deinem Fall) einfach nur: Aus einer Sammlung von mehreren 
Texten, die zusammen das Menü bilden, werden 2 ausgewählt (weil du nicht 
mehr Anzeigezeilen hast) die auf das LCD geschrieben werden. Und zwar 
jeder Text für sich. Es ist dein Job als Programmierer dafür zu sorgen, 
dass der jeweils richtige Text in der richtigen Ausgabezeile auftaucht. 
Egal was der Benutzer macht.

[Karl H. (kbuchegg)]

Willi schrieb:
>>dazu brauchst du noch eine Variable (in einem Register oder sonstwo),
>
>>Für den Anfang ist es für dich am einfachsten, wenn
>>alle Texte gleich lang sind (gegebenenfalls hinten mit Leerzeichen
>>auffüllen). Denn dann kannst du aus der Adresse des ersten Textes
>>ausrechnen, an welcher Stelle im Speicher der n-te Text anfängt. Und das
>>brauchst du, weildu ja bei einem Wert von 0 in ActMenu den 0-ten und den
>>1-ten Text anzeigen musst.
>
>
> diese Zeilen versteh ich nicht, also wörtlich verteh ich sie schon aber
> ich versteh nicht wie ich das realisieren soll

Das sei dein Text. Er steht ab Adresse 200 im Speicher

  MENUPUNKT1#MENU2#MEN9#Exit#
  ^          ^     ^    ^
  |          |     |    |
  |          |     |    +-- 222
  |          |     +--- 216
  |          +--- 210
  +--- 200

(# sei jeweils ein 0-Byte als Ende Kennung eines Textes)

Wenn alles was du hast
* die Startadresse der Texte, die hintereinander im Speicher stehen
* und die Textnummer ist
wo fängt dann der 3.te Text an? Du brauchst seine Startadresse, weil du 
diese Adresse der Textausgabefunktion übergeben musst, damit die diesen 
Text auf die Anzeige an eine bestimmte Stelle schreibt.

Und jetzt das ganze mit fixen Textlängen. Sagen wir 8 Zeichen pro Text
Wieder: die Texte fangen an der Adresse 200 im Speicher an
  MENU1  #Exit   #Status #Setup  #
  ^       ^       ^       ^
  |       |       |       |
  |       |       |       +---- 224
  |       |       +--- 216
  |       +--- 208
  +--- 200

Wo fängt der dritte Text im Speicher an?
Da jeder Text 8 Zeichen lang ist, fängt der 3.te Text an der 
Speicherposition (3-1) * 8 + 200 = 216 an.
Und der 4. Text?     (4-1) * 8 + 200 = 224
Und der 2. Text?     (2-1) * 8 + 200 = 208

Du kannst dir hier ausrechnen, wo genau im Speicher ein Text anfängt. 
Alles was du brauchst ist die Textnummer und die Adresse an der der 
erste Text steht. Alles andere kann dann davon errechnet werden.


Hast du denn keinen C-Compiler, der dir die ganzen lästigen Details 
abnimmt, so dass du das alles in Assembler machen musst? Das kann ja 
noch heiter werden mit deiner Alarmanlage, wenn es schon bei Textausgabe 
scheitert.