I am using an NTC to read temperature. I use the Steinhart-Hart formula to calculate the temperature from the Resistance of the NTC. The output of that formula is a float (double integer, 4 bytes).
I also want to log the results in memory. For that I have a couple of choices
Store the floating point variable : that will cost me 32 bits of memory for every temperature value logged
Store the original NTC reading and just pull that through the Steinhart-Hart formula again when needed, that will cost me 16 bits for every temperature logged.
As I really don’t need the high decimal precision that a floating point value can give and as I really didn’t expect my temperature range to go outside -15 to +30 degrees Celcius, both 16 bits and 32 bits seemed serious overkill.
So I was wondering if I just couldn’t store it in in 1 Byte. As the Steinhart-Hart formula gives an approximation of the temperature, one can wonder how precise of a reading one needs, but I decided I wanted a solution of 0.25 degrees, though no doubt 0.5 degrees would have been enough already.
I figured I would use the MSB for the sign bit, that left 7 bits
decimal number 31 is equal to 0b00011111, so to cover my range I needed 5 bits for the temperature that left 2 bits
In those two bits I can store numbers 0-3, that I could use for the decimal fraction.
Extracting the essential bits from the binary level of the float seemed to much of a problem so I mainly worked with the decimal values.
In the function floatToByte I do a couple of essential things: I first check if it is a positive or a negative number as that determines the MSB I need to set in my byte. Then Itake the absolute value of the float so I get rid of o potential minus value, which would complicate calculations.
Then I turn the float into an integer and subtract that from the float. That leaves the decimal fraction. In order to keep at least some precision in that I have to put that in a double. Initially it was my idea to turn the values 0-9 into 0-3, but a simple division by 3 didnt have the desired effect as ‘9’ was sometimes 0.89 which by division would give a 2, So I decided on some simple ‘if’ conditions to convert the double fraction into half a nibble.
I then would shift the 5 bit temperature 2 bits to the right bitwise OR it with the fraction (on the two least significant bits and bitwise OR it with the sign bit.
That gave me temperature values that I can store in 1 Byte of EEPROM.
The way back – from memory byte to sensible temperature. Goes the other way around
byte floatToByte(float temp2)
{
byte sign = 128;
if (temp2 >= 0) {
sign = 0;
}
double temp = abs(temp2);
int heel = int(temp);
double fractie = temp - heel;
fractie = (temp - heel);
fractie = fractie * 100;
byte fractie2 = 0;
if (fractie >= 25) {
fractie2 = 1;
}
if (fractie >= 50) {
fractie2 = 2;
}
if (fractie >= 75) {
fractie2 = 3;
}
byte temperatuur = (((heel << 2) | fractie2) | sign);
return temperatuur;
}
void getTempByte(byte Temp)
{
float temperatuurCelcius;
if (Temp & 0b10000000) // check negative
{
Temp = Temp ^ 0b10000000; // knock out MSB byte
double fractie = (Temp & 0b00000011);
byte body = (Temp >> 2);
Serial.println(-1 * (body + (fractie * 0.25)));
}
else
{
byte fractie = (Temp & 0b00000011);
byte body = (Temp >> 2);
Serial.println(body + fractie * 0.25);
}
}
void setup() {
Serial.begin(9600);
byte x = floatToByte(+31.10);
Serial.println(x, BIN);
x = floatToByte(+31.25);
Serial.println(x, BIN);
x = floatToByte(31.50);
Serial.println(x, BIN);
x = floatToByte(+31.75);
Serial.println(x, BIN);
x = floatToByte(-31.75);
Serial.println(x, BIN);
x = floatToByte(+0.15);
Serial.println(x, BIN);
Serial.println("temperatuur ");
getTempByte(0b1111101);
}
void loop() {
// put your main code here, to run repeatedly:
}
Arduino, ESP8266, ESP32 & Raspberry Pi stuff 