-         
Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 13

Thema: float in String umwandeln

  1. #1
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.03.2013
    Beiträge
    242

    float in String umwandeln

    Anzeige

    Hallo,

    gibt es einen Befehl, der float-Variable in Strings umwandelt?
    Ich dachte das wäre char(), der scheint es aber nicht zu sein.

    vG

    fredyxx

  2. #2
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.670
    ftostr
    dtostr

    printf
    sprintf

    es gibt sicher noch mehr
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  3. #3
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    22.06.2009
    Beiträge
    1.302
    Wenn nicht kann man das auch recht schnell selber implementieren oder sich zusammen googlen ( https://www.microchip.com/forums/m183763.aspx)

  4. #4
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    3.069
    @shedepe, Ceos
    hier gilt das gleiche wie in einem anderen Thread bezgl. i2c:

    Ihr vergesst leicht, dass Arduino != C/C++ ist.
    Arduino benutzt es zwar , aber es IST es nicht.

    sprintf z.B. funktioniert bei Arduino auf AVR cores z.B. nur für ints, aber ÜBERHAUPT NICHT für floats, es ist in lib.c disabled.
    Nur auf ARM Arduinos funktioniert es.

    Auch vsprintf gibt es für AVR core komplett überhaupt nicht (!),egal für welche Datentypen.
    Bei ARM Arduinos hingegen doch, mit vollem stdio.h Funktionsumfang.

    Aber auch die FILE -bezogen Varianten von stdio.h gibt es auf Arduinos nicht (fprintf, fscanf, fgets), da es für SD irrsinnigerweise bei Arduino kein Filesystem gibt.


    Also: erst den Arduino Playground und Arduino Foren befragen, bevor hier zu vorschnell aus der Hüfte geschossen wird.

    Für ARMs funktioniert also
    Code:
    char * str[20];
    float fvar;
    sprintf( str, "%8.3f", fvar);
    perfekt, aber nicht für AVRs.
    Hier muss man sich behelfen mit etwas wie


    Code:
    char *  ftos(char*str, int len, int prec, double var) {
       int16_t l, p;
       
       dtostrf(var,len,prec,str);
        
       l = strlen(str); 
       p = strchpos(str, '.');  
    
       if (l>len && p<len ) {  
          dtostrf( var,len, max(0,len-p-1), str );  
       } 
       else
       if ((p<=0 || p>=len) && l>len) { 
          p= max(0,len-6); 
          l= strlen( dtostre( var, str, p, 0 ) );
          if(l<len && p==0) {
            strcat(str, " ");  
          }
       }    
       return str;   
    }

    Als Sparvariante funktioniert dabei dtostrf(var,len,prec,str); auch alleine.


    Wenn Ihr also C/++ Lösungsideen postet, seid euch darüber bewusst, dass nicht alles auch auf Arduinos funktioniert, was es gemeinhin für g++ gibt.

    Hinweise wie " kann man das auch recht schnell selber implementieren " sind aber in jedem Falle alles andere als hilfreich und können eigentlich nur als arrogante Ohrfeige für den Fragesteller empfunden werden.
    Geändert von HaWe (08.03.2017 um 14:52 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  5. #5
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.03.2013
    Beiträge
    242
    und können eigentlich nur als arrogante Ohrfeige für den Fragesteller empfunden werden
    So krass habe ich es nicht empfunden, aber es klappte natürlich nicht.

    Als Sparvariante funktioniert dabei dtostrf(var,len,prec,str); auch alleine.
    Das Fazit was ich nun gezogen habe funktioniert aber auch nicht.

    Code:
          Akku_Spg = analogRead(PIN_Akku_Spg);            // Messwert einlesen
    
          Akku_Spg = Akku_Spg / 1023.0  *  21.51;         //  ergibt sich aus den engesetzten Widerständen
    
          Akku_String  =  dtostrf(Akku_Spg, 5, 2, Akku_String);
    Muss dann doch der Code von HaWe als Funktion vorhandne sein?

    Die Werte, die ich erwarte sind immer positiv, haben nicht mehr als 2 Stellen vor dem Punkt und müssen nicht mehr als 2 Stellen hinter dem Punkt haben.

    vG

    fredyxx

  6. #6
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    3.069
    du kannst nicht eine Variable sowohl als Argument in eine Funktion übergeben und sie ihr selber gleichzeitig als return-Wert zuweisen, und wo bitte druckst du sie aus?

    char* zuweisungen gehen sowieso nie mit dem Gleichheitszeichen in C, wenn du den Inhalt eines char *Arrays auf einen anderen Array übertragen willst! Das geht nur mit strcpy() !

    Bitte aber auch grundsätzlich immer den kompletten Code neben den Schnipseln posten!


    Das Ergebnis der Umwandlung steht aber in dem deinem char-string, und du kannst es in 2 Schritten tun oder in 1, wenn du per Serial ausgeben willst:

    die Syntax ist:

    char* Akku_String[20]; // oder was
    dtostrf(Akku_Spg, 5, 2, Akku_String);
    Serial.print(Akku_String);

    oder:

    Serial.print( dtostrf(Akku_Spg, 5, 2, Akku_String) );
    Geändert von HaWe (08.03.2017 um 14:32 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  7. #7
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.03.2013
    Beiträge
    242
    du kannst nicht eine Variable sowohl als Argument in eine Funktion übergeben und sie ihr selber gleichzeitig als return-Wert zuweisen, und wo bitte druckst du sie aus?
    War mir auch suspekt, aber ich hatte es nicht richtig verstanden.

    Bitte aber auch grundsätzlich immer den kompletten Code neben den Schnipseln posten!
    Das gesamte Programm mit 23 Unterprogrammen wäre wohl eine Zumutung. Diese Änderung darin ist nur eine Winzigkeit, die ich aber noch nicht gemacht habe und mir sehr viel einfacher vorgestellt hatte.

    und wo bitte druckst du sie aus?
    Zum Testen zunächst nur im SM (dafür würde ich die Umwandlung ja gar nicht benötigen), endgültig soll sie aber über eine bestehende Bluetooth-SS als Text zu einem Tablet übertragen werden.

    So habe ich das nun umgesetzt:
    Code:
          Serial.println(dtostrf(Akku_Spg, 5, 2, Akku_String));
    erhalte beim Kompilieren aber diese Fehlermeldung:

    "cannot convert 'String' to 'char*' for argument '4' to 'char* dtostrf(double, signed char, unsigned char, char*)'"

    Akku_Spg habe ich als double und Akku_String als String deklariert.

    vG

    fredyxx

  8. #8
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    3.069
    da haben wirs wieder! wo ist dein vollständiger Code???
    wo zT hast du deinen "string" Akku_String deklariert??
    offenbar aber nicht so wie ich es vorgegeben habe, oder?

    char* Akku_String[20]; // oder was

    Bei mir funktioniert der Code nämlich!

    Und du weißt ja hoffentlich, dass string aus der String class oder aus C++ <cstring> etwas ganz anderes ist als ein ANSI C \0-terminierter char * array?
    https://www.tutorialspoint.com/cplus...pp_strings.htm


    Du weißt aber auch, dass double auf AVR nicht anderes ist als die ganz simplen 32-bit float, oder?
    Geändert von HaWe (08.03.2017 um 15:49 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  9. #9
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.03.2013
    Beiträge
    242
    Und du weißt ja hoffentlich, dass string aus der String class oder aus C++ <cstring> etwas ganz anderes ist als ein ANSI C \0-terminierter char * array?
    Nein, weiß ich nicht und verstehe ich auch nicht.

    Du weißt aber auch, dass double auf AVR nicht anderes ist als die ganz simplen 32-bit float, oder?
    Hatte ich vergessen. Hilft mir aber auch nicht weiter.

    char* Akku_String[20];
    wo muss das denn stehen?

    Dann versuchen wir es mal so: wenn du nach "dtostrf" suchst findest du die Stelle

    Code:
    /*  Dieses Programm  steuert den Bagger   auch mit einem IR-Empfänger.
     *   ********************Die Steppersoftware ist selber gemacht.*******************************
        *****              es sind die Bagger - Programme
        *****   STOP   und
        *****   Justierung
        *****   Motor 2 fahren   >>>>   mit Schaufelbewegung
        *****   Motor 3 fahren   >>>>   mit Schaufelbewegung
        *****   xy- fahren   >>>>   mit Schaufelbewegung   ***  und Vorgabe der xy-Koordinaten vom Seriellen Monitor
        *****   LKW-beladen  >>>>   Arm senken, schaufeln, fahren und drehen, Arm senken und Schaufel beladen
                    >> Arm heben, Kurve rückwärts fahren, Kurve vorwärts fahren, Arn vor, Schaufel leeren
        *****   Steuerung des Baggers über den IR-Empfänger
        *****   Steuerung des Baggers über den BT-Empfänger
                     *****   Steuerung der Betriebsarten über den BT-Empfänger und nicht über das Mäuseklavier
        *****             (funktionsfähig)
        >>>>>>>>>>>>>>>>>>>>>           Die Motorspannungen sind :  Vm  11,4 V; VMot  11,9 V   <<<<<<<<<<<<<<<<<<<<<<<<
        >>>>>>>>>>>>>>>>>>>>>     Vcc = 5 V   <<<<<<<<<<<<<<<<<<<<<<<<
    
    
     *   ***********  um die PullUp-Widerstände zu nutzen, LOW = Aktivierung der Funktion  *****************
    
    
         - Nr.1 (PIN 2)   Stillstand
         - Nr.2 (PIN 3)   Justierung
         - Nr.3 (PIN 4)   eine Bewegung von M2 mit folgender Schaufelbewegung
         - Nr.4 (PIN 5)   eine Bewegung von M3 mit folgender Schaufelbewegung
         - Nr.5 (PIN 6)   eine Koordinate anfahren
         - Nr.6 (PIN 7)   einen "LKW" beladen
         - Nr.7 (PIN 8)   IR-Steuerung
         - Nr.8 (PIN 9)   Bluetooth-Steuerung
    
         SUCH-ZIELE:   #include   float HP_X1     void setup    void loop()
    
    
    */
    
    #define Pot2(x) (x*x) // das ist eine selbst gemachte Funktion, die die in Klammern stehende Zahl mit sich selbst multipliziert.
    // das habe ich so gewählt, weil eine Multiplikation zweier float-Zahlen schneller sein soll, als da mit der
    // Funktion  pow()  geschehen soll!
    
    //   >>>>>>>>>>>>>>>>>>   für IR Empfänger  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    #include "IRremote.h"  //Library für die IR-Steuerung; aus dem Internet
    
    int receiver = 14; // Signal Pin of IR receiver to Arduino Digital Pin 14
    
    /*-----( Declare objects )-----*/
    IRrecv irrecv(receiver);           // create instance of 'irrecv'
    decode_results results;            // create instance of 'decode_results'
    
    int IR_Nr_fuer_Mx;
    int Zykluszaehler = 0;   // ein Zähler zur Vermeidung eines delay-Befehls
    
    //   >>>>>>>>>>>>>>>>>>   für IR Empfänger  bis hier  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    
    String BT_Info = "";
    String BT_Laenge;
    int BT_Lae_int;
    int PIN_Akku_Spg = 0;
    double Akku_Spg;
    String Akku_String;
    //char* Akku_String[20];   //  das klappt auch nicht
    
    unsigned long deltamic;          // für Test der Zykluszeit
    unsigned long microsaltTest;
    unsigned long LZ_SpeicherBT_send = millis();          // Speicher für die Bluetooth-Lebenszeichenwachung-Sendesignal
    unsigned long LZ_SpeicherBT_empf = millis();;          // Speicher für die Bluetooth-Lebenszeichenwachung-Empfangssignal
    unsigned long LZ_SpeicherUNO = millis();;          // Speicher für die UNO-Zeitüberwachung
    unsigned long Akku_send = millis();
    
    
    boolean  MK1_1;      // Variable für die Eingänge des Mäusklaviers 1; schalten gegen GND
    boolean  MK1_2;      // sie sind aktiv bei LOW
    boolean  MK1_3;
    boolean  MK1_4;
    boolean  MK1_5;
    boolean  MK1_6;
    boolean  MK1_7;
    boolean  MK1_8;
    
    boolean  MK1_1alt;   // für die Prellunterrdrückung des Kontakts
    boolean  MK1_2alt;      // sie sind aktiv bei LOW
    boolean  MK1_3alt;
    boolean  MK1_4alt;
    boolean  MK1_5alt;
    boolean  MK1_6alt;
    boolean  MK1_7alt;
    boolean  MK1_8alt;
    
    
    boolean JustM3var = LOW;                  // wird erst HIGH, wenn JustPin wieder HIGH ist; Funktion Fangschaltung
    boolean M1solldrehen = true;             // für UP Justierung
    boolean M2solldrehen = true;             // für UP Justierung
    boolean M3solldrehen = false;             // für UP Justierung
    
    
    
    int Just_Taster = 53;                    // mit digital Eingang 53 wird beim Justieren die jeweilige Motorbewegung gestoppt
    int LKW_Zyklus = 1;                      //  steuert über switch den LKW-Ladevorgang
    
    
    
    //++++++++++++++++++ für weitere UPs
    
    float HP_X1 = 360.0;      //  hier werden für den "Handbetrieb die XY_Koordinaten vorgegeben
    float HP_Y1 = -35.0;
    float HP_X1neu;             //  hier werden vom Monitor die neuen Werte aufgenommen
    float HP_Y1neu;
    // Ecke oben rechts: x = 352;  y =  182
    // Ecke oben links: x = 216;  y =  47
    // Ecke unten links: x = 205;  y = -83
    // Ecke unten rechts: x = 392;  y = -50
    // links, y = 0:  x = 221;  y =  0
    // rechts, y = 0: x = 394;  y =  0
    // tiefster Punkt unten: x = 268;  y = -94
    //   >>>>  ohne dass die Schaufel den Boden berührt   y  >  -62
    
    
    boolean xy_fertig = false;
    boolean xy_Start = true;
    
    
    boolean M1_fertig = false;
    boolean M1_Start = true;
    int Zyklus_M1 = 1;                 // steuert das Zyklische Fahren
    float lzahn1_ist  = 0.0;            // Ausfahrlänge von Zahnstange 1 nach Justierung     1
    float lzahn1;            // Ausfahrlänge von Zahnstange 1 nach Justierung     1
    unsigned long Schrittz_M1;  // wird für Fernsteuerung benötigt
    int M1xy_dir;
    
    
    boolean M2_fertig = false;
    boolean M2_Start = true;
    int Zyklus_M2 = 1;
    float lzahn2_ist  = 98.0;            // Ausfahrlänge von Zahnstange 2 nach Justierung     98
    float lzahn2_soll;                        // neue Ausfahrlänge von Zahnstange 2
    float Schrittz_M2;  // wird für Fernsteuerung benötigt
    int M2xy_dir;
    
    boolean M3_fertig = false;
    boolean M3_Start = true;
    int Zyklus_M3 = 1;
    float lzahn3_ist  = 68.0;            // Ausfahrlänge von Zahnstange 3 nach Justierung     68
    float lzahn3_soll;                        // neue Ausfahrlänge von Zahnstange 3
    float Schrittz_M3;  // wird für Fernsteuerung benötigt
    int M3xy_dir;
    
    boolean M4_fertig = false;
    boolean M4_Start = true;
    
    boolean M5_fertig = false;
    boolean M5_Start = true;
    
    
    boolean M6_fertig = false;
    boolean M6_Start = true;
    int Zyklus_M6 = 1;
    
    
    //++++++++++++++++++++++++++++++++++
    
    
    //************************************************************************************************************************
    void setup() {    //******************************************************************************************************
    
      Serial.begin (250000);    //  diese Buadrate muss auch in der Konsole (Serieller Monitor) eingestellt sein
      while (!Serial);
    
      Serial.println("IR Receiver Button Decode");
      irrecv.enableIRIn(); // Start des IR-Empfängers
    
      Serial1.begin(9600);    // Öffnen der Seriellen Schnittstelle Nr 1 im Arduino MEGA zum Uno im Fahrwerk
      while (!Serial1);
    
      Serial2.begin(9600);    // Öffnen der Seriellen Schnittstelle Nr 2 im Arduino MEGA zum BT-Modul HC-06
      while (!Serial2);
    
      pinMode (Just_Taster, INPUT);               // wird nur im UP Justierung benötigt
      digitalWrite(Just_Taster, HIGH);            //schaltet den PullUp-Widerstand ein
    
    
      pinMode (2, INPUT);   // Pins als Eingänge deklarieren
      pinMode (3, INPUT);
      pinMode (4, INPUT);
      pinMode (5, INPUT);
      pinMode (6, INPUT);
      pinMode (7, INPUT);
      pinMode (8, INPUT);
      pinMode (9, INPUT);
    
      pinMode (52, OUTPUT);
      digitalWrite (52, LOW);
    
      pinMode (13, OUTPUT);
    
    
    
      digitalWrite (2, HIGH); // schaltet die 20 kOhm PullUp-widerstände ein
      digitalWrite (3, HIGH);
      digitalWrite (4, HIGH);
      digitalWrite (5, HIGH);
      digitalWrite (6, HIGH);
      digitalWrite (7, HIGH);
      digitalWrite (8, HIGH);
      digitalWrite (9, HIGH);
    
      MK1_1alt = digitalRead(2);  //  erforderlich gegen Schalterprellen
      MK1_2alt = digitalRead(3);
      MK1_3alt = digitalRead(4);
      MK1_4alt = digitalRead(5);
      MK1_5alt = digitalRead(6);
      MK1_6alt = digitalRead(7);
      MK1_7alt = digitalRead(8);
      MK1_8alt = digitalRead(9);
    
    
    
      pinMode (41, OUTPUT);           //  M1
      pinMode (43, OUTPUT);
      pinMode (45, OUTPUT);
      pinMode (47, OUTPUT);
    
      pinMode (22, OUTPUT);           //  M2
      pinMode (24, OUTPUT);
      pinMode (26, OUTPUT);
      pinMode (28, OUTPUT);
    
      pinMode (32, OUTPUT);           //  M3
      pinMode (34, OUTPUT);
      pinMode (36, OUTPUT);
      pinMode (38, OUTPUT);
    
      pinMode (42, OUTPUT);           //  M4
      pinMode (44, OUTPUT);
      pinMode (46, OUTPUT);
      pinMode (48, OUTPUT);
    
      pinMode (31, OUTPUT);           //  M5
      pinMode (33, OUTPUT);
      pinMode (35, OUTPUT);
      pinMode (37, OUTPUT);
    
    
    }
    //**********************************************************************************************************************
    void loop() {    //******************************************************************************************************
    
    
    
    
      if ((millis() - LZ_SpeicherUNO)  > 500) {            // Lebenszeichen an UNO-SChnittstelle
        LZ_SpeicherUNO = millis();
        Serial1.println("prima");                          //   an UNO;   +++ println +++ ist wichtig, nicht print
    
      }      //   *************  ENDE   if ((millis() - LZ_SpeicherUNO)  > 500)
    
    
    
    
    
      //  Teständerung
      if (  digitalRead(2)  == HIGH  &&  digitalRead(9)  == HIGH ) {    //  diese Schalterstellung heißt BA-Wahl über App
        // >>>>>>>>>>>>>>>>>>>>>>>>>>>   bei TEST ohne Mäuseklavier muss hier jeweils HIGH stehen <<<<<<<<<<<<<<<<<<<<<<<<<<
        //  das sind der Stop-   **  und **  der BT-Schalter
        // die Eingänge werden hier direkt verwendet, weil bei der BA-Wahl über App MK1_x nicht mehr die realen Stellungen der Schalter enthält
    
    
        if ((millis()  - Akku_send)  > 10000) {          // Akkuspannung an Tablet senden
    
          Akku_Spg = analogRead(PIN_Akku_Spg);            // Messwert einlesen
    
          Akku_Spg = Akku_Spg / 1023.0  *  21.51;         //  ergibt sich aus den engesetzten Widerständen
    
          Serial.print("Akkuspannung    =   "   );                         
          Serial.println(dtostrf(Akku_Spg, 5, 2, Akku_String));                          
          Serial.print(Akku_Spg);                          //
          Serial2.print("18");   //  ist hier zZ nur ein Versuch
    
          Akku_send = millis();
    
        }      //   *************  ENDE   if ((millis()  - Akku_send)  > 10000)
    
    
    
        if (((millis() - LZ_SpeicherBT_empf) >  2500)) {     //  &&  (IR_Nr_fuer_Mx != 0)
    
          Serial.println(" ");
          Serial.println("Zeitueberschreitung BT-Verbindung");
    
          IR_Nr_fuer_Mx = 20;   //  alle Motoren aus
          Fernsteuerung ();   // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
          LZ_SpeicherBT_empf = millis();       // damit bei BT-Fehler nicht ständig gesendet wird
    
        }      //   *************  ENDE   if((millis() - LZ_SpeicherBT_empf) >  2500)
    
    
    
        BT_Auswertung();     //  in dem UP werden die diversen Signale von BT ausgewertet
    
    
    
        if ((millis() - LZ_SpeicherBT_send)  > 1800) {            // Lebenszeichen an BT, wenn BA BT scharf
          //      LZ_SpeicherBT_send = millis();
          Serial2.print("18.23");                              //   an BT
    
        }      //   *************  ENDE   if ((millis() - LZ_SpeicherBT_send)  > 1800)
    
    
      }       //   *************  ENDE   if (digitalRead(2)  == LOW  &&  dig........
    
      else {   // dieser Block ist in der BA-Wahl von der App nicht mehr wirksam
        MK1_1 = digitalRead(2);  //digitalRead(2);      //   STOP   >  die Variablen MK.. erhalten die Zustände der Eingänge
        MK1_2 = digitalRead(3);  //digitalRead(3);       //  Justieren;                  sie sind aktiv bei LOW
        MK1_3 = digitalRead(4);  //digitalRead(4);      //   M1 und M2 fahren
        MK1_4 = digitalRead(5);  //digitalRead(5);      //   M1 und M3 fahren
        MK1_5 = digitalRead(6);  //digitalRead(6);      //   xy anfahren                float HP_X1
        MK1_6 = digitalRead(7);  //digitalRead(7);      //   LKW beladen
        MK1_7 = digitalRead(8);  //digitalRead(8);
        MK1_8 = digitalRead(9);  //digitalRead(9);
    
    
    
        if (MK1_1 != MK1_1alt || MK1_2 != MK1_2alt || MK1_3 != MK1_3alt || MK1_4 != MK1_4alt || MK1_5 != MK1_5alt || MK1_6 != MK1_6alt || MK1_7 != MK1_7alt || MK1_8 != MK1_8alt) {
    
          MK1_1alt = MK1_1;
          MK1_2alt = MK1_2;
          MK1_3alt = MK1_3;
          MK1_4alt = MK1_4;
          MK1_5alt = MK1_5;
          MK1_6alt = MK1_6;
          MK1_7alt = MK1_7;
          MK1_8alt = MK1_8;
    
        }   //   ENDE if(MK1_1 != MK1_1alt............................
    
      }   //   ENDE else
    
    
    
      if (digitalRead(Just_Taster) == LOW  && (MK1_2  ==  HIGH  ||  (digitalRead(2)  ==  LOW   &&   digitalRead(9)  ==  LOW)) ) {     // TESTMÖGLICHKEIT bei Problemen
        // soll nur reagieren, wenn nicht justiert wird, da der Taster dann eine ander Funktion hat.
        // oder   wenn BAs von der App eingestellt werden
    
    
        delay(300);  //  unterdrückt Tasterprellen
    
        Serial.print ("");
        Serial.print ("");
        Serial.print ("");
    
    
        Serial.print ("HP_X1 =  ");
        Serial.print (HP_X1);
        Serial.print (",    HP_Y1 =  ");
        Serial.println (HP_Y1);  Serial.println ("");
    
        Serial.print ("lzahn1_ist = steht bei =  ");
        Serial.println (lzahn1_ist);
        Serial.print ("lzahn1 = Ziel war =  ");
        Serial.println (lzahn1);  Serial.println ("");
    
        Serial.print ("lzahn2_ist = steht bei =  ");
        Serial.println (lzahn2_ist);
        Serial.print ("lzahn2_soll = Ziel war  =  ");
        Serial.println (lzahn2_soll);  Serial.println ("");
    
        Serial.print ("lzahn3_ist = steht bei =  ");
        Serial.println (lzahn3_ist);
        Serial.print ("lzahn3_soll = Ziel war  =  ");
        Serial.println (lzahn3_soll);  Serial.println ("");
    
        Serial.print ("M1_fertig =  ");
        Serial.println (M1_fertig);
        Serial.print ("M1_Start =  ");
        Serial.println (M1_Start);
        Serial.print ("Zyklus_M1 =  ");
        Serial.println (Zyklus_M1);
        Serial.println ("");
    
        Serial.print ("M2_fertig =  ");
        Serial.println (M2_fertig);
        Serial.print ("M2_Start =  ");
        Serial.println (M2_Start);
        Serial.print ("Zyklus_M2 =  ");
        Serial.println (Zyklus_M2);
        Serial.println ("");
    
        Serial.print ("M3_fertig =  ");
        Serial.println (M3_fertig);
        Serial.print ("M3_Start =  ");
        Serial.println (M3_Start);
        Serial.print ("Zyklus_M3 =  ");
        Serial.println (Zyklus_M3);
        Serial.println ("");
    
        Serial.print ("M4_fertig =  ");
        Serial.println (M4_fertig);
        Serial.print ("M4_Start =  ");
        Serial.println (M4_Start);
        Serial.println ("");
    
        Serial.print ("M5_fertig =  ");
        Serial.println (M5_fertig);
        Serial.print ("M5_Start =  ");
        Serial.println (M5_Start);
        Serial.println ("");
    
        Serial.print ("M6_fertig =  ");
        Serial.println (M6_fertig);
        Serial.print ("M6_Start =  ");
        Serial.println (M6_Start);
        Serial.print ("Zyklus_M6 =  ");
        Serial.println (Zyklus_M6);
        Serial.println ("");
    
        Serial.print ("xy_Start =  ");
        Serial.println (xy_Start);
        Serial.println ("");
        Serial.println ("");
    
      }
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    
      if (MK1_1  == LOW  &&  MK1_8 ==  HIGH)  {          //     STOP
    
        Ruecksetzen ();
    
        if (  digitalRead(2)  == LOW  &&  digitalRead(9)  == LOW ) {    //  diese Schalterstellung heißt BA-Wahl über App
    
          MK1_1  == HIGH;
          MK1_8 == LOW;
    
        }
      }
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      else if (MK1_2 == LOW   &&  MK1_1  == HIGH)  {     //  Justierung
        Justierung();    //   Programm 2:    Justierung
      }
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      else if (MK1_3 == LOW  &&  MK1_1  == HIGH )  {     // M2 bewegen
    
        M2_fahren();    //   Programm 3:    M2_fahren  ; von der letzten Position auf maximal ausgefahren
        M1_fahren();    //   Programm 3:    M1_fahren  ; von der letzten Position auf maximal ausgefahren
    
      }
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      else if (MK1_4 == LOW  &&  MK1_1  == HIGH )  {     // M3 bewegen
        M3_fahren();    //   Programm 4:    M3_fahren  ; von der letzten Position auf maximal ausgefahren
        M1_fahren();    //   Programm 4:    M1_fahren  ; von der letzten Position auf maximal ausgefahren
      }
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      else if (MK1_5 == LOW   &&  MK1_1  == HIGH)  {     //  x/y - Koordinate anfahren
    
        //    **************  neuen xy - Wert vom SerialMonitor empfangen   **************
    
    
        if (Serial.available() ) {            // es müssen 2 durch Kommata getrennte Werte eingegeben werden
          HP_X1neu = Serial.parseInt();        //der Befehl,und damit eine Wartezeit, wird nur ausgeführt, wenn ein Wert im Puffer ist
          HP_Y1neu = Serial.parseInt();
        }             //   ***************   ENDE    if (Serial.available() )    **********************
    
        if ( HP_X1neu > 0)  {
          Serial.print("HP_X1neu  =  ");
          Serial.println(HP_X1neu);
    
          Serial.print("HP_Y1neu  =  ");
          Serial.println(HP_Y1neu);
    
          Ruecksetzen ();
    
          HP_X1 = HP_X1neu;
          HP_Y1 = HP_Y1neu;
    
          HP_X1neu = 0;
    
        }             //   ***************   ENDE    if ( HP_X1neu > 0)    **********************
    
    
    
        xy_fahren(12, 12);   //   Programm 5:    eine x/y -Koordinate anfahren; Parameter sind die Geschwindigkeiten für M2 und M3
    
        if (M2_fertig == true) {     // hier wird der Zielwert übernommen
          lzahn2_ist = lzahn2_soll;
        }
    
        if (M3_fertig == true) {     // hier wird der Zielwert übernommen
          lzahn3_ist = lzahn3_soll;
        }
    
        if (M2_fertig == true  &&  M3_fertig == true) {
    
          M1_fahren();
    
        }   //  ***********  ENDE     (M2_fertig == true  &&  M3_fertig == true)   ***********
    
      }   //  ***********  ENDE     (MK1_5 == LOW   &&  MK1_1  == HIGH)
    
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      else if (MK1_6 == LOW   &&  MK1_1  == HIGH)  {     //  LKW beladen
    
    
        LKW_beladen ();
    
    
      }   //   *************  ENDE   else if (MK1_6 == LOW   &&  MK1_1  == HIGH)
    
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
      else if (MK1_7 == LOW   &&  MK1_1  == HIGH)  {     //  Steuerung über den IR-Empfänger
    
        if (++Zykluszaehler  > 5000) {   // soll mehrfach senden einer Tastenbetätigung verhindern  =  delay aber ohne Programm Stop
          // diese if-Schleife wird nur ; das ist die Anzahl der Zyklen mit einer Zykluszeit von ca. 0,1 ms
    
          Zykluszaehler = 0;
    
          if (irrecv.decode(&results)) // Wurde ein IR-Signal empfangen?
    
          {
    
            Serial.print("results.value  =  ");
            Serial.println(results.value);
    
    
            IR_Empfangen();   //  zum Unterprogramm, das dieses Signal auswertet
            irrecv.resume(); // empfange den nächsten Wert
          }       //   *************  ENDE   if (irrecv.decode(&results))
    
        }
    
        Fernsteuerung();   // UP Fernsteuerung aufrufen
    
    
    
      }       //   *************  ENDE   else if (MK1_7 == LOW   &&  MK1_1  == HIGH)
    
    
    
    
      //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    
      else if (MK1_8 == LOW   &&  MK1_1  == HIGH)  {      //    Steuerung über das Bluetoothmodul
    
    
    
    
      }       //   *************  ENDE   else if (MK1_8 == LOW   &&  MK1_1  == HIGH)
    
    
    
    
    }   //*************   ENDE  loop

  10. #10
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    3.069
    Und du weißt ja hoffentlich, dass string aus der String class oder aus C++ <cstring> etwas ganz anderes ist als ein ANSI C \0-terminierter char * array?
    Nein, weiß ich nicht und verstehe ich auch nicht.
    ok, da liegt der Hase im Pfeffer.

    Du hast deklariert:

    String Akku_String;

    char * und string sind 2 verschiedene Datentypen, den Unterschied musst du verstehen.
    String (groß geschrieben) ist sogar noch was anderes, das ist ein Arduino-Dialekt.

    Die Umwandlungsfunktion erwartet char* und nicht string und auch nicht String, und daher musst du eine char* Variable übergeben und keine string oder String Variable.
    Das eine ist C, das andere ist C++, und C++ ist eine andere Sprache. Das dritte ist Arduino Kauderwelsch.
    C++ schließt zwar C weitgehend ein, aber nicht umgekehrt, und genau daher kommt deine Fehlermeldung.

    Such die Deklaration deiner Floatstring-Variablen und ändere sie so um, wie ich geschrieben habe.
    Allerdings gehorchen char* und string und String auch anderen String-Operations-Funktionen, und daher musst du möglicherweise auch noch mehr an deinem Codes ändern.

    Ich habe dir oben ein kleines Tutorial zu char* und string verlinkt, guck dass du es lernst und verstehst:
    C und C++ sind nicht Kladderadatsch und Tohuwabohu, sondern exakt definierte Sprachen, an deren Regeln man sich halten muss - dabei verzeiht C schon einiges an Fehlern, was viele verfluchen, aber C++ tut es nicht in dieser Weise.

    Arduino arbeitet mit einem C++ Compiler, der auch C-Code in seinem C++ Code mitübersetzt, und auch die Arduino-Kauderwelsch-Wraps erfordern viel Genauigkeit.
    Ich kann dir es nicht beibringen, das musst du in einem C und einem C++ Lehrbuch und in Arduino-Tutorials lernen.
    Geändert von HaWe (08.03.2017 um 18:46 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Integer in String umwandeln????
    Von KüSä im Forum PIC Controller
    Antworten: 12
    Letzter Beitrag: 20.12.2008, 20:56
  2. byte umwandeln in string
    Von xcool im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 10
    Letzter Beitrag: 30.11.2008, 22:09
  3. String zerlegen und umwandeln ?!
    Von Roberto im Forum C - Programmierung (GCC u.a.)
    Antworten: 34
    Letzter Beitrag: 08.08.2007, 10:27
  4. Float, Double to String, Display ATMega16 Belichtungstimer
    Von Timo_P im Forum C - Programmierung (GCC u.a.)
    Antworten: 1
    Letzter Beitrag: 01.04.2007, 18:36
  5. string in zahl umwandeln
    Von pebisoft im Forum C - Programmierung (GCC u.a.)
    Antworten: 5
    Letzter Beitrag: 09.06.2005, 14:20

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •