steuerprogram ledmatrix hat fehler

[Mike B. (mike13579)]

hi ich habe ein Steuerprogramm für meine LEDMatrix geschrieben die 
Matrix ist 7zeilen hoch und 26zeilen breit. Die Matrix ist so gebogen 
das sie einen Kreis bildet, sollte aber trotzdem nicht anders 
funktionieren als wie wen sie plat wer.
mein Controller ist ein TAMEGA2560
die klemmen 14 bis 20 sind für die Zeilen die klemmen 21-46 für die 
spalten
das ist mein code:

//Bedinteil alles hier ist zu verendern und damit zu bedienen

//Lauftext
const int bewegen = true;   //lauftext ein aus
const int rechts = false;    //bewegungsrichtung lauftext false = links
const int wied = 50;        //bildwiederholung bis bewegung 100 ca. 1 sek.
const int textzeit = 2;      //anzeigedauer ein text, bei bewegung = anzahlrunden
//LED anzahl
const int ledzeile = 26;    // LEDs in der zeile 
const int ledspalte = 7;    // LEDs in der spalte (bei mehr als 7 ganz unten erweitern)
//Pins zuortnung
int ledzeilePins[] = { 
  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46 };   // pin nummern Zele
  
int ledspaltePins[] = { 
  14, 15, 16, 17, 18, 19, 20 };   // pin nummern Spalte
  
//Anzeige befüllen und stellenanzahl anpassen!!!
const int texte = 2; //anzahl te der texte die verwendet weden verwendung immer fon oben nach unten!!!
//1. text
int zeile1[] = { 
  HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };   //1. zeile HIGH an, LOW ab 
int zeile2[] = { 
  LOW, HIGH, LOW, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, LOW, LOW, LOW, HIGH, LOW, LOW, LOW, LOW, HIGH, HIGH, LOW, LOW };   //2. zeile HIGH an, LOW ab 
int zeile3[] = { 
  LOW, HIGH, LOW, LOW, HIGH, LOW, LOW, HIGH, LOW, HIGH, LOW, LOW, HIGH, LOW, LOW, LOW, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, LOW, HIGH, LOW };   //3. zeile HIGH an, LOW ab 
int zeile4[] = { 
  LOW, HIGH, HIGH, HIGH, HIGH, LOW, LOW, HIGH, HIGH, HIGH, LOW, LOW, HIGH, LOW, LOW, LOW, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, LOW, HIGH, LOW };   //4. zeile HIGH an, LOW ab 
int zeile5[] = { 
  LOW, HIGH, LOW, LOW, HIGH, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, HIGH, LOW, LOW, LOW, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, LOW, HIGH, LOW };   //5. zeile HIGH an, LOW ab 
int zeile6[] = { 
  LOW, HIGH, LOW, LOW, HIGH, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, HIGH, HIGH, HIGH, LOW, LOW, HIGH, HIGH, HIGH, LOW, LOW, HIGH, HIGH, LOW, LOW };   //6. zeile HIGH an, LOW ab 
int zeile7[] = { 
  HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };   //7. zeile HIGH an, LOW ab 
//2. text
int zeile8[] = { 
  HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };   //1. zeile HIGH an, LOW ab 
int zeile9[] = { 
  HIGH, HIGH, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW };   //2. zeile HIGH an, LOW ab 
int zeile10[] = { 
  HIGH, HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW };   //3. zeile HIGH an, LOW ab 
int zeile11[] = { 
  HIGH, HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW };   //4. zeile HIGH an, LOW ab 
int zeile12[] = { 
  HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW };   //5. zeile HIGH an, LOW ab 
int zeile13[] = { 
  HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW };   //6. zeile HIGH an, LOW ab 
int zeile14[] = { 
  HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };   //7. zeile HIGH an, LOW ab 
// bei weitern texten die gesamt zeilen unten erweitern!!!
//ab hier sind normalerweise keine enderrungen nötig (auser bei erweiterung) 
int beweg =0;
int text = 1;
int textplus =0;
void setup() {
  // Pins auf output setzen
  for (int thisLed3 = 0; thisLed3 < ledzeile; thisLed3++) {
    pinMode(ledzeilePins[thisLed3], OUTPUT);
    
  for (int thisLed4 = 0; thisLed4 < ledspalte; thisLed4++) {
    pinMode(ledspaltePins[thisLed4], OUTPUT);

  
  }
}
}
void loop() {
  //textwahl
    //rücksetzung textnummer
    if (text > texte){
    text = 1;
    }
    //textnummer auswerten
    text--;
    textplus = text * ledspalte;
    text++;
    
  //anzeigedauer bis text wechsel
  for (int textzeit1 = 0; textzeit1 < textzeit*ledzeile; textzeit1++) {  
    
  //laufrichtung
  if (bewegen == true && rechts ==true){      
  beweg = beweg + ledzeile - 1;
  }
  else if(bewegen == true && rechts ==false){
  beweg++;
  }
  else{
  beweg = 0;
  }
  //rüksetzung nach 1 umtrehung
  if(beweg > ledzeile ){
  beweg = beweg - ledzeile;
  }
  //bewegungszeitabschätzung
  for (int beweg2 = 0; beweg2 < wied; beweg2++) {
  int beweg1;  
  beweg1 = beweg;
  //darstellung erzeugen
  for (int thisLed1 = 0; thisLed1 < ledspalte; thisLed1++) {
       for (int thisLed2 = 0; thisLed2 < ledzeile; thisLed2++) {
        if (beweg1 + thisLed2 > ledzeile){
        beweg1 = beweg1 - ledzeile;
        } 
         if (thisLed1 + textplus == 0){ 
         digitalWrite(ledzeilePins[thisLed2],zeile1[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 1){
         digitalWrite(ledzeilePins[thisLed2],zeile2[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 2){
         digitalWrite(ledzeilePins[thisLed2],zeile3[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 3){
         digitalWrite(ledzeilePins[thisLed2],zeile4[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 4){
         digitalWrite(ledzeilePins[thisLed2],zeile5[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 5){
         digitalWrite(ledzeilePins[thisLed2],zeile6[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 6){
         digitalWrite(ledzeilePins[thisLed2],zeile7[thisLed2 + beweg1]); 
         } 
         else if(thisLed1 + textplus == 7){ 
         digitalWrite(ledzeilePins[thisLed2],zeile8[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 8){
         digitalWrite(ledzeilePins[thisLed2],zeile9[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 9){
         digitalWrite(ledzeilePins[thisLed2],zeile10[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 10){
         digitalWrite(ledzeilePins[thisLed2],zeile11[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 11){
         digitalWrite(ledzeilePins[thisLed2],zeile12[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 12){
         digitalWrite(ledzeilePins[thisLed2],zeile13[thisLed2 + beweg1]);
         }
         else if(thisLed1 + textplus == 13){
         digitalWrite(ledzeilePins[thisLed2],zeile14[thisLed2 + beweg1]); // bei zeilenanzahl heir erweiten ergenzung er aufsteigenden zahlen erforderlich!!!
         }
       }
       digitalWrite(ledspaltePins[thisLed1], HIGH);
       delay (1);
       digitalWrite(ledspaltePins[thisLed1], LOW);
  }
  }
  }
  text++;
}

nun ist es so das zunächst das Bild beziehungsweise die Anordnung der 
eingeschalteten LEDs richtig ist wen nun die Verschiebung (Lauftext) 
beginnt
scheint sich die letzte Zeile nach ganz oben zu bewegen und die anderen 
nachzurücken wobei nach der 1. Zeile an der stelle wo diese vorbei kommt 
das ganze wieder richtig erscheint bis die erste Zeile einmal im Greis 
herum kam dann beginnt die Verschiebung wieder neu.

danke schon mal im voraus

Gefundene Rechtschreibfehler dürfen behalten werden
(wie ging bei FIREFOX die Rechtschreibkorrektur an ?)

[Peter D. (peda)]

Also ich seh da nicht durch, mir ist das viel zu kompliziert.

Üblicher Weise trennt man einfach die Aufgaben:
D.h. ein Timerinterrupt macht allein nur das Multiplexen. Dazu gibt er 
aus einem Array die Bitmuster aus. Für ne 7*26 Matrix sind das 26 Byte 
(uint8_t).
Und das Main schreibt in dieses Array das anzuzeigende Bitmuster rein.

Sind Buchstaben darzustellen, benutzt man noch eine ASCII-Tabelle, d.h. 
das Main enthält die Zeichen im Klartext und die Tabelle wandelt diese 
in die entsprechenden Bitmuster (5*7 Zeichensatz) um.


Es ist auch sehr unüblich für Bits immer 16Bit-Variablen zu nehmen. 
Warum jedesmal 15 Bit ungenutzt verschwenden, das bläht nur unnötig den 
Code auf und kostet Zeit.

Und in C darf man auch Zeilen beliebig umbrechen. Ein Zeilenende hat in 
C keine Funktion (außer als Macro-Ende).
Nicht jeder hat einen 40Zoll-Monitor.


Peter

[Mike B. (mike13579)]

ich vergas zu erwehnen bin anfänger ich fersteh nur teilweise was du 
meinst gibt es irgendwo beispiel cods ?

[Mike B. (mike13579)]

könte mir bitte jemand erklähren wie das richtig geht oder wo ich das 
nachlessen kan .

[Thomas E. (thomase)]

Mike B. schrieb:
> Gefundene Rechtschreibfehler dürfen behalten werden

Da bist du auch noch stolz drauf?

Was deinen Code angeht: Alles markieren, Entf drücken, Speichern

mfg.

[Mike B. (mike13579)]

Thomas Eckmann schrieb:
>
> Was deinen Code angeht: Alles markieren, Entf drücken, Speichern

super Witz ich lach mal wen mir langweilig ist

>> Gefundene Rechtschreibfehler dürfen behalten werden

Rechtschreibung ist nicht meine stärke aber dafür gibt es 
Rechtschreibkorrekturen ich weiß aber nicht mehr wie man die in FIREFOX 
aktiviert.

was den Code an geht wies jemand wie ich wen ich ein DWORT also 32BIT 
als ein variable habe wie ich davon gezielt ein Bit auswählen kann und 
dieses da auf eine zuvor definierte klemme ausgebe also zum Beispiel wen 
das 3. Bit eine 0 ist das ich dann die klemme 13 auf 0 setzen kann und 
wen das 4. eine eins ist und ich dann die klemme 14 auf 1 setzen kann 
usw.
Das es da so Blöcke gibt die das wohl auch können hab ich gelesen das 
kann ich aber nicht benutzen klaube ich den  meine klemmen Belegung 
passt da nicht  oder kann man die auch irgendwie anpassen? Ich möchte 
meine klemmen nicht anders belegen.

[Wegstaben V. (wegstabenverbuchsler)]

> dafür gibt es Rechtschreibkorrekturen ich weiß aber nicht mehr
> wie man die in FIREFOX aktiviert.

da ist eine gute Anleitung dazu:

http://www.lmgtfy.com/?q=firefox+rechtschreibepr%C3%BCfung

[Thomas E. (thomase)]

Mike B. schrieb:
> Rechtschreibung ist nicht meine stärke aber dafür gibt es
>
> Rechtschreibkorrekturen ich weiß aber nicht mehr wie man die in FIREFOX
>
> aktiviert.

Dafür gibt es Deutschkurse und guten Willen.

[Lehrmann M. (ubimbo)]

Mike B. schrieb:
> Gefundene Rechtschreibfehler dürfen behalten werden

In diesem Forum disqualifiziert man sich mit sowas.

Mike B. schrieb:
> (wie ging bei FIREFOX die Rechtschreibkorrektur an ?)

Es ist ein ziemliches Armutszeugnis so einen Post abzugeben.  Wenn man 
nicht richtig schreiben kann, dann kann man das auch mit der 
Rechtschreibkorrektur nicht.

Ich muss dir ehrlich sagen, dass du hier keine Antwort bekommen wirst. 
Du gibst dir nicht die geringste Mühe und dann sehen wir auch nicht ein 
warum wir auch nur ein Quäntchen Arbeit in die Fehlersuche investieren 
sollten. In jedem Satz hagelt es nur so von Rechtschreibfehlern...

Die Grundsätze:

1. Schaltplan
2. Code leserlich machen (Array
3. eine vernünftige Fehlerbeschreibung (evtl. mit Video) - alleine für 
deine Fehlerbeschreibung brauche ich 5 Minuten um die zu dechiffrieren.
4. C vernpnftig lernen. Diese else-if sind nicht gerade schön. 
Stichwort: switch - case

zum Thema übersichtlich: warum nich angepasst à la:

buchstabe[][]{
{1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1},
{1,1,0,0,0,0,0,0},
{1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1},
{1,1,0,0,0,0,0,0},
{1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1}};

Das geübte Auge erkennt hier z.B. ein großes 'E' für eine 8x8 Matrix.

[Mike B. (mike13579)]

const int bewegen = true;   //Lauftext ein aus
const int rechts = false;    //Bewegungsrichtung Lauftext false = links
const int time = 200 ;      //Bildwiederholungen bis zur bewegung
const int ledzeile = 26;    // LEDs in der Zeile 
const int ledspalte = 7;    // LEDs in der Spalte
//Pins zuortnung
int ledzeilePins[] = { 
  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46 };   // pin nummern Zele
  
int ledspaltePins[] = { 
  14, 15, 16, 17, 18, 19, 20 };   // pin nummern Spalte
  
//Anzeige befüllen und stellenanzahl anpassen!!!
int zeile1[] = { 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile2[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile3[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile4[] = { 0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile5[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile6[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile7[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};


int beweg;
void setup() {
  // Pins auf output setzen
  for (int thisLed3 = 0; thisLed3 < ledzeile; thisLed3++) {
    pinMode(ledzeilePins[thisLed3], OUTPUT);
    
  for (int thisLed4 = 0; thisLed4 < ledspalte; thisLed4++) {
    pinMode(ledspaltePins[thisLed4], OUTPUT);
  }
}
}
void loop() 
{
  //laufrichtung
  if (bewegen == true && rechts ==true){      
  beweg = beweg + ledzeile - 1;
  }
  else if(bewegen == true && rechts ==false){
  beweg++;
  }
  else{
  beweg = 0;
  }
  //rüksetzung nach 1 umtrehung
  if(beweg > ledzeile ){
  beweg = beweg - ledzeile;
  }
  //bewegungszeitabschätzung
  for (int beweg2 = 0; beweg2 < time; beweg2++) 
  {
  int beweg1;  
  beweg1 = beweg;
  //darstellung erzeugen
     for (int Ledsenkrecht = 0; Ledsenkrecht < ledspalte; Ledsenkrecht++) 
     {
       for (int Ledwagerecht = 0; Ledwagerecht < ledzeile; Ledwagerecht++) 
       {
        if (beweg1 + Ledwagerecht > ledzeile)
        {
        beweg1 = beweg1 - ledzeile;
        } 
         switch(Ledsenkrecht)
        {
        case 0:digitalWrite (ledzeilePins[Ledwagerecht],zeile1[Ledwagerecht + beweg1]);
          break;
        case 1:digitalWrite (ledzeilePins[Ledwagerecht],zeile2[Ledwagerecht + beweg1]);
          break;
        case 2:digitalWrite (ledzeilePins[Ledwagerecht],zeile3[Ledwagerecht + beweg1]);
          break;
        case 3:digitalWrite (ledzeilePins[Ledwagerecht],zeile4[Ledwagerecht + beweg1]);
          break;
        case 4:digitalWrite (ledzeilePins[Ledwagerecht],zeile5[Ledwagerecht + beweg1]);
          break;
        case 5:digitalWrite (ledzeilePins[Ledwagerecht],zeile6[Ledwagerecht + beweg1]);
          break;
        case 6:digitalWrite (ledzeilePins[Ledwagerecht],zeile7[Ledwagerecht + beweg1]);
          break;
       
        default:;
        }
      }
      digitalWrite(ledspaltePins[Ledsenkrecht], HIGH);
      delay (1);
      digitalWrite(ledspaltePins[Ledsenkrecht], LOW);
    }
  }
}

Habe denn Code Optimiert damit er übersichtlicher ist hoffe ihr seht das 
auch so.
das Problem besteht jedoch immer noch die ersten 5 Verschiebungen sind 
verzert
das sieht dann etwa so aus :
erst so
000110
001001
001001
001001
001111
001001
101001
dann 2mal so
0110
0110
1001
1001
1111
1001
1001
dann so
0110
0010
1001
1101
1011
1001
1001
dann so
0110
1000
1001
1111
1001
1001
1001
danach wird es dann richtig angezeigt bis die anzeige einmal im Greis 
herum ist und es beginnt von neuem versteht das jemand ?

[Karl H. (kbuchegg)]

Mike B. schrieb:

> Habe denn Code Optimiert damit er übersichtlicher ist hoffe ihr seht das
> auch so.

NOch nicht ganz.
Deine Funktion loop() mit den ganzen beweg, beweg2, ledwaagrecht, 
ledsenkrecht und was weiß ich noch für Variablen, kommt mir extrem 
kompliziert vor.

Ich bin mir sehr sicher, dass man das auch um vieles einfacher schreiben 
kann.

Beim drüberlesen bin ich nicht davon überzeugt, dass deine Arrayzugriffe 
da alle richtig sind und nirgends über das Ende eines Arrays zugegriffen 
wird.

So würde ich die Sache angehen:

Zuerst mal schreib ich mir eine Funktion, die eine einzige Zeile 
ausgibt. Die Funktion bekommt die Zeilennummer und einen Offset 
übergeben. Aufgabe der Funktion ist es die entsprechende Zeile 
auszugeben. Das macht sie in 2 Schritten beginnend bei der ersten LED:
Der erste Schritt: vom Offset beginnend bis zum Ende der Zeile
Der zweite Schritt: vom Beginn der Zeile bis zum Offset


Durch erhöhen des Offsets kann man daher die Zeile entsprechend 
verschoben auf den LED darstellen.

Diese Funktion wird dann in einer zweite Funktion entsprechend oft mit 
unterschiedlichen Zeilennummern aufgerufen um das antsprechende Bild 
auszugeben.


(Wobei die ganze Ausgabe eigentlich in eine Interrupt Steuerung gehören 
würde, damit sie maximal regelmässig erfolgt)

[Mike B. (mike13579)]

Karl heinz Buchegger schrieb:
> So würde ich die Sache angehen:
>
> Zuerst mal schreib ich mir eine Funktion, die eine einzige Zeile
> ausgibt. Die Funktion bekommt die Zeilennummer und einen Offset
> übergeben. Aufgabe der Funktion ist es die entsprechende Zeile
> auszugeben. Das macht sie in 2 Schritten beginnend bei der ersten LED:
> Der erste Schritt: vom Offset beginnend bis zum Ende der Zeile
> Der zweite Schritt: vom Beginn der Zeile bis zum Offset
>
das verstehe ich jetzt nicht ganz was meinst du mit Offset, wie sieht so 
etwas aus ein kleine Beispiel wehre echt Super.

> Durch erhöhen des Offsets kann man daher die Zeile entsprechend
> verschoben auf den LED darstellen.
>
> Diese Funktion wird dann in einer zweite Funktion entsprechend oft mit
> unterschiedlichen Zeilennummern aufgerufen um das antsprechende Bild
> auszugeben.
>
erinnert mich irgendwie an das was ich da gemacht habe.

> (Wobei die ganze Ausgabe eigentlich in eine Interrupt Steuerung gehören
> würde, damit sie maximal regelmässig erfolgt)

das mit der Interrupt Steuerung hab ich nicht verstanden davon steht 
auch in dem Tutorien etwas drin 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

danke schon mal für jede weitere Antwort
MFG MIKE

ps bin halt noch Anfänger

[Thomas E. (thomase)]

Mike B. schrieb:
> mein Controller ist ein TAMEGA2560
>
> die klemmen 14 bis 20 sind für die Zeilen die klemmen 21-46 für die
>
> spalten

Was ist denn das für ein Board?
Und was sind die Klemmen?

Arduino Mega 2560?

mfg.

[Mike B. (mike13579)]

das hier :http://arduino.cc/en/Main/ArduinoBoardMega2560
und da oben ist ein Dreher drin auf dem Controller (ich mein das 
schwarze teil in der Mitte von dem Board)  steht ATMEGA2560

[Karl H. (kbuchegg)]

Mike B. schrieb:

> das verstehe ich jetzt nicht ganz was meinst du mit Offset, wie sieht so
> etwas aus ein kleine Beispiel wehre echt Super.

Ist ganz einfach

Das ist dein Zeilenarray (eines davon)

    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  ...
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

da stehen deine 0 und 1 drinnen

Der 'Offset' (ob man das Offset oder Startindex oder ... nennt, spielt 
keine Rolle) teilt dieses Array in 2 logische Teile

    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  ...
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
                                ^
                                |
                             Offset

beginnt man beim Offset auszugeben, bis zum Ende der Zeile, dann ist die 
erste LED abhängig vom Arrayelement mit der Nummer 7, die nächste von 8, 
die nächste von ....

Auf den Ausgängen erscheint das Array also so

    7   8   9   10  11  12  13  14    0   1   2   3   4   5   6
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    ^
    |
  Offset

legt man den Offset auf 8

    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  ...
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
                                    ^
                                    |
                                  Offset

dann wird auch das Array entsprechend anders an die Ausgänge ausgegeben

    8   9   10  11  12  13  14    0   1   2   3   4   5   6   7
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    ^
    |
  Offset

Der Offset sagt also nicht anderes aus, als ab wo, ab welcher Position 
eine Zeile auf die LED ausgegeben werden soll.

In Code

void WriteLine( int* zeile, int Spalte, int Offset )
{
  int i;
  int ledNr = 0;

  for( i = Offset; i < ledzeile; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[i] );

  for( i = 0; i < Offset; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[i] );

  digitalWrite(ledspaltePins[Spalte], HIGH);
  delay (1);
  digitalWrite(ledspaltePins[Spalte], LOW);
}

void WriteImage( int Offset )
{
  WriteLine( zeile1, 1, Offset );
  WriteLine( zeile2, 2, Offset );
  WriteLine( zeile3, 3, Offset );
  WriteLine( zeile4, 4, Offset );
  WriteLine( zeile5, 5, Offset );
  WriteLine( zeile6, 6, Offset );
  WriteLine( zeile7, 7, Offset );
}

Das macht IMHO genau dasselbe, was du da kompliziert mit deinen 
verschachtelten Schleifen versuchst zu bewerkstelligen.

>>
> erinnert mich irgendwie an das was ich da gemacht habe.

Ja es macht nichts anderes. Allerdings geordneter. Geordneter dadurch, 
dass ich nicht versuche alles in eine einzige innere Schleife zu 
quetschen. Der springende Punkt ist:
Du versuchst da einen Zähler über das Zeilenende wieder auf den 
Zeilenanfang laufen zu lassen und hast dich da irgendwo vertan.
Ich versuch das erst gar nicht, sondern akzeptiere, dass eine komplette 
Zeile in 2 Teile zerfällt, je nachdem wo die Ausgabe anfangen soll. 
Zuerst wird von der Anfangsstelle der verbleibende Rest dieser Zeile 
ausgegeben und dann hinten nach noch der Zeilenanfang.



PS: Ich denke in deinem letzten Code hat die Variable 'beweg' die 
Aufgabe die ich 'Offset' nenne. Ist aber schwer zu sagen, weil aus 
deinem Code nicht sehr gutb hervorgeht, welche Rolle beweg bzw. beweg2 
spielen und der Name der Variable ist nicht besonders hilfreich.

[Mike B. (mike13579)]

ich probiere das mal aus

[Mike B. (mike13579)]

:( leuchtet gar nichts mehr
habe das eingebaut was du geschrieben hast ist das so richtig ?

const int bewegen = true;   //Lauftext ein aus
const int rechts = false;    //Bewegungsrichtung Lauftext false = links
const int time = 200 ;      //Bildwiederholungen bis zur bewegung
const int ledzeile = 26;    // LEDs in der Zeile 
const int ledspalte = 7;    // LEDs in der Spalte
//Pins zuortnung
int ledzeilePins[] = { 
  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46 };   // pin nummern Zele
  
int ledspaltePins[] = { 
  14, 15, 16, 17, 18, 19, 20 };   // pin nummern Spalte
  
//Anzeige befüllen und stellenanzahl anpassen!!!
int zeile1[] = { 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile2[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile3[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile4[] = { 0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile5[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile6[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile7[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};


int beweg;
void setup() {
  // Pins auf output setzen
  for (int thisLed3 = 0; thisLed3 < ledzeile; thisLed3++) {
    pinMode(ledzeilePins[thisLed3], OUTPUT);
    
  for (int thisLed4 = 0; thisLed4 < ledspalte; thisLed4++) {
    pinMode(ledspaltePins[thisLed4], OUTPUT);
  }
}
}
void WriteLine( int* zeile, int Spalte, int Offset )
{
  int i;
  int ledNr = 0;

  for( i = Offset; i < ledzeile; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[i] );

  for( i = 0; i < Offset; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[i] );

  digitalWrite(ledspaltePins[Spalte], HIGH);
  delay (1);
  digitalWrite(ledspaltePins[Spalte], LOW);
}

void WriteImage( int Offset )
{
  WriteLine( zeile1, 1, Offset );
  WriteLine( zeile2, 2, Offset );
  WriteLine( zeile3, 3, Offset );
  WriteLine( zeile4, 4, Offset );
  WriteLine( zeile5, 5, Offset );
  WriteLine( zeile6, 6, Offset );
  WriteLine( zeile7, 7, Offset );
}

void loop() 
{WriteImage;


}

hab ich das so richtig gemacht oder muss man das anders machen ?

[Karl H. (kbuchegg)]

Mike B. schrieb:
> :( leuchtet gar nichts mehr

Denk immer drann: Ich hab nicht deine Hardware.
Ich kann das daher nicht testen, sondern muss blind schreiben.

Eine gewisse Skepsis bzw. mitdenken bei der Übernahme von Code ist daher 
immer angebracht.

[Karl H. (kbuchegg)]

Mike B. schrieb:

> void loop()
> {WriteImage;
>
>
> }

> hab ich das so richtig gemacht oder muss man das anders machen ?


Das kompiliert nicht mal

void loop
{
  int i;

  for( i = 0; i < ledzeile; ++i )
    WriteImage( i );
}

Wie du da jetzt deine Bewegung (mit Richtungsänderung) reinbaust, musst 
du entscheiden.

[Mike B. (mike13579)]

es Läuft danke an alle die mir geholfen haben
MFG MIKE
hier mein Code

const int bewegen = true;   //Lauftext ein aus
const int rechts = false;    //Bewegungsrichtung Lauftext false = links
const int time = 50 ;      //Bildwiederholungen bis zur bewegung
const int ledzeile = 26;    // LEDs in der Zeile 
const int ledspalte = 7;    // LEDs in der Spalte
//Pins zuortnung
int ledzeilePins[] = { 
  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46 };   // pin nummern Zele
  
int ledspaltePins[] = { 
  14, 15, 16, 17, 18, 19, 20 };   // pin nummern Spalte
  
//Anzeige befüllen und stellenanzahl anpassen!!!
int zeile1[] = { 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile2[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile3[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile4[] = { 0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile5[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile6[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int zeile7[] = { 0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};


int beweg;
void setup() {
  // Pins auf output setzen
  for (int thisLed3 = 0; thisLed3 < ledzeile; thisLed3++) {
    pinMode(ledzeilePins[thisLed3], OUTPUT);
    
  for (int thisLed4 = 0; thisLed4 < ledspalte; thisLed4++) {
    pinMode(ledspaltePins[thisLed4], OUTPUT);
  }
}
}
void loop()
{ 
  
  int i;
  if (bewegen == true && rechts ==true){      
  for( i = ledzeile; i > 0; --i )
    WriteImage( i );
  
  }
  else if(bewegen == true && rechts ==false){
  for( i = 0; i < ledzeile; ++i )
    WriteImage( i );
  }
  else{
  i = 0;
  
  
    WriteImage( i );
  }
}

void WriteLine( int* zeile, int Spalte, int Offset )
{
  int i;
  int ledNr = 0;
  for( i = Offset; i < ledzeile; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[i] );
  for( i = 0; i < Offset; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[i] );
  digitalWrite(ledspaltePins[Spalte], HIGH);
  delay (1);
  digitalWrite(ledspaltePins[Spalte], LOW); 
}

void WriteImage( int Offset )
{
  for( int timer =0; timer < time;timer++){
  WriteLine( zeile1, 0, Offset );
  WriteLine( zeile2, 1, Offset );
  WriteLine( zeile3, 2, Offset );
  WriteLine( zeile4, 3, Offset );
  WriteLine( zeile5, 4, Offset );
  WriteLine( zeile6, 5, Offset );
  WriteLine( zeile7, 6, Offset );
}
}

[Peter D. (peda)]

Mike B. schrieb:
> es Läuft

Es könnte sich trotzdem lohnen, nicht so verschwenderisch mit Speicher 
umzugehen, er könnte Dir sonst schnell ausgehen, wenn das Programm noch 
mehr machen soll.

Dein Zeilenspeicher belegt ja schon 364 Byte, nötig sind aber nur 26 
Byte.


Peter

[Mike B. (mike13579)]

wen ich aufspiele steht da das hier
Binary sketch size: 2910 bytes (of a 258048 byte maximum)
das aber auch erst seit dem ich die werte für die anzeige im boolean 
habe im int
steht dann da :
Binary sketch size: 3616 bytes (of a 258048 byte maximum)

aktueller code (für lange Texte kann man wahrscheinlich noch länger 
machen ich werde nur das Gefühl nicht los das ich bei dieser Art der 
Zeilen Verlängerung Rechenleistung und Zeit verschenke ich denke ich 
sollte eine weitere variable benutzen um die Länge der anzeige von der 
Länge des anzuzeigenden Inhaltes zu trennen, das werde ich morgen mal 
ausprobieren):

const int bewegen = true;   //Lauftext ein aus
const int rechts = false;    //Bewegungsrichtung Lauftext false = links
const int time = 30 ;      //Bildwiederholungen bis zur bewegung
const int ledzeile = 100;    // LEDs in der Zeile 
const int ledspalte = 7;    // LEDs in der Spalte
//Pins zuortnung
int ledzeilePins[] = { 
  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,47,47 ,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 ,47,47,47,47,47,47,47,47,47,47,47 };   // pin nummern Zele
  
int ledspaltePins[] = { 
  14, 15, 16, 17, 18, 19, 20 };   // pin nummern Spalte
  
//Anzeige befüllen und stellenanzahl anpassen!!!
boolean zeile[][100]= {
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
{0,1,0,0,1,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,0,1,1,1,0,0,1,1,1,0,0,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,1,0,0,1,0,1,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,1,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,0,1,1,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0},
{0,1,0,0,1,0,1,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,1,0,0,1,0,1,0,0,1,0,1,1,1,0,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}};

int beweg;
void setup() {
  // Pins auf output setzen
  for (int thisLed3 = 0; thisLed3 < ledzeile; thisLed3++) {
    pinMode(ledzeilePins[thisLed3], OUTPUT);
  for (int thisLed4 = 0; thisLed4 < ledspalte; thisLed4++) {
    pinMode(ledspaltePins[thisLed4], OUTPUT);
  }
}
}
void loop()
{ 
  int i;
  if (bewegen == true && rechts ==true){      
  for( i = ledzeile; i > 0; --i )
    WriteImage( i );
  }
  else if(bewegen == true && rechts ==false){
  for( i = 0; i < ledzeile; ++i )
    WriteImage( i );
  }
  else{
  i = 0;
  WriteImage( i );
  }
}
void WriteLine( int Spalte, int Offset )
{
  int i;
  int ledNr = 0;
  for( i = Offset; i < ledzeile; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[Spalte][i] );
  for( i = 0; i < Offset; ++i )
    digitalWrite( ledzeilePins[ledNr++], zeile[Spalte][i] );
  digitalWrite(ledspaltePins[Spalte], HIGH);
  delay (1);
  digitalWrite(ledspaltePins[Spalte], LOW); 
}
void WriteImage( int Offset )
{
  for( int timer =0; timer < time;timer++){
  WriteLine( 0, Offset );
  WriteLine( 1, Offset );
  WriteLine( 2, Offset );
  WriteLine( 3, Offset );
  WriteLine( 4, Offset );
  WriteLine( 5, Offset );
  WriteLine( 6, Offset );
}
}