Go Down

Topic: Mein Arduino verträgt ein kleines Stück meines Programms nicht (Read 924 times) previous topic - next topic

MagicSmoke

Code: [Select]
void umwandeln()
{
 
 laengenanzeige2=0;
 for (int i=0; i<laengenanzeige; i++)
 {




   if (Position[i]==1){
     for (int n=0; n<7; n++){
       Position2[laengenanzeige2+n]=27+n;
     }
     laengenanzeige2=laengenanzeige2+7;
   }


   if (Position[i]==2){
     for (int n=0; n<7; n++){
       Position2[laengenanzeige2+n]=34+n;
     }
     laengenanzeige2=laengenanzeige2+7;
   }


   if (Position[i]==3){
     for (int n=0; n<15; n++){
       Position2[laengenanzeige2+n]=41+n;
     }
     laengenanzeige2=laengenanzeige2+14;
   }


   if (Position[i]==4){
     for (int n=0; n<15; n++){
       Position2[laengenanzeige2
       +n]=55+n;
     }
     laengenanzeige2=laengenanzeige2+14;
   }
 }
 
 Serial.println("umwandeln");
 {
     for(int i=0;i<laengenanzeige2;i++){


       Serial.print(Position2[i],DEC);
       Serial.print(",");
     }

   }
}


Also der oben genannte Code soll einfach eine kleine aufgabe ausführen.
Ich habe ein Array mit den Zahlen 1-4 in dem Array Position.
die Anzahl der im Array gespeicherten zahlen ist in laengenanzeige gespeichert.

wenn jetzt im array die zahl 1 ist, soll im array Position2 die zahlen 27, 28,29,30,31,32,33 gespeichert werden und laengenanzeige2 ssoll um 7 addiert werden.

bei einer 2 sollen die zahlen 34-40 gespeichert werden; laengenanzeige2   +7

bei einer 3 41-54; laengenanzeige2  +14

bei einer 4   55-68; laengenanzeige2 +14


also mal ein beispiel:

Wenn Posoition[]={3,1};
laengenanzeige=2;

dann soll dies gespeichert werden.

Position2[]={41,42,43,44,45,46,47,48,49,50,51,52,53,54,27,28,29,30,31,32,33}
und laengenanzeige2= 21.

allerdings klappt dies überhaupt nicht.  ich schicke mir den inhalt des arrays zur kontrolle über serial.println() und es kommt nonstop dieses zeichen  þ  .
Könnt ihr mir helfen. Wenn ihr nicht versteht, was ich hier wwill, dann schreibt mich ruhig an. Danke im Voraus!!!!!!!!

mde110

Bitte gesamten Sketch.

Code: [Select]
if (Position[i]==4){
     for (int n=0; n<15; n++){
       Position2[laengenanzeige2
       +n]=55+n;
     }


Position2[laengenanzeige2
       +n]=
55+n;


Was ist das für ein Zeilenumbruch?

Was gibt der Monitor aus, wenn du das Array vor dem bearbeiten ausgibst?

nussecke


Bitte gesamten Sketch.


Ich würd mal glatt aufn falsch initialisierten Array Position 2 tippen, da sich die Länge dieses Arrays ja beliebig ändern kann.

jurs

Wie sind die Arrays deklariert und wie gross können sie maximal werden?
Byte- oder Integer-Zahlen?

Position1 maximal 4 Zahlen lang, also
byte Position1[4];
??

Und das andere Array entsprechend 7+7+14+14= 42 Zahlen lang?
byte Position2[42];
??

nussecke


Wie sind die Arrays deklariert und wie gross können sie maximal werden?
Byte- oder Integer-Zahlen?

Position1 maximal 4 Zahlen lang, also
byte Position1[4];
??

Und das andere Array entsprechend 7+7+14+14= 42 Zahlen lang?
byte Position2[42];
??



könnte ja auch  Position 1 = {2,2,2,2,4,1,2,1...} sein wenn ichs richtig verstanden hab, da ja nich die Länge vorgegeben ist sondern nur der Inhalt.. oder hab ichs nicht gerafft :D

MagicSmoke


Bitte gesamten Sketch.

Code: [Select]
if (Position[i]==4){
      for (int n=0; n<15; n++){
        Position2[laengenanzeige2
        +n]=55+n;
      }


Position2[laengenanzeige2
        +n]=
55+n;


Was ist das für ein Zeilenumbruch?

Was gibt der Monitor aus, wenn du das Array vor dem bearbeiten ausgibst?
der umbruch war ein schribfehler,den ich beim posten zu  spät gesehen habe.
es kommen die zaahlen 1,2,3,4 raauss. oder 3,2,3,4,1,1,2 als beispiel

Wie sind die Arrays deklariert und wie gross können sie maximal werden?
Byte- oder Integer-Zahlen?

Position1 maximal 4 Zahlen lang, also
byte Position1[4];
??

Und das andere Array entsprechend 7+7+14+14= 42 Zahlen lang?
byte Position2[42];
??


int laengenanzeige=4;
int laengenanzeige2;
unsigned char Position[1000]={4,2,1,3};
unsigned char Position2[1000]; 
die 4,2,1,3 ist jetzt einfach nur zufall


Wie sind die Arrays deklariert und wie gross können sie maximal werden?
Byte- oder Integer-Zahlen?

Position1 maximal 4 Zahlen lang, also
byte Position1[4];
??

Und das andere Array entsprechend 7+7+14+14= 42 Zahlen lang?
byte Position2[42];
??



könnte ja auch  Position 1 = {2,2,2,2,4,1,2,1...} sein wenn ichs richtig verstanden hab, da ja nich die Länge vorgegeben ist sondern nur der Inhalt.. oder hab ichs nicht gerafft :D
exakt richtig. aber ich werde praxisbedingt nicht mehr als 20 zahlen in Position haben

Serenifly

Ohne das jetzt groß zu analysieren, kann es leicht sein dass er dir da mal über die Array-Grenzen schreibt oder liest. Lass dir vielleicht mal deine Index-Variablen mit ausgeben.

mde110

Den gesamten Sketch bitte. Ich Stückle mir deinen Code aus den Fetzen nicht zurecht, das benötigt nur unnötige extra Zeit...

jurs


unsigned char Position[1000]={4,2,1,3};
unsigned char Position2[1000];  
...
exakt richtig. aber ich werde praxisbedingt nicht mehr als 20 zahlen in Position haben


In Position2 sind dann aber 7 bis 14 mal so viele Zahlen enthalten wie in Position, d.h. vom ungünstigsten Fall ausgehend muss Position2 14mal größer definiert werden.

Code: [Select]

#define MAXZAHLEN 20
unsigned char Position[MAXZAHLEN]={4,2,1,3};
unsigned char Position2[MAXZAHLEN*14];  


Du bist sicher, dass Du Position2 im Programmverlauf so RAM-speicherverbrauchend als Array benötigen wirst und dass es nicht ausreicht, eine Funktion zu haben, die einen nach dem anderen Wert ausrechnen und zurückliefern kann, weil Du den Zugriff sowieso immer nur fortlaufend benötigst? Du benötigst also wirklich wahlfreien Zugriff, vorwärts, rückwärts und zu jedem Zeitpunkt auf jedes beliebige Element von Position2? Wenn nicht, und ein fortlaufender Zugriff reicht, könnte man es viel speichersparender als Funktion machen.

Anyway, Test-Sketch:
Code: [Select]

#define MAXZAHLEN 20
unsigned char Position[MAXZAHLEN]={4,2,1,3};
int laengenanzeige=4;
unsigned char Position2[MAXZAHLEN*14]; 
int laengenanzeige2;

void padd (int &laenge, byte startwert, byte anzahlwerte)
// Werte ab startwert in Array einfügen
{
  for (byte i=0;i<anzahlwerte;i++)
  {
    Position2[laenge]=startwert+i;
    laenge++;
  }
}

int calculatePos2()
{
  int neuelaenge=0;
  memset(Position2,0,sizeof(Position2));
  for (int i=0;i<laengenanzeige;i++)
  {
    switch (Position[i])
    {
      case 1: padd(neuelaenge,27,7);break;
      case 2: padd(neuelaenge,34,7);break;
      case 3: padd(neuelaenge,41,14);break;
      case 4: padd(neuelaenge,55,14);break;
    }
  }
  return neuelaenge;
}

void setup() {
  Serial.begin(9600);
  // Berechnen
  laengenanzeige2=calculatePos2();
  // Ausgeben
  for (int i=0;i<laengenanzeige2;i++)
  {
    Serial.print("Position2[");
    Serial.print(i);
    Serial.print("]=\t");
    Serial.println(Position2[i]);
  }
  Serial.println("Fertig.");
}

void loop() {
  // put your main code here, to run repeatedly:
 
}

uwefed

MagicSmoke ich finde es einfach eine Frechheit von Dir, um Hilfe zu bitten, aber dem mehrfaches Bitten, den gesamten Sketch zu posten, nicht nachzukommen. Wieso glaubst Du denn, daß der Fehler in dem von Dir ausgesuchten Sketchschnipseln ist?
Grüße Uwe Federer
Moderator.

MagicSmoke

Code: [Select]
#include <avr/pgmspace.h>
#define kat1 13 // kata ist Basis des Transistors für Ebene a (unten) katg Basis Ebene oben
#define kat2 12
#define kat3 11
#define kat4 10
#define kat5 9
#define kat6 8
#define kat7 7
#define ser 3// serielle Datenkabel
#define sck 4 // Serielle Clock
#define rck 5 // Clock zum Schiebens ins Ausgangsregister
#define flacker 1500
int time;
boolean animation=0;
int Animation[]={
  27,33,7,34,40,7,41,54,14,55,68,14};
int E1 [7];
int E2 [7];
int E3 [7];
int E4 [7];
int E5 [7];
int E6 [7];
int E7 [7];
int i=0;
unsigned int platz;
int maxbild=68;
int empfangen = 0;
unsigned long Tempo;
unsigned long Tempo2;
int neu=0;
int maxlaenge =1000;
int laenge=0;
int laengenanzeige;
int laengenanzeige2;
unsigned char Position[100];
unsigned char Position2[1000
];
prog_uchar  PROGMEM data[]={
  // Blank
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
  B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, //0

};



void setup(){
  for (int i = 0; i <20; i++)
  {
    pinMode(i, OUTPUT);
    digitalWrite(i,0);
  }
  Serial.begin(9600);
}



void loop()
{
  recieve();   
  for(int i=0;i<laengenanzeige;i++){


    Serial.print(Position[i],DEC);
    Serial.print(",");
  }


  Serial.println(" ");
  Serial.println(laengenanzeige,DEC);
  Serial.println(animation,DEC);
main_prog:

 
  if(animation==1)
  {
 
  umwandeln();
 
  }
 

  {
    for (int i =0; i<laengenanzeige; i++)
    {
      platz=Position[i];

      info();


      for(int j=0; j<20;j++)
      {
        shift();
      }
      delay(50);
    }
  }





  Tempo2=millis();
  do{
    if(Serial.read()==35)
    {
      recieve();
    }
  }

  while((millis()-Tempo2) < 4000);

  goto main_prog;
}


void info ()
{


  for( int h = 0; h<8; h++){
    E1[h] = pgm_read_byte_near((platz*49)+data+h);
  }
  for( int h = 0; h<8; h++){
    E2[h] = pgm_read_byte_near((platz*49)+data+7+h);
  }
  for( int h = 0; h<8; h++){
    E3[h] = pgm_read_byte_near((platz*49)+data+14+h);
  }
  for( int h = 0; h<8; h++){
    E4[h] = pgm_read_byte_near((platz*49)+data+21+h);
  }
  for( int h = 0; h<8; h++){
    E5[h] = pgm_read_byte_near((platz*49)+data+28+h);
  }
  for( int h = 0; h<8; h++){
    E6[h] = pgm_read_byte_near((platz*49)+data+35+h);
  }
  for( int h = 0; h<8; h++){
    E7[h] = pgm_read_byte_near((platz*49)+data+42+h);
  }





}


void shift () // ins Shiftregister reinschieben
{

  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E7[f]);
  } // schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat1, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat1 , LOW);


  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E6[f]);
  } // schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat2, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat2 , LOW);


  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E5[f]);
  } // schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat3, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat3 , LOW);   


  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E4[f]);
  } // schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat4, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat4 , LOW);



  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E3[f]);
  } // schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat5, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat5 , LOW); 


  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E2[f]);
  }// schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat6, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat6 , LOW);


  for (int f = 7 ;f > -1; f--)  //zähler der einzelnen B000 teile einer ebene
  {
    shiftOut (ser,sck,LSBFIRST,E1[f]);
  }// schriebt ein B0000 info raus. Die letzte mit LSB zuerst
  digitalWrite(rck,1);
  delayMicroseconds(1);
  digitalWrite(rck,0);
  digitalWrite(kat7, HIGH);   
  delayMicroseconds(flacker);
  digitalWrite(kat7 , LOW);

}

void umwandeln()
{
 
  laengenanzeige2=0;
  for (int i=0; i<laengenanzeige; i++)
  {




    if (Position[i]==1){
      for (int n=0; n<7; n++){
        Position2[laengenanzeige2+n]=27+n;
      }
      laengenanzeige2=laengenanzeige2+7;
    }


    if (Position[i]==2){
      for (int n=0; n<7; n++){
        Position2[laengenanzeige2+n]=34+n;
      }
      laengenanzeige2=laengenanzeige2+7;
    }


    if (Position[i]==3){
      for (int n=0; n<15; n++){
        Position2[laengenanzeige2+n]=41+n;
      }
      laengenanzeige2=laengenanzeige2+14;
    }


    if (Position[i]==4){
      for (int n=0; n<15; n++){
        Position2[laengenanzeige2
        +n]=55+n;
      }
      laengenanzeige2=laengenanzeige2+14;
    }
  }
 
  Serial.println("umwandeln");
  {
      for(int i=0;i<laengenanzeige2;i++){


        Serial.print(Position2[i],DEC);
        Serial.print(",");
      }

    }
}

void recieve()
{
  if (empfangen ==0)
  {
    Serial.flush();
    do {                                              // Zeichen von serieller Schnittstelle empfangen
      if (Serial.available()) {       
        Position[laenge] = Serial.read();
        if (Position[laenge] == 32) Position[laenge]=0;   
        if (Position[laenge] >64 && Position[laenge]<91) {

          Position[laenge] = Position[laenge]-64;   
        }
        if (Position[laenge] >96 && Position[laenge]<123) {
          Position[laenge] = Position[laenge]-96;   
        }


        animation=0;
        laenge++;
        neu=1;
        empfangen =1;

        laengenanzeige=laenge;
      }     
      //else goto main_prog;
      if(laenge<1)Tempo = millis();   

    }
    while (laenge<maxlaenge && (millis()-Tempo) < 4000);
    laenge=0;
    if(Position[laengenanzeige-1]==35)
    {
      animation=1;
      laengenanzeige=laengenanzeige-1;
    }
    if(neu==1){
      for(int i=0;i<laengenanzeige;i++){


        Serial.print(Position[i],DEC);
        Serial.print(",");
      }

    }
    Serial.println(" ");
    Serial.println(laengenanzeige,DEC);
    Serial.println(animation,DEC);

    neu=0; 
    Tempo=0;
    empfangen=0;
    Serial.flush();   
  }
  delay(20);
}







ich habe mir mal erlaubt den progmem zu kürzen.
ich habe mal die beiden arrays verkleinert. Das war wirklich weil der Ram zu voll war.Dankescön an denjenigen, der mir den Tipp gegeben hat. und für die Leute die den Code haben wollten.
Im progmem sind die einzelnen bilder für meinen LED Würfel gespeichert. In Position ist der Platz gespeichert, an dem ich das bild im progmem gespeichert habe.
in info hole ich die bilder in die arrays für die ebenen, in shift schiebe ich die informationen in die schieberegister.

jetzt wirds interessant. In recieve hole ich mir die Buchstaben oder animation. ich habe dort das so gedreht, dass A und a in 1 umgewandelt werden, b und B in 2 usw. (siehe ASCII Tabelle) im loop habe ich eingebaut, dass nachdem alle bilder angezeigt wurden gecheckt wird, ob ich ein # zeichen eingesendet habe. wenn ja, wird erneut die funktion recieve aktiviert.

Wenn ich ne animation starten will, dann schreibe ich den buchstaben der animation(animation 1 ist a; animation 2 ist b) und am ende ein #. dann soll der obengenennte code" umwandeln()" die buchstaben der animation in die einzelbilder der animation zerlegen. Also animation a hat die einzelbilder 27-33 usw.

ES TUT MIR ÜBERIGENS LEID, DASS ICH EUCH NICHT SOFORT DEN CODE GESENDEHABE, ABER ICH HATTE FREITAG ABEND WAS ANDERS VOR.

MagicSmoke

Generell ein dickes Dankeschön, an alle, die sich wegen mir mühe gemacht haben... :smiley-eek-blue:

Go Up