mikrocontroller.net

Forum: Compiler & IDEs double-konvertierung von 2d Feld


Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Leute!

Folgendes:

Schicke aus MATLAB einen String (mit RS232) an einen Mega32 in der Form: 
A1.23455"2.34565"3.45678"3.67988"9.34827"3.23478"Z.
Die Zahlen sind nur Beispiele, ihr seht es sollen also 6 double Werte 
interpretiert werden. 'A' und 'Z' fungieren als "Erkennungszeichen" 
(Anfang, Ende) das '"' dient als Trennungszeichen.

Unten also der Code (klappt alles) aber hier kurz das Problem (ohne 
Bezug zum Code) formuliert:

Ich habe ein 2d Feld z.B
char array[10][10].
ich möchte nun dieses in das Array
double werte[10]
 wandeln.

Hätte ich folgendes
char array = "1.23456"
 geht die problemlos mit
*tempPtr = array;
double wert;
wert = atof(tempPtr);

Aber wie mit einem [m]x[n] array ?

Nach langem Lesen und rumprobieren hab ich nichts gefunden, deshalb 
dacht ich, ich frag mal.....
Alternativ könnte ich im Code (in der Interrupt Funktion oder auch in 
Main) ein switch case Geschichte schreiben und jeden einzelnen double 
Wert dann in eine eingene Variable konvertieren, da ich aber in 
Anschluss noch ne Menge Code brauche möchte ich so speichersparsam wie 
möglich schreiben.
(Wie es einem Anfänger wie mir nur eben möglich ist) ;)

Also schon mal danke fürs anlesen und

viele Grüße !



Realisiert habe ich das folgendermaßen:

(stelle nur den für das Problem wesentlichen Code hinein...)

UDR RX Complete IR Funktion:
//Uart Empfang abgeschlossen. Interrupt Funktion. Wird jedes mal aufgerufen, wenn Zeichen empfangen....
ISR(USART_RXC_vect)
{
  //udr schützt/speichert den aktuellen Inhalt des Empfangsregisters UDR... 
  udr = UDR;
  puffer[i] = udr;
  i=i+1;
}

der Inhalt von puffer[i] wird in main dann folgendermaßen verarbeitet:
//Falls "Abschlusszeichen"
if(udr=='Z')
    {
      //...wird dies durch die entsprechenden LED signalisiert...
      PORTC=0b11111111;
      //...leeren des Empfangsregisters
      UDR = 0;
      //...Interrupts aus (nicht unterbrechen !)
      cli();
      //...bis ende des Empfangspuffers puffer erreicht..
      for(j=0;j<i;j++)
      {        
        //Zwischenspeichern..
        buffer=puffer[j];      
        char_senden(buffer);
        //...und das entsprechende Zeichen senden
      }
      o=l=m=n=0;
      //puffer durchzählen...
      for(j=0;j<i;j++)
      {
        //zwischenspeichern...
        buffer=puffer[j];
        //falls eine Zahl oder Punkt in die entsprechende Zeile packen        
        if ( isdigit(buffer)|| (buffer == '.'))
        {
          val_puffer[o][l] = buffer;
          l = l+1;
                
        }
        //falls "Trennungszeichen" (") nächste Zeile im Feld
        if (buffer == '"')
        {
          //hier der Knackpunkt...
          //ich kann die erste "Zeile" des Arrays konvertieren, bei den weiteren scheitert es...
          const char *tempPtr = double_puffer;
          //konvertierung in double...

          val[o] = atof(tempPtr);
          o=o+1;
          k=l+1;
          l=0;
        }      
      }
      j=0;
      //Zum debuggen: Inhalt von val_puffer[][] ausgeben zum Überprüfen..
      //Das hie ist UNWESENTLICH
      chars_senden("####");      
      for(m=0;m<o;m++)
      {
        for(n=0;n<k;n++)
        {
          char_senden('{');
          int_senden(m);
          char_senden(';');
          int_senden(n);
          char_senden('}');
          buffer = val_puffer[m][n];
          char_senden(buffer);                 
        }          
      }  
      double_senden(val[0]);
      //den Zähler wieder auf Null setzen (kein Überlauf)
      i=0;
      m=0;        
      //globale Interrupts wieder zulassen
      sei();
      udr=0;  
      PORTC=0x00;        
    }
    


Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Mal ein Update von mir:

Das klappt (sieht aber unmöglich aus) val[] ist double:
      char *tempPtr = val_puffer[0]; 
      val[0] = atof(tempPtr);

      char *tempPtr1 = val_puffer[1];
      val[1] = atof(tempPtr1);

      char *tempPtr2 = val_puffer[2];
      val[2] = atof(tempPtr2);

      char *tempPtr3 = val_puffer[3]; 
      val[3] = atof(tempPtr3);

      char *tempPtr4 = val_puffer[4];
      val[4] = atof(tempPtr4);

      char *tempPtr5 = val_puffer[5];
      val[5] = atof(tempPtr5);



das hier jedoch nicht :
      char *ptr;
      u08 feld_counter;

      for(feld_counter=0;feld_counter<6;feld_counter++)
      {
        *ptr  = val_puffer[feld_counter];
        val[feld_counter] = atof(ptr);
      }

Beides gibt eine (bzw sechs) Warnungen und das kanns doch nicht 
sein...oder?

Beste Grüße !

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was hast du nur immer mit deinem Zwischenpointer?

      for(feld_counter=0;feld_counter<6;feld_counter++)
      {
        val[feld_counter] = atof(val_puffer[feld_counter]);
      }

Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Karl Heinz!

Weils so nicht klappt (leider)...

Compiler:

../I2CMASTER.c:123: warning: passing arg 1 of `atof' discards qualifiers 
from pointer target type

Ich bekomm nur Unsinn wenn ich den Wert dann über Usart raushaue....

Viele Grüße !

Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nochmal Update:

Wie Karl-Heinz es postet klappt es doch.
Hab da wohl etwas falsch gemacht. Die Compilerwarnung bleibt jedoch.

Was meint der Compiler damit denn?

Danke für die Hilfe!

Gruß!

Autor: Jörg Wunsch (dl8dtl) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ein `type qualifier' ist eins der Schlüsselworte "const", "volatile"
oder "restricted".  (Letzteres kommt erst mit C99 hinzu und hat nur
für Zeigerargumente in Funktionsdeklarationen Sinn.)

Du hast also einen Datentyp, der entweder "const" oder "volatile"
deklariert ist und übergibst diesen an atof(), das von dieser
Besonderheit nichts weiß.  Der Compiler teilt dir daraufhin mit,
dass letztlich atof() diese Tatsache aus Unkenntnis ignorieren
wird.

Wenn's trotzdem geht, ist es ein gutes Anzeichen, dass es des
type qualifiers wohl auch gar nicht erst bedurft hätte.

Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Jörg!

Verstanden.

val[] hatte ich unnötigerweise als volatile deklariert.
Muss aber nicht da nur in main verwendet.

Danke! Wieder mal was dazu gelernt!

Tolles Forum hier!

Viele Grüße!

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.