www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Brauche dringend Hilfe wegen LED Matrix!


Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Ralf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> ...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

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 :/

Autor: Chris K. (chrisk86)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zuerst könntest du den Quellcode hier mal posten ;)

Autor: hmm. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich denk das wird nix mit den Ferien... Die Ferien sind ohne C gelernt 
zu haben einfach nicht verdient... Vielleicht das naechste Jahr.
:-)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 :/

Autor: Marius S. (lupin) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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.

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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. ;-)

Autor: Falk Brunner (falk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Chris K. (chrisk86)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wir können nur helfen, wenn du deinen Quellcode postest...

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#define F_CPU 20000000UL  // 20 MHz


#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"



/* Timer1-Werte berechnen */
#define SPALTEN        8            /* Spaltenanzahl         */
#define MATRIX_REFRESH     60            /* Bildwiederholfrequenz in Hz 
*/
#define T1_PRESCALE         1            /* Vorteiler des Timers 
*/
#define T1_MAX_COUNTER  65535            /* Maximalwert des Timers 
*/
#define T1_FREQ         (MATRIX_REFRESH * SPALTEN)  /* Spaltenrequenz 
*/
#define T1_PRELOAD      (T1_MAX_COUNTER-(F_CPU/T1_PRESCALE/T1_FREQ))  /* 
resultierender Preloadwert  */

#define _TIMSK_TIMER1   TIMSK1
#define  preload  10000;


volatile uint16_t timer_preload  = T1_PRELOAD;


int i,x,y;

//volatile int Array[8] = {255,129,129,129,129,129,129,255};
volatile int Array[8] = {0,92,84,84,116,0,0,0};
volatile long clicks;


/* Interruptroutine Steuerung Cube-Hardware */
ISR(TIMER1_OVF_vect)
 {
  int i;
  TCNT1  =  preload;
  for(i=0;i<=7;i++)
    {
  PORTC = ~(1<<i);
  PORTA = Array[i];
  _delay_ms(1);
  }
   PORTC = ~(1<<0);
  PORTA = clicks;
  _delay_ms(1);

 clicks = clicks +3;
}


/* diverse Dinge initialisieren */
void init(void)
{
  clicks = 0;
    DDRA  = 0xff;       // Alle Pin als Ausgang
    DDRC  = 0xff;      // Alle Pin als Ausgang
    PORTC = 0x00;

  /* Timer und Interrupt initialisieren*/
  TCNT1  =  preload;
//  TCNT1   =  60000;      //timer_preload;  Preload-Wert     */
  TCCR1B |=  0x03;    //0x05;           Vorteiler 1:1 */
  TIMSK1 |= (1 << TOIE1);  //           Interrupt Timer1 */
  sei();
}


void LED_ein(int x, int y)
{
  Array[x] |= 0 << (7-y);
}


void LED_aus(int x, int y)
{
  Array[x] &= ~(1 << (7-y));
}


 void wait(int warte)
{
 clicks = 0;
 while(clicks <= warte){}
}



int main (void)
 {
  init();
 //  LED_ein(4,4);

 while(1)
 {
  for(y=0;y<=7;y++)
    {
    for(x=5;x<=7;x++)
    {
       LED_ein(x,y);
       wait(1);
     }
  }
 }
}

Autor: ... ... (docean) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>#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)

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
danke für deinen beitrag hat mir sehr weitergeholfen! gute kritik 
ehrlich!

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> das der buchstabe die ganze zeit blink
Das willst du aber gar nicht.
Also schraubst du an der falschen Stelle :-/
ISR(TIMER1_OVF_vect)
 {
  :
  _delay_ms(1);
  :
  _delay_ms(1);
 }
Nun gut, in Interrupt-Behandlungen gehört kein delay().
Vergiss erst mal den Interrupt. Das kannst du nach dem Urlaub 
machen/lernen.

Also:
volatile int Array[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:
volatile int Array[8] = {0b00000000,
                         0b01011100,
                         0b01010100,
                         0b01010100,
                         0b01110100,
                         0b00000000,
                         0b00000000};

Am einfachsten dürfte sein, diese Tabelle etwas zu erweitern (HALLO):
volatile int Array[]  = {0b00000000,
                         0b01111100,
                         0b00010000,
                         0b01111100,
                         0b00000000,
                         0b01111000,
                         0b00010100,
                         0b01111000,
                         0b00000000,
                         0b01111100,
                         0b01000000,
                         0b01000000,
                         0b00000000,
                         0b01111100,
                         0b01000000,
                         0b01000000,
                         0b00000000,
                         0b00111000,
                         0b01000100,
                         0b00111000,
                         0b00000000,
                         0b00000000,
                         0b00000000,
                         0b00000000,
                         0b00000000,
                         0b00000000,
                         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:
#define F_CPU 20000000UL  // 20 MHz

#include <io.h>
#include <delay.h>

char i;
char offset = 0;
char cnt;

char Array[24]= {0b00000000,
                 0b01111100,
                 0b00010000,
                 0b01111100,
                 0b00000000,
                 0b01111000,
                 0b00010100,
                 0b01111000,
                 0b00000000,
                 0b01111100,
                 0b01000000,
                 0b01000000,
                 0b00000000,
                 0b01111100,
                 0b01000000,
                 0b01000000,
                 0b00000000,
                 0b00111000,
                 0b01000100,
                 0b00111000,
                 0b00000000,
                 0b00000000,
                 0b00000000,
                 0b00000000,
                 0b00000000};

void init(void)
{
    DDRA  = 0xff;      // Alle Pin als Ausgang
    DDRC  = 0xff;      // Alle Pin als Ausgang
    PORTC = 0x00;
    PORTA = 0xff;
}

int main (void)
{
  init();
  while(1)
  { 
    // den aktuellen Tabelleninhalt anzeigen
    mask <= 0xFE;
    for(i=0;i<=7;i++) // ein Durchlauf braucht ca. 16 ms
    {
       PORTC = mask;  // Auswahl der LED-Spalte
       PORTA = Array[i+offset];
       _delay_ms(2);
       PORTA = 0;     // Ausschalten vor dem Weiterschieben der Maske
       _delay_us(10);
       mask <<= 1;
     }

     // Laufschrift: Spalten durchlaufen lassen
     cnt++; 
     if (cnt == 31) { // 31*16 ms= 0,5 sec 
       cnt = 0;
       offset++;
       if (offset == 24-8) {
          offset = 0;
       }
     }
   }
}
Das ist jetzt schon recht kompakt, das solltest du verstehen lernen.


BTW:
Das hier
   PORTC = ~(1<<0);
ist das selbe wie das:
   PORTC = ~(1);
ist das selbe wie das:
   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?

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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)

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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
void LED_ein(int x, int y)
{
  Array[x] |= 0 << (7-y);
}
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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Lothar Miller schrieb:

> Und ob die Funktion
>
> void LED_ein(int x, int y)
> {
>   Array[x] |= 0 << (7-y);
> }
> 
> Das tut, was sie verspricht, das möchte ich bezweifeln :-o

LOL.
Scheint so, als ob da schon jemand Hand angelegt hat :-)

Autor: Michael (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 :)

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> void LED_ein(int x, int y)
> {
>   Array[x] |= 0 << (7-y);
> }
>
wenn der compiler schlau ist, kann er das sehr gut optimieren.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Probier das mal aus
#define F_CPU 20000000UL  // 20 MHz

#include "avr\io.h"
#include "util\delay.h"
#include "avr\interrupt.h"

uint8_t Display[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
uint8_t MultiplexCntr = 0;

uint8_t Characters[][8] =
{
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // ASCII Code: 0x20  Leerzeichen
  { 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00, 0x00 },   //             0x21  !
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x22  "
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x23  #
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x24  $
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x25  %
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x26  &
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x27  '
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x28  (
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x29  )
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x2A  *
  { 0x00, 0x10, 0x10, 0x7E, 0x10, 0x10, 0x00, 0x00 },   //             0x2B  +
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x2C  ,
  { 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00 },   //             0x2D  -
  { 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x00 },   //             0x2E  .
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x2F  /
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // ASCII Code: 0x30  0
  { 0x00, 0x00, 0x04, 0x02, 0xFF, 0x00, 0x00, 0x00 },   //             0x31  1
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x32  2
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x33  3
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x34  4
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x35  5
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x36  6
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x37  7
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x38  8
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x39  9
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x3A  :
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x3B  ;
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x3C  <
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x3D  =
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x3E  >
  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   //             0x3F  ?    to be continued :-)
};

ISR( TIMER1_OVF_vect )
{
  PORTC = 0xFF;                     // alles aus

  PORTA = Display[ MultiplexCntr ]; // nächste Zeile
  PORTC = ~( 1 << MultiplexCntr );  // und Zeile scharf schalten

  MultiplexCntr++;                  // vorbereiten für den nächsten
  if( MultiplexCntr == 8 )          // Durchgang
    MultiplexCntr = 0;
}

void clear()
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
    Display[i] = 0;
}

void lampTest()
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
  {
    Display[i] = 0xFF;
    _delay_ms( 1000 );
  }

  clear();
}

void showChar( char c )
{
  uint8_t i;
  uint8_t index = c - ' ';

  for( i = 0; i < 8; ++i )
  {
    Display[i] = Characters[index][i];
  }
}
  
/* diverse Dinge initialisieren */
void init(void)
{
  DDRA  = 0xff;       // Alle Pin als Ausgang
  DDRC  = 0xff;      // Alle Pin als Ausgang
  PORTC = 0x00;

  /* Timer und Interrupt initialisieren*/
  TCCR1B =  ( 1 << CS10 );    // Prescaler 1:1
  TIMSK1 = (1 << TOIE1);

  clear();
}

int main (void)
{
  init();

  sei();

  lampTest();

  while(1)
  {
    showChar( '.' );
    _delay_ms( 500 );
    showChar( '+' );
    _delay_ms( 500 );
    showChar( '-' );
    _delay_ms( 500 );
    showChar( '1' );
    _delay_ms( 500 );
  }
}

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.

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Simon K. (simon) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Steven Lahmann (blackrain)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
DAnke an alle die mir geholfen haben habs jetzt hinbekommen :)
thx thx

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> habs jetzt hinbekommen :)
Lass doch mal sehen...

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.