Forum: Mikrocontroller und Digitale Elektronik Programm für Dot Matrix Ansteuerung


von Stefan K. (Gast)


Angehängte Dateien:

Lesenswert?

Hallo leute

Bin gerade eine Laufschrift am Programmieren. Das ganze soll an eine 5*6 
Dot Matrix Anzeige ausgegeben werden.
Die Anzeige hab ich aus 35 einzelnen LED's aufgebaut, ist also kein 
fertiges Modul.
Die einzelnen Reihen und spalten hab ich wie auf dem Bild im Anhang 
direkt über Transistoren mit dem uC (ATMEGA 168) verdratet (keine 
Schieberegister oder Treiber).

Mit der Hardware bin ich so zufrieden, brauche keine Treiber oder so. 
Wird ein Geburtstagsgeschenk und muss technisch nicht top sein, optisch 
ist es aber in Ordnung.

Nun kommen wir zum Code. Wie bei Dot Matrix Anzeigen üblich steuere ich 
sie per Multiplexen an. Nun ist es aber relativ mühsam, einen Text über 
die Anzeige laufen zu lassen. Habe bis jetzt Happy B-Day implementiert, 
und habe ziemlich viel Zeit, sowie 57% des Programmspeichers gebraucht.
Im Anhang sieht ihr mein Code. habe alles über for Schleifen gemacht.

Ich bin sicher, es gibt viel einfachere Wege, das ganze zu realisieren. 
Ich hoffe ihr könnt mir einen guten zeigen.

Die Implementierung sollte nicht zu viel Zeit in Anspruch nehmen, da es 
wie gesagt ein Geburtstagsgeschenk werden soll und dieses bis spätestens 
Freitag fertig sein muss;)

Hoffe auf eure Hilfe

Grüsse Stefan

von xyz (Gast)


Lesenswert?

Optimierung einschalten.
Kommentare einfügen.
Ansonsten bist du nicht der erste der Multiplexert. Wie haben es deine 
Vorgänger gemacht?

von LordZiu (Gast)


Lesenswert?

Ohne jetzt zu tief in den Code einzusteigen würde ich es folgendermaßen 
machen:

- ein globales 2D-Array, dass deine LEDs repräsentiert (Kann auch 1D 
sein, dann nimmst du halt die Bits eines Wertes als Repräsentation der 
LEDs)

- Eine Funktion, die in einem bestimmten Takt dieses Array "anzeigt", 
soll heißen: die Funktion iteriert über das Array und setzt bzw. löscht 
die LEDs

- Nun kannst du die einzelnen - nennen wir es Frames - als 
Array-Deklarationen nehmen und immer in das globale Array kopieren

Pseudocode für ein durchlaufendes 'A':
1
uint8_t Frame1[]
2
{
3
    0b00000001,
4
    0b00000001,
5
    0b00000001,
6
    0b00000001,
7
    0b00000001   
8
};
9
10
uint8_t Frame2[]
11
{
12
    0b00000011,
13
    0b00000010,
14
    0b00000011,
15
    0b00000010,
16
    0b00000010   
17
};
18
19
uint8_t Frame3[]
20
{
21
    0b00000111,
22
    0b00000100,
23
    0b00000111,
24
    0b00000100,
25
    0b00000100   
26
};
27
28
uint8_t Frame4[]
29
{
30
    0b00001111,
31
    0b00001000,
32
    0b00001111,
33
    0b00001000,
34
    0b00001000   
35
};
36
37
uint8_t Frame5[]
38
{
39
    0b00011111,
40
    0b00010001,
41
    0b00011111,
42
    0b00010001,
43
    0b00010001   
44
};

Geht sicher noch eleganter, aber zum Einstieg sollte es klappen. Die 
Arrays solltest du in den Programmspeicher packen.

von Uwe B. (boerge) Benutzerseite


Lesenswert?

MoinMoin,

hier mal ein Beispiel für eine 8x8-Matrix, welches sich aber an deine 
Hardware anpassen lassen sollte (und beliebigen Text ausgeben kann)...

http://bralug.de/wiki/8x8-LED-Matrix#Laufschrift

Grüße Uwe

PS.: 5x6 sind 30 (und nicht 35)...

von S. T. (cmdrkeen)


Lesenswert?

Hier meine Anregung ... das Programm schreibt H A L L O
7 LED-Zeilen hängen an PORTB
und die 5 Spalten an PORTD
Die Buchstaben könnte man noch im EEPROM ablegen und gezielt per 
funktion aufrufen.
den Refresh der Anzeige übernimmt der TIMER1
die Hauptschleife kümmert sich nur um den Text (und das effizienter zu 
programmieren sollte kein Problem sein)
1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
#include <util/delay.h>
4
5
volatile char disp[5];
6
volatile char col;
7
8
SIGNAL(SIG_OUTPUT_COMPARE1A)
9
{
10
      PORTB=0x00;
11
      PORTD=0x00;
12
}
13
14
SIGNAL(SIG_OUTPUT_COMPARE1B)
15
{
16
    TCNT1H=0; TCNT1L=0;
17
    
18
    PORTD=(1<<col);
19
    PORTB=disp[col-2];
20
    if(col==7) col=2;
21
    else col++;
22
    TCNT1H=0; TCNT1L=0;
23
}
24
25
void Start_Timer()  // the timer disables the current after 0.25 sec
26
{
27
  OCR1AH=0x00; OCR1AL=0x38;  
28
  OCR1BH=0x02; OCR1BL=0x40;  
29
  TCNT1H=0;  TCNT1L=0;       
30
  TIMSK |= (1 << OCIE1A);    
31
  TIMSK |= (1 << OCIE1B);  
32
  sei();            
33
  TCCR1B=0b00000010;      
34
  
35
}
36
37
int main()
38
{
39
  DDRB=0xFF;
40
  PORTB=0x00;
41
  DDRD=0xFF;
42
  PORTD=0x00;
43
  col=2;
44
  Start_Timer();
45
  while (1)
46
  {
47
    
48
    disp[0]=0b01111111;
49
    disp[1]=0b00001000;
50
    disp[2]=0b00001000;
51
    disp[3]=0b00001000;
52
    disp[4]=0b01111111;
53
    _delay_ms(750);
54
    disp[0]=0x00;
55
    disp[1]=0x00;
56
    disp[2]=0x00;
57
    disp[3]=0x00;
58
    disp[4]=0x00;
59
    _delay_ms(150);
60
    disp[0]=0b00111111;
61
    disp[1]=0b01001000;
62
    disp[2]=0b01001000;
63
    disp[3]=0b01001000;
64
    disp[4]=0b00111111;
65
    _delay_ms(750);
66
    disp[0]=0x00;
67
    disp[1]=0x00;
68
    disp[2]=0x00;
69
    disp[3]=0x00;
70
    disp[4]=0x00;
71
    _delay_ms(150);
72
    disp[0]=0b00000001;
73
    disp[1]=0b00000001;
74
    disp[2]=0b00000001;
75
    disp[3]=0b00000001;
76
    disp[4]=0b01111111;
77
    _delay_ms(750);
78
    disp[0]=0x00;
79
    disp[1]=0x00;
80
    disp[2]=0x00;
81
    disp[3]=0x00;
82
    disp[4]=0x00;
83
    _delay_ms(150);
84
    disp[0]=0b00000001;
85
    disp[1]=0b00000001;
86
    disp[2]=0b00000001;
87
    disp[3]=0b00000001;
88
    disp[4]=0b01111111;
89
    _delay_ms(750);
90
    disp[0]=0x00;
91
    disp[1]=0x00;
92
    disp[2]=0x00;
93
    disp[3]=0x00;
94
    disp[4]=0x00;
95
    _delay_ms(150);
96
    disp[0]=0b00111110;
97
    disp[1]=0b01000001;
98
    disp[2]=0b01000001;
99
    disp[3]=0b01000001;
100
    disp[4]=0b00111110;
101
    _delay_ms(750);
102
    disp[0]=0x00;
103
    disp[1]=0x00;
104
    disp[2]=0x00;
105
    disp[3]=0x00;
106
    disp[4]=0x00;
107
    _delay_ms(150);
108
  }
109
}

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
Noch kein Account? Hier anmelden.