ASCII code in Marix 2D Array umwandeln

[Mike B. (mike_b)]

halle

ich Habe eine LED MATRIX 16X64 Gebaut die läuft soweit auch ganz gut, 
nun möchte ich von einer SD Karte Einen Text Anzeigen Lassen mein 
Problem ist nun
das ich nicht weiß wie ich aus einem

char i[] ="A";

effizient so etwas

boolean Anzreige[][]= {
{0,0,1,1,0,0,0},
{0,1,0,0,1,0,0},
{0,1,0,0,1,0,0},
{0,1,0,0,1,0,0},
{1,1,1,1,1,1,0},
{1,0,0,0,0,1,0},
{1,0,0,0,0,1,0},
{1,0,0,0,0,1,0}};

machen kann.
schön wer etwas fertiges, ich dachte schon mal an ein

switch (i){
case A:
boolean Anzreige[][]= {
{0,0,1,1,0,0,0},
{0,1,0,0,1,0,0},
{0,1,0,0,1,0,0},
{0,1,0,0,1,0,0},
{1,1,1,1,1,1,0},
{1,0,0,0,0,1,0},
{1,0,0,0,0,1,0},
{1,0,0,0,0,1,0}};

oder so ähnlich

dabei wird der sours code jedoch Riesig.
hat das schon mal jemand gemacht,
geht mein Ansatz überhaupt in die richtige Richtung?
gibt es Tabelle die zeigen wie die Zeichen in Punkten schön aussehen?

danke im voraus an alle die mir helfen MFG MIKE

[Falk B. (falk)]

@  Mike B. (mike_b)

>das ich nicht weiß wie ich aus einem

>char i[] ="A";

>effizient so etwas

Mit einem zweidimensionalen Array.

char my_ascii[128][8];

Der erste Index ist der ASCII Code, der zweite adressiert die einzelnen 
Zeilen deines Zeichens.

>hat das schon mal jemand gemacht,

Millionen. Jeder Zeichensatz in jedem Computer ist so aufgebaut.

>geht mein Ansatz überhaupt in die richtige Richtung?

Jain.

>gibt es Tabelle die zeigen wie die Zeichen in Punkten schön aussehen?

gurgel ASCII Zeichensatz.

MfG
Falk

danke im voraus an alle die mir helfen MFG MIKE

[Helfer (Gast)]

Vlt kannst du mit dem 5x8 "vertikal" was anfangen. HTH. :)

[Mike B. (mike_b)]

Falk Brunner schrieb:
> @  Mike B. (mike_b)
>
>>das ich nicht weiß wie ich aus einem
>
>>char i[] ="A";
>
>>effizient so etwas
>
> Mit einem zweidimensionalen Array.
>
> char my_ascii[128][8];
>
> Der erste Index ist der ASCII Code, der zweite adressiert die einzelnen
> Zeilen deines Zeichens.
>
soll das heisen "char my_ascii[128][8];" würde um beim beispiel A zu 
bleiben und von oben nach unten betrachtet das: {1,0,0,0,0,1,0}}; 
enthalten ? müste dan nicht eher ein 3D arey verwendet werden die ersten 
beiden ebenen enthalten das Zeichen des 3. den verwaltet die zeichen?

>>gibt es Tabelle die zeigen wie die Zeichen in Punkten schön aussehen?
>
> gurgel ASCII Zeichensatz.

hab "gegurgelt" aber da finde ich nur listen mit dez hex und Zeichen was 
ich eigentlich meine ist eher so was

A =

  ##
 #  #
 ####
#    #
#    #

usw

 danke im voraus an alle die mir helfen MFG MIKE

[Frank M. (aktenasche)]

da 'A' nur eine zahl repräsentiert, hat der computer logischerweise auch 
keine ahnung wie das 'A' auszusehen hat.

es ist nur konvention, dass 63 dezimal das 'A' sein soll.

belibt dir nix anderes uebrig, also alles abzuspeichern. wieso hast du 
angst davor dass der sours code groß wird? ist ja wohl genug platz auf 
der SD karte...

[hans (Gast)]

Du brauchst einen Character Generator:

http://www.atariarchives.org/cgp/Ch02_Sec04.php

Hier hast du deine Zeichen ;)

hans

[Mike B. (mike_b)]

Helfer schrieb:
> Vlt kannst du mit dem 5x8 "vertikal" was anfangen. HTH. :)

das sieht gut aus nur wie bekomme ich das in einen 2D boolean arey ?
ich häng mal meinen bisherigen sours code an

[Karl H. (kbuchegg)]

Mike B. schrieb:

> enthalten ? müste dan nicht eher ein 3D arey verwendet werden die ersten
> beiden ebenen enthalten das Zeichen des 3. den verwaltet die zeichen?

Nein.
Denn man nimmt für ein einzelnes Zeichen keine 2D MAtrix.

Aus deiner Zeichendefinition siehst du, dass du 8 Zeilen übereinander 
hast. In jeder Spalte eines Zeichens (in einer Zeile) kann nur 0 oder 1 
stehen.

Ein Byte hat 8 Bit. Jedes Bit kann nur 0 oder 1 sein.

Also würde icgh mal sagen, das damit ein Byte perfekt passt, um darin 
eine komplette Spalte abzulegen. Aber diesmal in Bit Form(!) und nicht 
so aufgeblasen, wie du das machst.

[Mike B. (mike_b)]

Frank Meier schrieb:
> da 'A' nur eine zahl repräsentiert, hat der computer logischerweise auch
> keine ahnung wie das 'A' auszusehen hat.
>
> es ist nur konvention, dass 63 dezimal das 'A' sein soll.
das man aus einem Zeichen eine dez macht ist mir bekannt das ist im 
großen ganzen ja der ASCII.

> belibt dir nix anderes uebrig, also alles abzuspeichern. wieso hast du
> angst davor dass der sours code groß wird? ist ja wohl genug platz auf
> der SD karte...

ich wollte auf die SD nur den text machen weil der sich ändert und man 
den AVR nicht unbegrenzt oft überschreiben kann, die SD zwa auch nicht 
die kostet aber auch nicht so fiel. und ein wenig Übersicht im code 
würde ich mir gerne erhalten mfg Mike

[Mike B. (mike_b)]

Karl Heinz Buchegger schrieb:
> Mike B. schrieb:
>
>> enthalten ? müste dan nicht eher ein 3D arey verwendet werden die ersten
>> beiden ebenen enthalten das Zeichen des 3. den verwaltet die zeichen?
>
> Nein.
> Denn man nimmt für ein einzelnes Zeichen keine 2D MAtrix.
>
> Aus deiner Zeichendefinition siehst du, dass du 8 Zeilen übereinander
> hast. In jeder Spalte eines Zeichens (in einer Zeile) kann nur 0 oder 1
> stehen.
 das hab ich inzwischen schon gesehen "Helfer (Gast)" hate da ein 
Beispiel

> Ein Byte hat 8 Bit. Jedes Bit kann nur 0 oder 1 sein.
>
> Also würde ich mal sagen, das damit ein Byte perfekt passt, um darin
> eine komplette Spalte abzulegen. Aber diesmal in Bit Form(!) und nicht
> so aufgeblasen, wie du das machst.

wiso aufgeblasen ein 8 Boolean sind auch ein byte und in einem arey kan 
ich einfacher navigieren

mfg mike

[Karl H. (kbuchegg)]

Mike B. schrieb:

> wiso aufgeblasen ein 8 Boolean

ne. 8 Boolean sind 8 Boolean. Jeder belegt 1 Byte

[Karl H. (kbuchegg)]

> hab "gegurgelt" aber da finde ich nur listen mit dez hex und
> Zeichen was ich eigentlich meine ist eher so was

Das werden dann wohl genau diese Dinge sein.


Dein A

  ##
 #  #
 ####
#    #
#    #

in ein 6*8 Raster gebracht

  +---+---+---+---+---+---+
  |   |   | # | # |   |   |
  +---+---+---+---+---+---+
  |   | # |   |   | # |   |
  +---+---+---+---+---+---+
  |   | # | # | # | # |   |
  +---+---+---+---+---+---+
  | # |   |   |   |   | # |
  +---+---+---+---+---+---+
  | # |   |   |   |   | # |
  +---+---+---+---+---+---+
  |   |   |   |   |   |   |
  +---+---+---+---+---+---+
  |   |   |   |   |   |   |
  +---+---+---+---+---+---+
  |   |   |   |   |   |   |
  +---+---+---+---+---+---+

und spaltenweise als Hex-Zahl ausgedrückt. Ob das Low-Bit jetzt oben 
oder unten sein soll, kannst du dir aussuchen. Ich nehme mal oben


   +---+---+---+---+---+---+
8  | 0 | 0 | 1 | 1 | 0 | 0 |
   +---+---+---+---+---+---+
4  | 0 | 1 | 0 | 0 | 1 | 0 |
   +---+---+---+---+---+---+
2  | 0 | 1 | 0 | 0 | 1 | 0 |
   +---+---+---+---+---+---+
1  | 1 | 0 | 0 | 0 | 0 | 1 |
   +---+---+---+---+---+---+
8  | 1 | 0 | 0 | 0 | 0 | 1 |
   +---+---+---+---+---+---+
4  | 0 | 0 | 0 | 0 | 0 | 0 |
   +---+---+---+---+---+---+
2  | 0 | 0 | 0 | 0 | 0 | 0 |
   +---+---+---+---+---+---+
1  | 0 | 0 | 0 | 0 | 0 | 0 |
   +---+---+---+---+---+---+

         ^       ^       ^
        0x60    0x80    0x18

     ^       ^       ^
    0x18    0x80    0x60


Also lässt dich das aussehen deines 'A' so beschreiben

char A[6] = { 0x18, 0x60, 0x80, 0x80, 0x60, 0x18 };

oder aber, wenn du dann einen ganzen Zeichensatz, für alle  Buchstaben 
hast

char Font[256][6] = {

   {  .......... },
   {  .......... },
   { 0x18, 0x60, 0x80, 0x80, 0x60, 0x18 },  // A
   { ........... },                         // B
   { ........... },                         // C
   ....
};


> wiso aufgeblasen ein 8 Boolean sind auch ein byte und in einem
> arey kan ich einfacher navigieren

Angst vor Bitoperationen?
Solltest du schleunigst ablegen.

[Mike B. (mike_b)]

Karl Heinz Buchegger schrieb:
> Mike B. schrieb:
>
>> wiso aufgeblasen ein 8 Boolean
>
> ne. 8 Boolean sind 8 Boolean. Jeder belegt 1 Byte

ok ich hab das nochmal nachgelesen das stimmt aber dann bleibt mir immer 
noch das ich 16 brauche (16X64 LED MATRIX)dann müsste ich woll eher ein 
word nehmen ich seh schon ich muss noch fiel über arbeiten,
wie greife ich jetzt aber dan auf die einzelnen bit zu den ich kann da 
nicht einfach ein byte ausgeben den beim bau habe ich die pins nicht der 
reihe nach genommen ich muss das also bit genau zuordnen was ich aus den 
Anschlüssen raus lassen.

[Mike B. (mike_b)]

Karl Heinz Buchegger schrieb:

>> wiso aufgeblasen ein 8 Boolean sind auch ein byte und in einem
>> arey kan ich einfacher navigieren
>
> Angst vor Bitoperationen?
> Solltest du schleunigst ablegen.

Angst würde ich nicht sagen mir fehlt es vielmehr am wissen.

[Karl H. (kbuchegg)]

Mike B. schrieb:
> Karl Heinz Buchegger schrieb:
>
>>> wiso aufgeblasen ein 8 Boolean sind auch ein byte und in einem
>>> arey kan ich einfacher navigieren
>>
>> Angst vor Bitoperationen?
>> Solltest du schleunigst ablegen.
>
> Angst würde ich nicht sagen mir fehlt es vielmehr am wissen.

Dann wirds Zeit. Es sind nur 3 Operationen (ok, 4) die du beherrschen 
musst. bitweises oder |, bitweises und &, negation ~, und den 
Schiebeoperator << (oder >>)

Bitmanipulation


Das wirft allerdings dann gleich ein ganz anderes Licht auf deine 
Ursprungsaussage
> ich Habe eine LED MATRIX 16X64 Gebaut die läuft soweit auch ganz gut,

die kann nicht gut laufen, wenn du von Bitoperationen keine Ahnung hast.

[Mike B. (mike_b)]

ich fasse mal zusammen ich weiß jetzt wie ich ein Zeichen in Bytes hin 
bekomme nun muss ich nur noch meine Ausgabe also die Ansteuerung der 
LEDs auf diese Art hin bekommen
bisher steuere ich meine matrix so an

void WriteMatrix(){//Mtrix schreiben
  int a;
  int i;
 for( a = 0; a < 64; ++a ){
  digitalWrite(ledzeilePins[0],ledzeilePinsCODE[0][a]);
  digitalWrite(ledzeilePins[1],ledzeilePinsCODE[1][a]);
  digitalWrite(ledzeilePins[2],ledzeilePinsCODE[2][a]);
  digitalWrite(ledzeilePins[3],ledzeilePinsCODE[3][a]); 
  digitalWrite(ledzeilePins[4],ledzeilePinsCODE[4][a]);  
  digitalWrite(ledzeilePins[5],ledzeilePinsCODE[5][a]);
  
   for( i = 0; i < 16; ++i ){
   digitalWrite(ledspaltePins[i], Anzreige[i][a]);
   }
    delayMicroseconds(20); 
   for( i = 0; i < 16; ++i ){
   digitalWrite(ledspaltePins[i],LOW);
   }
 }
}

wie muss ich das machen machen wen ich nun anstelle des arey nun 2byte 
oder 1word nehme ?

[Mike B. (mike_b)]

Karl Heinz Buchegger schrieb:

> Das wirft allerdings dann gleich ein ganz anderes Licht auf deine
> Ursprungsaussage
>> ich Habe eine LED MATRIX 16X64 Gebaut die läuft soweit auch ganz gut,
>
> die kann nicht gut laufen, wenn du von Bitoperationen keine Ahnung hast.

hast du mal meine sours code gelesen ? ich dacht mir schon irgendwie das 
das besser gehen muss aber hat ja funktioniert!

[Karl H. (kbuchegg)]

Mike B. schrieb:
> Karl Heinz Buchegger schrieb:
>
>> Das wirft allerdings dann gleich ein ganz anderes Licht auf deine
>> Ursprungsaussage
>>> ich Habe eine LED MATRIX 16X64 Gebaut die läuft soweit auch ganz gut,
>>
>> die kann nicht gut laufen, wenn du von Bitoperationen keine Ahnung hast.
>
> hast du mal meine sours code gelesen ?

Nein.
Weil ich ein File mit einer Endung .pde grundsätzlich nicht aufmache

> ich dacht mir schon irgendwie das
> das besser gehen muss aber hat ja funktioniert!

Das ist noch kein Argument.
Ich kann auch mit Sohnemanns Sandkastenschäufelchen den Kelleraushub 
unseres Hauses machen. Funktionieren wird es. Nur mit einem Bagger gehts 
halt besser und nervenschonender.

[Mike B. (mike_b)]

Karl Heinz Buchegger schrieb:

>> hast du mal meine sours code gelesen ?
>
> Nein.
> Weil ich ein File mit einer Endung .pde grundsätzlich nicht aufmache

ok kennst du Arduino ? scheinbar nicht das ist eine Firma aus Italien 
und deren Software (Editor und Compiler)Arduino 0022 lässt beim 
speichern diese Endung raus ist aber eigentlich ne normale txt

>> ich dacht mir schon irgendwie das
>> das besser gehen muss aber hat ja funktioniert!
>
> Das ist noch kein Argument.
> Ich kann auch mit Sohnemanns Sandkastenschäufelchen den Kelleraushub
> unseres Hauses machen. Funktionieren wird es. Nur mit einem Bagger gehts
> halt besser und nervenschonender.

was weren wen du nicht wüstest das es einen Bagger gibt ?
(das bringt nun auch keinem was)

wen nun jemand mir ein Beispiel machen könnte wie ich aus einem byte ein 
einzelnes bit lese könnte das vielleicht schon das ende und die Lösung 
sein. den das ist mir noch immer nicht klar.

[Karl H. (kbuchegg)]

Mike B. schrieb:
> ich fasse mal zusammen ich weiß jetzt wie ich ein Zeichen in Bytes hin
> bekomme nun muss ich nur noch meine Ausgabe also die Ansteuerung der
> LEDs auf diese Art hin bekommen
> bisher steuere ich meine matrix so an
>
>

> void WriteMatrix(){//Mtrix schreiben
>   int a;
>   int i;
>  for( a = 0; a < 64; ++a ){
>   digitalWrite(ledzeilePins[0],ledzeilePinsCODE[0][a]);
>   digitalWrite(ledzeilePins[1],ledzeilePinsCODE[1][a]);
>   digitalWrite(ledzeilePins[2],ledzeilePinsCODE[2][a]);
>   digitalWrite(ledzeilePins[3],ledzeilePinsCODE[3][a]);
>   digitalWrite(ledzeilePins[4],ledzeilePinsCODE[4][a]);
>   digitalWrite(ledzeilePins[5],ledzeilePinsCODE[5][a]);
> 
>    for( i = 0; i < 16; ++i ){
>    digitalWrite(ledspaltePins[i], Anzreige[i][a]);
>    }
>     delayMicroseconds(20);
>    for( i = 0; i < 16; ++i ){
>    digitalWrite(ledspaltePins[i],LOW);
>    }
>  }
> }
>

>
> wie muss ich das machen machen wen ich nun anstelle des arey nun 2byte
> oder 1word nehme ?

ALs erstes solltest du erst mal von diesem digitalWrite wegkommen.
Man kann auch auf dem Arduino einen Port als ganzes ansprechen und muss 
nicht den µC jedesmal durch eine Orgie durchjagen.
Dann hat man mit 1 Zuweisung

    PORTx = ColumByte[i];

in einem Rutsch 8 Led ein oder aus geschaltet. Und dazu sucht man sich 
einen Port, der komplet als Ganzes auf die Steckerleisten herausgeführt 
wird.

Wenn es denn aber sein muss

   digitalWrite( ledzeilePins[0], ledzeilePinsCODE[a] & 0x80 );
   digitalWrite( ledzeilePins[1], ledzeilePinsCODE[a] & 0x40 );
   digitalWrite( ledzeilePins[2], ledzeilePinsCODE[a] & 0x20 );
   digitalWrite( ledzeilePins[3], ledzeilePinsCODE[a] & 0x10 );
   digitalWrite( ledzeilePins[4], ledzeilePinsCODE[a] & 0x08 );
   digitalWrite( ledzeilePins[5], ledzeilePinsCODE[a] & 0x04 );

(oder so, ich weiß ja nicht, was deine ledzeilePinsCode sein soll)

Und das mit der Schleife auf 64.
Ja genau so hab ich mir das gedacht, das du das machen wirst. Das ist 
Murx.
Multiplexing macht man komplett anders. Das fängt schon mal damit an, 
dass man dafür einen Timer braucht, der in regelmässigen Zeitabständen 
eine ISR aufruft in der dann 1(!) Spalte (die jeweils nächste) 
ausgegeben wird. Dazu benötigt man dann noch einen Buffer, der das 
auszugebende, und zwar für die komplette Anzeige (also bei dir ein 
uint16_t Array mit 64 Elementen) enthält.

Das rausschaufeln auf die LED geschieht im Hintergrund in einer ISR. Das 
im Vordergrund laufende Hauptprogramm kriegt das gar nicht mit. Das 
setzt in besagtem Buffer einfach nur für jede LED das entsprechende Bit 
auf 0 oder 1 und um mehr muss es sich dann nicht mehr kümmern.

Warum fangt ihr immer in der Königsklasse an, anstatt erst mal die 
Grundlagen zu lernen, wie eigentlich Multiplexing funktioniert?

[Mike B. (mike_b)]

Karl Heinz Buchegger schrieb:

> ALs erstes solltest du erst mal von diesem digitalWrite wegkommen.
> Man kann auch auf dem Arduino einen Port als ganzes ansprechen und muss
> nicht den µC jedesmal durch eine Orgie durchjagen.
> Dann hat man mit 1 Zuweisung
>
>     PORTx = ColumByte[i];
>
> in einem Rutsch 8 Led ein oder aus geschaltet. Und dazu sucht man sich
> einen Port, der komplet als Ganzes auf die Steckerleisten herausgeführt
> wird.

dan múss ich umlöten die reihenfolge stimmt nicht :(

> Wenn es denn aber sein muss
>
>    digitalWrite( ledzeilePins[0], ledzeilePinsCODE[a] & 0x80 );
>    digitalWrite( ledzeilePins[1], ledzeilePinsCODE[a] & 0x40 );
>    digitalWrite( ledzeilePins[2], ledzeilePinsCODE[a] & 0x20 );
>    digitalWrite( ledzeilePins[3], ledzeilePinsCODE[a] & 0x10 );
>    digitalWrite( ledzeilePins[4], ledzeilePinsCODE[a] & 0x08 );
>    digitalWrite( ledzeilePins[5], ledzeilePinsCODE[a] & 0x04 );
>
> (oder so, ich weiß ja nicht, was deine ledzeilePinsCode sein soll)
>
> Und das mit der Schleife auf 64.
> Ja genau so hab ich mir das gedacht, das du das machen wirst. Das ist
> Murx.

ich weis normal macht man das anderst rum aber ich komte keine MC mit 
über 64 pins finden und hab das dan mit Transystoren über 6 pins codiert
das müsste aber eh in die andere zeile integriert werden.

> Multiplexing macht man komplett anders. Das fängt schon mal damit an,
> dass man dafür einen Timer braucht, der in regelmässigen Zeitabständen
> eine ISR aufruft in der dann 1(!) Spalte (die jeweils nächste)
> ausgegeben wird. Dazu benötigt man dann noch einen Buffer, der das
> auszugebende, und zwar für die komplette Anzeige (also bei dir ein
> uint16_t Array mit 64 Elementen) enthält.
das will ich ja endern ich hab da hald bisher nen bool arey 16 X 64

> Das rausschaufeln auf die LED geschieht im Hintergrund in einer ISR. Das
> im Vordergrund laufende Hauptprogramm kriegt das gar nicht mit. Das
> setzt in besagtem Buffer einfach nur für jede LED das entsprechende Bit
> auf 0 oder 1 und um mehr muss es sich dann nicht mehr kümmern.

was heist ISR ? aber das kling so ähnlich wie ich das mache

> Warum fangt ihr immer in der Königsklasse an, anstatt erst mal die
> Grundlagen zu lernen, wie eigentlich Multiplexing funktioniert?

ich dachte das hätte ich aber da gabs dann doch noch mehr :(

[Karl H. (kbuchegg)]

Mike B. schrieb:

>> Und das mit der Schleife auf 64.
>> Ja genau so hab ich mir das gedacht, das du das machen wirst. Das ist
>> Murx.
>
> ich weis normal macht man das anderst rum aber ich komte keine MC mit
> über 64 pins finden und hab das dan mit Transystoren über 6 pins codiert
> das müsste aber eh in die andere zeile integriert werden.

Und?
Das ändert softwareseitig immer noch nichts daran, dass deine ganze 
Multiplexsystematik Murks ist.


>> uint16_t Array mit 64 Elementen) enthält.
> das will ich ja endern ich hab da hald bisher nen bool arey 16 X 64

No.
Du brauchst 1 Array mit 64 Elementen (für jede Spalte eines), wobei 
jedes Element 16 Bit hat (also ein uint16_t). Jede LED hat ihr Bit.

Du verschenkst doch massenhaft Speicher für nix und wieder nix!

>> auf 0 oder 1 und um mehr muss es sich dann nicht mehr kümmern.
>
> was heist ISR ?

Interrupt Service Routine

> aber das kling so ähnlich wie ich das mache

No. du machst was ganz anderes.
Beim richtigen Multiplex über einen Timer und seine ISR gibt es weder 
einen delay noch wird das Bild in einem Rutsch ausgegeben. Es wird immer 
nut 1 Spalte ausgegeben. Und ein paar µs später (wann der nächste ISR 
Aufruf erfolgt) dann die nächste Spalte. Das alles geschieht im 
Hintergrund ohne das das Hauptprogramm davon etwas mitbekommt.

Beschäftige dich erst mal mit Timern.

[... (Gast)]

Mike B. schrieb:
> was heist ISR ?

"Interrupt Service Routine"
In C eine Funktion, die durch einen Interrupt (z.B. Timer) aufgerufen 
wird.

[Mike B. (mike_b)]

ok byte anstelle der bit areys benutzen! mach ich
jetzt zum interrupt ich finde nur dieses beispiel

void setup() {}

void loop()
{
  noInterrupts();
  // critical, time-sensitive code here //1
  interrupts();
  // other code here //2
}

die Zahlen 1 und 2 sind von mir heist das jetzt das ich bei 1 den code 
reinschreibe der die LEDs ansteuert und bei 2 den rest ?
und wo schreibe ich meine Zeit hin ?
kann man da dan überhaupt noch mehere voids nutzen ?

[... (Gast)]

Mike B. schrieb:
> jetzt zum interrupt ich finde nur dieses beispiel
> ...

Aua, da steht Dir noch einiges bevor.
Thema Interrupt:
http://www.mikrocontroller.net/articles/Interrupt
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmieren_mit_Interrupts

[... (Gast)]

...
Thema Multiplexing:
http://www.mikrocontroller.net/articles/LED-Matrix
http://www.mikrocontroller.net/articles/LED_cube
via Forumsuche:
http://www.mikrocontroller.net/search?query=%2Bled+%2Bmatrix&forums[]=1&forums[]=2&forums[]=4&forums[]=6
oder z.B. auch:
http://www.ulrichradig.de/home/index.php/avr/avr-mega-dis

[Wegstaben V. (wegstabenverbuchsler)]

ich bekomme bald eine Netzhaut-Ablösung!

die Dinger heißen ARRAYS, und nicht arey!!!!!!


und Transystoren  gibts auch nicht. Oder ist das eine Mischung aus 
Transistoren und Thyristoren?