float in String umwandeln

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

ftostr
dtostr

printf
sprintf

es gibt sicher noch mehr

Wenn nicht kann man das auch recht schnell selber implementieren oder sich zusammen googlen ( https://www.microchip.com/forums/m183763.aspx)

@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.

Zitat:

---

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.

Zitat:

---

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

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) );

Zitat:

---

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.

Zitat:

---

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.

Zitat:

---

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

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?

Zitat:

---

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.

Zitat:

---

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.

Zitat:

---

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

---

Zitat:

---

Zitat:

---

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.

okay Arduino Forum ... jo klar sorry :)

übrigens ist mir auch gerade in Fehler in deinem Code aufgefallen beim durchscrollen:

in

Code:

---


  //  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

  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;

    }
  }

---

muss es richtig heißen:


MK1_1 = HIGH;
MK1_8 = LOW;

Zitat:

---

muss es richtig heißen:


MK1_1 = HIGH;
MK1_8 = LOW;

---

Danke für den Hinweis. Das hat sich im Ablauf bisher nicht störend bemerkbar gemacht.

vG

Fredyxx