Hallo,
folgendes Problem: Ich möchte mehrere Anweisungen auf einem LCD (2x40
Zeichen) über einen ATmega32 ausgeben. Die Anweisungen sollen
hintereinander durch drücken eines Tasters, der am µC angeschlossen ist,
aufgerufen werden. Mit einem weiteren Taster kann man eine Anweisung
zurück gehen. Insgesamt habe ich 28 Anweisungen. Das Problem besteht nun
darin, dass die ersten 5 Anweisungen nicht auf dem Display angezeigt
werden. Erst wenn der Taster 6 mal gedrückt wurde erscheint Anweisung 6.
Programmiere ich den µC allerdings für nur insgesamt 20 Anweisungen oder
weniger funktioniert es einwandfrei. Hat jemand eine Idee? Zur
Ansteuerung des Displays verwende ich die Library von Peter Fleury und
zur Tastenentprellung das Debounce-Makro von Peter Dannegger auf der
Artikelseite. Hier der Code:
1
#include<avr/io.h>
2
#include<stdlib.h>
3
#include<stdio.h>
4
#include<stdint.h>
5
#include<string.h>
6
#include<debounce.h>
7
#include<util/delay.h>
8
#include<avr/interrupt.h>
9
#include<lcd.c>
10
#include<lcd.h>
11
12
unsignedcharstep=0;// Schrittvariable
13
14
15
voidnext_instruction(void)// Funktion für den nächsten Schritt
16
{
17
switch(step)
18
{
19
case0:
20
lcd_gotoxy(0,0);
21
lcd_puts("Anweisung 1 ");
22
lcd_gotoxy(0,1);
23
lcd_puts("Anweisung 1 01/28");
24
step=1;
25
break;
26
27
case1:
28
lcd_gotoxy(0,0);
29
lcd_puts("Anweisung 2 ");
30
lcd_gotoxy(0,1);
31
lcd_puts("Anweisung 2 02/28");
32
step=2;
33
break;
34
35
case2:
36
lcd_gotoxy(0,0);
37
lcd_puts("Anweisung 3 ");
38
lcd_gotoxy(0,1);
39
lcd_puts("Anweisung 3 03/28");
40
step=3;
41
break;
42
43
case3:
44
lcd_gotoxy(0,0);
45
lcd_puts("Anweisung 4 ");
46
lcd_gotoxy(0,1);
47
lcd_puts("Anweisung 4 04/28");
48
step=4;
49
break;
50
51
52
case4:
53
lcd_gotoxy(0,0);
54
lcd_puts("Anweisung 5 ");
55
lcd_gotoxy(0,1);
56
lcd_puts("Anweisung 5 05/28");
57
step=5;
58
break;
59
60
case5:
61
lcd_gotoxy(0,0);
62
lcd_puts("Anweisung 6 ");
63
lcd_gotoxy(0,1);
64
lcd_puts("Anweisung 6 06/28");
65
step=6;
66
break;
67
68
case6:
69
lcd_gotoxy(0,0);
70
lcd_puts("Anweisung 7 ");
71
lcd_gotoxy(0,1);
72
lcd_puts("Anweisung 7 07/28");
73
step=7;
74
break;
75
76
case7:
77
lcd_gotoxy(0,0);
78
lcd_puts("Anweisung 8 ");
79
lcd_gotoxy(0,1);
80
lcd_puts("Anweisung 8 08/28");
81
step=8;
82
break;
83
84
case8:
85
lcd_gotoxy(0,0);
86
lcd_puts("Anweisung 9 ");
87
lcd_gotoxy(0,1);
88
lcd_puts("Anweisung 9 09/28");
89
step=9;
90
break;
91
92
case9:
93
lcd_gotoxy(0,0);
94
lcd_puts("Anweisung 10 ");
95
lcd_gotoxy(0,1);
96
lcd_puts("Anweisung 10 10/28");
97
step=10;
98
break;
99
100
case10:
101
lcd_gotoxy(0,0);
102
lcd_puts("Anweisung 11 ");
103
lcd_gotoxy(0,1);
104
lcd_puts("Anweisung 11 11/28");
105
step=11;
106
break;
107
108
case11:
109
lcd_gotoxy(0,0);
110
lcd_puts("Anweisung 12 ");
111
lcd_gotoxy(0,1);
112
lcd_puts("Anweisung 12 12/28");
113
step=12;
114
break;
115
116
case12:
117
lcd_gotoxy(0,0);
118
lcd_puts("Anweisung 13 ");
119
lcd_gotoxy(0,1);
120
lcd_puts("Anweisung 13 13/28");
121
step=13;
122
break;
123
124
case13:
125
lcd_gotoxy(0,0);
126
lcd_puts("Anweisung 14 ");
127
lcd_gotoxy(0,1);
128
lcd_puts("Anweisung 14 14/28");
129
step=14;
130
break;
131
132
case14:
133
lcd_gotoxy(0,0);
134
lcd_puts("Anweisung 15 ");
135
lcd_gotoxy(0,1);
136
lcd_puts("Anweisung 15 15/28");
137
step=15;
138
break;
139
140
case15:
141
lcd_gotoxy(0,0);
142
lcd_puts("Anweisung 16 ");
143
lcd_gotoxy(0,1);
144
lcd_puts("Anweisung 16 16/28");
145
step=16;
146
break;
147
148
case16:
149
lcd_gotoxy(0,0);
150
lcd_puts("Anweisung 17 ");
151
lcd_gotoxy(0,1);
152
lcd_puts("Anweisung 17 17/28");
153
step=17;
154
break;
155
156
case17:
157
lcd_gotoxy(0,0);
158
lcd_puts("Anweisung 18 ");
159
lcd_gotoxy(0,1);
160
lcd_puts("Anweisung 18 18/28");
161
step=18;
162
break;
163
164
case18:
165
lcd_gotoxy(0,0);
166
lcd_puts("Anweisung 19 ");
167
lcd_gotoxy(0,1);
168
lcd_puts("Anweisung 19 19/28");
169
step=19;
170
break;
171
172
case19:
173
lcd_gotoxy(0,0);
174
lcd_puts("Anweisung 20 ");
175
lcd_gotoxy(0,1);
176
lcd_puts("Anweisung 20 20/28");
177
step=20;
178
break;
179
180
case20:
181
lcd_gotoxy(0,0);
182
lcd_puts("Anweisung 21 ");
183
lcd_gotoxy(0,1);
184
lcd_puts("Anweisung 21 21/28");
185
step=21;
186
break;
187
188
case21:
189
lcd_gotoxy(0,0);
190
lcd_puts("Anweisung 22 ");
191
lcd_gotoxy(0,1);
192
lcd_puts("Anweisung 22 22/28");
193
step=22;
194
break;
195
196
case22:
197
lcd_gotoxy(0,0);
198
lcd_puts("Anweisung 23 ");
199
lcd_gotoxy(0,1);
200
lcd_puts("Anweisung 23 23/28");
201
step=23;
202
break;
203
204
case23:
205
lcd_gotoxy(0,0);
206
lcd_puts("Anweisung 24 ");
207
lcd_gotoxy(0,1);
208
lcd_puts("Anweisung 24 24/28");
209
step=24;
210
break;
211
212
case24:
213
lcd_gotoxy(0,0);
214
lcd_puts("Anweisung 25 ");
215
lcd_gotoxy(0,1);
216
lcd_puts("Anweisung 25 25/28");
217
step=25;
218
break;
219
220
case25:
221
lcd_gotoxy(0,0);
222
lcd_puts("Anweisung 26 ");
223
lcd_gotoxy(0,1);
224
lcd_puts("Anweisung 26 26/28");
225
step=26;
226
break;
227
228
case26:
229
lcd_gotoxy(0,0);
230
lcd_puts("Anweisung 27 ");
231
lcd_gotoxy(0,1);
232
lcd_puts("Anweisung 27 27/28");
233
step=27;
234
break;
235
236
case27:
237
lcd_gotoxy(0,0);
238
lcd_puts("Anweisung 28 ");
239
lcd_gotoxy(0,1);
240
lcd_puts("Anweisung 28 28/28");
241
step=28;
242
break;
243
244
245
default:break;
246
}
247
248
}
249
250
251
voidprevious_instruction(void)// Funktion für den vorherigen Schritt
252
{
253
switch(step)
254
{
255
case2:
256
lcd_gotoxy(0,0);
257
lcd_puts("Anweisung 1 ");
258
lcd_gotoxy(0,1);
259
lcd_puts("Anweisung 1 01/28");
260
step=1;
261
break;
262
263
case3:
264
lcd_gotoxy(0,0);
265
lcd_puts("Anweisung 2 ");
266
lcd_gotoxy(0,1);
267
lcd_puts("Anweisung 2 02/28");
268
step=2;
269
break;
270
271
case4:
272
lcd_gotoxy(0,0);
273
lcd_puts("Anweisung 3 ");
274
lcd_gotoxy(0,1);
275
lcd_puts("Anweisung 3 03/28");
276
step=3;
277
break;
278
279
case5:
280
lcd_gotoxy(0,0);
281
lcd_puts("Anweisung 4 ");
282
lcd_gotoxy(0,1);
283
lcd_puts("Anweisung 4 04/28");
284
step=4;
285
break;
286
287
288
case6:
289
lcd_gotoxy(0,0);
290
lcd_puts("Anweisung 5 ");
291
lcd_gotoxy(0,1);
292
lcd_puts("Anweisung 5 05/28");
293
step=5;
294
break;
295
296
case7:
297
lcd_gotoxy(0,0);
298
lcd_puts("Anweisung 6 ");
299
lcd_gotoxy(0,1);
300
lcd_puts("Anweisung 6 06/28");
301
step=6;
302
break;
303
304
case8:
305
lcd_gotoxy(0,0);
306
lcd_puts("Anweisung 7 ");
307
lcd_gotoxy(0,1);
308
lcd_puts("Anweisung 7 07/28");
309
step=7;
310
break;
311
312
case9:
313
lcd_gotoxy(0,0);
314
lcd_puts("Anweisung 8 ");
315
lcd_gotoxy(0,1);
316
lcd_puts("Anweisung 8 08/28");
317
step=8;
318
break;
319
320
case10:
321
lcd_gotoxy(0,0);
322
lcd_puts("Anweisung 9 ");
323
lcd_gotoxy(0,1);
324
lcd_puts("Anweisung 9 09/28");
325
step=9;
326
break;
327
328
case11:
329
lcd_gotoxy(0,0);
330
lcd_puts("Anweisung 10 ");
331
lcd_gotoxy(0,1);
332
lcd_puts("Anweisung 10 10/28");
333
step=10;
334
break;
335
336
case12:
337
lcd_gotoxy(0,0);
338
lcd_puts("Anweisung 11 ");
339
lcd_gotoxy(0,1);
340
lcd_puts("Anweisung 11 11/28");
341
step=11;
342
break;
343
344
case13:
345
lcd_gotoxy(0,0);
346
lcd_puts("Anweisung 12 ");
347
lcd_gotoxy(0,1);
348
lcd_puts("Anweisung 12 12/28");
349
step=12;
350
break;
351
352
case14:
353
lcd_gotoxy(0,0);
354
lcd_puts("Anweisung 13 ");
355
lcd_gotoxy(0,1);
356
lcd_puts("Anweisung 13 13/28");
357
step=13;
358
break;
359
360
case15:
361
lcd_gotoxy(0,0);
362
lcd_puts("Anweisung 14 ");
363
lcd_gotoxy(0,1);
364
lcd_puts("Anweisung 14 14/28");
365
step=14;
366
break;
367
368
case16:
369
lcd_gotoxy(0,0);
370
lcd_puts("Anweisung 15 ");
371
lcd_gotoxy(0,1);
372
lcd_puts("Anweisung 15 15/28");
373
step=15;
374
break;
375
376
case17:
377
lcd_gotoxy(0,0);
378
lcd_puts("Anweisung 16 ");
379
lcd_gotoxy(0,1);
380
lcd_puts("Anweisung 16 16/28");
381
step=16;
382
break;
383
384
case18:
385
lcd_gotoxy(0,0);
386
lcd_puts("Anweisung 17 ");
387
lcd_gotoxy(0,1);
388
lcd_puts("Anweisung 17 17/28");
389
step=17;
390
break;
391
392
case19:
393
lcd_gotoxy(0,0);
394
lcd_puts("Anweisung 18 ");
395
lcd_gotoxy(0,1);
396
lcd_puts("Anweisung 18 18/28");
397
step=18;
398
break;
399
400
case20:
401
lcd_gotoxy(0,0);
402
lcd_puts("Anweisung 19 ");
403
lcd_gotoxy(0,1);
404
lcd_puts("Anweisung 19 19/28");
405
step=19;
406
break;
407
408
case21:
409
lcd_gotoxy(0,0);
410
lcd_puts("Anweisung 20 ");
411
lcd_gotoxy(0,1);
412
lcd_puts("Anweisung 20 20/28");
413
step=20;
414
break;
415
416
case22:
417
lcd_gotoxy(0,0);
418
lcd_puts("Anweisung 21 ");
419
lcd_gotoxy(0,1);
420
lcd_puts("Anweisung 21 21/28");
421
step=21;
422
break;
423
424
case23:
425
lcd_gotoxy(0,0);
426
lcd_puts("Anweisung 22 ");
427
lcd_gotoxy(0,1);
428
lcd_puts("Anweisung 22 22/28");
429
step=22;
430
break;
431
432
case24:
433
lcd_gotoxy(0,0);
434
lcd_puts("Anweisung 23 ");
435
lcd_gotoxy(0,1);
436
lcd_puts("Anweisung 23 23/28");
437
step=23;
438
break;
439
440
case25:
441
lcd_gotoxy(0,0);
442
lcd_puts("Anweisung 24 ");
443
lcd_gotoxy(0,1);
444
lcd_puts("Anweisung 24 24/28");
445
step=24;
446
break;
447
448
case26:
449
lcd_gotoxy(0,0);
450
lcd_puts("Anweisung 25 ");
451
lcd_gotoxy(0,1);
452
lcd_puts("Anweisung 25 25/28");
453
step=25;
454
break;
455
456
case27:
457
lcd_gotoxy(0,0);
458
lcd_puts("Anweisung 26 ");
459
lcd_gotoxy(0,1);
460
lcd_puts("Anweisung 26 26/28");
461
step=26;
462
break;
463
464
case28:
465
lcd_gotoxy(0,0);
466
lcd_puts("Anweisung 27 ");
467
lcd_gotoxy(0,1);
468
lcd_puts("Anweisung 27 27/28");
469
step=27;
470
break;
471
472
case29:
473
lcd_gotoxy(0,0);
474
lcd_puts("Anweisung 28 ");
475
lcd_gotoxy(0,1);
476
lcd_puts("Anweisung 28 28/28");
477
step=28;
478
break;
479
480
default:break;
481
}
482
483
}
484
485
486
487
488
//----------------------------------------------
489
490
intmain(void)
491
{
492
DDRB=0xFF;// PortB als Ausgang schalten
493
DDRC=0xFF;// PortC als Ausgang schalten
494
DDRD=0x00;// PortD als Eingang schalten
495
PORTB=0x1C;
496
PORTC=0x00;
497
PORTD=0x00;// interne Pull-ups an PORTD deaktivieren
498
499
500
501
lcd_init(LCD_DISP_ON);
502
lcd_gotoxy(0,0);
503
lcd_puts(" *** PROGRAMMABLAUF XY *** ");
504
505
506
507
508
509
while(1)// Überwachen ob und welcher Taster gedrückt wird
reiner zufall dasses überhaupt läuft.. initialisiere step in main() und
lass mal step in der main schleife hoch+runterzählen und übergeb den
konkreten wert an die funktion als parameter.
Und denk mal darüber nach, deine Texte in ein Stringarray zu legen, die
du mit der step Variablen indizierst. Das ist doch Unmenge an Code für
nichts, mit massenhaft Textduplikaten.
Sind eigentlich deine restlichen Dinge die du bei jedem step machst in
previous_step bzw next_step immer gleich, d.h. wenn bei next_step der
step 2 von 1 ausgehend erreicht wird, passiert dann das gleiche, wie
wenn step 2 von previous_step von der 3 aus erreicht wird?
Wenn ja, dann solltest du unbedingt deine Systematik auf jeden Fall
ändern. Du hast eine Funktion show_step und das erhöhen bzw. erniedrigen
ist nicht das Bier dieser Funktion, sondern passiert ausserhalb. Dein
Gedöns mit PORTB ist, soweit ich das auf die Schnelle gesehen habe, auch
in allen Fällen gleich nur PORTC wird anders behandelt.
Alles in allen sieht es so aus, als ob man die Funktionalität leicht
mittels Tabellen und einer Abarbeitungsmaschine (ähnlich einer
State-maschine) einfach implementieren kann.
Edit:
Nein, eigentlich ist eine State-maschine in einer Tabelle schon ziemlich
genau der Ansatz um das Programm extrem zu vereinfachen. Es sei denn, da
kommt noch was dazu, was man jetzt noch nicht absehen kann.
@Dennis (Gast)
Was soll der Unsinn mit dem ellenlangen Code im Posting? Im Anhang ist
er prima aufgehoben. Siehe Netiquette!
Und wie bereits gesagt, das macht man mit Arrays und einer
Statemachine.
MFG
Falk
Du hast Strings mit 40 Zeichen (41 Bytes) Länge. Je Schritt zeigst Du 2
davon an, macht 80 Zeichen (82 Bytes). Pro case hast du 28 Einträge.
Du hältst die Strings unpassenderweise im initialisierten SRAM, nicht im
Flash.
Insgesamt hast Du also
1
2 * 28 * 82 Bytes = 4592 Bytes
an Strings im SRAM. Der ATmega32 hat 4kBytes SRAM. Merkst Du was?
Nur Gemecker von den Forumshirschen, aber keine Lösung des Problems,
war ja klar. Beantwortet doch mal die Frage des TO. Den Code solltet
ihr doch gar nicht diskutieren. Klar, Profis programmieren das mit
minimalem Aufwand, aber jeder hat mal angefangen und macht das erst
mal umständlich, nur funktionieren sollte es.
Mike Hammer schrieb:> Nur Gemecker von den Forumshirschen, aber keine Lösung des Problems,> war ja klar. Beantwortet doch mal die Frage des TO.
Die ist längst beantwortet.
Viel zu viel SRAM verbraucht.
> Den Code solltet> ihr doch gar nicht diskutieren.
Doch.
Mit einer einfacheren SW-Architektur hätte er viel weniger SRAM
verbraucht.
> Klar, Profis programmieren das mit> minimalem Aufwand, aber jeder hat mal angefangen und macht das erst> mal umständlich,
drum sagen wir ihm ja auch, wie man es besser machen kann.
Um ehrlich zu sein befasse ich mich mit mikrocontrollern sehr selten und
mache das hier nur nebenbei....deshalb ergeben sich mir ne menge fragen
auf euere antworten...
smatlok schrieb:> reiner zufall dasses überhaupt läuft.. initialisiere step in main() und>> lass mal step in der main schleife hoch+runterzählen und übergeb den>> konkreten wert an die funktion als parameter.
ich dachte man initialisiert globale variablen immer am anfang des
codes? hab es mal ausprobiert und es erscheint eine fehlermeldung, dass
der compiler die variable step in der funktion next_step() nicht kennt.
und ist es nicht wurst ob ich die variable in der mainschleife hochzähle
oder in der funktion?
ich glaube nicht dass es ein zufall ist dass es mit weniger anweisungen
klappt.
Falk Brunner schrieb:> Und wie bereits gesagt, das macht man mit Arrays und einer>> Statemachine.
wusste bisher nicht was eine statemachine ist aber nachdem ich mir den
artikel durchgelesen hab sieht mein programm doch exakt so aus (vgl
erstes bsp in dem artikel) nur dass meine variable step heist und nicht
state.
Karl heinz Buchegger schrieb:> Mit einer einfacheren SW-Architektur hätte er viel weniger SRAM>> verbraucht.
und wenn man strings in einem array abspeichert verbraucht man weniger
speicher als wenn man jeden einzelnen string abspeichert? Warum?
ich will das eigentlich zügig ohne großen aufwand erledigt haben und da
das eigentliche problem ja der mangelnde platz an sram ist, ist doch das
abspeichern der strings im flash die schnellste lösung wenn auch nicht
die eleganteste...
Dennis schrieb:> ich dachte man initialisiert globale variablen immer am anfang des> codes?
Deine Initialisierung funktioniert genauso gut. Lass dir da mal nichts
einreden.
> wusste bisher nicht was eine statemachine ist aber nachdem ich mir den> artikel durchgelesen hab sieht mein programm doch exakt so aus (vgl> erstes bsp in dem artikel) nur dass meine variable step heist und nicht> state.
Ja, da hast du recht. Verstehe auch nicht warum da der Falk meinte, du
sollst eine Statemachine bauen. Er hatte wohl eine andere elegantere
Struktur im Kopf. Aber das von einem Anfänger verlangen/erwarten?
>> Karl heinz Buchegger schrieb:>> Mit einer einfacheren SW-Architektur hätte er viel weniger SRAM>>>> verbraucht.>> und wenn man strings in einem array abspeichert verbraucht man weniger> speicher als wenn man jeden einzelnen string abspeichert? Warum?
Nein, dass ist natürlich nicht der Fall. Aber du hast elendig viele
gleiche Anteile in den Strings. Die gleichen Strings könntest du nur
einmal ablegen und dann mehrere Ausgaben starten für jeden Step. Erst
den für alle gemeinsamen Text "Anweisung ", dann die Stepnummer und dann
gotoxy(35,1) und noch die Ausgabe "18/28" oder so. Die vielen
Leerzeichen brauchst du als String doch garnicht. Der String "Anweisung
" wäre dann nur einmal da und nicht über 40 mal. Und schon würde auch
dein SRAM reichen.
z.B.:
1
staticcharsAnweisung[]="Anweisung";// Text "Anweisung " ist so nur einmal vorhanden
2
charbuffer[20];
3
4
sprintf(buffer,"%s %2d",sAnweisung,step);// "Anweisung " + step nummer als String vorbereiten
5
lcd_gotoxy(0,0);
6
lcd_puts(buffer)// "Anweisung step" ausgeben
7
lcd_gotoxy(0,1);
8
lcd_puts(buffer)
9
sprintf(buffer,"%2d/28",step);// step/max. Step als String vorbereiten
10
lcd_gotoxy(35,1);
11
lcd_puts(buffer)
12
step=27;
> ich will das eigentlich zügig ohne großen aufwand erledigt haben und da> das eigentliche problem ja der mangelnde platz an sram ist, ist doch das> abspeichern der strings im flash die schnellste lösung wenn auch nicht> die eleganteste...
Das so zu erledigen geht natürlich auch.
Dein nicht ausreichendes SRAM wird sicher der Grund sein, warum du solch
ein merkwürdiges Verhalten hast. Das es überhaupt läuft, ist schon ein
wunder. Aber das wurde ja schon gesagt.
Ich muss sagen, auch wenn ich die Meinung der "Platzhirsche" hier sehr
schätze, dass ihre Antwort hier suboptimal war. Sicher kann man alles
besser und hübscher machen. Aber als Anfänger(?) ist es auf einem
einfachen Wege erstmal OK finde ich. Dabei lernt man schonmal etwas. Ich
bin echt verwundert. Wenn ein Anfänger ein komplexes Projekt mit einem
AVR aufziehen will und hier fragt, dann rät man ihm mit einer LED und
einem Taster anzufangen. Hier erwartet man umgekehrt gleich gute und
ordentliche Programmstrukturen u.s.w.. Für einen Anfänger finde ich das
oben garnicht so schlecht.
900ss D. schrieb:> einem Taster anzufangen. Hier erwartet man umgekehrt gleich gute und> ordentliche Programmstrukturen u.s.w.. Für einen Anfänger finde ich das> oben garnicht so schlecht.
Na ja.
Zumindest so hätte man das ja doch machen können. Das wäre ziemlich
naheliegend:
1
voidshow_instruction(uint8_tschritt)
2
{
3
switch(schritt)
4
{
5
case0:
6
lcd_gotoxy(0,0);
7
lcd_puts("Anweisung 1 ");
8
lcd_gotoxy(0,1);
9
lcd_puts("Anweisung 1 01/28");
10
break;
11
12
case1:
13
lcd_gotoxy(0,0);
14
lcd_puts("Anweisung 2 ");
15
lcd_gotoxy(0,1);
16
lcd_puts("Anweisung 2 02/28");
17
break;
18
19
...
20
}
21
22
intmain()
23
{
24
...
25
26
lcd_init(LCD_DISP_ON);
27
lcd_gotoxy(0,0);
28
lcd_puts(" *** PROGRAMMABLAUF XY *** ");
29
30
step=0;
31
32
while(1)
33
{
34
if(debounce(PIND,PD0))
35
{
36
if(step<29){
37
step++;
38
show_instruction(step);
39
}
40
}
41
42
if(debounce(PIND,PD1))
43
{
44
if(step>0){
45
step--;
46
show_instruction(step);
47
}
48
}
49
}
50
}
damit hätte man schon mal die doppelte Aufzählung aller steps in
previous_... und next_... weg, weil es previous_... und next_... schon
gar nicht mehr gibt, sondern nur noch 1 Funktione die einen Parameter
bekommt, für welchen Schritt sie die Anzeige aufbereiten soll.
Vo da ist es dann kein weiter Weg mehr, dass man realisiert, dass doch
im Grunde alle cases in der Funktion dasselbe machen. Also legt man sich
die gleich in eine Tabelle, die aus den beiden Texten für einen Status
besteht.
1
structstate
2
{
3
char*text1;
4
char*text2;
5
};
6
7
structstatesStates[]=
8
{
9
{"Anweisung 1 ",
10
"Anweisung 1 01/28"},
11
12
{"Anweisung 2 ",
13
"Anweisung 2 02/28"},
14
15
...dierestlichen26States
16
};
17
18
voidshow_instruction(uint8_tschritt)
19
{
20
if(schritt<sizeof(States)/sizeof(*States)){// sicher ist sicher
21
lcd_gotoxy(0,0);
22
lcd_puts(States[schritt].text1);
23
lcd_gotoxy(0,1);
24
lcd_puts(States[schritt].text2);
25
}
26
}
27
28
intmain()
29
{
30
...
31
32
lcd_init(LCD_DISP_ON);
33
lcd_gotoxy(0,0);
34
lcd_puts(" *** PROGRAMMABLAUF XY *** ");
35
36
step=0;
37
38
while(1)
39
{
40
if(debounce(PIND,PD0))
41
{
42
if(step<29){
43
step++;
44
show_instruction(step);
45
}
46
}
47
48
if(debounce(PIND,PD1))
49
{
50
if(step>0){
51
step--;
52
show_instruction(step);
53
}
54
}
55
}
56
}
die restlichen Informationen, die sonst noch zu einem State gehören,
kann man auch noch in die Tabelle verfrachten und hat dort dann die
komplette Info beisammen, was in einem State alles zu tun ist (und wenn
man will kann man in die Tabelle dann auch noch den jeweiligen Vorgänger
btw. Nachfolgezustand mit angeben.
Vorteil des Ganzen: Änderungsaufwand ist kleiner und vor allen Dingen
übersichtlicher, weil alles an einer Stelle beisammen ist und nicht über
2 Funktionen verstreut (und dort auch noch dupliziert) ist.
Das man die Texte dann allesamt ins Flash verlegt ist dann der nächste
Schritt. Dadurch, dass die Anzeigefunktion jetzt viel einfacher ist, ist
das programmtechnisch keine Hexerei, in den Daten ist es sowieso nicht
mehr als einfach nur eine entsprechende Attributierung der Texte per
Makro.
Karl heinz Buchegger schrieb:> .... Vorteil des Ganzen: ....
Ja du hast ja Recht. Aber trotzdem ist das schon eine Stufe komplexer
und nicht mehr nur die LED am AVR sondern auch ein Pegelwandler mit
Schieberegister um 80 LEDS anzusteuern (oder so) ;-)
Unsere beiden Verbesserungen machen da schon was hübsches draus ;-)
900ss D. schrieb:> Karl heinz Buchegger schrieb:>> .... Vorteil des Ganzen: ....>> Ja du hast ja Recht. Aber trotzdem ist das schon eine Stufe komplexer
Funktionen mit Argumenten sind komplex?
OK, ich zieh meinen Einwand zurück.
Karl heinz Buchegger schrieb:> Funktionen mit Argumenten sind komplex?
Mensch, heute hast du deinen Hut wohl mit dem Hammer aufgesetzt ;-)
> OK, ich zieh meinen Einwand zurück.
Und auch noch beleidigt. Tzzzz Tzzzz Tzzzz.... ;-)
Ich meinte dein Gesamtkonstrukt, also das umschalten der States u.s.w.
u.s.w.
Sicher zu verstehen, aber als Anfänger mußt du da auch erst drauf
kommen. Da überlegst du dir doch erstmal was SEHR einfaches, einfach
gerade runter.
Nein.
Aber einen gewissen Grundstock an Kentnissen setzte ich schon vorraus,
wenn jemand ein Projekt durchziehen will.
Arrays und Funktionen mit Argumenten gehören dazu.
Wer Klemptnerarbeiten machen will, wird auch nicht weit kommen, wenn
alles was er kann ein Rohr mit Isolierband umwickeln ist.
Ist nun mal so.
(Kann auch sein, das ich es einfach nur leid bin, wieder und immer
wieder mit anzusehen, wie Menschen glauben Computer programmieren ist so
ähnlich wie Wurstbrötchen essen. Kann doch jeder, muss man nichts können
oder lernen. Und hinterher ist das Geschrei groß ....
Deine Vergleiche find ich etwas unpassend zumal, dass das was ich
geschrieben habe nicht direkt falsch ist sondern einfach
ressourcenraubend.
Mir war es ehrlich gesagt beim schreiben nicht bewusst, dass es auch
eleganter geht aber mit den aufgezeigten Beispielen wird mir auch
einiges klarer und nur so lernt man ja auch dazu. Nebenbei bilde ich mir
absolut nicht ein dass ich perfekt programmieren kann...keine ahnung wie
ich so einen eindruck hinterlassen habe...
Trotzdem Danke für die Hilfe...werde es morgen ausprobieren...
Thread beobachten
Seitenaufteilung abschalten