Mikrocontroller und Digitale Elektronik
›
Thread
Spielkonsole mit LED-Matrix und 2 Atmega644
JB
Julian B.
(juli55)
OP
14.02.2014 19:54 #3534777
Hallo, ich habe mir eine Spielkonsole gebaut mit Tastern und zur Anzeige
eine LED-Matrix ich steuere sie mit 2 Atmega644.
Ich habe mehrere Matrix pins an dem einen Controllern und mehrere an dem
anderen.
Ich lass sie über UART miteinander kommunizieren und das funktioniert
auch soweit.
Mein Problem ist,dass wenn ich erst eine Led, welcher der Pin der Reihe
an dem einen controller hängt und die Zeile der Led an dem anderen
Controller, oder eben anderstherum ist und ich dann zu einer led
wechseln will bei dem reihe und zeile amersten controller hängen dann
bleibt die erstgenannte led trotzdem an. Hat vlt. jemand eine Idee
D
Dennis
Gast
14.02.2014 19:56 #3534780
Ist ja super wenn es soweit klappt, aber wieso für sowas zwei uC?
F
Fehler
Gast
14.02.2014 19:56 #3534781
Es liegt am C16, bestimmt.
JB
Julian B.
(juli55)
OP
14.02.2014 19:58 #3534788
c16?
PS: Wenn ich was wichtiges nicht genannt habe schreibt es einfach
anstatt sich drüber aufzuren hilft allen mehr
F
Fehler
Gast
14.02.2014 20:01 #3534792
Naja,
wir kennen weder deinen Schaltplan, noch deine Quellcode,
ich vermute dann immer, das C16 defekt ist und die Probleme
erzeugt.
Vielleicht fehlen auch nur Treiber-Transistoren, aber das wird
sich zeigen, wenn du mehr als sagen wie 10 LED s anhast, und jede
etwa 2mA zieht..
(
(Gast)
Gast
14.02.2014 20:05 #3534799
Muss ich meine Brillen putzen, oder seht ihr auch keinen Spannungsregler
auf der Platine? Habe ich den Schaltplan auch übersehen?
JB
Julian B.
(juli55)
OP
14.02.2014 20:07 #3534805
Also das ist noch ein altes bild davon und ich hab jetzt n
Spannungsregler und Bypasskondensatoren an den mcs und die kondensatoren
für den regler. Das war noch mein altes Problem.
PS: Es handelt sich hier jedoch um ein Softwareproblem nicht um ein
Hardwarefehler
Julian Bertsch schrieb: > PS: Es handelt sich hier jedoch um ein Softwareproblem nicht um ein
> Hardwarefehler
Jetzt sehe ich den Fehler. In der 32. Zeile der main hast du den
Dereferenzierungsoperator falsch angewendet.
Poste deinen Code, und der Schaltplan könnte bei der Fehlersuche auch
hilfreich sein.
JB
Julian B.
(juli55)
OP
14.02.2014 20:17 #3534824
1. Kann man mich nicht eifach auf was fehlendes Hinweisen anstatt gleich
sarkastisch reagiert aber egal jetz, ich poste einfach mal den quellcode
main mc1 1 #include <avr/io.h>
2 #define numberOfButtons 2
3 #include <util/delay.h>
4 #include "UART_read.h"
5 #include "UART_send.h"
6
7 #include "matrix_register.h"
8 #include "button_register.h"
9 #include "bild.h"
10
11
12 int main(void){
13
14 DDRD |= (1<<7);
15 DDRD &= ~(1<< PIND5) | (1<< PIND6);
16
17 PORTD |= 1 << PIND5 | 1 << PIND6;
18
19
20
21 DDRC = (1<<DDC0) | (1<<DDC1) | (1<<DDC2) | (1<<DDC3) | (1<<DDC4)| (1<<DDC5) | (1<<DDC6) | (1<<DDC7);
22 PORTC |= (1<<DDC0) | (1<<DDC1) | (1<<DDC2) | (1<<DDC3) | (1<<DDC4)| (1<<DDC5) | (1<<DDC6) | (1<<DDC7);
23
24 DDRB = (1<<DDB0) | (1<<DDB1) | (1<<DDB2);
25 PORTB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2);
26 DDRA = (1<<DDA0) | (1<<DDA1) | (1<<DDA2) | (1<<DDA3) | (1<<DDA4) | (1<<DDA5) | (1<<DDA6) | (1<<DDA7);
27 PORTA |= (1<<DDA0) | (1<<DDA1) | (1<<DDA2) | (1<<DDA3) | (1<<DDA4) | (1<<DDA5) | (1<<DDA6) | (1<<DDA7);
28
29
30 PORTC |= (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5) | (1<<PC6) | (1<<PC7);
31
32
33 PORTD &= ~(1<<7);
34
35 PORTB &= ~(1<<0);
36
37 PORTB &= ~(1<<2);
38
39 PORTB &= ~(1<<1);
40
41 PORTA &= ~(1<<0);
42
43 PORTA &= ~(1<<1);
44
45 PORTA &= ~(1<<2);
46
47 PORTA &= ~(1<<3);
48
49 PORTA &= ~(1<<4);
50
51 PORTA &= ~(1<<5);
52
53 PORTA &= ~(1<<6);
54
55 PORTA &= ~(1<<7);
56
57
58
59
60 int Pressed =0;
61 int i = 0;
62 int pos_s1 = 1;
63 int pos_s2 = 1;
64 int pos_col_ball = 2;
65 int pos_row_ball = 2;
66
67 int UBBRValue = 25;
68
69 //Put the upper part of the baud number here (bits 8 to 11)
70 UBRR0H = (unsigned char) (UBBRValue >> 8);
71
72 //Put the remaining part of the baud number here
73 UBRR0L = (unsigned char) UBBRValue;
74
75 //Enable the receiver and transmitter
76 UCSR0B = (1 << RXEN0) | (1 << TXEN0);
77
78 //Set 2 stop bits and data bit length is 8-bit
79 UCSR0C = (1 << USBS0) | (3 << UCSZ00);
80
81
82
83 while(1)
84 {
85
86
87
88
89
90
91
92
93 if (ButtonPressed(0, PIND, 5, 0)){
94
95 pos_s1++;
96 if(pos_s1 >= 16 ){
97 pos_s1 = 16;
98 }
99 }
100
101 if (ButtonPressed(1, PIND, 6, 0)){
102
103 pos_s1--;
104 if(pos_s1 < 1 ){
105 pos_s1 = 1;
106 }
107 }
108
109
110
111
112
113
114 //bild(i,pos_s1,pos_s2,pos_col_ball,pos_row_ball);
115
116 if(i<= 500){
117
118 matrix(1,9);
119
120 }
121 else {
122 if(i<= 1000){
123
124 matrix(16,8);
125
126 }
127 else{
128 if(i<= 1500){
129 matrix(16,7);
130
131 }
132 else{
133 i = 0;
134 }
135 }
136 }
137 i++;
138
139 }
140 }
matrix_register.h 1 #include <avr/io.h>
2 void matrix(int col, int row){
3 float ms = 0.1;
4
5 if((col == 5 && row == 9)||(col == 5 && row == 10)||
6 (col == 5 && row == 11) ||(col == 5 && row == 12)||
7 (col == 5 && row == 13) ||(col == 5 && row == 14)||
8 (col == 5 && row == 15)|| (col == 5 && row == 16)){
9
10 switch(row){
11 case 9:
12 uart_send(1);
13 while(uart_read() != 0);
14 break;
15
16 case 10:
17 uart_send(2);
18 while(uart_read() != 0);
19 break;
20
21 case 11:
22 uart_send(34);
23 while(uart_read() != 0);
24 break;
25
26 case 12:
27 uart_send(4);
28 while(uart_read() != 0);
29 break;
30
31 case 13:
32 uart_send(5);
33 while(uart_read() != 0);
34 break;
35
36 case 14:
37 uart_send(6);
38 while(uart_read() != 0);
39 break;
40
41 case 15:
42 uart_send(20);
43 while(uart_read() != 0);
44 break;
45
46 case 16:
47 uart_send(8);
48 while(uart_read() != 0);
49 break;
50 }
51
52 }
53 else if((col == 6 && row == 9)||(col == 6 && row == 10)||
54 (col == 6 && row == 11) ||(col == 6 && row == 12)||
55 (col == 6 && row == 13) ||(col == 6 && row == 14)||
56 (col == 6 && row == 15)|| (col == 6 && row == 16)){
57 switch(row){
58 case 9:
59 uart_send(9);
60
61 break;
62
63 case 10:
64 uart_send(10);
65
66 break;
67
68 case 11:
69 uart_send(11);
70
71 break;
72
73 case 12:
74 uart_send(12);
75
76 break;
77
78 case 13:
79 uart_send(13);
80
81 break;
82
83 case 14:
84 uart_send(14);
85
86 break;
87
88 case 15:
89 uart_send(33);
90
91 break;
92
93 case 16:
94 uart_send(16);
95
96 break;
97 }
98 }
99 else if((col == 7 && row == 9)||(col == 7 && row == 10)||
100 (col == 7 && row == 11) ||(col == 7 && row == 12)||
101 (col == 7 && row == 13) ||(col == 7 && row == 14)||
102 (col == 7 && row == 15)|| (col == 7 && row == 16)){
103 switch(row){
104 case 9:
105 uart_send(17);
106 while(uart_read() != 0);
107 break;
108
109 case 10:
110 uart_send(18);
111 while(uart_read() != 0);
112 break;
113
114 case 11:
115 uart_send(19);
116 while(uart_read() != 0);
117 break;
118
119 case 12:
120 uart_send(35);
121 while(uart_read() != 0);
122 break;
123
124 case 13:
125 uart_send(21);
126 while(uart_read() != 0);
127 break;
128
129 case 14:
130 uart_send(22);
131 while(uart_read() != 0);
132 break;
133
134 case 15:
135 uart_send(23);
136 while(uart_read() != 0);
137 break;
138
139 case 16:
140 uart_send(24);
141 while(uart_read() != 0);
142 break;
143 }
144 }
145
146 else if((col == 8 && row == 9)||(col == 8 && row == 10)||
147 (col == 8 && row == 11) ||(col == 8 && row == 12)||
148 (col == 8 && row == 13) ||(col == 8 && row == 14)||
149 (col == 8 && row == 15)|| (col == 8 && row == 16)){
150 switch(row){
151 case 9:
152 uart_send(25);
153 while(uart_read() != 0);
154 break;
155
156 case 10:
157 uart_send(26);
158 while(uart_read() != 0);
159 break;
160
161 case 11:
162 uart_send(27);
163 while(uart_read() != 0);
164 break;
165
166 case 12:
167 uart_send(28);
168 while(uart_read() != 0);
169 break;
170
171 case 13:
172 uart_send(29);
173 while(uart_read() != 0);
174 break;
175
176 case 14:
177 uart_send(30);
178 while(uart_read() != 0);
179 break;
180
181 case 15:
182 uart_send(31);
183
184 break;
185
186 case 16:
187 uart_send(32);
188
189 break;
190 }
191 }
192 else{
193 switch(col){
194
195 case 1:
196
197
198 PORTD |= 1 << 7;
199
200 break;
201
202 case 2:
203
204
205 PORTB |= 1 << 0;
206
207 break;
208
209 case 3:
210
211
212
213 PORTB = 1 << 2;
214
215 break;
216
217 case 4:
218
219 PORTB |= 1 << 1;
220
221 break;
222
223 case 5:
224
225 uart_send(0b11111111);
226
227 break;
228
229 case 6:
230
231 uart_send(0b00000011);
232
233 break;
234
235 case 7:
236
237 uart_send(0b00000111);
238
239 break;
240 case 8:
241
242 uart_send(0b00001111);
243
244 break;
245
246
247
248 case 9:
249
250 PORTA |= 1 << 0;
251
252
253
254 break;
255
256 case 10:
257
258
259 PORTA |= 1 << 1;
260
261 break;
262
263 case 11:
264
265
266 PORTA |= 1 << 2;
267
268 break;
269
270 case 12:
271
272
273 PORTA |= 1 << 3;
274
275 break;
276
277 case 13:
278
279 PORTA |= 1 << 4;
280
281 break;
282
283 case 14:
284
285
286 PORTA |= 1 << 5;
287
288 break;
289
290 case 15:
291
292
293 PORTA |= 1 << 6;
294
295 break;
296
297 case 16:
298
299
300 PORTA |= 1 << 7;
301
302 break;
303
304
305
306
307
308 }
309
310 switch(row){
311 case 1:
312
313
314
315 PORTC &= ~(1<<PC0);
316 _delay_ms(ms);
317 PORTC |= (1<<PC0);
318
319 break;
320
321 case 2:
322
323 PORTC &= ~(1<<PC1);
324 _delay_ms(ms);
325 PORTC |= (1<<PC1);
326
327 break;
328
329 case 3:
330 PORTC &= ~(1<<PC2);
331 _delay_ms(ms);
332 PORTC |= (1<<PC2);
333 break;
334
335 case 4:
336 PORTC &= ~(1<<PC3);
337 _delay_ms(ms);
338 PORTC |= (1<<PC3);
339 break;
340
341 case 5:
342 PORTC &= ~(1<<PC7);
343 _delay_ms(ms);
344 PORTC |= (1<<PC7);
345 break;
346
347 case 6:
348 PORTC &= ~(1<<PC6);
349 _delay_ms(ms);
350 PORTC |= (1<<PC6);
351 break;
352
353 case 7:
354 PORTC &= ~(1<<PC5);
355 _delay_ms(ms);
356 PORTC |= (1<<PC5);
357 break;
358
359 case 8:
360 PORTC &= ~(1<<PC4);
361 _delay_ms(ms);
362 PORTC |= (1<<PC4);
363 break;
364
365
366
367 case 9:
368 uart_send(0b00000000);
369 while(uart_read() != 0);
370 break;
371
372 case 10:
373 uart_send(0b10000000);
374 while(uart_read() != 0);
375 break;
376
377 case 11:
378 uart_send(0b11000000);
379 while(uart_read() != 0);
380 break;
381
382 case 12:
383 uart_send(0b11100000);
384 while(uart_read() != 0);
385 break;
386
387 case 13:
388 uart_send(0b11110000);
389 while(uart_read() != 0);
390 break;
391
392 case 14:
393 uart_send(0b11111000);
394 while(uart_read() != 0);
395 break;
396
397 case 15:
398 uart_send(0b11111100);
399 while(uart_read() != 0);
400 break;
401
402 case 16:
403 uart_send(0b11111110);
404 while(uart_read() != 0);
405 break;
406 }
407
408
409
410
411 switch(col){
412
413 case 1:
414
415
416
417 PORTD &= ~(1<<7);
418 break;
419
420 case 2:
421
422
423
424 PORTB &= ~(1<<0);
425 break;
426
427 case 3:
428
429
430
431
432 PORTB &= ~(1<<2);
433 break;
434
435 case 4:
436 PORTB &= ~(1<<1);
437
438 break;
439
440 case 9:
441
442 PORTA &= ~(1<<0);
443
444
445 break;
446
447 case 10:
448
449 PORTA &= ~(1<<1);
450
451 break;
452
453 case 11:
454
455 PORTA &= ~(1<<2);
456
457 break;
458
459 case 12:
460
461 PORTA &= ~(1<<3);
462 break;
463
464 case 13:
465
466 PORTA &= ~(1<<4);
467
468 break;
469
470 case 14:
471
472 PORTA &= ~(1<<5);
473
474 break;
475
476 case 15:
477
478 PORTA &= ~(1<<6);
479
480 break;
481
482 case 16:
483
484 PORTA &= ~(1<<7);
485
486 break;
487
488
489
490
491
492 }
493
494 }
495
496 }
main.c mc2 1 #include <avr/io.h>
2 #define numberOfButtons 6
3 #include <util/delay.h>
4 #include "UART_send.h"
5 #include "UART_read.h"
6 #include "matrix_register.h"
7 #include "button_register.h"
8
9
10
11 int main(void){
12 int b = 1;
13
14 DDRB &= ~(1<<b) ;
15
16 PORTB |= 1 << b ;
17
18
19
20
21
22 DDRB = (1<<2) ;
23 DDRC = (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6);
24 DDRA = (1<<0) | (1<<1) | (1<<2) | (1<<3);
25 PORTA |= (1<<0) | (1<<1) | (1<<2);
26 PORTC |= (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) ;
27 PORTB |= (1<<2);
28
29
30
31 DDRD |= (1<<7);
32
33
34 PORTD &= ~(1<<7);
35 PORTD |= (1<<7);
36 PORTB &= ~(1<<2);
37 PORTA &= ~(1 << 2);
38 PORTA &= ~(1 << 0);
39 PORTA &= ~(1 << 1);
40
41
42
43
44 int UBBRValue = 25;
45
46 //Put the upper part of the baud number here (bits 8 to 11)
47 UBRR0H = (unsigned char) (UBBRValue >> 8);
48
49 //Put the remaining part of the baud number here
50 UBRR0L = (unsigned char) UBBRValue;
51
52 //Enable the receiver and transmitter
53 UCSR0B = (1 << RXEN0) | (1 << TXEN0);
54
55 //Set 2 stop bits and data bit length is 8-bit
56 UCSR0C = (1 << USBS0) | (3 << UCSZ00);
57
58
59
60
61
62
63
64
65 int i = 0;
66 int col = 9;
67 int uart = 0;
68 int matrix_led = 0;
69
70
71
72 while(1)
73 {
74
75
76
77
78
79
80 switch(uart_read()){
81
82
83
84 case 0b00000000:
85 matrix_led = 1;
86
87 break;
88
89 case 0b10000000:
90 matrix_led = 2;
91
92 break;
93
94 case 0b11000000:
95 matrix_led = 3;
96
97 break;
98
99 case 0b11100000:
100 matrix_led = 4;
101
102 break;
103
104 case 0b11110000:
105 matrix_led = 5;
106
107 break;
108
109 case 0b11111000:
110 matrix_led = 6;
111
112 break;
113
114 case 0b11111100:
115 matrix_led = 7;
116
117 break;
118
119 case 0b11111110:
120 matrix_led = 8;
121
122 break;
123
124 case 0b11111111:
125 matrix_led = 9;
126
127 break;
128
129 case 0b00000011:
130 matrix_led = 10;
131
132 break;
133
134 case 0b00000111:
135 matrix_led = 11;
136
137 break;
138
139 case 0b00001111:
140 matrix_led = 12;
141
142 break;
143
144 case 1:
145 matrix_led = 13;
146
147 break;
148
149 case 2:
150 matrix_led = 14;
151
152 break;
153
154 case 34:
155 matrix_led = 15;
156
157 break;
158
159 case 4:
160 matrix_led = 16;
161
162 break;
163
164 case 5:
165 matrix_led = 17;
166
167 break;
168
169 case 6:
170 matrix_led = 18;
171
172 break;
173
174 case 20:
175 matrix_led = 19;
176
177 break;
178
179 case 8:
180 matrix_led = 20;
181
182 break;
183
184 case 9:
185 matrix_led = 21;
186
187 break;
188
189 case 10:
190 matrix_led = 22;
191
192 break;
193
194 case 11:
195 matrix_led = 23;
196
197 break;
198
199 case 12:
200 matrix_led = 24;
201
202 break;
203
204 case 13:
205 matrix_led = 25;
206
207 break;
208
209 case 14:
210 matrix_led = 26;
211
212 break;
213
214 case 33:
215 matrix_led = 27;
216
217 break;
218
219 case 16:
220 matrix_led = 28;
221
222 break;
223
224 case 17:
225 matrix_led = 29;
226
227 break;
228
229 case 18:
230 matrix_led = 30;
231
232 break;
233
234 case 19:
235 matrix_led = 31;
236
237 break;
238
239 case 35:
240 matrix_led = 32;
241
242 break;
243
244 case 21:
245 matrix_led = 33;
246
247 break;
248
249 case 22:
250 matrix_led = 34;
251
252 break;
253
254 case 23:
255 matrix_led = 35;
256
257 break;
258
259 case 24:
260 matrix_led = 36;
261
262 break;
263
264 case 25:
265 matrix_led = 37;
266
267 break;
268
269 case 26:
270 matrix_led = 38;
271
272 break;
273
274 case 27:
275 matrix_led = 39;
276
277 break;
278
279 case 28:
280 matrix_led = 40;
281
282 break;
283
284 case 29:
285 matrix_led = 41;
286
287 break;
288
289 case 30:
290 matrix_led = 42;
291
292 break;
293 case 31:
294 matrix_led = 43;
295
296 break;
297 case 32:
298 matrix_led = 44;
299
300 break;
301
302 }
303
304 switch(matrix_led){
305
306 case 1:
307 matrix(0,9);
308 uart_send(0);
309 break;
310
311 case 2:
312 matrix(0,10);
313 uart_send(0);
314 break;
315
316 case 3:
317 matrix(0,11);
318 uart_send(0);
319 break;
320
321
322 case 4:
323 matrix(0,12);
324 uart_send(0);
325 break;
326
327 case 5:
328 matrix(0,13);
329 uart_send(0);
330 break;
331
332 case 6:
333 matrix(0,14);
334 uart_send(0);
335 break;
336
337
338 case 7:
339 matrix(0,15);
340 uart_send(0);
341 break;
342
343 case 8:
344 matrix(0,16);
345 uart_send(0);
346 break;
347
348 case 9:
349 matrix(5,0);
350 uart_send(0);
351 break;
352
353 case 10:
354 matrix(6,0);
355 uart_send(0);
356 break;
357
358 case 11:
359 matrix(7,0);
360 uart_send(0);
361 break;
362
363 case 12:
364 matrix(8,0);
365 uart_send(0);
366 break;
367
368 case 13:
369 matrix(5,9);
370 uart_send(0);
371 break;
372 case 14:
373 matrix(5,10);
374 uart_send(0);
375 break;
376
377 case 15:
378 matrix(5,11);
379 uart_send(0);
380 break;
381 case 16:
382 matrix(5,12);
383 uart_send(0);
384 break;
385
386 case 17:
387 matrix(5,13);
388 uart_send(0);
389 break;
390 case 18:
391 matrix(5,14);
392 uart_send(0);
393 break;
394
395 case 19:
396 matrix(5,15);
397 uart_send(0);
398 break;
399 case 20:
400 matrix(5,16);
401 uart_send(0);
402 break;
403
404
405 case 21:
406 matrix(6,9);
407 uart_send(0);
408 break;
409 case 22:
410 matrix(6,10);
411 uart_send(0);
412 break;
413
414 case 23:
415 matrix(6,11);
416 uart_send(0);
417 break;
418 case 24:
419 matrix(6,12);
420 uart_send(0);
421 break;
422
423 case 25:
424 matrix(6,13);
425 uart_send(0);
426 break;
427 case 26:
428 matrix(6,14);
429 uart_send(0);
430 break;
431
432 case 27:
433 matrix(6,15);
434 uart_send(0);
435 break;
436 case 28:
437 matrix(6,16);
438 uart_send(0);
439 break;
440
441 case 29:
442 matrix(7,9);
443 uart_send(0);
444 break;
445 case 30:
446 matrix(7,10);
447 uart_send(0);
448 break;
449
450 case 31:
451 matrix(7,11);
452 uart_send(0);
453 break;
454 case 32:
455 matrix(7,12);
456 uart_send(0);
457 break;
458
459 case 33:
460 matrix(7,13);
461 uart_send(0);
462 break;
463 case 34:
464 matrix(7,14);
465 uart_send(0);
466 break;
467
468 case 35:
469 matrix(7,15);
470 uart_send(0);
471 break;
472 case 36:
473 matrix(7,16);
474 uart_send(0);
475 break;
476
477 case 37:
478 matrix(8,9);
479 uart_send(0);
480 break;
481 case 38:
482 matrix(8,10);
483 uart_send(0);
484 break;
485
486 case 39:
487 matrix(8,11);
488 uart_send(0);
489 break;
490 case 40:
491 matrix(8,12);
492 uart_send(0);
493 break;
494
495 case 41:
496 matrix(8,13);
497 uart_send(0);
498 break;
499 case 42:
500 matrix(8,14);
501 uart_send(0);
502 break;
503
504 case 43:
505 matrix(8,15);
506 uart_send(0);
507 break;
508 case 44:
509 matrix(8,16);
510 uart_send(0);
511 break;
512 }
513
514
515
516 }
517 }
matrix_register.h mc2 1 #include <avr/io.h>
2 void matrix(int col, int row){
3 float ms = 0.1;
4 switch(col){
5
6
7 case 5:
8 PORTB |= 1 << 2;
9 break;
10
11 case 6:
12 PORTA |= 1 << 2;
13 break;
14
15 case 7:
16 PORTA |= 1 << 0;
17 break;
18
19 case 8:
20 PORTA |= 1 << 1;
21 break;
22
23
24
25
26
27
28
29
30 }
31
32 switch(row){
33 case 9:
34 PORTD &= ~(1<<7);
35 _delay_ms(ms);
36 PORTD |= (1<<7);
37 break;
38
39 case 10:
40 PORTC &= ~(1<<PC0);
41 _delay_ms(ms);
42 PORTC |= (1<<PC0);
43 break;
44
45 case 11:
46 PORTC &= ~(1<<PC1);
47 _delay_ms(ms);
48 PORTC |= (1<<PC1);
49 break;
50
51 case 12:
52 PORTC &= ~(1<<PC2);
53 _delay_ms(ms);
54 PORTC |= (1<<PC2);
55 break;
56
57 case 13:
58 PORTC &= ~(1<<PC3);
59 _delay_ms(ms);
60 PORTC |= (1<<PC3);
61 break;
62
63 case 14:
64 PORTC &= ~(1<<PC4);
65 _delay_ms(ms);
66 PORTC |= (1<<PC4);
67 break;
68
69 case 15:
70 PORTC &= ~(1<<PC5);
71 _delay_ms(ms);
72 PORTC |= (1<<PC5);
73 break;
74
75 case 16:
76 PORTC &= ~(1<<PC6);
77 _delay_ms(ms);
78 PORTC |= (1<<PC6);
79 break;
80 }
81
82 switch(col){
83
84
85 case 5:
86 PORTB &= ~(1<<2);
87 break;
88
89 case 6:
90 PORTA &= ~(1 << 2);
91 break;
92
93 case 7:
94 PORTA &= ~(1 << 0);
95 break;
96
97 case 8:
98 PORTA &= ~(1 << 1);
99 break;
100
101
102
103 }
104
105
106
107 }
Wie soll man darauf reagieren, wenn nicht sarkastisch?
Hut ab an alle die sich in ihrer Freizeit damit auseinander setzen.
MS
Matthias S.
(mschoeldgen)
(Firma: matzetronics)
14.02.2014 20:55 #3534889
Julian Bertsch schrieb: > aber egal jetz, ich poste einfach mal den quellcode
Um Himmels Willen - viel Fleissarbeit, wenig System. Auch die Kommentare
sind vorbildlich...
Aber mal im Ernst, was glaubst du, wie wir dir hier helfen können, du
rotzt hier den Code hin (anstatt einen Anhang draus zu machen),
unkommentiert und ohne Kommentar - hunderte von Zeilen und wir sollen
uns jetzt da durchwühlen?
Julian Bertsch schrieb: > 1. Kann man mich nicht eifach auf was fehlendes Hinweisen anstatt gleich
> sarkastisch reagiert aber egal jetz, ich poste einfach mal den quellcode
Hübscher Kot. Vor allen Dingen schön lang. Das Scrollrad von meiner Maus
ist kurz vor einem Lagerschaden.
Wer soll dir jetzt sagen, wo der Fehler ist?
Weisst du was Funktionen sind?
Tu dir selbst den Gefallen und packe die Programmteile, die jeweils
bestimmte Sachen machen, in einzelne Funktionen. Da steigt so doch keine
Sau durch! Erzähl jetzt nicht, daß du da durchsteigst!
Wenn du damit fertig bist, grenzt du dein Problem soweit ein, daß du
sagen kannst, in welcher dieser Funktionen der Fehler liegt. Und vor
allen Dingen beschreibst du genau, was der Fehler ist. Dann kann man dir
auch helfen. Und du kannst dir selber helfen, weil du dann nämlich
einzelne Programmteile, die besagten Funktionen eben, testen kannst.
Dann rückst du deinen Code noch schön ein und geizt ein wenig mit den
Leerzeilen.
Und wenn du damit fertig, kommst du nochmal wieder und dir wird auch
geholfen.
mfg.
und Frohe Ostern
Am leichtesten würdest du uns die Arbeit machen, wenn du den Teil der
die LED s ansteuert postest bzw. markierst. Und dazu den Schaltplan dazu
postest. Es ist unmöglich, den Fehler zu finden, wenn man nicht weiß an
welchen Pins die LED s hängen.
Antwort schreiben
Bitte melde dich an, um einen Beitrag zu schreiben.
Noch kein Account?
Die Registrierung ist kostenlos und dauert nur eine Minute.
Jetzt registrieren
20140206_161604.jpg
(130 KB)
