Programm für Dot Matrix Ansteuerung

Stefan K. Gast #1572304
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
Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
LordZiu Gast #1572322
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
S. T. #1572346
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
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren