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
:
Verschoben durch Admin
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
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.
Es ist eine Text LCD mit 2 Zeilen Das ist der Code als Demo:
1 | ; *********************************************************** |
2 | ; * Demoprogramm zur Ansteuerung der Display-Unit 2 * |
3 | ; * (MCLS-modular/PSD1-Konfiguration) * |
4 | ; * ------------------------------------------------------- * |
5 | ; * LCD-UNIT im 4-Bit Modus am PSD1-Modul * |
6 | ; * (HD44780-kompatibler Anzeigecontroller) * |
7 | ; * ------------------------------------------------------- * |
8 | ; * Display-Unit 2 im 4-Bit Modus am PSD1-Modul * |
9 | ; * (HD44780-kompatibler Anzeigecontroller) * |
10 | ; * a) Datensignale * |
11 | ; * DB7 - P1.7 * |
12 | ; * DB6 - P1.6 * |
13 | ; * DB5 - P1.5 * |
14 | ; * DB4 - P1.4 * |
15 | ; * b) Steuersignale * |
16 | ; * E - P4.0 ; Enable, 1-0 zur Datenübernahme * |
17 | ; * R/W - P4.1 ; Read/Write, 0 für Schreiben * |
18 | ; * ; 1 für Lesen * |
19 | ; * RS - P4.2 ; Register Select * |
20 | ; * ; 0 - Daten sind Befehle * |
21 | ; * ; 1 - Daten für Display-RAM * |
22 | ; *********************************************************** |
23 | ; * HAG 17.10.2000 * |
24 | ; *********************************************************** |
25 | |
26 | |
27 | |
28 | ; Assemblerdirektiven |
29 | CPU 80515 |
30 | INCLUDE stddef51 |
31 | |
32 | |
33 | SEGMENT code |
34 | org 0000h |
35 | |
36 | |
37 | |
38 | ; Demoprogramm |
39 | ; *********************************************************** |
40 | Demo_LCD: |
41 | call INIT_LCD ; LCD-Anzeige initialisieren |
42 | d01: call text_zeile1 |
43 | call wait_lang |
44 | call text_zeile2 |
45 | call wait_lang |
46 | call init_lcd |
47 | call wait_lang |
48 | jmp d01 |
49 | ; *********************************************************** |
50 | |
51 | |
52 | |
53 | ; ----------------------------------------------------------- |
54 | text_zeile1: |
55 | mov a,#00h+2 ; Cursorposition 1. Zeile |
56 | call CURSOR_POS |
57 | mov b,#000h ; Offset für Text rücksetzen |
58 | mov dptr,#text1 ; Zeiger auf Textanfang |
59 | m00: mov a,b ; Offset nach a |
60 | movc a,@a+dptr ; Zuriff auf Textelement |
61 | jz m01 ; Endekennung erreicht ? |
62 | ; wenn ja, dann zur Endlosschleife |
63 | call WRITE_DREG ; Zeichen ins LCD-Datenregister schreiben |
64 | call wait_kurz ; 100us warten |
65 | inc b ; Offset +1 |
66 | jmp m00 ; weiter machen |
67 | m01: ret |
68 | ; ----------------------------------------------------------- |
69 | |
70 | |
71 | ; ----------------------------------------------------------- |
72 | text_zeile2: |
73 | mov a,#40h ; Cursorposition 2. Zeile |
74 | call CURSOR_POS |
75 | mov b,#000h ; Offset für Text rücksetzen |
76 | mov dptr,#text2 ; Zeiger auf Textanfang |
77 | m02: mov a,b ; Offset nach a |
78 | movc a,@a+dptr ; Zuriff auf Textelement |
79 | jz m03 ; Endekennung erreicht ? |
80 | ; wenn ja, dann zur Endlosschleife |
81 | call WRITE_DREG ; Zeichen ins LCD-Datenregister schreiben |
82 | call wait_kurz ; 100us warten |
83 | inc b ; Offset +1 |
84 | jmp m02 ; weiter machen |
85 | m03: ret |
86 | ; ----------------------------------------------------------- |
87 | |
88 | |
89 | |
90 | ; ----------------------------------------------------------- |
91 | ; Demotexte |
92 | text1 db "MCLS-modular!",00 |
93 | |
94 | text2 db "Demo LCD-UNIT",00 |
95 | ; ----------------------------------------------------------- |
96 | |
97 | |
98 | |
99 | ; ----------------------------------------------------------- |
100 | ; # # |
101 | ; # Steuersignalzuordnung # |
102 | ; # # |
103 | ; ----------------------------------------------------------- |
104 | |
105 | E equ P4.0 ; Enable |
106 | RW equ P4.1 ; Read/Write |
107 | RS equ P4.2 ; Register Select |
108 | ; ----------------------------------------------------------- |
109 | |
110 | |
111 | |
112 | |
113 | ; ----------------------------------------------------------- |
114 | ; # INIT_LCD # |
115 | ; # LCD-Unit initialisieren und löschen # |
116 | ; ----------------------------------------------------------- |
117 | INIT_LCD: |
118 | ; SW-Reset |
119 | call wait_10ms |
120 | |
121 | mov a,#00110000b |
122 | call WRITE_CREG_8BIT ; ins Befehlsreg. schreiben |
123 | call wait_2ms |
124 | |
125 | mov a,#00110000b |
126 | call WRITE_CREG_8BIT |
127 | call wait_1ms |
128 | |
129 | mov a,#00110000b |
130 | call WRITE_CREG_8BIT |
131 | call wait_1ms |
132 | |
133 | ; Umschalten auf 4-Bit Modus |
134 | mov a,#00100000b |
135 | call WRITE_CREG_8BIT |
136 | call wait_1ms |
137 | |
138 | mov a,#00101000b ; Funktion Set, 2 Zeilen |
139 | ; 5*7 Dots |
140 | call WRITE_CREG_4BIT |
141 | call wait_1ms |
142 | |
143 | mov a,#00001000b ; Funktion Display off |
144 | call WRITE_CREG_4BIT |
145 | call wait_1ms |
146 | |
147 | mov a,#00000001b ; Funktion Display clear |
148 | call WRITE_CREG_4BIT |
149 | call wait_1ms |
150 | |
151 | mov a,#00000110b ; Entry Mode |
152 | call WRITE_CREG_4BIT |
153 | call wait_1ms |
154 | |
155 | call WAIT_FOR_READY |
156 | mov a,#00001100b ; Display on |
157 | ; Cursor off, Blinken off |
158 | call WRITE_CREG_4BIT |
159 | call WAIT_FOR_READY |
160 | |
161 | ret |
162 | ; ----------------------------------------------------------- |
163 | |
164 | |
165 | |
166 | |
167 | ; ----------------------------------------------------------- |
168 | ; # CURSOR_HOME # |
169 | ; # Cursor auf Startposition # |
170 | ; ----------------------------------------------------------- |
171 | CURSOR_HOME: |
172 | mov a,#00000010b |
173 | call WRITE_CREG_4BIT |
174 | call wait_1ms |
175 | ret |
176 | ; ----------------------------------------------------------- |
177 | |
178 | |
179 | |
180 | ; ----------------------------------------------------------- |
181 | ; # CURSOR_POS # |
182 | ; # Cursor positionieren # |
183 | ; # Adressen für Zeile 1: 00h - 1fh # |
184 | ; # Adressen für Zeile 2: 40h - 4fh # |
185 | ; # Adresse des Zeichens über Akku bereitstellen # |
186 | ; ----------------------------------------------------------- |
187 | CURSOR_POS: |
188 | orl a,#10000000b ; Bit 7 setzen |
189 | call WRITE_CREG_4BIT |
190 | call wait_1ms |
191 | ret |
192 | ; ----------------------------------------------------------- |
193 | |
194 | |
195 | |
196 | ; ----------------------------------------------------------- |
197 | ; # WRITE_CREG_8BIT # |
198 | ; # Steuerwort zur LCD-Unit (8-Bit Modus) # |
199 | ; ----------------------------------------------------------- |
200 | WRITE_CREG_8BIT: |
201 | push b |
202 | clr RS ; Daten sind Befehlswort |
203 | clr RW ; in Display Schreiben |
204 | clr E ; erst mal auf 0 |
205 | nop |
206 | |
207 | setb E ; E in Grundstellung |
208 | anl a,#0f0h ; LT im Steuerwort rücksetzen |
209 | anl p1,#0fh ; HT im Port 1 rücksetzen |
210 | orl p1,a ; Tetraden zusammenfügen |
211 | clr E ; jetzt Übernahmeflanke |
212 | nop |
213 | |
214 | orl p1,#0f0h ; HT Port 1 setzen |
215 | pop b |
216 | ret |
217 | ; ----------------------------------------------------------- |
218 | |
219 | |
220 | |
221 | ; ----------------------------------------------------------- |
222 | ; # WRITE_CREG_4BIT # |
223 | ; # Steuerwort zur LCD-Unit (4-Bit Modus) # |
224 | ; ----------------------------------------------------------- |
225 | WRITE_CREG_4BIT: |
226 | push b |
227 | mov b,a ; Daten in b puffern |
228 | clr RS ; Daten sind Befehlswort |
229 | clr RW ; in Display Schreiben |
230 | clr E ; erst mal auf 0 |
231 | nop |
232 | |
233 | setb E ; E in Grundstellung |
234 | anl a,#0f0h ; LT im Steuerwort rücksetzen |
235 | anl p1,#0fh ; HT im Port 1 rücksetzen |
236 | orl p1,a ; Tetraden zusammenfügen |
237 | clr E ; jetzt Übernahmeflanke |
238 | nop |
239 | |
240 | setb E |
241 | mov a,b |
242 | swap a |
243 | anl a,#0f0h |
244 | anl p1,#0fh |
245 | orl p1,a |
246 | clr E |
247 | nop |
248 | |
249 | orl p1,#0f0h |
250 | pop b |
251 | ret |
252 | ; ----------------------------------------------------------- |
253 | |
254 | |
255 | |
256 | ; ----------------------------------------------------------- |
257 | ; # WAIT_FOR_READY # |
258 | ; # Warten, bis LCD-UNIT bereit! # |
259 | ; ----------------------------------------------------------- |
260 | WAIT_FOR_READY: |
261 | push acc |
262 | wa0: |
263 | call READ_CREG |
264 | jb acc.7,wa0 |
265 | pop acc |
266 | ret |
267 | ; ----------------------------------------------------------- |
268 | |
269 | |
270 | |
271 | ; ----------------------------------------------------------- |
272 | ; # READ_CREG # |
273 | ; # Auslesen des Steuerregisters # |
274 | ; ----------------------------------------------------------- |
275 | READ_CREG: |
276 | push b |
277 | orl p1,#0f0h |
278 | clr RS |
279 | setb RW |
280 | clr E |
281 | nop |
282 | |
283 | setb E |
284 | nop |
285 | mov a,p1 |
286 | anl a,#0f0h |
287 | mov b,a |
288 | clr E |
289 | nop |
290 | |
291 | setb E |
292 | nop |
293 | mov a,p1 |
294 | anl a,#0f0h |
295 | swap a |
296 | orl a,b |
297 | clr E |
298 | nop |
299 | |
300 | clr RW |
301 | pop b |
302 | ret |
303 | ; ----------------------------------------------------------- |
304 | |
305 | |
306 | |
307 | ; ----------------------------------------------------------- |
308 | ; # WRITE_DREG # |
309 | ; # Schreiben ins Datenregister # |
310 | ; # ASCII-Zeichencode über Akku bereitstellen # |
311 | ; ----------------------------------------------------------- |
312 | WRITE_DREG: |
313 | push b |
314 | mov b,a |
315 | setb RS |
316 | clr RW |
317 | clr E |
318 | nop |
319 | |
320 | setb E |
321 | anl a,#0f0h |
322 | anl p1,#0fh |
323 | orl p1,a |
324 | clr E |
325 | nop |
326 | |
327 | setb E |
328 | mov a,b |
329 | swap a |
330 | anl a,#0f0h |
331 | anl p1,#0fh |
332 | orl p1,a |
333 | clr E |
334 | nop |
335 | |
336 | clr RS |
337 | nop |
338 | orl p1,#0f0h |
339 | pop b |
340 | ret |
341 | ; ----------------------------------------------------------- |
342 | |
343 | |
344 | |
345 | ; ----------------------------------------------------------- |
346 | ; # Zeitverzögerungen für LCD_UNIT # |
347 | ; ----------------------------------------------------------- |
348 | ; etwa 1 s warten |
349 | wait_lang: |
350 | mov r5,#100 |
351 | w04: call wait_10ms ; 10ms |
352 | djnz r5,w04 ; 2us |
353 | ret ; 2us |
354 | |
355 | ; etwa 100us warten |
356 | wait_kurz: |
357 | mov r6,#48 ; 2us |
358 | w00: djnz r6,w00 ; 96us |
359 | ret ; 2us |
360 | |
361 | wait_1ms: |
362 | mov r6,#10 |
363 | w01: call wait_kurz |
364 | djnz r7,w01 |
365 | ret |
366 | |
367 | wait_2ms: |
368 | mov r6,#20 |
369 | w02: call wait_kurz |
370 | djnz r7,w02 |
371 | ret |
372 | |
373 | wait_10ms: |
374 | mov r6,#98 |
375 | w03: call wait_kurz ; 100us |
376 | djnz r7,w03 ; 2us |
377 | ret ; 2us |
378 | ; ----------------------------------------------------------- |
379 | |
380 | |
381 | END |
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.
Hier hast du doch beispielsweise Code, der einen Text ausgibt
1 | ; ----------------------------------------------------------- |
2 | text_zeile1: |
3 | mov a,#00h+2 ; Cursorposition 1. Zeile |
4 | call CURSOR_POS |
5 | mov b,#000h ; Offset für Text rücksetzen |
6 | mov dptr,#text1 ; Zeiger auf Textanfang |
7 | m00: mov a,b ; Offset nach a |
8 | movc a,@a+dptr ; Zuriff auf Textelement |
9 | jz m01 ; Endekennung erreicht ? |
10 | ; wenn ja, dann zur Endlosschleife |
11 | call WRITE_DREG ; Zeichen ins LCD-Datenregister schreiben |
12 | call wait_kurz ; 100us warten |
13 | inc b ; Offset +1 |
14 | jmp m00 ; weiter machen |
15 | 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
1 | ; |
2 | ; Voraussetzungen |
3 | ; dptr enthält die Startadresse des auszugebenden Textes |
4 | ; der Cursor am LCD ist schon an der richtigen Stelle |
5 | ; |
6 | ; veränderte Register: b, a und alles in WRITE_DREG, wait_kurz |
7 | ; |
8 | TEXT_OUT: |
9 | mov b,#000h ; Offset für Text rücksetzen |
10 | to00: mov a,b ; Offset nach a |
11 | movc a,@a+dptr ; Zuriff auf Textelement |
12 | jz to1 ; Endekennung erreicht ? |
13 | ; wenn ja, dann Ausgabe beenden |
14 | call WRITE_DREG ; Zeichen ins LCD-Datenregister schreiben |
15 | call wait_kurz ; 100us warten |
16 | inc b ; Offset +1 |
17 | jmp to00 ; weiter machen |
18 | to01: ret |
welches du so aufrufen kannst
1 | mov dptr,#menu_1 |
2 | call TEXT_OUT |
3 | .... |
4 | |
5 | 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:
1 | ; ----------------------------------------------------------- |
2 | text_zeile1: |
3 | mov a,#00h+2 ; Cursorposition 1. Zeile |
4 | call CURSOR_POS |
5 | mov dptr,#text1 ; Zeiger auf Textanfang |
6 | call TEXT_OUT ; Text ausgeben |
7 | ret |
8 | |
9 | ; ----------------------------------------------------------- |
10 | text_zeile2: |
11 | mov a,#40h ; Cursorposition 2. Zeile |
12 | call CURSOR_POS |
13 | mov dptr,#text2 ; Zeiger auf Textanfang |
14 | call TEXT_OUT ; Text ausgeben |
15 | ret |
16 | |
17 | text1 db "MCLS-modular!",00 |
18 | text2 db "Demo LCD-UNIT",00 |
19 | |
20 | |
21 | ; |
22 | ; Voraussetzungen |
23 | ; dptr enthält die Startadresse des auszugebenden Textes |
24 | ; der Cursor am LCD ist schon an der richtigen Stelle |
25 | ; |
26 | ; veränderte Register: b, a und alles in WRITE_DREG, wait_kurz |
27 | ; |
28 | TEXT_OUT: |
29 | mov b,#000h ; Offset für Text rücksetzen |
30 | to00: mov a,b ; Offset nach a |
31 | movc a,@a+dptr ; Zuriff auf Textelement |
32 | jz to1 ; Endekennung erreicht ? |
33 | ; wenn ja, dann Ausgabe beenden |
34 | call WRITE_DREG ; Zeichen ins LCD-Datenregister schreiben |
35 | call wait_kurz ; 100us warten |
36 | inc b ; Offset +1 |
37 | jmp to00 ; weiter machen |
38 | to01: ret |
Allerdings hättest du das selbst auch sehen müssen, wie man eine bestimmte Funktionalität (Textausgeben) aus dem Demobeispiel herausziehen kann.
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.
Also soweit habe ich die Tastatur jetzt programmiert.
1 | ; -------- Declarations required for Assembler ---------- |
2 | |
3 | CPU 80515 ; MC selection (identical with 80C535) |
4 | |
5 | INCLUDE stddef51 ; SFR definitions |
6 | INCLUDE bitfuncs |
7 | SEGMENT code ; Program code segment starts here |
8 | |
9 | ORG 0000H ; Program code starts at 0000H |
10 | |
11 | |
12 | ; ------------------------------------------------------- |
13 | |
14 | ; ------------------------------------------------------------------ |
15 | ;Setzt alle Werte der Display Unit auf 0 |
16 | ;------------------------------------------------------------------- |
17 | Main: |
18 | |
19 | init: Mov P1,#11000000B |
20 | SETB P4.0 |
21 | CLR P4.0 |
22 | SETB P4.0 |
23 | |
24 | Mov P1,#11000000B |
25 | SETB P4.1 |
26 | CLR P4.1 |
27 | SETB P4.1 |
28 | |
29 | Mov P1,#11000000B |
30 | SETB P4.2 |
31 | CLR P4.2 |
32 | SETB P4.2 |
33 | |
34 | Mov P1,#11000000B |
35 | SETB P4.3 |
36 | CLR P4.3 |
37 | SETB P4.3 |
38 | |
39 | Mov 030H,#11000000B |
40 | Mov 040H,#11000000B |
41 | Mov 050H,#11000000B |
42 | Mov 060H,#11000000B |
43 | |
44 | |
45 | ;Schleife die auf Druecken einer Taste wartet |
46 | ;---------------------------------------------------------------- |
47 | |
48 | loop: JNB P5.0,NULL |
49 | JNB P5.1,EINS |
50 | JNB P5.2,ZWEI |
51 | JNB P5.3,DREI |
52 | JNB P5.4,Eingeben |
53 | |
54 | |
55 | SJMP loop |
56 | |
57 | ;Setz D0 von Display auf eingeben Wert ein |
58 | ;--------------------------------------------------------------- |
59 | |
60 | Start1: MOV 060H,050H |
61 | MOV 050H,040H |
62 | MOV 040H,030H |
63 | |
64 | MOV DPTR,#Tab0 |
65 | MOVC A,@A+DPTR |
66 | |
67 | MOV 030H,A |
68 | |
69 | MOV P1,030H |
70 | SETB P4.0 |
71 | CLR P4.0 |
72 | SETB P4.0 |
73 | |
74 | MOV P1,040H |
75 | SETB P4.1 |
76 | CLR P4.1 |
77 | SETB P4.1 |
78 | |
79 | MOV P1,050H |
80 | SETB P4.2 |
81 | CLR P4.2 |
82 | SETB P4.2 |
83 | |
84 | MOV P1,060H |
85 | SETB P4.3 |
86 | CLR P4.3 |
87 | SETB P4.3 |
88 | |
89 | noch_gedrueckt5: JB P4.7,noch_gedrueckt5 |
90 | sjmp loop |
91 | |
92 | |
93 | NULL: MOV A,#0 |
94 | noch_gedrueckt0: JB P4.7,noch_gedrueckt0 |
95 | SJMP Start1 |
96 | |
97 | |
98 | EINS: MOV A,#1 |
99 | noch_gedrueckt1: JB P4.7,noch_gedrueckt1 |
100 | SJMP Start1 |
101 | |
102 | |
103 | ZWEI: MOV A,#2 |
104 | noch_gedrueckt2: JB P4.7,noch_gedrueckt2 |
105 | SJMP Start1 |
106 | |
107 | |
108 | DREI: MOV A,#3 |
109 | noch_gedrueckt3: JB P4.7,noch_gedrueckt3 |
110 | SJMP Start1 |
111 | |
112 | |
113 | Eingeben: Mov R0,030H |
114 | Mov P1,030H |
115 | |
116 | noch_gedrueckt4: JB P4.7,noch_gedrueckt4 |
117 | |
118 | SJMP loop |
119 | |
120 | |
121 | |
122 | Tab0: DB 11000000B ;Null |
123 | DB 11111001B ;Eins |
124 | DB 10100100B ;Zwei |
125 | DB 10110000B ;Drei |
126 | |
127 | 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ü.
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.
Ok ich versuche jetzt das mal zu verstehen und melde mich dann wieder danke für die antwort
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
>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
Dann sollte das Tutorial doch helfen; mehr wird man dir hier auch nicht sagen können - sonst würde es im Tutorial stehen.
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.
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.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.