Making a portable, battery powered DS18B20 display unit

4 Sep 2024

Recently, I started making pour-over coffee at home, and it turns out that water temperature can change the taste a lot. I don’t have a kettle that can measure temperature, so time to make something.

I found a few DS18B20s with stainless steel housing and a long cable, which are perfect for this purpose. Initially, I just used an Arduino Uno with a TFT display shield, but it was quite janky, and also needed USB power to run.

So here’s the plan:
- 18650 cell for power
- 4 digit 7 segment displays
- USB-C charging
- 3D printed housing

Schematics and PCB

I didn’t want to wait a week for PCBs, so I decided to use my 3D printer, which I modified to be able to hold a 48V spindle motor. To make this more interesting, I decided to limit myself to using a single layer PCB design, and an ATTINY AVR microcontroller.

I chose the ATTINY24A, and a MAX7219 for driving the display. The ATTINY needs 1.8V to 5.5V, while the MAX7219 requires 4V to 5.5V, but I found that it works down to about 3V without any issues. This means I do not need a voltage regulator and can run everything straight off the 18650(~3.5V to 4.2V).

Originally I had the MAX7219 share the SCK/MISO pins with the ICSP header, and also forgot the RST pullup, but didn’t make a new PCB with these changes, just cut the traces and hooked up some bodge wires, visible in later photos. The original version would’ve worked too, but having separate pins helped with debugging, and had plenty of unused GPIOs on the AVR anyways.

Here’s the original layout that I ended up milling:

In the end, I needed 3 through-hole jumpers, shown as the back layer with blue in the layout.

This was one of the first PCBs I milled, didn’t have everything figured out yet, so it’s not the best looking, with a lot of the traces ending up thinner than they should be. They all made proper electrical contact though, so good enough for this purpose.

AVR code

Controlling the MAX7219 was quite easy, just need to send out two bytes on MOSI, the first being register address, and the second is the value to write.

#define CS 3
#define MOSI 2
#define SCK 1

void set(uint8_t pin, uint8_t val) {
	if (val == 0) {
		PORTA &= ~(1 << pin);
	}
	else {
		PORTA |= (1 << pin);
	}
}

void shiftOut(uint8_t data) {
	for(uint8_t i = 0; i < 8; i++) {
		int bit = data & (1 << (7-i));
		set(MOSI, bit);

		_delay_us(1);
		set(SCK, 1);
		_delay_us(1);
		set(SCK, 0);
	}
}

void setMAXRegister(uint8_t reg, uint8_t value) {
	set(CS, 0);
	_delay_us(1);
	shiftOut(reg);
	shiftOut(value);
	_delay_us(1);
	set(CS, 1);
	_delay_us(1);
}

To set up the MAX7219, I had to disable shutdown mode, disable “Display Test mode”, enable “Code B decode for digits 0-3”, set the brightness, and enable the first 4 displays only:

setMAXRegister(0x0C, 1);	// Shutdown -> Normal mode
setMAXRegister(0x0F, 0);	// Display Test -> Normal mode
setMAXRegister(0x09, 0x0F);	// Decode Mode -> Code B decode for digits 0-3
setMAXRegister(0x0A, 0);	// Intensity -> 0
setMAXRegister(0x0B, 3);	// Scan Limit -> 0,1,2,3

Displaying digits was simple as well, the MAX7219 can figure out on its own what segments to power on, all I needed to do was put the number I wanted to display in a register.

void setMAXDigit(uint8_t digit, uint8_t val, bool dot) {
	uint8_t lookup[] = {0, 2, 3, 1};
	uint8_t dig = lookup[digit];
	if (dot == true) {
		val |= (1 << 7);
	}
	setMAXRegister(dig+1, val);
}

The lookup array is needed, because I didn’t connect the 7 segment displays in order, due to layout constraints on the PCB.

For reading temperature from the DS18B20, I ended up slightly modifying a library I found on GitHub(https://github.com/Jacajack/avr-ds18b20), mostly just removing parts I didn’t need.

First, I set the DS18B20 to 11bit resolution (0.125C per count), which I found to be a good compromise between readout rate and precision:

ds18b20wsp(&PORTB, &DDRB, &PINB, ( 1 << 2 ), 0, 0, 125, DS18B20_RES11);

Then all I had to do was tell the DS18B20 to start a conversion, and then read the result.

int16_t temp = 0;
ds18b20convert(&PORTB, &DDRB, &PINB, ( 1 << 2 ), 0);
_delay_ms(10);
ds18b20read(&PORTB, &DDRB, &PINB, ( 1 << 2 ), 0, &temp);

The library returns the temperature multiplied by 16, to avoid having to use floats/doubles(the highest resolution 12-bit mode has a resolution of 0.0625C, which is 1/16^th C).

To display this number properly, I wrote the following function:

void setMAXfromDS(int16_t dstemp) {
	if(dstemp >= 0) {
		uint16_t temp_integer = dstemp / 16;
		if(dstemp < 100*16) { // Under 100C
			uint16_t temp_fraction = ((dstemp % 16) * 100) / 16;

			setMAXDigit(0, temp_integer / 10, false);
			setMAXDigit(1, temp_integer % 10, true);
			setMAXDigit(2, temp_fraction / 10, false);
			setMAXDigit(3, temp_fraction % 10, false);
		}
		else { // Over 100C
			uint16_t temp_fraction = ((dstemp % 16) * 10) / 16;
				
			setMAXDigit(0, temp_integer / 100, false);
			temp_integer = temp_integer % 100;
			setMAXDigit(1, temp_integer / 10, false);
			setMAXDigit(2, temp_integer % 10, true);
			setMAXDigit(3, temp_fraction, false);
		}
	}
	else {
		//TODO - negative temp handling
	}
}

Temperatures at or over 100C are displayed with one decimal point of accuracy, between 0-100 two decimal points are used. I haven’t implemented negative temperature handling yet, as I have no need for it currently.

I also wanted some way to measure battery voltage and display it at startup. The straightforward solution, which would be to connect the battery to an ADC pin, wouldn’t work without an external reference, which would also need to be at least 4.2V to work properly.

The solution is to not connect the battery to an ADC pin at all, but use the ADC to measure an internal 1.1V reference instead, with the ADC reference set to Vcc. Here’s an example how this would work:

The ADC is 10-bit, meaning 0-1023. Let’s assume Vcc=2.2V, and we know that the internal reference is 1.1V. This means the ADC will read 512, since the internal reference(1.1V) is exactly half the voltage of the ADC reference(Vcc). (Vcc/1.1V = 1024/ADC_counts)

The internal reference isn’t exactly 1.1V though, so first step is to figure out the exact value. By measuring Vcc externally with a multimeter, and taking an ADC measurement, we can calculate the accurate value using this formula: measured_vcc * ADC_counts / 1024. In my case, I got 1.0906875V.

Knowing this, Vcc can be calculated like so: 1.0906875V * 1024 / ADC_counts. To avoid having to deal with floats here too, I further multiplied this value by 1000, to end up with 3 decimal points of accuracy in the end. Since Vcc will always be a number between 1.8V(hopefully more like 3.5V) and 4.2V, I can always assume the decimal point is after the first digit(that’s what the “true” in the first “setMAXDigit” function call is). The formula now simplifies to 1116860 / ADC_counts.

Accuracy is within 0.05V compared to what my multimeter measures, so I’m pleasantly surprised with how well this works, although I haven’t tested how much the reference drifts with ambient temperature change.

void showVccVoltage(uint16_t adcval) {
	// Bandgap voltage: (actualVcc * adcReading) / 1024
	// Vcc: (bandgapVoltage * 1024) / adcReading
	
	uint16_t num = 1116860 / adcval; // Multiplied by 1000 to not have to deal with floats
	
	setMAXDigit(0, num / 1000, true);
	num = num % 1000;
	setMAXDigit(1, num / 100, false);
	num = num % 100;
	setMAXDigit(2, num / 10, false);
	setMAXDigit(3, num % 10, false);
}

ADMUX = 0b00100001; // Vcc as reference, measuring 1.1V internal bandgap
ADCSRA = 0b10000100; // Enable ADC, prescaler 16

ADCSRA |= (1 << ADSC); // Start conversion
while(!(ADCSRA & (1 << ADIF))); // Wait for conversion to complete
ADCSRA |= (1 << ADIF); // Clear the ADC interrupt flag
volatile uint16_t adcl = ADCL; // Read lower byte
uint16_t value = (((uint16_t)ADCH) << 8) | adcl; // Read upper byte and merge into uint16_t
showVccVoltage(value);

Here's the entire code:

#include <avr/io.h>
#include <util/delay.h>
#include <stdbool.h>
#include "ds18b20.h"

#define CS 3
#define MOSI 2
#define SCK 1

void set(uint8_t pin, uint8_t val) {
	if (val == 0) {
		PORTA &= ~(1 << pin);
	}
	else {
		PORTA |= (1 << pin);
	}
}

void shiftOut(uint8_t data) {
	for(uint8_t i = 0; i < 8; i++) {
		int bit = data & (1 << (7-i));
		set(MOSI, bit);

		_delay_us(1);
		set(SCK, 1);
		_delay_us(1);
		set(SCK, 0);
	}
}

void setMAXRegister(uint8_t reg, uint8_t value) {
	set(CS, 0);
	_delay_us(1);
	shiftOut(reg);
	shiftOut(value);
	_delay_us(1);
	set(CS, 1);
	_delay_us(1);
}

void setMAXDigit(uint8_t digit, uint8_t val, bool dot) {
	uint8_t lookup[] = {0, 2, 3, 1};
	uint8_t dig = lookup[digit];
	if (dot == true) {
		val |= (1 << 7);
	}
	setMAXRegister(dig+1, val);
}

void showVccVoltage(uint16_t adcval) {
	// Bandgap voltage: (actualVcc * adcReading) / 1024
	// Vcc: (bandgapVoltage * 1024) / adcReading
	
	uint16_t num = 1116860 / adcval; // Multiplied by 1000 to not have to deal with floats
	
	setMAXDigit(0, num / 1000, true);
	num = num % 1000;
	setMAXDigit(1, num / 100, false);
	num = num % 100;
	setMAXDigit(2, num / 10, false);
	setMAXDigit(3, num % 10, false);
}

void setMAXfromDS(int16_t dstemp) {
	if(dstemp >= 0) {
		uint16_t temp_integer = dstemp / 16;
		if(dstemp < 100*16) { // Under 100C
			uint16_t temp_fraction = ((dstemp % 16) * 100) / 16;

			setMAXDigit(0, temp_integer / 10, false);
			setMAXDigit(1, temp_integer % 10, true);
			setMAXDigit(2, temp_fraction / 10, false);
			setMAXDigit(3, temp_fraction % 10, false);
		}
		else { // Over 100C
			uint16_t temp_fraction = ((dstemp % 16) * 10) / 16;
				
			setMAXDigit(0, temp_integer / 100, false);
			temp_integer = temp_integer % 100;
			setMAXDigit(1, temp_integer / 10, false);
			setMAXDigit(2, temp_integer % 10, true);
			setMAXDigit(3, temp_fraction, false);
		}
	}
	else {
		//TODO - negative temp handling
	}
}

int main(void) {
	_delay_ms(500);
	
	// Set pins as output
	DDRA |= (1 << CS);
	DDRA |= (1 << SCK);
	DDRA |= (1 << MOSI);
	
	set(CS, 1);
	set(SCK, 0);
	set(MOSI, 0);
	
	ADMUX = 0b00100001; // Vcc as reference, measuring 1.1V internal bandgap
	ADCSRA = 0b10000100; // Enable ADC, prescaler 16
	_delay_ms(1);

	setMAXRegister(0x0C, 1);	// Shutdown -> Normal mode
	setMAXRegister(0x0F, 0);	// Display Test -> Normal mode
	setMAXRegister(0x09, 0x0F);	// Decode Mode -> Code B decode for digits 0-3
	setMAXRegister(0x0A, 0);	// Intensity -> 0
	setMAXRegister(0x0B, 3);	// Scan Limit -> 0,1,2,3
	_delay_ms(200);

	ds18b20wsp(&PORTB, &DDRB, &PINB, ( 1 << 2 ), 0, 0, 125, DS18B20_RES11); // Set DS18B20 to 11bit resolution mode
	
	// Display battery voltage for about 3 seconds (displays 30 values, each taking 100ms to calculate)
	for(uint8_t j = 0; j < 30; j++) {
		// Take an average of 100 ADC readings
		uint16_t adcsum = 0;
		for(uint8_t i = 0; i < 100; i++) {
			ADCSRA |= (1 << ADSC); // Start conversion
			while(!(ADCSRA & (1 << ADIF))); // Wait for conversion to complete
			ADCSRA |= (1 << ADIF); // Clear the ADC interrupt flag
			volatile uint16_t adcl = ADCL; // Read lower byte
			adcsum += (((uint16_t)ADCH) << 8) | adcl; // Read upper byte and merge into uint16_t, add to sum
			_delay_ms(1);
		}
		// Show the averaged voltage
		showVccVoltage(adcsum / 100);
	}
	
	int16_t temp = 0;
	while (1) {
		// Start DS18B20 conversion
		ds18b20convert(&PORTB, &DDRB, &PINB, ( 1 << 2 ), 0);
		_delay_ms(10);
		// Fetch result
		ds18b20read(&PORTB, &DDRB, &PINB, ( 1 << 2 ), 0, &temp);
		// Display result
		setMAXfromDS(temp);
	}
	
	return 0;
}