Arduino, strippen van decimale waarde

blackdog

Honourable Member

Hi,

Ik ben met software bezig voor een kleine microcontroler, die intern wat functies regelt, zoals het uitlezen van druktoetsjes, relais sturing en temperatuur metingen en de Power OpAmp in of uitschakeld.

Het een en ander gaat ook op een mini OLED schermpje worden weergegeven.
Ik heb bij het weergeven van de temperaturen geen ruimte om de waarde achter de comma aan te geven.
Ook al zou ik dit willen, is het onnodig bij deze toepassing, van 36C en dan naar 37C gaan is mooi zat.

De Variabel die uiteindelijk de temperatuur bevat kan er zo wat inhoud betreft uitzien: 36.63883

De de vraag is dus, hoe strip is alles na de punt er af, en als ik b.v toch 1 decimaal zou willen overhouden voor een bepaalde toepassing, hoe doe ik dat dan?

Dank en groet,
Bram

Existence, well, what does it matter? I exist on the best terms I can... Heart and soul, one will burn

Hangt van je programmeertaal af, maar de meeste hebben een functie floor(), die geeft het getal terug wat het grootste integer is dat lager of gelijk is aan de waarde.
Om af te ronden gebruik je floor(variabele + 0.5)

round() werkt gewoon op arduino.

Zo maak je het aantal cijfers achter de comma variabel:

c code:


float truncate(float val, byte dec) 
{
    float x = val * pow(10, dec);
    float y = round(x);
    
    x = y / pow(10, dec);
    return x;
}

truncate(3.1415,2) geeft dan 3.14

Korter genoteerd zonder functie:

c code:


round(3.1415*100)/100

Ipv van floor kan je de floot variabele in een integer variabele zetten

Door:

c code:


float temp = 31,12;
int displaywaarde = 0;

displaywaarde = temp;

displaywaarde bevat dan 31, is wel altijd naar beneden afgerond.

Of omzetten naar een integer.
Met afronden gaat dat zo:

code:

   float Temp = 36.63883;
   int T = (int)(Temp + 0.5);

Wil je 1 cijfer houden dan eerst met 10 vermenigvuldigen:

code:

   float Temp = 36.63883;
   int T = (int)(Temp * 10. + 0.5);

Meestal heeft de print functie ook mogelijkheden om het aantal decimalen te kiezen.

Voor arduino:
Als je een float print kun je met een 2e parameter het aantal decimalen opgeven. Moet ook werken voor een LCD:

code:

   float Temp = 36.63883;
   Serial.print(Temp,0);  // 0 cijfers achter de komma
   Serial.print(Temp,1);  // 1 cijfers achter de komma

Toch hebben al deze methodes ook wel een nadeel wat als je temperatuur eerst 10,0 en daarna 9,2 is op je display zie je dan waarschijnlijk 90 staan, de 9 van de nieuwe waarde en de 0 van 10.

Om displaay waarde ter formateren kan je

c code:

char buffer[2];
sprintf(buffer, "%2d", temperatuur + 0,5);
print buffer;

In buffer staat dan voor
10,0 > 1, 0
9,2 > spatie, 9

en als ik b.v toch 1 decimaal zou willen overhouden voor een bepaalde toepassing, hoe doe ik dat dan?

c code:

char buffer[4];
snprintf(buffer, 4, "%2.1f", temperatuur);
print buffer;

"%2.1f" betekend converteer de float waarde van temperatuur naar het formaat met 2 cijfers voor de komma en 1 er achter.
Dat word als ascii in buffer gezet vandaar dat je buffer grote ook minimaal 4 moet zijn. Want de komma is daar dan gewoon de ascii waarde voor een komma. Dus 36,8901 word dan een drie, zes, komma en acht. Rond ook weer altijd naar beneden af, eigenlijk word er in het geheel niet afgerond maar worden gewoon alle cijfer voor de komma en de cijfer erachter gewoon letterlijk gebruikt. En als er maar 1 cijfer voor de komma staat woord het aangevuld met spaties

Het gaat wel fout als je temperatuur ooit groter dan 99 word, want dan word ook weer alle cijfers voor de komma gebruikt die ongelijk aan 0 zijn. Dus bedenk vooraf goed wat de minimale en maximale waarden kunnen zijn.

PS print buffer is onzin code. Ik bedoel daar dat de geformatteerde waarde die je wilt printen nu in buffer staat.

Het klopt wel wat benleentje zegt, maar de printf op een arduino AVR heeft bij default geen ondersteuning voor floats. Die moet je dan eerst inschakelen en dat gaat zomaar niet in de arduino IDE.

Als alternatief kun je wel terugvallen op de dtostr() funktie:

code:

   float Temp = 36.287;
   char Buffer[20];
   dtostr(Temp, 4, 1, Buffer);
   Serial.print(Buffer);

Hier
- 4 : totaal minimum aantal letters, inclusief komma en decimalen
- 1 : aantal cijfers achter de komma

blackdog

Honourable Member

Heren, dames ook als van toepsssing, :-)

Hartelijk dank voor de voorbeelden hoe mij vragen op te lossen!
Ik ga morgen wat van jullie oplossingen toepassen, de temperatuur zal vanaf 10C° tot denk ik 80C° lopen, hoger wil ik de temperatuur absoluut niet hebben in mijn kastje van het meetinstrument.

Ik meet drie onderdelen wat temperatuur betreft, de LT1210 OpAmp, de voeding regelaars op de achterzijde van het kastje en de trafo temperatuur.

Voor de drie temperaturen ga ik een limiet stellen en boven de gestelde limieten worden een aantal zaken uitgeschakeld tot de temperatuur weer voldoende laag is geworden.

Ik zal testen of er met de simpele oplossing van deKees geen artefacten achter blijven en anders b.v. de dtostr() testen of de manier van benleenje.
Dan gaan we morgen eens mooi empirisch onderzoeken. ;)

Dank en groet,
Bram

Existence, well, what does it matter? I exist on the best terms I can... Heart and soul, one will burn

Op 31 maart 2022 00:00:28 schreef benleentje:
Om displaay waarde ter formateren kan je

c code:

char buffer[2];
sprintf(buffer, "%2d", temperatuur + 0,5);
print buffer;

Je buffer is te klein, voor sprintf (en alle andere C-functies met strings) moet er ook nog plek zijn voor de terminating zero.

c code:

char buffer[3];
sprintf(buffer, "%2d", temperatuur + 0,5);
my_hardware_dependent_print(buffer);

ik zet anders om:

bv temp = 36.63883

int(temp) = 36
int(temp*10)/10 = 36,6. heel korte methode om 1 komma te behouden.
meestal vermenigvuldig ik de hele boel met 10 in het begin van het programma, houd alles in integers, en enkel bij weergave doe ik dit naar het display. bespaart je veel geheugen door geen floats te gebruiken, en heeft als voordeel ook dat subroutines van displays er ook geen problemen mee hebben (int en strings aanvaarden ze altijd)

temp is dan 366 in het programma
print(String(int(temp)/10)); geeft me dan 36,6 op het display

want veel van die printf enzo worden niet ondersteund door display libraries. met bovenstaande geef je altijd tekst (string) naar het display. tot nu toe nooit problemen mee gehad

ik hou van werken ..., ik kan er uren naar kijken

Fcapri, in c of c++ is int(temp) een int en als je die door 10 deelt wordt dat met int deling gedaan. Tenzij jij een functie mag declareren genaamd int, die precies niet doet wat de naam impliceert.

Ik doe zelf

code:

printf ("%d.%01d", temp/10, temp÷10);

[Bericht gewijzigd door rew op 31 maart 2022 07:17:50 (14%)

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Met Arduino is dit toch wel het makkelijkste;

c code:


String MyDisplayStr = String(temperatuur, 0);                  // using a float and the decimal places

die printf doet dat misschien wel, maar als je naar een display schrijft geeft dat foutmeldingen. die %D.%01D is niet bij elk scherm aanvaard.

gisteren gedaan met een U8G2 library waarbij ik 1 decimaal op het scherm wou.
en die aanvaarde enkel strings.
ik deed dat met u8g2.print(String(int(temp*10)/10));
en dat werkte toch, had kommagetal op display

ik hou van werken ..., ik kan er uren naar kijken

Op 31 maart 2022 09:12:11 schreef fcapri:
die printf doet dat misschien wel, maar als je naar een display schrijft geeft dat foutmeldingen. die %D.%01D is niet bij elk scherm aanvaard.

Daar is sprintf voor.

Of nog beter, implementeer __putc() (hangt een beetje af van welke C-library je hebt), en printf werkt gewoon zoals je wilt.

Voor bonuspunten, zoek uit hoe je C-library streams doet, en je kunt fprintf(DEBUG, "%d ...) voor je debug-rs232 gebruiken, en fprintf(SCREEN, "%d") voor je schermpje.

Het probleem is natuurlijk dat er geen één methode is die altijd werkt. Wat mij betreft schiet arduino hier ook te kort. Net als de meeste grafische libraries.

En dat betekent dat je steeds weer een eigen library moet maken om het precies goed te krijgen.

code:

sprintf(Buffer, "%5.1f", Temp);
  • Geeft soms teveel letters
  • Ondersteunt niet altijd floats
  • Is gevaarlijk met de parameterlijst (al geeft de compiler wel goede waarschuwingen.
  • Verwacht een buffer die groot genoeg moet zijn.

code:

Serial.print(Temp,1)
  • Werkt alleen op arduino
  • Geeft soms te weinig letters zodat niet alle text op het scherm wordt overschreven.

code:

dtostr(Buffer, 5,1,Temp);
  • is niet-standaard. En dus niet altijd aanwezig.
  • Geeft soms teveel letters
  • Verwacht een buffer die groot genoeg moet zijn.

code:

String(int(temp)/10)
  • Werkt alleen op arduino
  • Geeft niet altijd genoeg cijfers
  • Vreemd als dat werkt. Ik zou verwachten dat die een integer print in tientallen graden.
  • Ik zou hier ook geen komma in de output verwachten.

code:

int T = (int)Temp;
  • Geeft wel een integer, maar die moet dan nog naar een string geconverteerd worden. Geen afronding.

code:

int T = round(Temp);
  • Geeft wel een afgeronde integer
  • Moet nog naar een string geconverteerd worden.

code:

sprintf (Buffer, "%2d.%1d", (int)(temp/10), ((int)temp)%10);
  • Deze werkt waarschijnlijk in de meeste gevallen.
  • Maar kan ook teveel chars geven.
  • Nogal omslachtige notatie
  • Afhankelijk van een buffer die groot genoeg moet zijn

Op 31 maart 2022 14:17:30 schreef deKees:
Het probleem is natuurlijk dat er geen één methode is die altijd werkt. Wat mij betreft schiet arduino hier ook te kort. Net als de meeste grafische libraries.

En dat betekent dat je steeds weer een eigen library moet maken om het precies goed te krijgen.

Werkt alleen op arduino
Geeft soms te weinig letters zodat niet alle text op het scherm wordt overschreven.

hangt van het display af, als je eerst een clear buffer doet, en dan de nieuwe data wegschrijft, is dat geen probleem.
bij één van mijn TFT's heb ik in gecalculeert dat een temp waarde 4 karakters is.
dus telkens als ik een update doe van de temp, schrijf ik 4 spaties naar het scherm en schrijf dan de correcte waarde terug.
1x had ik een scherm die daarop flikkert. heb ik 2 temp waardes gebruik.
eerst inverteerde ik het kleur, en schreef tempOld naar het display, die schreef zijn bestaande tekst dus in backgroudkleur, en daarna schreef ik de goeie naar het scherm

Op 31 maart 2022 14:17:30 schreef deKees:

code:

String(int(temp)/10)
  • Werkt alleen op arduino
  • Geeft niet altijd genoeg cijfers
  • Vreemd als dat werkt. Ik zou verwachten dat die een integer print in tientallen graden.
  • Ik zou hier ook geen komma in de output verwachten.

ik heb het eens gedaan, maar vermoed dat ik
float temp = 30.64;
...
temp = int(temp*10); //geeft 306 terug naar de float van temp
print(temp/10); // geeft 30.6 terug

of in 1 keer
temp = int(temp*10)/10;

bij temperatuur van 10-99° heb je geen probleem aangezien je altijd 2 karakters hebt

PS: serial.println in arduino maakt altijd maar 2 cijfers na de komma voor een float. daarmee kan je dus niet testen. en elke display library zal dit op zijn eigen manier oplossen.
heb toevallig deze week nog die manier gebruikt om naar een display te schrijven, dus weet dat het werkte

ik hou van werken ..., ik kan er uren naar kijken

Op 31 maart 2022 14:27:31 schreef fcapri:

temp = int(temp*10); //geeft 306 terug naar de float van temp
print(temp/10); // geeft 30.6 terug

of in 1 keer
temp = int(temp*10)/10;

Dat die eerste zal werken zijn deKees en ik het over eens.

Die eerste doet 10-> 10.0 dat dan floatingpoint-multiply met temp en dan opslaan in de float temp. Ga je dan "temp/10" printen, dan wordt de float (bijvoorbeeld 346.0) door tien gedeeld (34.6) en dan geprint. Duidelijk.

Maar doe je int(temp*10), dan krijgt de functie "int" de float temp*10 als input. Volgens mij is in C++ als je een typenaam als functienaam gebruikt dat de conversie naar dat type. Doe je ook met "string (...)" . Dus mijns inziens komt daar een "int" uit En als je "type-int / type-int" doet in een C-achtige taal (C++ dus ook) dan wordt dat met een int-deling gedaan. Je krijgt dan dus 346/10 = 34 (integer deling, afronden naar beneden). Als je hem dan toekent aan de float variable "temp", dan zou temp de waarde 34.0 moeten krijgen. In eerdere voorbeelden werd ie daarvandaan geprint.

Als je darentegen " int (temp*10)/10. " schrijft, dan is de 10. een float, dan wordt een float deling gedaan en zou het resultaat dus een float moeten zijn. Dan snap ik dat het werkt.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

als temp 34,65432 is, dan doet die eerste

int(34,65432 * 10) = 346
dan ben je toch al die 0.05432 kwijt.

daarna een deling van 10, krijg je weer 34,6.
meen ergens te weten dat C toch ook weer van int naar float gaat als je een deling doet.
((int(float * 10))/10)

code:


((int( float * 10  ) ) / 10   )

((int(34,65432 * 10 ) )  / 10       )
     (float 346.5432)
 (    int   346       )
(     float 34.6                    )

echter als ik dat nu test (weliswaar met serial.println) doet die het niet meer. serial.println doet altijd een float met 2 cijfers na de komma

[Bericht gewijzigd door fcapri op 31 maart 2022 15:36:12 (14%)

ik hou van werken ..., ik kan er uren naar kijken

meen ergens te weten dat C toch ook weer van int naar float gaat als je een deling doet.

Soms wel, soms niet. Dat hangt van de context af.

serial.println doet altijd een float met 2 cijfers na de komma.

Dat is inderdaad de default.
Maar dat kun je wel opgeven in de 2e parameter

code:


   Serial.println(Temp);    // 34.65   default 2 decimalen
   Serial.println(Temp,3);  // 34.652  3 decimalen
   Serial.println(Temp,1);  // 34.6    1 decimaal
blackdog

Honourable Member

Hi,

Ik zal even wat feedback geven over hoe ver ik er tot nog toe mee ben.
Ik kan de drie temperatuur sensoren weergeven op het 128x32 display zonder ghosting.

Ik gebruik hiervoor een stukje code voor het weergeven op dit kleine display van "robojax".

De code is in het geheel nog niet klaar, maar de basis werkt, ook de buttons zijn fuctioneel, ik moet echter wel nog de teksten aan de button status koppelen.

Ook zijn de verschillen tussen de TMP37 sensoren die ik gebruik te groot en ik heb al een variabele per sensor opgenomen voor een correctie waarde welke nog in de berekening van de temperatuur moet worden opgenomen.

De Microcontroler wordt een Teensy-LC of een Teensy-4, de Teensy-4 test ik nu mee omdat dit de enige Teensy is die ik hier beschikbaar heb.

Trouwens de meeste tijd wordt hier weggegooit door typefouten die ik maak als dyslectische Aap en de resulterende foutcode van de Arduino IDE die vaak geen betrekking heeft op mijn gemaakte typefout.

Ook heb ik de statusbalk onder in de IDE aangepast naar leesbare kleuren en font grote, zodat het buiten op mijn laptop ook nog leesbaar is.

Ik gebruik het volgende display voor de weergave:
https://www.tinytronics.nl/shop/nl/displays/oled/0.91-inch-oled-displa…

De laatste code:

c code:


#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <JC_Button.h>                                                          // https://github.com/JChristensen/JC_Button
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#include <ADC.h>
#include <ADC_util.h>
ADC* adc = new ADC();

//Gebruikt referentie spanning voorde ADC
float Ref = 3.288;

//Correctie waarden ter compensatie TMP37 kalibratie
float T_Amp_Cor = 0;
float T_PSU_Cor = 0;
float T_Trafo_Cor = 0;

// Variabelen nodig voor de temperatuur omzetting
int T_Amp = 0, T_Amp_D = 0, T_PSU = 0, T_PSU_D = 0, T_Trafo = 0, T_Trafo_D = 0 ;


// this is the Width and Height of Display which is 128 xy 32 
#define LOGO16_GLCD_HEIGHT 32
#define LOGO16_GLCD_WIDTH  128 

// pin assignments
const byte
    Output_1(4),                                                      // Input relais, switch 50 Ohm or 1K Impedance
    Output_2(5),                                                      // Output Enable Relais
    Output_3(6),                                                      // LT1210 Enable, used for "High Temp" condition
    BUTTON1_PIN(2),                                                   // connect a button switch from this pin to ground, internel pull-up is used
    BUTTON2_PIN(3);                                                   // connect a button switch from this pin to ground, internal pull-up is used

ToggleButton                                                          // define the buttons fuction
    btn1(BUTTON1_PIN, false, 5),                                      // this button's initial state is off, used for = Input Impedance
    btn2(BUTTON2_PIN, false, 5);                                      // this button's initial state is off, used for = Output Enable

byte state_btn1;
byte state_btn2;







void setup()   {                
Serial.begin(9600);

// ADC0 Settings Teensy-4, Teessy-LC
    adc->adc0->setAveraging(64); // set number of averages
    adc->adc0->setResolution(16); // set bits of resolution
    adc->adc0->setConversionSpeed(ADC_CONVERSION_SPEED::VERY_LOW_SPEED);  // change the conversion speed
    adc->adc0->setSamplingSpeed(ADC_SAMPLING_SPEED::MED_SPEED);           // change the sampling speed


// by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);                              // initialize with the I2C addr 0x3C (for the 128x32)

// Clear the buffer.
  display.clearDisplay(); 

// initialize the button objects
    btn1.begin();
    btn2.begin();

// set the vollowing pins as outputs
    pinMode(Output_1, OUTPUT);
    pinMode(Output_2, OUTPUT);
    pinMode(Output_3, OUTPUT);
    
// show the initial states
    digitalWrite(Output_1, btn1.toggleState());
    digitalWrite(Output_2, btn2.toggleState());
}







void loop() {

// Serial.println(state_btn1 = digitalRead(4));
// Serial.println(state_btn2 = digitalRead(5));

// LT1210 temperatuur berekening 
    T_Amp = adc->adc0->analogRead(14);
    T_Amp_D = (T_Amp*Ref/adc->adc0->getMaxValue()/0.02);
    
// Voedings temperatuur berekening
    T_PSU = adc->adc0->analogRead(15);
    T_PSU_D = (T_PSU*Ref/adc->adc0->getMaxValue()/0.02);
    
// Trafo temperatuur berekening
    T_Trafo = adc->adc0->analogRead(16);
    T_Trafo_D = (T_Trafo*Ref/adc->adc0->getMaxValue()/0.02);  


// Plaats variabelen voor de temperatuur metingen op het display
  display.clearDisplay();
  String T_Amp_Display =  String(T_Amp_D);                 
  robojaxText(T_Amp_Display, 19, 25, 1, false);

  String T_PSU_Display =  String(T_PSU_D);                 
  robojaxText(T_PSU_Display, 59, 25, 1, false);

  String T_Trafo_Display =  String(T_Trafo_D);                 
  robojaxText(T_Trafo_Display, 100, 25, 1, false);


// Plaatsen van statische tekst op het display  
  robojaxText("OUTPUT            ON", 0, 1, 1, false);            // "ON" = Tijdelijke tekst, deze twee regels worden later vervangen in een If/els gezet voor weergeve van te hoge temperaturen
  robojaxText("INPUT Impedance   1K", 0, 12, 1, false);           // "1K" = Tijdelijke tekst, deze twee regels worden later vervangen in een If/els gezet voor weergeve van te hoge temperaturen
  robojaxText("Ta   C Tp   C Tt   C", 1, 25, 1, false);

  display.display();
// read the buttons
    btn1.read();
    btn2.read();

// if button state changed, update the LEDs
    if (btn1.changed()) digitalWrite(Output_1, btn1.toggleState());
    if (btn2.changed()) digitalWrite(Output_2, btn2.toggleState());
  
}
  
void robojaxText(String text, int x, int y,int size, boolean d) 
    {
    display.setTextSize(size);
    display.setTextColor(WHITE);
    display.setCursor(x,y);
    display.println(text);
  if(d){
        display.display();
       }
    }

Dank allemaal voor de voorbeelden en uitleg!
In verhouding en simpele vraag maar met toch wel een grote dosis complexitijd.

Groet,
Bram

Existence, well, what does it matter? I exist on the best terms I can... Heart and soul, one will burn

Trouwens de meeste tijd wordt hier weggegooit door typefouten die ik maak als dyslectische Aap en de resulterende foutcode van de Arduino IDE die vaak geen betrekking heeft op mijn gemaakte typefout.

Ja dat ken ik maar al te goed. Vorig jaar 2 dagen aan het zoeken geweest in een stuk code. Was in de functie declaratie een : vergeten, maar de foutmelding was heel erg verwarrend.

Heb zelf ook wel dyslexie, maar je word er toch wel steeds beter in en de foutopsporing gaat bij mij steeds sneller. Maar als je geen fouten maakt leer je er lang niet zoveel van ;).

Op 31 maart 2022 05:01:00 schreef blurp:
[...]

Je buffer is te klein, voor sprintf (en alle andere C-functies met strings) moet er ook nog plek zijn voor de terminating zero.

Ik zat al te twijfelen toen ik dit gisteren poste, meestal maar ik de buffer gewoon vrij ruim omdat juist te voorkomen.

meen ergens te weten dat C toch ook weer van int naar float gaat als je een deling doet.

Nee alleen als beide een float zijn anders gewoon een int deling.

float temp = 30,67432124323
print(temp/10); >> geeft dan gewoon 30
print(temp/10,0);>> geeft 30,6

Dus pas als je een float deelt door een andere float dan krijg je ook pas een float terug.

Het klopt wel wat benleentje zegt, maar de printf op een arduino AVR heeft bij default geen ondersteuning voor floats.

Werk volgens mij wel een floats als inputvariabele maar je krijgt geen float terug, dus ja dat klopt was ik alweer vergeten vandaar dat ik ook met snprinf ben gaan werken waar ik ook echt een float als eindwaarde terug krijg.

Op 31 maart 2022 19:40:32 schreef benleentje:
Ik zat al te twijfelen toen ik dit gisteren poste, meestal maar ik de buffer gewoon vrij ruim omdat juist te voorkomen.

[...]vandaar dat ik ook met snprinf ben gaan werken

snprintf is juist weer leuk dat je de bufferlengte kunt (moet) opgeven, en dat ie dan nooit over het eind van je buffer gaat.

Nadeel is dat de terminating 0 dan niet altijd in de buffer terecht komt, en dat geeft vreemde en ongewenste effected als je de buffer daarna in een print-routine stopt die alles tot de terminating 0 uitprint.

Wat wel werkt:

c code:


#define BUFFER_LENGTH 42

char buffer[BUFFER_LENGTH+1];
buffer[BUFFER_LENGTH] = '\0';       //altijd een terminator op de buffer

snprintf (buffer, BUFFER_LENGTH, "%d bla bla", floatwaarde);

hardware_dependent_print_functie(buffer);
PE9SMS

Golden Member

De hele buffer op 0 initialiseren kan ook toch?

c code:

#define BUFFER_LENGTH 42
char buffer[BUFFER_LENGTH+1] = {0};
This signature is intentionally left blank.

... maar dat is onnodig (langzaam).

Ik protesteer tegen:

... C ...

float temp;
print(temp/10); >> geeft dan gewoon 30

Ik heb de proef op de som genomen:

code:

#include <stdio.h>
int main (int argc, char **argv)
{
  float temp = 36.456;
  printf ("%f\n", temp/10);
}

en daar komt uit:

code:

3.645600

Als 1 van de twee argumenten een float is, dan wordt een DOUBLE deling gedaan. (volgens de standaard. Ik heb embedded microcontrollers die een float FPU hebben (niet double), en daar kan ik de compiler vertellen: Negeer de standaard, doe gewoon met floats!).

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Op 1 april 2022 11:44:34 schreef rew:
Ik protesteer tegen:

Als ik terug kijk naar de code waarbij ik die problemen tegen kwam zie ik nu ook dat het grote getal een integer is. Dus ik heb me behoorlijk vergist.
maar dit werkte bv niet

c code:

float resulaat = 0,0;
int counterwaarde = 2345;
resultaat = counterwaarde / 10; >> geeft interger
resultaat = counterwaarde / float(10); geeft integer
resultaat = float(counterwaarde / 10); geeft integer

dit werkte wel

c code:

resultaat = counterwaarde / 10,0; geeft een float