Kommastelle filtern, eigenartiges Verhalten

Hallo,

so stimmt das ja erstmal. Zum Test ob alles richtig rechnet, habe ich die letzten drei Serial Ausgaben mit 4 Kommastellen anzeigen lassen. Und plötzlich kommt Müll raus. Normal müßten doch x.0000 immer angezeigt werden, weil es Ganzzahlen sind. Was macht dabei Serial.print(x,4) anders?

Änderung mit unsinnigen Werten

Serial.print("Vorkommastellen ");
  Serial.println(Vorkommastellen,4);
  Restwert = Mittelwert * 100;               // 2 Kommastellen als Ganzzahl (Bsp. 2537)
  Serial.print("Restwert ");
  Serial.println(Restwert,4);
  Kommastellen = Restwert - Vorkommastellen; // Kommastellen für sich als Ganzzahl
  Serial.print("Kommastellen ");
  Serial.println(Kommastellen,4);

kompletter Code

//  Arduino Mega 2560

// Deklaration der Funktionen, übernimmt die Arduino IDE selbst
// unsigned int read_MAX6675();
  
//  Arduino Mega 2560

// Port-Pins definieren
int    MAX_CS = 24;               // Arduino Pin, SPI ChipSelect, 1. MAX6675
int    MAX_SO  = 26;              // Arduino Pin, SPI Datenleitung
int    MAX_CLK = 28; 	          // Arduino Pin, SPI Clockleitung

// Deklaration Datentypen und Variablen
int Poti = 0;                     // Eingang A0
int Filterfaktor = 1;
float Teiler = 2.0;

unsigned int Vorkommastellen;        // Sicherung der Vorkommastellen
unsigned int Restwert;               // 2 Kommastellen als Ganzzahl
unsigned int Kommastellen;           // Kommastellen für sich als Ganzzahl

unsigned int value = 0;

unsigned int Temp = 0;	
float Mittelwert = 0;
float actual = 0;

void setup() {

  Serial.begin(9600); 
 
  pinMode(MAX_CS, OUTPUT);
  pinMode(MAX_SO, INPUT);
  pinMode(MAX_CLK, OUTPUT);
  
  digitalWrite(MAX_CS, HIGH);               // Ruhezustand
  digitalWrite(MAX_CLK, LOW);               // Ruhezustand
    
}

void loop() {
  
  delay(1000);
  Filterfaktor = analogRead(Poti)/8;        // lese analog Pin A0 ein und Begrenzung auf 128
  if(Filterfaktor == 0) Filterfaktor = 1;   // wenn A0 = 0, dann setze es auf 1 (Mindestwert)
  Teiler = Filterfaktor + 1;                // Teiler immer eins größer wie Filterfaktor
  Temp = read_MAX6675();
  actual = Temp / 4.0;
  Serial.print(Filterfaktor);
  Serial.print("  ");
  Serial.print(actual,2);                   // aktueller Meßwert von A0
  Serial.print("  ");
  Mittelwert = (Temp/4.0 + Mittelwert * Filterfaktor) / Teiler;
  Serial.println(Mittelwert,4);              // gleitender Mittelwert  (Bsp. 25,37)
  Vorkommastellen = (unsigned int) Mittelwert*100;   // Sicherung der Vorkommastellen (Bsp. 2500)
  Serial.print("Vorkommastellen ");
  Serial.println(Vorkommastellen);
  Restwert = Mittelwert * 100;               // 2 Kommastellen als Ganzzahl (Bsp. 2537)
  Serial.print("Restwert ");
  Serial.println(Restwert);
  Kommastellen = Restwert - Vorkommastellen; // Kommastellen für sich als Ganzzahl
  Serial.print("Kommastellen ");
  Serial.println(Kommastellen);
  
}

// -----------------------------------------------------------------------------------------------------	 
// Der MAX6675 wird ausgelesen und der 12-Bit-Wert zurückgegeben ********
unsigned int read_MAX6675 ()
{
  int i;
  unsigned int data;
  data = 0;
  digitalWrite(MAX_CS, LOW);            // CS=Low
  for(i=0;i<16;i++)
    {
     delayMicroseconds(1);             // warte 100us
     digitalWrite(MAX_CLK,HIGH);	 // SCK=High
     delayMicroseconds(1);		 // warte 100us
     // data = ((data<<1) | MAX_SO);	 // schiebe nach links und lies SO
     data = ((data<<1) | digitalRead(MAX_SO));	 // schiebe nach links und lies SO
     digitalWrite(MAX_CLK, LOW);	 // SCK=Low
    }
  delayMicroseconds(1); 	
  digitalWrite(MAX_CS, HIGH);         	 // CS=High
  delayMicroseconds(1); 		 // warte 100us
  return (data>>3);			 // gib 12-Bit Wert zurück
}

Was passiert, wenn du "Restwert" als float deklarierst?

Hallo,

das ändert nichts. Die neu hinzugefügte Kommazahlauswertung funktioniert jedoch mit 0.x000.
Ich erhalte:

22.7424
Vorkommastellen 202120
Restwert 2274.2431
Kommastellen 1022
Komma 0.5000

Wenn ich das mit dem 4 Kommastellen weglasse, erhalte ich richtigerweise das hier:

22.4838
Vorkommastellen 2200
Restwert 2248.38
Kommastellen 48
Komma 0.0000

Scheinbar irgendwo ein Problem mit dem Datentyp wie Du schon vermutest.
Nochmal für mein Verständnis. Bei einer Rechnung mit Ganzzahlen oder Übergabe von Fließkomma in Ganzzahl, wird doch die Kommastelle einfach knallhart abgeschnitten. Oder?

Mein Problem ist, warum ändert Serial.print eine Ganzzahl derart ab, sobald wenn Kommastellen ausgegeben werden sollen? Die Kommastellen müßten alles Nullen sein.

Edit: habe den Code entwirrt für Euch, zu viele nichts sagende Serialausgaben für "Code fremde".

//  Arduino Mega 2560

// Deklaration der Funktionen, übernimmt die Arduino IDE selbst
// unsigned int read_MAX6675();
  
//  Arduino Mega 2560

// Port-Pins definieren
int    MAX_CS = 24;               // Arduino Pin, SPI ChipSelect, 1. MAX6675
int    MAX_SO  = 26;              // Arduino Pin, SPI Datenleitung
int    MAX_CLK = 28; 	          // Arduino Pin, SPI Clockleitung

// Deklaration Datentypen und Variablen
int Poti = 0;                     // Eingang A0
int Filterfaktor = 1;
float Teiler = 2.0;

unsigned int Vorkommastellen;        // Sicherung der Vorkommastellen
float Restwert;               // 2 Kommastellen als Ganzzahl
unsigned int Kommastellen;           // Kommastellen für sich als Ganzzahl
float Komma;

unsigned int value = 0;

unsigned int Temp = 0;	
float Mittelwert = 0;
float actual = 0;

void setup() {

  Serial.begin(9600); 
 
  pinMode(MAX_CS, OUTPUT);
  pinMode(MAX_SO, INPUT);
  pinMode(MAX_CLK, OUTPUT);
  
  digitalWrite(MAX_CS, HIGH);               // Ruhezustand
  digitalWrite(MAX_CLK, LOW);               // Ruhezustand
    
}

void loop() {
  
  delay(1000);
  Filterfaktor = analogRead(Poti)/8;        // lese analog Pin A0 ein und Begrenzung auf 128
  if(Filterfaktor == 0) Filterfaktor = 1;   // wenn A0 = 0, dann setze es auf 1 (Mindestwert)
  Teiler = Filterfaktor + 1;                // Teiler immer eins größer wie Filterfaktor
  Temp = read_MAX6675();
  actual = Temp / 4.0;
  //Serial.print(Filterfaktor);
  //Serial.print("  ");
  //Serial.print(actual,2);                   // aktueller Meßwert von A0
  //Serial.print("  ");
  Mittelwert = (Temp/4.0 + Mittelwert * Filterfaktor) / Teiler;
  Serial.println(Mittelwert,4);              // gleitender Mittelwert  (Bsp. 25,37)
  Vorkommastellen = (unsigned int) Mittelwert*100;   // Sicherung der Vorkommastellen (Bsp. 2500)
  Serial.print("Vorkommastellen ");
  Serial.println(Vorkommastellen,4);
  Restwert = Mittelwert * 100;               // 2 Kommastellen als Ganzzahl (Bsp. 2537)
  Serial.print("Restwert ");
  Serial.println(Restwert,4);
  Kommastellen = Restwert - Vorkommastellen; // Kommastellen für sich als Ganzzahl
  Serial.print("Kommastellen ");
  Serial.println(Kommastellen,4);
  if (Kommastellen < 50)
     {
      Komma = 0.0;
     }
     else 
        {
         Komma = 0.5;
        }
  Serial.print("Komma ");
  Serial.println(Komma,4);    
  
}

// -----------------------------------------------------------------------------------------------------	 
// Der MAX6675 wird ausgelesen und der 12-Bit-Wert zurückgegeben ********
unsigned int read_MAX6675 ()
{
  int i;
  unsigned int data;
  data = 0;
  digitalWrite(MAX_CS, LOW);            // CS=Low
  for(i=0;i<16;i++)
    {
     delayMicroseconds(1);             // warte 100us
     digitalWrite(MAX_CLK,HIGH);	 // SCK=High
     delayMicroseconds(1);		 // warte 100us
     // data = ((data<<1) | MAX_SO);	 // schiebe nach links und lies SO
     data = ((data<<1) | digitalRead(MAX_SO));	 // schiebe nach links und lies SO
     digitalWrite(MAX_CLK, LOW);	 // SCK=Low
    }
  delayMicroseconds(1); 	
  digitalWrite(MAX_CS, HIGH);         	 // CS=High
  delayMicroseconds(1); 		 // warte 100us
  return (data>>3);			 // gib 12-Bit Wert zurück
}

Hallo,

habe das Problem eingekreist, aber noch nicht lösen können.

wenn ich 25.3724 mit 100 multipliziere in eine Ganzzahl, erhalte ich 213010 statt 2537.
Kann doch nun wirklich nicht sein!

Vorkommastellen = (unsigned int) Mittelwert*100;

//  Arduino Mega 2560
// Deklaration Datentypen und Variablen

float Mittelwert = 25.3724;
unsigned int Vorkommastellen;        // Sicherung der Vorkommastellen


void setup() {

  Serial.begin(9600); 
 
  Serial.print("Mittelwert ");
  Serial.println(Mittelwert,4);                      // gleitender Mittelwert  (Bsp. 25,3724)
  
  Vorkommastellen = (unsigned int) Mittelwert*100;   // Sicherung der Vorkommastellen (Bsp. 2537)
  Serial.print("Vorkommastellen ");
  Serial.println(Vorkommastellen,4);
  
}

void loop() {
}

Doc_Arduino:
habe das Problem eingekreist, aber noch nicht lösen können.

wenn ich 25.3724 mit 100 multipliziere in eine Ganzzahl, erhalte ich 213010 statt 2537.
Kann doch nun wirklich nicht sein!

Hm, und ich multipliziere den String "Hänschen klein, ging allein" mit 100 und erhalte 14532.

void setup() {
  Serial.begin(9600); 
  char str[]="Hänschen klein, ging allein";
  int ergebnis=(unsigned int) str*100;
  Serial.println(ergebnis);
}

void loop() {}

Erkennst Du, was Du gemacht hast?
Erkennst Du, was ich gemacht habe?

Dein Typecasting "(unsigned int) Mittelwert" einer Gleitkommazahl auf eine Ganzzahl ist genau so ein programmtechnischer Irrsinn wie mein Typecasting "(unsigned int) str" eines String-Pointers auf eine Ganzzahl, wenn danach irgendwas mal 100 ausgerechnet werden soll.

Tipp: Mache kein Type-Casting, wenn Du kein Type-Casting haben möchtest!

Normalerweise schneidet ein Cast einer Gleitkommazahl einfach die Nachkommastellen ab (solange man keine negativen Zahlen hat und auf unsigned castet! Dann kommt wirklich Unsinn heraus).

Bei (unsigned int) 25,3724 * 100 sollte allerdings theoretisch 2500 rauskommen.

Serenifly:
Normalerweise schneidet ein Cast einer Gleitkommazahl einfach die Nachkommastellen ab (solange man keine negativen Zahlen hat und auf unsigned castet! Dann kommt wirklich Unsinn heraus).

Mein Fehler, Du hast Recht, zwischen int und float und umgekehrt wird bei C++ ja tatsächlich vom Compiler auch konvertiert und nicht nur einfach der Typ auf einen anderen Typ zugewiesen.

Serenifly:
Bei (unsigned int) 25,3724 * 100 sollte allerdings theoretisch 2500 rauskommen.

Der einzige Fehler in seinem Code scheint dann tatsächlich zu sein, dass er versucht eine Ganzzahl per println() mit der Aufrufkonvention für eine Gleitkommazahl mit vier Nachkommastellen formatiert auszugeben. Also

Serial.println(Vorkommastellen,4);
statt richtig:
Serial.println(Vorkommastellen);

Hallo,

ich weis was Du mir sagen willst. Aber ob das Programm technisch Unsinn ist oder nicht spielt doch erstmal gar keine Rolle. Normal sollte das funktionieren in der Programmierung. Und nur in der Programmierung. Denn wenn das Unsinn wäre, dann sind auch solche Sachen wie

x = x * 2;

Unsinn. Weil in der Mathematik einfach falsch.

Zurück zur Aufgabe. Also heißt das ich muß bei float bleiben. Man kann den Datentyp zwar von Ganzzahl auf Fließkomma ändern, aber nicht wieder zurück. Einmal float immer float bis zum Zerlegungsende? Ist es das was Du mir sagen möchtest?

Aber normalerweise sollte bei 25,3724 * 100 im Ergebnis 2537 rauskommen. Das mußt Du doch zugeben. Weil der Rest einfach abgeschnitten wird bei Ganzzahlen. So ist das doch definiert. Wird jedoch hier nicht gemacht. Warum ist die Frage.

Ein Bsp. von meinem Renesas R8C13. Hier wird auch eine Fließkommazahl zerlegt für eine LCD Ausgabe. Auch mit Ganzzahl. Beim R8C13 wurde fast alles mit Ganzzahlen gemacht und Fließkomma vermieden, weil wenig Speicher vorhanden war und er mit vielen Fließkommazahlen einfach in die Knie ging.

// ********************************* Ausgabe an LCD ****************************** \\
// *************** Ausgabe mit voller 0.25°C Auflösung des MAX6675 *************** \\
void lcd_MAX6675_full (uint data)
   {
	uchar byt;										// byt ist eine Ganzzahl Variable
	value = (float) data / 4;						// Bsp. value = 861,75 = 3447 / 4
	if ( value >= 10000 ) {value = 9999; }			// Anzeigenlimitierung auf 9999 
	
   	byt   = value / 1000;							// byt = 0  (0,86175)
   	if(byt == 0)									// wenn Tausenderstelle = 0
   		display_chars_on_lcd(" ", 1);				// dann wird ein Leerzeichen ausgegeben
			else   
				display_digits_on_lcd(byt + 48);	// Tausender Ausgabe
	
	value = value - byt * 1000;						// value = 861,75 = 861,75 - 0 * 1000			
   	byt   = value / 100;							// byt = 8   (8,6175)
   	if(byt == 0)									// wenn Hunderter = 0
   		display_chars_on_lcd(" ", 1);				// dann wird ein Leerzeichen ausgegeben
			else 
				display_digits_on_lcd(byt + 48);	// Hunderter Ausgabe
	
	value = value - byt * 100;						// value = 61,75			
   	byt   = value / 10;								// byt = 6   (6,175)
   	if(byt == 0)									// wenn Zehnerstelle = 0
   		display_chars_on_lcd(" ", 1);				// dann wird ein Leerzeichen ausgegeben
			else 
				display_digits_on_lcd(byt + 48);	// Zehner Ausgabe
	
	value = value - byt * 10;						// value = 1,75			
	byt   = value;									// byt = 1   (1,75)
   	if(byt == 0)									// wenn Einerstelle = 0
   		display_digits_on_lcd(48);					// dann wird eine 0 ausgegeben
			else 
   				display_digits_on_lcd(byt + 48); 	// Einer Ausgabe
				
	display_chars_on_lcd(".", 1);					// Dezimalpunktausgabe an LCD
	value = value - byt;							// value = 0,75
	value = value * 10;								// value = 7,5
	byt   = value;								    // byt = 7
	value = value - byt;	        				// data = 0,5
	display_digits_on_lcd(byt + 48); 				// erste Kommastellenausgabe
	byt   = value * 10;								// byt = 5
	display_digits_on_lcd(byt + 48); 				// zweite Kommastellenausgabe
	send_byte_to_lcd(0xDF);							// Zeichen ° an LCD
	display_chars_on_lcd("C", 1);					// Zeichen C an LCD
			
	}

Dann müsstest du es aber schon so machen:
int i = (unsigned int)(25,3724 * 100);

Ansonsten hat der Cast Vorrang vor der Multiplikation und es kommt 2500 raus

Hallo,

funktioniert leider auch nicht.

Mittelwert 25.3724
Vorkommastellen 213221
//  Arduino Mega 2560
// Deklaration Datentypen und Variablen

float Mittelwert = 25.3724;
unsigned int Vorkommastellen;        // Sicherung der Vorkommastellen

void setup() {

  Serial.begin(9600); 
 
  Serial.print("Mittelwert ");
  Serial.println(Mittelwert,4);                      // gleitender Mittelwert  (Bsp. 25,3724)
  
  Vorkommastellen = (unsigned int) (Mittelwert*100);   // Sicherung der Vorkommastellen (Bsp. 2500)
  Serial.print("Vorkommastellen ");
  Serial.println(Vorkommastellen,4);
}

void loop() {  
}

Spinnt der Compiler rum oder was ist hier nur los?
Weil im "Simulator für Arduino" funktioniert alles.

Ansonsten muß ich anders rangehen. Vorher die Größe der Zahl ermitteln und dann ähnlich der R8C13 LCD Zerlegung mich durcharbeiten.

Doc_Arduino:
Spinnt der Compiler rum oder was ist hier nur los?

Du ignorierst Reply #6.

Hallo,

ignoriert nicht, nur nicht mitbekommen. Bei meiner letzten Antwort war Deine entweder noch nicht da oder ich hab's glatt übersehen.

Antwort #6.

Ja, dass ist genau das was ich bebobachtet habe. Gibt man ohne Kommastellen aus stimmt es, gibt man mit Kommastellen an, stimmt es nicht mehr. Das war mehr oder weniger Zufall das ich das so ausprobiert habe.

Ich dachte dann wird einfach mit Nullen aufgefüllt. 0 ist doch auch 0,0000. Dagegen spricht doch nichts.
Macht die Serial.print Funktion etwas falsch? Die ist doch dafür da Zahlen auszugeben. Ob nun mit oder ohne Kommastellen. Im Augenblick verfälscht sie Ganzzahlen.

Das funktioniert wie gedacht. Nur mit Gleitkommazahlen. Deine Variable ist ein Integer. Daher kannst du diese Formatierung nicht verwenden.

Doc_Arduino:
x = x * 2;

Unsinn. Weil in der Mathematik einfach falsch.

Stimmt so nicht wirklich. Es handelt sich hierbei um keine Gleichung, in der beide Seiten identisch sind.
Man kann es sich dabei einfach so denken, der Controller holt sich seinen Wert für x aus dem Speicher, berechnet diesen neu, und legt ihn als neues x wieder auf die alte Stelle.

Doc_Arduino:
Ja, dass ist genau das was ich bebobachtet habe. Gibt man ohne Kommastellen aus stimmt es, gibt man mit Kommastellen an, stimmt es nicht mehr.

Es stimmt alles.

Die Funktion print/println hat verschiedene Aufruf-Interfaces je nach Art der übergebenen Variablen:

Serial.print(float, int) ==> gibt eine Gleitkommazahl aus, int steht für die Anzahl der Nachkommastellen
Serial.print(int, int) ==> gibt eine Ganzzahl aus, das zweite int steht für die Zahlenbasis bei der Ausgabe

Vielleicht sind Dir die folgenden Aufrufe bekannt:
Serial.print(int, BIN) für die Ausgabe als Binärzahl, das ist gleichbedeutend mit
Serial.print(int, 2)
Ausgegeben wird eine Ganzzahl zur Basis 2.

Oder Serial.print(int, HEX) für die Ausgabe als Hexadezimalzahl, gleichbedeutend mit
Serial.print(int, 16)

Die zweite Ganzzahl steht für die Zahlenbasis bei der Konvertierung für die Ausgabe.
Serial.print(int, 4) gibt also einen Zahlenwert zur Basis 4 aus
In der so ausgegebenen Zahl kommen nur die Ziffern 0, 1, 2, und 3 vor.
Das ist einfach eine Ausgabe in einem umgerechneten Zahlensystem.
Und zwar umgerechnet in ein wenig gebräuchliches Zahlensystem.

Für die Ausgabe im Dezimalsystem kannst Du statt Serial.print(int) auch verwenden:
Serial.print(int, 10)
Dann erfolgt die Ausgabe der Ganzzahl dezimal zur Basis 10.

Hallo,

@ sschultewolter: ist klar. Das war meine Anspielung auf jurs Kommentar zu meinem Programmtechnischen Unsinn. In der Programmierung wird das so gemacht. Rein mathematisch betrachtet bleibt die Gleichung Unsinn. Mehr wollte ich nicht sagen.

@ jurs: Ich glaube wir kommen zum Pudels Kern. Dann wäre allerdings die Beschreibung zur Serial.print Ausgabe nicht ganz vollständig. Die habe ich nämlich mehrfach durchgelesen.
Dort steht für Zahlenbasis nur die Auswahl BIN, OCT, DEC und HEX.
Alle anderen Angaben habe ich immer so verstanden, dass man damit die Anzahl der gewünschten Kommastellen angibt. Deshalb meine Annahme das aus 11 dann einfach 11.0000 wird.

Nach Deiner jetzigen Erklärung wird mir das Problem glasklar.
Man muß wissen welchen Datentyp man ausgeben möchte. Bei Fließkommazahlen sind es Kommastellen und bei Ganzzahlen die Zahlenbasis. Das habe ich jetzt verstanden.

Prüft die Serial.print Funktion den Datentyp?

Warum dann aber aus der x.24 mit mehr Kommastellen x.23999 wird bleibt auch ein Geheimnis. Oder?

Mittelwert 25.3724
Vorkommastellen DEC 2537
Mittelwert 2537.24
2537.2
2537.24
2537.240
2537.2399
2537.23999
//  Arduino Mega 2560
// Deklaration Datentypen und Variablen

float Mittelwert = 25.3724;
unsigned int Vorkommastellen;        // Sicherung der Vorkommastellen

void setup() {

  Serial.begin(9600); 
 
  Serial.print("Mittelwert ");
  Serial.println(Mittelwert,4);                      // gleitender Mittelwert  (Bsp. 25,3724)
  
  Vorkommastellen = (unsigned int) (Mittelwert*100);   // Sicherung der Vorkommastellen (Bsp. 2500)
  Mittelwert = Mittelwert * 100;
  Serial.print("Vorkommastellen DEC ");
  Serial.println(Vorkommastellen,DEC);
  Serial.print("Mittelwert ");
  Serial.println(Mittelwert);
  Serial.println(Mittelwert,1);
  Serial.println(Mittelwert,2);
  Serial.println(Mittelwert,3);
  Serial.println(Mittelwert,4);
  Serial.println(Mittelwert,5); 
  
}

void loop() {
}

Doc_Arduino:
@ jurs: Ich glaube wir kommen zum Pudels Kern. Dann wäre allerdings die Beschreibung zur Serial.print Ausgabe nicht ganz vollständig. Die habe ich nämlich mehrfach durchgelesen.
Dort steht für Zahlenbasis nur die Auswahl BIN, OCT, DEC und HEX.

// From "c:\program files\arduino\hardware\cores\arduino\print.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2

DEC, HEX, OCT, BIN, das sind nur vordefinierte Zahlenwerte.

"Die Beschreibung" ist bei "Open Source Software" eben im Zweifelsfall immer der Quellcode.
:wink:

Doc_Arduino:
Warum dann aber aus der x.24 mit mehr Kommastellen x.23999 wird bleibt auch ein Geheimnis. Oder?

Nö, die Rundungsfehler bei der Verwendung von Gleitkommazahlen sind systembedingt. Wenn Du diese entstehenden Rundungsfehler nicht begriffen hast, hast Du Gleitkommazahlen insgesamt noch nicht verstanden.

Aber tröste Dich, das geht selbst Profis so. Der vom wirtschaftlichen Schaden her größte Fall, dass Profis sich mit Gleitkommazahlen verhauen haben, ist im Jahr 1994 aufgedeckt worden, mehr als ein Jahr nach Markteinführung des Pentium-Prozessors, bei dem der Fehler im Hardware-Layout fest eingebrannt war:

Gleitkommazahlen können in der Verwendung tricky sein.
Falls möglich, verzichtet man besser darauf.

Ich kann z.B. eine Temperatur in Zehntelgrad auch gleich ganzzahlig in Zehntelgrad im Programm rechnen. Oder eine Spannung mit drei Nachkommastellen in Millivolt ganzzahlig rechnen. Dann brauche ich im ganzen Programm keine einzige Gleitkommazahl. Und wenn eine Angabe in Millivolt für die "menschengerechte" Anzeige trotzdem wie eine Gleitkommazahl dargestellt werden soll, kann man das mit einfacher Modulo-Arithmetik hinbekommen - wieder ohne Gleitkommarechnung. RAM-speichersparend, blitzschnell und ohne Rundungsfehler.

Hallo,

okay, alles klar. Ist "nur" eine Frage der Definition. :wink: Hier entscheidend.

Jedenfalls vielen Dank an Dich/Euch für Eure Geduld zur Klärung des Problems.

Jenseits aller Serial.print diskussion (die ich sehr lehrreich finde!) hatte ich den Eindruck, du willst einen float Wert auf dem LCD ausgeben.

Ich hätte dafür eine Funktion in meinem Baukasten.

write2LCDf.ino (4.13 KB)

Hallo,

das Gefühl täuscht Dich nicht. Das kommt auch noch dran. Ich beacker immer noch viele Grundlagen und probiere und mache und ... stoße dann immer wieder auf solche Kleinigkeiten wie die hier.

Wenn ich das alles begriffen habe, soweit mir das möglich ist, setze ich die Teilabschnitte zusammen. Am Ende soll eine Spannung, eine Temperatur und vielleicht noch etwas "Spielkram" gemessen werden, auf eine SD-Karte mitgeschrieben, paar Werte auf ein LCD und mindestens ein Wert über WLAN angezeigt werden. Das ist der große Masterplan. :wink: Ob das mit dem WLAN funktioniert ist aber nicht sicher. Hängt von den Empfangsverhältnissen vorm Gebäude ab. Wenn das WLAN funktionieren würde, käme noch die Erweiterung mit der sql Datenbank hinzu. War vor kurzem hier ein tolles Projekt mit weiterführenden Links aus der Taufe gehoben wurden. Raspberry ist vorhanden und langweilt sich.

Dein Code sieht auf jeden Fall kürzer aus als der den ich vom R8C13 kenne. Ist paar Einträge zurück gepostet. Deinen werde ich zu gegebener Zeit ausprobieren. Vielen Dank schon einmal dafür.