Hey leute!
Habe eine LED Matrix gebaut 8x8, funktioniert auch alles leuchtet schön,
wenn ich ein vorgefertigtes programm meines freundes nehme. ( Also 1
buchstaben krieg ich rein) Nur mir fehlt das script für eine Laufschrift
:(
bin leider der komplette Programmier Anfänger und habe nur nen ATMega
644 und das AVR STudio 4 ( kann halt auch das programm auf den
controller schreiben ). Es müsste ein script in der Sprache C sein, nur
ehrlich gesagt habe ich keine ahnung wie man sowas überhaupt anfängt,
habe schon etliche tutorials gemacht aber verstehe einfach nichts davon!
Hat vllt einer so ein Laufschrift script in C , oder kann mir einer
einen guten tipp geben ausser die sache zu vergessen? Das ding ist habe
nur noch bis freitag zeit das fertig zu machen, da ich danach in Urlaub
fliege...
Ich weiß klingt komisch aber helft mir bitte!
mfg black
> ...oder kann mir einer einen guten tipp geben ausser die sache zu> vergessen?
Ja, ruhig durchatmen, dann Programm lesen, Programm nochmal lesen,
Programm nochmal lesen & verstehen.
Dann überleg dir was du hast. Du hast die Daten für EINEN Buchstaben.
Ein Wort setzt sich aus mehreren Buchstaben zusammen. Entsprechend ein
Satz aus mehreren Wörtern.
Soweit, so gut. Du musst also entsprechend Daten für die jeweiligen
Buchstaben zur Verfügung stellen, und gibts dann im Hauptprogramm
jeweils mit einem zeitlichen Versatz die Buchstaben nacheinander aus.
Wenn du die Buchstaben scrollen willst, musst halt noch n klein bisschen
mehr machen, aber das dürfte auch nicht allzu viel sein.
Ralf
Das Problem dabei ist ^^, dass ich wirklich keine ahnung habe wie i,was
funktioniert, ich kann kein bisschen C , noch nie was damit gemacht ^^
aber ich soll das halt fertig machen bis freitag und ehrlich gesagt hab
ich netmal deine antwort verstanden inwiefern mir das weiterhilft :/
Steven Lahmann schrieb:
> aber ich soll das halt fertig machen bis freitag
Warum?
Wenn du ohnehin auf Urlaub fliegst, spielt es doch keine Rolle, wenn es
zunächst auf Halde liegt und darauf wartet, bis du wiederkommst.
Und dann gehst du das in aller Ruhe an.
> und ehrlich gesagt hab> ich netmal deine antwort verstanden inwiefern mir das weiterhilft :/
Das ist allerdings bedenklich.
ach leute hat keiner son script was ne 8x8 led matrix mit C
programmierung versorgen kann? ich habe wirklich kein plan und wenn ich
mir das 1000 mal durchlese werd ich das nicht verstehen wirklich, hab
schon 3 wochen versucht C programmieren zu verstehen aber das hört sich
alles wie chinesisch an wenn ich mir das durchlese :/
Erstmal runter laden und installieren:
http://sourceforge.net/projects/winavr/
Dann hier lesen:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
Dann versuchst du erstmal in C ein Projekt zu erstellen, dass irgendwas
macht (z.B. eine LED zum leuchten bringen - nur damit du siehst, dass
etwas passiert).
Dann fängst du an und versuchst nen buchstaben dar zu stellen.
Du musst das Display spaltenweise aufbauen. d.h. du arbeitest zB den
Buchstaben "A" von links nach rechts ab und stellst die richtigen Pixel
auf der LED Matrix da.
Wenn du dann scrollst musst du das "A" nach links verschieben und von
rechts kommt dann ein neuer Buchstabe rein den du darstellen musst.
Am besten definierst du dir ein Array in dem deine Buchstaben drin
stehen (in dem Array muss für jede Spalte eines Buchstabens drin stehen
wie die Pixel der einzelnen Zeilen leuchten sollen).
Edit: Wenn du das überhaupt nicht hin bekommst warum musst du das dann
überhaupt aufbauen?
Wenn das hier jemand fertig macht (was keiner machen wird) ist dir ja
auch nicht geholfen.
> Habe eine LED Matrix gebaut 8x8, funktioniert auch alles leuchtet> schön, wenn ich ein vorgefertigtes programm meines freundes nehme.> ( Also 1 buchstaben krieg ich rein)
Poste das doch mal.
Wenn es nur darum geht, dass ein paar Buchstaben nacheinander
aufleuchten, musst du noch nicht mal genau wissen, wie dieser Buchstabe
auf die Anzeige kommt.
Das sollte sich aus dem was du hast relativ leicht generieren lassen
(wenn das Programm deines Freundes einigermassen vernünftig aufgebaut
ist)
Wenn es allerdings darum geht, dass die Schrift schön von rechts nach
links durch die Anzeige scrollt, hast du einen langen Weg vor dir.
> ach leute hat keiner son script was ne 8x8 led matrix mit C> programmierung versorgen kann?
Die Details, wie so ein Programm aussehen muss, hängen von deiner
konkreten Hardware ab.
> Es müsste ein script in der Sprache C sein, nur
C ist kein Script.
> ehrlich gesagt habe ich keine ahnung wie man sowas überhaupt anfängt
Ja, wir waren alle mal jung und dumm und mussten da durch :-/
> oder kann mir einer einen guten tipp geben ausser die sache zu vergessen?
Naja, die Aufgabe ist anspruchsvoll, aber bis Freitag hast du noch
8+24+24=56 Stunden Zeit. Und wenn du erst im Urlaub bist: Jede Menge
Zeit zum Lernen.
Im Ernst:
Was meinst du, was dir das Lauflichtprogramm eines anderen Menschen
helfen könnte? Der hat doch garantiert
1) seine Leds ganz anders angeschlossen.
2) einen ganz anderen Controller.
3) die falsche Taktfrequenz.
Wie Karl heinz schon geschrieben hat: Poste doch mal deine SW, da sieht
man schon mal die Pinbelegung, und ob man aus dem Programm was machen
kann.
BTW:
@ Ralf:
> dann Programm lesen
Wer C für ein script hält, kann das nicht. ;-)
Mensch Leute, glaub ihr denn nur ein Sekunde, dass ihr so einem
hyperaktiven Scriptkiddie auch nur einen Funken Verstand per Forum
beibringen könnt?
Am besten bis Freitag?
Kopfschüttelnd
Falk
P S Bei solchen "mal schnell ganz dringend" Anfragen ist es wie in einer
Firma. Wenn es soweit gekommen ist, ist vorher EINIGES schief gelaufen
und die Lösung wird GANZ SICHER NICHT "mal ganz schnell" aus dem Hut zu
zaubern sein.
na jo hab jetzt schon hinbekommen das der buchstabe die ganze zeit blink
, jetzt nur die frage kann ich mehrere arrays miteinander verknüpfen
damit mehrere buchstaben als Folge hintereinander wegverlaufen? und wie
krieg ich es hin das die Spalten an sich durchlaufen werden? :D gibts da
i.ein typischen befehl wie ich die buchstaben durch die spalten laufen
lassen kann?
danke bis jetzt leute und mal ehrlich @Falk , wenn man keine ahnung hat
und dein post kein bisschen hilfreich ist dann doch bitte stfu :)
mfg black
>#include "C:\Programme\Atmel\AVR Tools\winavr\avr\include\avr\io.h">#include "C:\Programme\Atmel\AVR Tools\winavr\avr\include\util\delay.h">#include "C:\Programme\Atmel\AVR>Tools\winavr\avr\include\avr\interrupt.h"
lol, rofl
lern C, dann sehen wir weiter...
(das gilt auch für denjenigen von dem du das Programm hast)
> das der buchstabe die ganze zeit blink
Das willst du aber gar nicht.
Also schraubst du an der falschen Stelle :-/
1
ISR(TIMER1_OVF_vect)
2
{
3
:
4
_delay_ms(1);
5
:
6
_delay_ms(1);
7
}
Nun gut, in Interrupt-Behandlungen gehört kein delay().
Vergiss erst mal den Interrupt. Das kannst du nach dem Urlaub
machen/lernen.
Also:
1
volatileintArray[8]={0,92,84,84,116,0,0,0};
Hier ist wohl das Bitmuster für ein kleines 's' definiert.
00000000 = ........
01011100 = .O.OOO..
01010100 = .O.O.O..
01010100 = .O.O.O..
01110100 = .OOO.O..
00000000 = ........
00000000 = ........
Lesbarer könntest du das so schreiben:
1
volatileintArray[8]={0b00000000,
2
0b01011100,
3
0b01010100,
4
0b01010100,
5
0b01110100,
6
0b00000000,
7
0b00000000};
Am einfachsten dürfte sein, diese Tabelle etwas zu erweitern (HALLO):
1
volatileintArray[]={0b00000000,
2
0b01111100,
3
0b00010000,
4
0b01111100,
5
0b00000000,
6
0b01111000,
7
0b00010100,
8
0b01111000,
9
0b00000000,
10
0b01111100,
11
0b01000000,
12
0b01000000,
13
0b00000000,
14
0b01111100,
15
0b01000000,
16
0b01000000,
17
0b00000000,
18
0b00111000,
19
0b01000100,
20
0b00111000,
21
0b00000000,
22
0b00000000,
23
0b00000000,
24
0b00000000,
25
0b00000000,
26
0b00000000,
27
0b00000000};
Das ganze ohne Keyword volatile, denn an der Tabelle ist nichts volatil.
Und dann lässt du den Spaltenindex pro halbe Sekunde um eins ansteigen.
Insgesamt dürfte das dann so aussehen:
1
#define F_CPU 20000000UL // 20 MHz
2
3
#include<io.h>
4
#include<delay.h>
5
6
chari;
7
charoffset=0;
8
charcnt;
9
10
charArray[24]={0b00000000,
11
0b01111100,
12
0b00010000,
13
0b01111100,
14
0b00000000,
15
0b01111000,
16
0b00010100,
17
0b01111000,
18
0b00000000,
19
0b01111100,
20
0b01000000,
21
0b01000000,
22
0b00000000,
23
0b01111100,
24
0b01000000,
25
0b01000000,
26
0b00000000,
27
0b00111000,
28
0b01000100,
29
0b00111000,
30
0b00000000,
31
0b00000000,
32
0b00000000,
33
0b00000000,
34
0b00000000};
35
36
voidinit(void)
37
{
38
DDRA=0xff;// Alle Pin als Ausgang
39
DDRC=0xff;// Alle Pin als Ausgang
40
PORTC=0x00;
41
PORTA=0xff;
42
}
43
44
intmain(void)
45
{
46
init();
47
while(1)
48
{
49
// den aktuellen Tabelleninhalt anzeigen
50
mask<=0xFE;
51
for(i=0;i<=7;i++)// ein Durchlauf braucht ca. 16 ms
52
{
53
PORTC=mask;// Auswahl der LED-Spalte
54
PORTA=Array[i+offset];
55
_delay_ms(2);
56
PORTA=0;// Ausschalten vor dem Weiterschieben der Maske
57
_delay_us(10);
58
mask<<=1;
59
}
60
61
// Laufschrift: Spalten durchlaufen lassen
62
cnt++;
63
if(cnt==31){// 31*16 ms= 0,5 sec
64
cnt=0;
65
offset++;
66
if(offset==24-8){
67
offset=0;
68
}
69
}
70
}
71
}
Das ist jetzt schon recht kompakt, das solltest du verstehen lernen.
BTW:
Das hier
1
PORTC=~(1<<0);
ist das selbe wie das:
1
PORTC=~(1);
ist das selbe wie das:
1
PORTC=0xFE;
Such mal das 0xFE in meinem Programm, da taucht das auch auf.
Der, der dir das Programm geschrieben hat, ist aber auch noch am Lernen,
oder?
EDIT:
Sieh dir das nochmal an:
>> #define F_CPU 20000000UL // 20 MHz
Stimmt das wirklich?
Hey danke schonmal, habe das programm jetzt versucht zu laden, aber
leider passiert nichts auf meiner led matrix :( , keine ahnung warum
nicht wenn ich ehrlich bin, er zeigt keine errors keine warnings und
doch kein licht zu sehen.
Steven Lahmann schrieb:
> keine ahnung warum> nicht wenn ich ehrlich bin, er zeigt keine errors keine warnings und> doch kein licht zu sehen.
Sagen wir es mal so.
Dem Compiler sind Logikfehler aber sowas von egal.
Als Beispiel:
"Die Tamburmajore tirillieren in der Nichtigkeit des Seins."
ist zwar ein gültiger deutscher Satz. Abzüglich möglicher Tippfehler
widerspricht er keinerlei Regeln der deutschen Sprache.
Und trotzdem ergibt er keinen Sinn.
(Und wenn ich Tippfehler gemacht hätte und diese korrigieren würde,
würde er immer noch keinen Sinn ergeben)
Der Compiler ist sozusagen der Duden der Programmiersprache. Ihn
interessiert nur, ob du die Regeln einhältst.
> er zeigt keine errors keine warnings
Ich bin ein toller Hecht:
ohne Syntaxcheck ein fehlerfreies Programm geschrieben ;-)
> Dem Compiler sind Logikfehler aber sowas von egal.
Ja, und er weiß nicht, wie und wo die LEDs genau an den uC angeschlossen
sind. Und ich weiß das auch nicht. Poste doch mal den Schaltplan.
Steven Lahmann schrieb:
> #define F_CPU 20000000UL // 20 MHz
....
Dieses Programm zeigt keinen Buchstaben an, sondern schaltet nach und
nach jeweils eine LED ein.
Zeig doch mal das Programm, welches den Buchstaben anzeigt.
(Du willst ja schliesslich Text anzeigen und nicht ausgefüllte Flächen)
> Dieses Programm zeigt keinen Buchstaben an, sondern schaltet nach und> nach jeweils eine LED ein.
Das ist wesentlich verzwickter, als gedacht:
wait() wird wegen dem den Interrupt (clicks) verlassen.
Vorher wird aber noch was aus dem Array auf di Matrix ausgegeben.
Und ob die Funktion
1
voidLED_ein(intx,inty)
2
{
3
Array[x]|=0<<(7-y);
4
}
Das tut, was sie verspricht, das möchte ich bezweifeln :-o
> Zeig doch mal das Programm, welches den Buchstaben anzeigt.
Ja, das würde mich auch interessieren.
Der Anzeigenteil ist ja dabei, in der IRQ Funktion wird mit PORTC die
jeweilige Spalte bestromt und mit PortA die jeweiligen Zeilen
angesprochen. Daher auch das Wait in der IRQ Funktion, da er mit der for
Schleife über seine Spalten iteriert :)
Michael schrieb:
> Der Anzeigenteil ist ja dabei, in der IRQ Funktion wird mit PORTC die> jeweilige Spalte bestromt und mit PortA die jeweiligen Zeilen> angesprochen. Daher auch das Wait in der IRQ Funktion, da er mit der for> Schleife über seine Spalten iteriert :)
Ich denke wir sind uns alle einig, dass derjenige der das geschrieben
hat, das Prinzip des Multiplexens in einer ISR nicht richtig verstanden
hat.
Die Frage ist jetzt: Schreiben wir das dem OP um oder nicht?
Umschreiben ist bei solchen Sachen ohne die Hardware hier zu haben immer
ein wenig fehleranfällig.
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},// 0x3F ? to be continued :-)
44
};
45
46
ISR(TIMER1_OVF_vect)
47
{
48
PORTC=0xFF;// alles aus
49
50
PORTA=Display[MultiplexCntr];// nächste Zeile
51
PORTC=~(1<<MultiplexCntr);// und Zeile scharf schalten
52
53
MultiplexCntr++;// vorbereiten für den nächsten
54
if(MultiplexCntr==8)// Durchgang
55
MultiplexCntr=0;
56
}
57
58
voidclear()
59
{
60
uint8_ti;
61
62
for(i=0;i<8;++i)
63
Display[i]=0;
64
}
65
66
voidlampTest()
67
{
68
uint8_ti;
69
70
for(i=0;i<8;++i)
71
{
72
Display[i]=0xFF;
73
_delay_ms(1000);
74
}
75
76
clear();
77
}
78
79
voidshowChar(charc)
80
{
81
uint8_ti;
82
uint8_tindex=c-' ';
83
84
for(i=0;i<8;++i)
85
{
86
Display[i]=Characters[index][i];
87
}
88
}
89
90
/* diverse Dinge initialisieren */
91
voidinit(void)
92
{
93
DDRA=0xff;// Alle Pin als Ausgang
94
DDRC=0xff;// Alle Pin als Ausgang
95
PORTC=0x00;
96
97
/* Timer und Interrupt initialisieren*/
98
TCCR1B=(1<<CS10);// Prescaler 1:1
99
TIMSK1=(1<<TOIE1);
100
101
clear();
102
}
103
104
intmain(void)
105
{
106
init();
107
108
sei();
109
110
lampTest();
111
112
while(1)
113
{
114
showChar('.');
115
_delay_ms(500);
116
showChar('+');
117
_delay_ms(500);
118
showChar('-');
119
_delay_ms(500);
120
showChar('1');
121
_delay_ms(500);
122
}
123
}
wenn alles klappt (ist bei Programmierung ohne reale Hardware immer
schwer zu sagen), dann sollte das nacheinander die 'Buchstaben' . + -
und 1 anzeigen. Die restlichen Buchstaben darfst du dir dann selbst in
den Zeichensatzgenerator eintragen.
Es kann jetzt höchstens sein, dass das alles furchtbar flackert. Der 16
Bit Timer ist dafür nicht wirklich eine gute Wahl.
THx hab nur das problem , dass bei meiner 8X8 Matrix die zeichen nicht
wirklich durchlaufen, also erst ist der test der einfach durchläuft und
i.wann kommt dann ein + was kreuz und quer durch die matrix flitzt,
änderungsversuche haben auch keine ergebnisse erzielt :/
wie krieg ich denn da nen buchstaben rein der einfach nur von einer
seite zur anderen läuft?
Peter schrieb:
>> void LED_ein(int x, int y)>> {>> Array[x] |= 0 << (7-y);>> }>>> wenn der compiler schlau ist, kann er das sehr gut optimieren.
lol, wahrlich, ja. Das kann er.
Thread beobachten
Seitenaufteilung abschalten