Hallo,
suche bzw. bastle an einer Funktion zum "zurecht schneiden" von Zahlen (keine floats) fürs LCD oder Serial oder... Habe bisher noch nicht ganz das rechte gefunden und es mal selbst probiert, aber zum einen tuts noch nicht ganz richtig (mit der Nachkommazahl) und ist sicher nicht optimal vom Code/Ram.
So habe ich mir die Funktion vorgestellt:
Input:
z... signed long Zahl
t... Teiler, gibt Anzahl der Nachkommastellen an
vk... Vorkommastellen, wird ggf. mit '0' oder 'LEERZEICHEN' aufgefüllt
nk... Nachkommastellen die angezeigt werden sollen
Output:
String... der fertige string zum senden an Serial / LCD / SD / ...
BSP1: z = 1001; t = 3; vk = 4; nk = 3; String: 0001,001
BSP2: z = -12345; t = 2; vk = 3; nk = 3; String: -123,450
BSP3: z = 12345; t = 4; vk = 3; nk = 1; String: 012,3
Würde mich über Anregungen und Tipps freuen. Vielen Dank!
Hier mal mein bisheriger (noch fehlerhafter) Code:
//### Long2String L2S() #######################################################
// Zahl, Teiler<0..6>, Vor-,NachkommaStellen <0..10>, Füllzeichen, Trennzeichen
//### Long2String L2S() #######################################################
String L2S(long z, byte t, byte vk,byte nk, char c, char k){ // Zahl, Teiler, Vor-,Nachkommastellen, Füll-, Trennzeichen
String out; u_long teiler = 1; long z1; bool neg = 0; byte t2 = t; int st = 1;
SPrL(); SPr("Z: "); SPrL(z); //DEBUG
while(t--){ //Potenz von Teiler bilden
teiler *= 10;
}
if(z<0){ // Test ob negative Zahl
z *= -1; // pos. Zahl
vk--; // Eine Vorkommastelle weniger wegen "-"
neg = 1; // negativ Flag setzen
}
//Gesamtstellenanzhal ermitteln
if(z>999999999) st = 10;
else if(z>99999999) st = 9;
else if(z>9999999) st = 8;
else if(z>999999) st = 7;
else if(z>99999) st = 6;
else if(z>9999) st = 5;
else if(z>999) st = 4;
else if(z>99) st = 3;
else if(z>9) st = 2;
//else st = 1;
if(t2) {
z1 = z / teiler; // Vorkommazahl (VKZ)
z %= teiler; // Nachkommazahl (NKZ), nur wenn t>0
SPr("NKZ: "); SPrL(z); //DEBUG
}
else{
z1 = z;
}
switch (vk)
{ case 10: if(z1<1000000000) out+=c; //Serial.print(" 10,");
case 9: if(z1<100000000) out+=c; //Serial.print(" 9,");
case 8: if(z1<10000000) out+=c; //Serial.print(" 8,");
case 7: if(z1<1000000) out+=c; //Serial.print(" 7,");
case 6: if(z1<100000) out+=c; //Serial.print(" 6,");
case 5: if(z1<10000) out+=c; //Serial.print(" 5,"); // KEIN break; !
case 4: if(z1<1000) out+=c; //Serial.print(" 4,");
case 3: if(z1<100) out+=c; //Serial.print(" 3,");
case 2: if(z1<10) out+=c; //Serial.print(" 2,");
default: break;
}
if(neg) out += String('-');
out += String(z1); // "leer-zeichen" + VKZ
if(nk && t2){ // gibt es eine NKZ?
out += String(k); // Kommazeichen
// Potenz der Nachkommazahl
byte t = nk-1; // mit 100 statt 1000 testen!
teiler = 1;
while(t--){
teiler *= 10;
}
SPr("Teiler: "); SPrL(teiler); //DEBUG
//Test ob NKZ kleiner als Potenz, und wievielkleiner
byte cnt_0 = 0;
while(t>9){ // >=10, also mehrstellig
// wenn NKZ < Potenz t, dann add '0'
if(z < t){
out += String('0');
cnt_0++;
}
else{break;}
t /= 10; // Potenz verringern um 10
}
SPr("cnt_0: "); SPrL(cnt_0); //DEBUG
// Add NKZ
//out += String(z);
String str1;
str1 = String(z); // NKZ
str1 = str1.substring(0,(nk-cnt_0)); // NKZ ggf. abschneiden wenn zu lang
SPr("str1 cuted: "); SPrL(str1); //DEBUG
out += str1;
// //Verhältnis gesamt Stellen und Teiler
// SPr("t2: "); SPrL(t2); //DEBUG
// SPr("st: "); SPrL(st); //DEBUG
// int delta = t2 - st;
// SPr("delta: "); SPrL(delta); //DEBUG
// byte nullen = 0;
// if(delta > 0) nullen = delta;
// int i = constrain(nullen, 0, nk); //i 0...Nachkommastellen
// int i2 = i;
// SPr("i: "); SPrL(i); //DEBUG
// while(i--){
// out += String('0');
// }
// if(i2 < nk){
// int frei = nk-i2; // noch freie NackkommaStellen
// if(frei < 0) frei = 0;
// if(frei){ // Nur Stubstring zurechtschneiden, wenn noch was frei
// String str1;
// str1 = String(z);
// out += str1.substring(0,frei); // Substrings
// }
//}//if(i2 < nk){
}// if(nk && t2){
return out;
}// L2S
.
In der Tat, ein sehr dummer Fehler von mir, habe nicht aufgepasst und die Flash Variante erwischt!
