Daten aus zweidimensinoalen Array versenden

[Steff G. (steff_123)]

Hallo Leute,

ich bin seit ein paar Stunden am rumtüfteln, aber ich komm auf keinen 
grünen Zweig.

Hintergrund:
Ein DC-Motor (inkl. Encoder) wird mit einer konstanten Drehzahl 
gesteuert und es wird die Zeit zwischen zwei auftretenden Flanken 
bestimmt.

Der Zyklus wird i mal durchlaufen und es soll nacheinander die Differenz 
der beiden Zeitwerte (int) in ein zweidimensionales Array FELD 
geschrieben werden und später via UART an den PC geschickt werden.

Wenn ich das ganze mit nur einem Prüfzyklus probieren und somit nur ein 
eindimensionales Array habe, dann klappt das wunderbar.
Sobald ich aber ein mehrdimensionales Array verwende spuckt er mir am 
Terminalprogramm nur "Schrott" raus.

Das zweidimensionale Array habe ich mal mit von der Größe her so 
angenommen, damit es fürs erste von der Größe her passt.

Mein Codeausschnitt:

...
int Feld [2][2000] = {0};

for (int i=0;i<Anzahl;i++)
   {
    OCR1AL = n_soll[i];      // Motor ansteuern
    RESET_T4();
    RESET_T5();
    RESET_T3();
    k=0;      // Laufindex zum Beschreiben der Drehzahldaten
    
    
    while (counter4_OVERFLOW < Zeit[i]*5)    // Zeitdauer Zeit[i] des i-ten Prüfzykluses
    {
      
      if(counter5_OVERFLOW >= 2) // alle 20ms
      {
        diff_time = (counter2 - counter1);         
        Feld[i][k] = diff_time;                  // Ablegen der Zeitdifferenz im Drehzahlarray Feld
        k++;
        counter5_OVERFLOW = 0;
      }
      
    }
    y_dat[i] = k;                    // Anzahl der vorhandenen Drehzahl des i-ten Prüfzykluses in y_dat ablegen
    
  }
  
OCR1AL = 0; // Abbremsen des Motors

int gogo = Feld[0][0];

uart_puts( "N\n" );
char buffer1 [20];
itoa(gogo,buffer1, 10);
uart_puts(buffer1);
uart_puts( "\n" );

...

ISR(TIMER4_COMPA_vect) // Overflows Zeitdauer
{
  counter4_OVERFLOW++;
}

ISR(TIMER5_COMPA_vect) // Overflows Regelung
{
  counter5_OVERFLOW++;
}

ISR(INT0_vect) // Impulse zum detektieren der Zeitabschnitte
{
  counter1=counter2;
  counter2=TCNT3;
}

Bitte um Hilfe.

[Steff G. (steff_123)]

Evtl. sollte ich meine Frage ein bisschen verkürzen:

Wenn meine erhaltenen Daten in ein eindimensionales Array geschrieben 
werden, dann werden die Werte richtig an die UART Verbindung ausgegeben.

Sobald ich jedoch die Werte in ein zweidimensionales Array packe, 
bekomme ich nur noch wirres Zeug raus.

Wäre um jede Hilfe dankbar.

[guest (Gast)]

Steff G. schrieb:
> Evtl. sollte ich meine Frage ein bisschen verkürzen:

Eventuell solltest Du nicht nur irgendwelche sinnlosen Fragmente posten!
Z.B. welchen Wert hat 'Anzahl'? Wenn das >2 ist hast Du schon verloren.

[PittyJ (Gast)]

Ich blick da nicht durch.
Da wird doch kein Feld verschickt, sondern buffer1.
Ich sehe nicht wo da was aus dem Feld entnommen wird. ist doch immer nur 
0,0
Noch nie so konfusen Code gesehen, bzw mindestens 30 Jahre her.

Und was ist mit RESET_T2. Das vermisse ich auch.

[Wolfgang (Gast)]

Steff G. schrieb:
> Sobald ich aber ein mehrdimensionales Array verwende spuckt er mir am
> Terminalprogramm nur "Schrott" raus.

Was soll man mit der Fehlerbeschreibung anfangen?
Im Speicher sind die Daten immer linear angeordnet, d.h. dort liegt nur 
ein eindimensionales Array. Das kannst du einfach seriell übertragen und 
am Empfänger interpretierst du den Speicherinhalt wieder als Array. Da 
braucht man gar nicht groß rumzutricksen.

Wozu wurden eigentlich Pointer erfunden?

[genervt (Gast)]

in Zeile 21 steht das Semikolon an der falschen Stelle.

[Frank M. (ukw) (Moderator)]

Steff G. schrieb:
> int Feld [2][2000] = {0};

Hier werden schon mal knapp 8K RAM verballert.

Um welchen AVR handelt es sich?

[Walter K. (Gast)]

"...
y_dat[i] = k;
..."

Was ist das? Wofür ist das Array? Woher kommt das?

Und die Frage von Guest nach der Variable Anzahl ist ja auch berechtigt.

[fop (Gast)]

Hmmm... einiges an Quellcode - aber nicht das Senden des ganzen Arrays. 
Ich sehe nur, wie das erste Element des Arrays genommen wird, in Ascii 
gewandelt wird und dann gesendet wird. Da sollte es nun wirklich kaum 
Unterschiede machen, wie viele Dimensionen das Array hat.
In Sachen Senden muss ja nur die Zeile

int gogo = Feld[0][0];

 angepasst werden.
Füll Dein Array doch mal mit bekannten Konstanten, um zu sehen, ob das 
Messen oder das Senden Murks bauen - falls kein Debugger zur Hand, mit 
dem Du den Inhalt des Arrays anschauen kannst.

[Strukturdenker (Gast)]

Was stellen denn die Daten im 2-dimensionalen Feld Dar? Warum nicht in 
einem einzigen, n-mal grösseren, eindimensionalen Feld?

Warum ist das senden nicht in einer Funktion gekapselt?

Warum muss im selben Codeabschnitt mit der Datenstruktur, mit 
Peripherieregister und mit Timers gleichzeitig hantiert werden?

  Ein bisschen Schichtung und Abstraktion bekommt dem Code, der Denke 
und dem Codelesen sicher gut!

[Limi (Gast)]

- ein Trennzeichen für Spalten zB. ";"
- ein anderes Trennzeichen für Zeilen zB:"\r\n" (sind eigentlich zwei 
Zeichen, ein Windows-Rechner kommt damit besser klar)