After seeing a picture of a thermometer using a bargraph style nixie tube in place of a mercury column, [Juergen Grau] decided he wanted to build his own. Dubbed the “Nixietherm”, his replica looks even better than the original. He used an IN-9 Nixie tube mounted on top of a custom plastic case, all powered by a 5v USB connection. He points out that his version does not use a PIC or any other sort of processor – it is built entirely from analog circuits. There are some RGB LEDs embedded in the plastic case that make for a cool effect, but they seem to simply cycle through the colors rather than represent how warm or cold the temperature is at any given time.

[Juergen] does not give a lot of details regarding the build as far as PCB layout or a parts list is concernred, but most of that can be extrapolated from the wiring schematic he provided. He also mentions that he will be making kits available in the near future. Be sure to keep reading to see the thermometer in action.

Thanks [Brian]

We’re always a little surprised by how well a vacuum thermos works, but eventually the contents will cool down (or warm up depending on what’s in there). [Gamesh_] added a temperature meter to his thermos using an Arduino and a temperature sensor. The original post is in Portuguese but [Bruno] republished it in English.

The temperature sensor has been repurposed from a digital thermometer meant for taking your temperature. Holes for the LEDs making up the indicator bar were melted in the side of the plastic housing. When the hot liquid is poured out at about 0:45 into the video you can glimpse the Arduino hanging our on the other side of the pot and a power cord running off behind the laptop. It would be nice to see this migrated over to a less powerful chip and run from a small coin cell, but we like the concept.

Unlike regular thermometers that can get incorrect readings because of the sun’s heat, shading, and airflow, aspirated thermometers isolate the temperature sensor from precipitation and the sun, while providing constant air circulation. Take ten 1-wire T2SS boards and combine them with DS18B20s and you’ve got yourself the start of an aspirated thermometer. A foot of PVC pipe, fans, and the above mentioned parts and you’ll have accurate temperature readings in no time.

[Dave] made his to control a natural gas boiler, pumps, and 11 gas-fired unit heaters for a combined output of 5.3 million BTUs per hour – keeping his greenhouse nice and toasty.

Update: Thanks Firetech for pointing out our silly typo.

The guys over at NerdKits put together a really informative video on a meat thermometer using predictive filtering which is viewable below. The video, supplemental text, and code is available on their website. The thermometer is constructed of a LM34 temperature sensor attached to a piece of 12 gauge solid copper wire. The thermometer signal is processed on an ATmega168 microcontroller and visualized using the pygame library for python. The real gem in this project is their excellent explanation of predictive filtering, which could easily be utilized for a large number of projects.

[Thanks Humberto]

This digital thermometer won’t win any awards for being something innovative and new, but we really like how it looks. The bar graph style display adds something to the project that a normal character display just wouldn’t. You can download source code and schematics on the site.

[via YourITronics]

[Chris] sent in the Thermosmart. It is an Arduino controlled thermostat. It has a web interface which allows him to see the current temperature and make adjustments from remote locations. He can set heating or cooling to on, off, or auto and adjust the ranges as well. We’ve seen similar done with an Arduino before, even one with a nice LCD interface. This could possibly be useful for remote plant monitoring as well.

[Peter] sent in this writeup on how to build a remotely accessible thermometer. The hardware side is pretty easy on this one, all you need is an Arduino, a resistor and an thermistor. The software is where the main focus is.  You can check the temperature via command line, but also via email. It can also tell you the temperature using the host computers sound hardware. You can see a video of it in action after the break. We have to wonder why he didn’t make it twitter.

Here’s another nerdy present that was built for Valentine’s Day. [João Silva] created a temperature sensing Munny. A Munny is a vinyl toy made to be customized. Other than these Munny speakers, we haven’t seen them in many electronics projects. The LM35CZ temperature sensor has an analog output that connects to the ADC on the ATtiny15L. The microcontroller changes the RGB LED’s color based on the temperature: blue for cold, green for comfortable, and red for hot. It only flashes every three minutes to conserve the power in the coin cells. His one-off circuit board also includes an ISP header for programming. The Munny’s head looks like it does a great job diffusing the light.

[Alanson Sample] and [Joshua R. Smith] have been experimenting with wireless power transfer for their sensing platform. Their microcontroller of choice is the MSP430, which we used on our e-paper clock. They chose it specifically for its ability to work with low voltages and they discus its specific behavior at different voltages. The first portion of their paper uses a UHF RFID reader to transmit to the sensor’s four stage charge pump. They added a supercap to provide enough power for 24 hours of logging while the node isn’t near a reader. For the second half of the paper, they use a UHF antenna designed for digital TV with the same circuit and pointed it at a television tower ~4.1km away. It had an open circuit voltage of 5.0V and 0.7V across an 8KOhm load, which works out to be 60uW of power. They connected this to the AAA battery terminals of the thermometer/hygrometer pictured above. It worked without issue. The thermometer’s draw on a lab power supply was 25uA at 1.5V.

It’s an interesting approach to powering devices. Do you have an application that needs something like this? For more on wireless power, checkout this earlier post on scratch building RFID tags.

[via DVICE]

Microchip’s TC74 is an inexpensive digital temperature sensor with a simple I2C interface. It has a resolution of 1 degree Celsius, and a range of -40 to +125 degrees. This is an easy way to add temperature measurement to a project without an analog to digital converter. We’ll show you how to use the TC74 below.

Microchip TC74 digital temperature sensor (Octopart search, starting at $0.88)

The TC74 comes in five pin through-hole and surface mount packages, see the TC74 datasheet (PDF). We couldn’t find a Cadsoft Eagle footprint for any version of this part, if you know of one please link to it in the comments.

Different versions of the TC74 are calibrated for specific voltages, but all work from 2.7-5volts. The TC74A5 we used is most accurate when operating at 5volts, but we powered it from a 3.3volt supply. The I2C connection needs 2 pull-up resistors to hold the bus high (R1, R2), 2K-10K should work. C1 is a 0.1uF decoupling capacitor.

We used the Bus Pirate universal serial interface in I2C mode to test drive the TC74, but the same principals apply to any microcontroller. We powered the TC74 from the Bus Pirate’s 3.3volt supply, and used the on-board pull-up resistors to hold the I2C bus high.

The TC74′s write address is 0x9a, and the read address 0x9b. It has two, one-byte registers. Register address 0 holds the temperature reading, register 1 holds the configuration settings.

Configuration register

Bit 6 of the configuration register is 0 at power-on, and changes to 1 when the first valid temperature reading is available. Bit 7 is writable, and puts the TC74 in a power saving standby mode. Reading the register involves two steps: use a partial write command to select the register, then use the read command to retrieve the value.

I2C>{0x9a 1}
210 I2C START CONDITION
220 I2C WRITE: 0x9A GOT ACK: YES <–write address
220 I2C WRITE: 0×01 GOT ACK: YES <–select config register
240 I2C STOP CONDITION

First, we select the configuration register with a partial write command. This doesn’t actually write a value, it selects the register to read and write. { creates the I2C start condition, followed by the TC74 write address (0x9a) and the select configuration register command (0×01). } issues the I2C stop condition and ends the transaction.

Now we can read the contents of the register.

I2C>{0x9b r}
210 I2C START CONDITION
220 I2C WRITE: 0x9B GOT ACK: YES <–read address
230 I2C READ: 0×40 <– register value (01000000)
240 I2C STOP CONDITION
I2C>

The read address (0x9b) returns the one byte register value (r). The configuration register value, 0×40 or 01000000, shows that the device is out of standby (bit 7=0), and a valid temperature reading is available (bit 6=1).

The TC74 has a low-power standby mode. Enable it by writing 1 to bit 7 of the configuration register.

I2C>{0x9a 1 0b10000000}
210 I2C START CONDITION
220 I2C WRITE: 0x9A GOT ACK: YES <–write address
220 I2C WRITE: 0×01 GOT ACK: YES <–select config register
220 I2C WRITE: 0×80 GOT ACK: YES <–value to write (01000000)
240 I2C STOP CONDITION
I2C>

The register is written with single three-byte command. First we send the write address (0x9a), followed by the register to select (0×01), and finally the value to write (0×80). Only bit 7 of the configuration register is writable, the values of bits 6-0 are ignored.

Read the register again to verify that the command worked.

I2C>{0x9a 1}{0x9b r}
210 I2C START CONDITION <–first command sets register
220 I2C WRITE: 0x9A GOT ACK: YES <–write address
220 I2C WRITE: 0×01 GOT ACK: YES <–config register (1)
240 I2C STOP CONDITION <–end first command
210 I2C START CONDITION <–begin second command
220 I2C WRITE: 0x9B GOT ACK: YES <–read address
230 I2C READ: 0×80 <– register value (10000000)
240 I2C STOP CONDITION <–end second command
I2C>

The register value, 10000000, now shows that the device is in standby (bit 7=1). Notice that bit 6 is now 0, no temperature data is available.

Clear bit 7 to exit standby, then wait for bit 6 to return to 1 before reading the temperature register.

I2C>{0x9a 1 0b00000000}
210 I2C START CONDITION
220 I2C WRITE: 0x9A GOT ACK: YES <–write address
220 I2C WRITE: 0×01 GOT ACK: YES<–select config register
220 I2C WRITE: 0×00 GOT ACK: YES<–value to write (00000000)
240 I2C STOP CONDITION
I2C>

Temperature data is ready when the configuration register value returns to 0×40 (01000000).

Temperature

The temperature register is read in two steps. First, a partial write command selects the temperature register (0), then a read sequence returns the contents.

I2C>{0x9a 0}{0x9b r}
210 I2C START CONDITION
220 I2C WRITE: 0x9A GOT ACK: YES <–write address
220 I2C WRITE: 0×00 GOT ACK: YES <–select temperature register
240 I2C STOP CONDITION
210 I2C START CONDITION
220 I2C WRITE: 0x9B GOT ACK: YES <–read address
230 I2C READ: 0×18 <–grab one byte
240 I2C STOP CONDITION
I2C>

The temperature is an integer value of degrees Celsius, negative numbers are represented as a twos complement. Positive values from 0 to 127 degrees Celsius are simply represented by that value. Negative temperatures have bit 7 set, and range from -1 to -65 (255-128), see table 4.4 on page 8 of the datasheet. The hexadecimal value 0×18 is equal to 24 in decimal, so the temperature reading is 24C (75F).

Like this post? Check out the parts posts you may have missed.