Amtliche LED-Laufschrift ansteuern

[frickler_01]

Guten Abend
(Das hier gabs schon im Kleinen_fragen-Thread, aber da gabs keine antwort)
Beim diesjährigen Treffen wurde mir eine Dot-Matrix-Laufschrift verkauft.
Besteht aus insgesamt 12 5*7 LED-Matrizen, also insgesamt 7*60 Dots.

Unter Jedem 5*7 LED-Modul ist eine Kleine Platine mit 2 D-Flipflops drauf.
Beim Reverse Engineering kam folgender Schaltplan zutage (wenn ich alles richtig gemacht habe)

Es sind also 12 Dieser module in einer Reihe. Was bei dem einen Anliegt liegt auch bei allen anderen an.
Man kann also keine Einzelnen module "Clocken".

-Hat jemand eine Idee wie man das Ansteuern soll?
-Kann sich der VErkäufer vll dazu Äußern, ich weiß gar nimmer genau wer das War
-Hab ich beim Reverse Engineering vll einen Fehler gemacht und jemandem fällt ein Ähnlicher aufbau ein?
Hilfe wäre nett, das Teil wäre nämlich ein echt amtliches Spielzeug

MfG frickler

[Chefbastler]

Kann leider dein Bild nicht sehen, verlinkt einen nur zu so einem Imagehoster auswärts, wo mann das bild leider auch nicht betrachten kann...
PS: hier im Forum gibt es einen eigenen der funktioniert übrigens sehr gut.

[frickler_01]

http://www.fingers-welt.de/imghost/up/2 ... TL0001.jpg
Bitte sehr

MfG frickler

[Fritzler]

Sicher, dass das richtig abgezeichnet ist?
Macht irgwndwie keinen Sinn beide D-FF in Reihe zu schalten, sind ja keine Latches.

[Chefbastler]

Hm, hätte da eher Zähler oder Schieberegister erwartet für die Spalten.
Sicher dass die Datenleitungnen so verdrahtet sind? Nicht das die Flipflops irgendwie hintereinander gehängt wurden als Schieberegister, fals das mit denen funktionieren sollte.
Weil wenn die so wie bei dir im Plan alle 12 Module Parallel hängen, macht das so irgendwie wenig sinn da alle 12 das selbe machen würden.

[xoexlepox]

Macht irgwndwie keinen Sinn beide D-FF in Reihe zu schalten, sind ja keine Latches.

Ein Schieberegister in der unteren Reihe würde Sinn machen...

[urmel]

Das ergibt schon wo sinn,

im ersten Zyklus lädt man die neuen Daten in das obere DFF, das widerholt man für alle Zellen.
Anschließend schaltet man die aktuelle Zeile aus, lädt das untere DFF und schaltet die nächste Zeile ein.

[Name vergessen]

Mit nur einem Modul geht das, aber wie selektiert man die einzelnen Module? Die beiden Clocks gehen an alle gleichzeitig, ich sehe hier nichts, das eine Kaskadierung so erlaubt, daß nicht alle Module immer dieselben Daten bekommen, da ja alle Leitungen durchgeschleift sind, und nicht z.B. ein Q des ersten D-FF z.B. die Clock2 des nächsten ergibt. Guck mal nach, evtl. ist Clock1 oder 2 nicht wie gezeichnet durchgeschleift.

[Asterix]

Moin zusammen,

ich hab auch so ein Display am Treffen bekommen und bin schon soweit am Erstellen einer Steuerplatine. Die Poster vor mir hatten recht, Zeilenweise will das Display betrieben werden. 5V Spannung scheint für die LEDs sehr gut zu sein.

Eine Zeile aus 12 Elementen zieht so Pi * Daumen 1 A, dafür brauchst du sinnvollerweise eine gute Ansteuerungshalbleiter für die Zeilen. ich werde dazu BTS 432 E2 benutzten.
Steuerung werde ich über einen Billig arduino vom Chinesen machen.

Wenn du willst lade ich nachher noch Programm und Schaltplan hoch.

Viele Grüße
Asterix

Ädit:

Die Clocks sind separat für die Beiden FFs.
Das Eine wird zum Schieben der Daten an die Module benutzt, das Andere übernimmt es zum Anzeigen.

Ädit2:

Die Spalten kommen vor dem Einen FF an und gehen zwischen den Beiden FFs weiter. Da stimmt der Schaltplan nicht so, wie fritzler auch bemerkt hat.

[frickler_01]

Klingt interessant, zeig mal her

MfG frickler

[Fritzler]

Wenn es zwischen den beiden 174er weitergeht, dann ist die Ansteuerung recht simpel und die 2 in Reihe geschalteten 174er auf der Platine machen auch Sinn.
Eines ist das Schieberegister mit den anderen Platinen und das andere der Ausgangsspeicher mit im HIntergrund was neues reingeschoben werden kann.

[Asterix]

Hi,

das Programm ist lange weg von fertig, aber hier sind mal meine Zwischenergebnisse

Viele Grüße
Asterix

http://www.fingers-welt.de/imghost/up/2 ... ltplan.png

Code: Alles auswählen

int r1=5;
int r2=6;
int r3=4;
int r4=7;
int r5=3;
int r6=8;
int r7=2;

int s1=12;
int s2=A2;
int s3=11;
int s4=A3;
int s5=10;

int queueup=A1;
int allisset=A0;


static const byte ASCII[][7] =
{
  {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 20  
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 21 !
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 22 "
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 23 #
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 24 $
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 25 %
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 26 &
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 27 '
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 28 (
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 29 )
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 2a *
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 2b +
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 2c ,
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 2d -
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 2e .
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 2f /
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 30 0
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 31 1
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 32 2
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 33 3
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 34 4
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 35 5
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 36 6
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 37 7
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 38 8
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 39 9
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 3a :
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 3b ;
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 3c <
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 3d =
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 3e >
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 3f ?
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 40 @
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 41 A
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 42 B
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 43 C
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 44 D
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 45 E
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 46 F
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 47 G
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 48 H
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 49 I
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 4a J
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 4b K
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 4c L
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 4d M
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 4e N
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 4f O
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 50 P
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 51 Q
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 52 R
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 53 S
  ,{
    0x1F, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04             } // 54 T
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 55 U
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 56 V
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 57 W
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 58 X
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 59 Y
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 5a Z
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 5b [
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 5c ¥
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 5d ]
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 5e ^
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 5f _
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 60 `
  ,{
    0x00, 0x00, 0x0E, 0x01, 0x0F, 0x11, 0x0F             } // 61 a
  ,{
    0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x1E             } // 62 b
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 63 c
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 64 d
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 65 e
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 66 f
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 67 g
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 68 h
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 69 i
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 6a j 
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 6b k
  ,{
    0x0C, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0E             } // 6c l
  ,{
    0x00, 0x00, 0x1A, 0x15, 0x15, 0x11, 0x11             } // 6d m
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 6e n
  ,{
    0x00, 0x00, 0x0E, 0x11, 0x11, 0x11, 0x0E             } // 6f o
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 70 p
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 71 q
  ,{
    0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10             } // 72 r
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 73 s
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 74 t
  ,{
    0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0D             } // 75 u
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 76 v
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 77 w
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 78 x
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 79 y
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 7a z
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 7b {
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 7c |
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 7d }
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 7e ←
  ,{
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00             } // 7f →
};

byte rein[12];
unsigned long currentMillis;

long previousMillis = 0;
int intervall=1;
int led=13;
int schalter1 = A4;
int Schalter2 = A5;
int Schalter3 = A6;

void setup(){
  pinMode(r1, OUTPUT);
  pinMode(r2, OUTPUT);
  pinMode(r3, OUTPUT);
  pinMode(r4, OUTPUT);
  pinMode(r5, OUTPUT);
  pinMode(r6, OUTPUT);
  pinMode(r7, OUTPUT);
  pinMode(s1, OUTPUT);
  pinMode(s2, OUTPUT);
  pinMode(s3, OUTPUT);
  pinMode(s4, OUTPUT);
  pinMode(s5, OUTPUT);
  pinMode(queueup, OUTPUT);
  pinMode(allisset, OUTPUT);
  pinMode(led, OUTPUT);
}
















void loop(){
  
  Anzeigen("Turmlabor ");
  
}












/*
XXXXX XXXXX XXXXX XXXXX XXXXX |168421
-----     -----     -----     |
*/

void Anzeigen(char* zeichen){
  for (int i=0; i<7; i++){
    rein[11]=(ASCII[zeichen[0] - 0x20][i])&0x1F;
    rein[10]=((ASCII[zeichen[1] - 0x20][i])&0x1F)>>1;    
    rein[9]=((((ASCII[zeichen[1] - 0x20][i])&0x1F)<<4)&0x10)+(((ASCII[zeichen[2] - 0x20][i])&0x1F)>>2);
    rein[8]=((((ASCII[zeichen[2] - 0x20][i])&0x1F)<<3)&0x18)+(((ASCII[zeichen[3] - 0x20][i])&0x1F)>>3);
    rein[7]=((((ASCII[zeichen[3] - 0x20][i])&0x1F)<<2)&0x1C)+(((ASCII[zeichen[4] - 0x20][i])&0x1F)>>4);
    rein[6]=(((ASCII[zeichen[4] - 0x20][i])&0x1F)<<1)&0x1E;
    
    rein[5]=(ASCII[zeichen[5] - 0x20][i])&0x1F;
    rein[4]=((ASCII[zeichen[6] - 0x20][i])&0x1F)>>1;    
    rein[3]=((((ASCII[zeichen[6] - 0x20][i])&0x1F)<<4)&0x10)+(((ASCII[zeichen[7] - 0x20][i])&0x1F)>>2);
    rein[2]=((((ASCII[zeichen[7] - 0x20][i])&0x1F)<<3)&0x18)+(((ASCII[zeichen[8] - 0x20][i])&0x1F)>>3);
    rein[1]=((((ASCII[zeichen[8] - 0x20][i])&0x1F)<<2)&0x1C)+(((ASCII[zeichen[9] - 0x20][i])&0x1F)>>4);
    rein[0]=(((ASCII[zeichen[9] - 0x20][i])&0x1F)<<1)&0x1E;
    digitalWrite(led, HIGH);
    for (int j=0; j<12 ; j++){
      digitalWrite(queueup, LOW);
      if ((rein[j]&0x10)==0x10) digitalWrite(s1,LOW);
      if ((rein[j]&0x10)==0x00) digitalWrite(s1,HIGH);
      if ((rein[j]&0x08)==0x08) digitalWrite(s2,LOW);
      if ((rein[j]&0x08)==0x00) digitalWrite(s2,HIGH);
      if ((rein[j]&0x04)==0x04) digitalWrite(s3,LOW);
      if ((rein[j]&0x04)==0x00) digitalWrite(s3,HIGH);
      if ((rein[j]&0x02)==0x02) digitalWrite(s4,LOW);
      if ((rein[j]&0x02)==0x00) digitalWrite(s4,HIGH);
      if ((rein[j]&0x01)==0x01) digitalWrite(s5,LOW);
      if ((rein[j]&0x01)==0x00) digitalWrite(s5,HIGH);
      digitalWrite(queueup, HIGH);
      
    }
    digitalWrite(led, LOW);
    if (i>0){
      currentMillis = millis();
      while(currentMillis - previousMillis > intervall){
        currentMillis = millis();
      }      
    }
    switch (i){
            case 0:
            break;
            case 1:
            digitalWrite(r1, LOW);
            break;
            case 2:
            digitalWrite(r2, LOW);
            break;
            case 3:
            digitalWrite(r3, LOW);
            break;
            case 4:
            digitalWrite(r4, LOW);
            break;
            case 5:
            digitalWrite(r5, LOW);
            break;
            case 6:
            digitalWrite(r6, LOW);
            break;
            
    }
    digitalWrite(allisset,HIGH);
    previousMillis=  currentMillis = millis();
    digitalWrite(allisset,LOW);
    switch (i){
            case 0:
            digitalWrite(r1, HIGH);
            break;
            case 1:
            digitalWrite(r2, HIGH);
            break;
            case 2:
            digitalWrite(r3, HIGH);
            break;
            case 3:
            digitalWrite(r4, HIGH);
            break;
            case 4:
            digitalWrite(r5, HIGH);
            break;
            case 5:
            digitalWrite(r6, HIGH);
            break;
            case 6:
            digitalWrite(r7, HIGH);
            break;
            
    }
  }
  unsigned long currentMillis = millis();
  while(currentMillis - previousMillis > intervall){
     unsigned long currentMillis = millis();
  }     
  digitalWrite(r7,LOW);
}

[frickler_01]

VIelen Dank für deine Hilfe, Asterix

JP1, JP2 und JP3 sind für den Arduino, oder?
Und die 7 Bausteine auf der Linken seite sind die BTS 432 E2, oder?

MfG frickler

[Asterix]

Genau. Hatten wir schon da.

Die Schaltung wurde gestern Nacht als Grillanzeige ausprobiert. ( mit besserem Code) die Helligkeit ließ leider zu wünschen übrig. Vllt. ist so ein Arduino für das Multiplexing zu langsam, oder mein Code zu grottenschlecht...

Ich berichte später nochmals, ob sich etwas verbessern ließ.

[Name vergessen]

Vllt. ist so ein Arduino für das Multiplexing zu langsam

Ja, ist er, bzw. die Bibliotheken, nicht der Prozessor. Was das arme Teil zum Setzen eines einzelnen Pins alles anstellen muß, ist grausam. Klar liegt das daran, daß der AVR die Pins eben nicht einzeln setzen kann, die Lib aber davon ausgehen muß, daß die restlichen Pins auf keinen Fall den Zustand wechseln dürfen. Also muß immer erst ausgelesen werden, dann das ganze, logisch mit dem neuen Wert verknüpft, neu gesetzt werden (es gibt zwar einen ASM-Befehl zum Setzen einzelner Bits, aber der macht intern auch nichts Anderes, allerdings trotzdem noch weniger als die Lib, die noch die Portzugehörigkeit und Modes abfangen muß - und das bei jedem einzelnen Bitset...). Ggfs. müssen dann noch Portkonfigurationen umgebastelt werden usw.. Macht man das selber, geht das erheblich schneller, denn man kann 1) die Pins so legen, daß man den Port nicht in verschiedenen Modi braucht, und 2) sich einfach die Zahl merken sowie 3) die passende logische Verknüpfung benutzen und 4) ggfs. alle möglichen Zahlen hardcoden, so daß man lediglich die passende Zahl in den Port zu schieben braucht, je nachdem, an welcher Programmstelle man gerade ist. Wenn man zudem die ganzen Register nicht braucht, kann man die Zahlen sogar bei Programmstart auf die Register verteilen und dann geht's ganz fix, einfach das passende Register in den Port treten und weitermachen. All diese Optimierungen kann die Lib aber nicht riskieren, da sie halt nicht weiß, wie und wann der Port noch benutzt wird.

IOW, ein Arduino-Sketch ist gut, um mal eben Kram zum laufen zu bringen, aber für die Bequemlichkeit zahlt man mit erheblichen Geschwindigkeitseinbußen. Da man jeden Arduino aber auch in stinknormalem AVR-Assembler programmieren kann, kann man das trotzdem prima als allgemeines Entwicklungsboard nutzen - man muß halt wissen, was man braucht und ggfs. die Sprache wechseln.

[Nicki]

Zum Arduinopreis gibts aber schon gute ARM-μCs, z.B. den STM32F103, der ist fast 5* schneller.
Den zu programmieren ist anfangs etwas umständlich, wenn mans aber mal gelernt hat gehts gut, die Tutorials sind nicht zu unterschätzen.

[Name vergessen]

Der soll ja auch nicht für jedes Projekt einen neuen Arduino kaufen, sondern den fertig programmierten Prozessor rausnehmen, ins Zielgerät stopfen und einen neuen in das Arduinoboard stecken. Dann muß man nämlich nur einmal den Bootloader über ISP in den neuen AVR stecken und kann danach wieder gemütlich über USB zugreifen. Außerdem kommt dann immer ein neuer Prozessor in den Sockel, der nicht schon durch tausende Flashzyklen vorgeschädigt ist. Das verwendete Assembler ist derselbe, und wenn der Arduino, wie hier, nun schonmal vorliegt und (mit der richtigen Programmiersprache) auch locker ausreicht, warum dann noch einen µC kaufen, der dann zusätzlich zur nicht vorhandenen Erfahrung mit Assembler noch mit Fusebits und einem Selbstbau-ISP-Programmer sowie einer passenden "Drumrum"-Platine zig zusätzliche Anfängerfallen bereitstellt? IMO ist ein Arduino als Entwicklungsboard anzusehen, und im Vergleich zu anderen Entwicklungsboards ist das ziemlich preiswert.

[Fritzler]

Wie sieht eigentlich die Ansteuerung der Zeilen aus?
Bei Multiplexing brauchts da gut Überstrom und da es gut Strom zieht externe FETs.
Also zeichmal

Lektüre (theorie):
http://www.fritzler-avr.de/HP/tipps/multi.php

Hier dann nochmal mit Igor mehr Strom erklärt:
http://www.fritzler-avr.de/HP/ledscreen.php