Archiv verlassen und diese Seite im Standarddesign anzeigen : 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
char * str[20];
float fvar;
sprintf( str, "%8.3f", fvar);
perfekt, aber nicht für AVRs.
Hier muss man sich behelfen mit etwas wie
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.
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.
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) );
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:
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/cplusplus/cpp_strings.htm
Du weißt aber auch, dass double auf AVR nicht anderes ist als die ganz simplen 32-bit float, oder?
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
/* 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
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
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
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;
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
Powered by vBulletin® Version 4.2.5 Copyright ©2024 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.