The last blog was a difficult one, as the experiments were long, but the reward was a set of characterisation results that seemed to match well with the datasheet information (just with an offset). But my proposal for this “experimenting-with” series didn’t end at characterisation – I also wanted to put the thermistors to practical use, especially of the ring type. As a result, this blog will focus on applying the ring thermistors in various experiments, end up destroying a bead thermistor and involve a little bit more lateral thinking about the ESP8266 hack previously shown.
Table of Contents
The Mounting Challenge
Measuring temperature is an important thing to do, but have you noticed that ordinary thermocouples and thermistors usually come in bead form? These rounded ends may be cheap and easily manufactured, but they pose a challenge when trying to mount on a flat surface. Simply clamping a round thing to a flat surface results in a concentration of stress which can damage the device, or the potential for the device to slide out of position. Usually, the best way to use beads in a permanently mounted configuration is to use thermal epoxy which “glues” the bead in place, but this makes it hard to replace. It can also crack and work loose over time, as I’ve experienced some very chalky thermal adhesive which has failed me in the past.
One option is to opt for thermistors in the “chip” form, however, often this needs some level of protection from the elements to maintain accuracy, similar to how bare Pt100 elements may be provided as bare chips. The chips still have to be mounted to a substrate, and if that’s by thermal epoxy, the same disadvantages apply.
Perhaps the sensible option is to package the thermistor as an electronic component so it can be handled and mounted in much the same way. This has definitely occurred – Littelfuse has made a TO-220 thermistor, for example, but there is only one standard value. This makes it easy to mount against heatsinks, but it also occupies quite a bit of space on the board and on the heatsink. I’ve seen such devices used in precision power supplies for temperature compensation, but it seems to be a relatively uncommon approach.
A more common and often seen approach is to use a “flag” type mounting such as the USP5510 series from Littelfuse (image from Littelfuse). I’ve seen these used inside lower-end power supplies for monitoring heatsink temperature, with the right-angle design allowing the thermistor to be mounted off the end of the heatsink. This design certainly works – but it’s likely not to be as thermally accurate depending on how it is mounted.
A close relative is the “ring” type which Molex have provided (image from Molex). This type doesn’t have the right-angle approach, which can make them a more compact solution in some instances and shares the need for careful mounting for the best thermal accuracy. Both solutions make mounting easy, by having a flat mounting surface which can be attached by simply screwing or bolting it down. No need to think about the rounded surfaces, no need for thermal epoxy, no need for waiting for it to set and no need to worry about difficult replacement.
Not The Only Ring in Town!
The concept of a ring thermistor definitely sounds appealing, but after taking a little look around, it became apparent that Molex are not the only suppliers of ring thermistors! It would be remiss of me not to at least mention and compare some aspects between these competitors. Of note is that they are referred to by other terms – Vishay likes to use the word “lug” instead of “ring”.
Perhaps the most direct competitor is Vishay Bccomponents’ many NTCALUG series products which comprises of a standard catalog along with the potential to create a customised device. Standard devices come in Mini-Lug (M3), Standard Lug (M3.5), Low Thermal Gradient varieties. All come with bare ends, but the mini also comes with a 2-pole JST ZHR-2 connector as an option. While the resistance range available is quite wide, the actual values available seem more limited than the Molex offering with some offering poorer tolerance values.
Ametherm seem to be in this market as well, with their PANR series which is also advertised as customisable. Their lugs come with a hold diameter of 3.7mm or 4.4mm, making them comparable in size.
Littelfuse have a number of series including the USP4261, USP7570 (10kΩ, #6), USP6295 (10kΩ, #4), USP6998 (200kΩ, ¼”) and USUR1000 (Various, #6). All appear to be bare-wire, with tolerance values ranging from 2-10%, making them somewhat less accurate than the Molex.
Amwei also came up in my search, with a 100kR thermistor lug with 3.2mm hole suitable for 200°C, which is rather unique as most only operate up to around 100-150°C. Their site didn’t seem to have much of a variety of choice though, as this seems to be the only ring thermistor they offered.
Of course, being such a large market, there are also a number of mystery “small-brand” or generic products which have been rebranded. These have not been included in this round-up, nor have products from seemingly discontinued lines from Amphenol Thermometrics, Honeywell and Cantherm.
What most differentiates Molex’s ring thermistors from the rest of the market is perhaps the availability of pre-crimped Molex Micro-Lock Plus connectors which are both small and vibration resistant with its latch design. Unfortunately, not being provided with a matching mating connector, it was not possible to assess this aspect of the thermistor in any great detail. Of course, Molex also offers bare-wire alternatives for applications requiring them. Another is their generally tighter tolerances, which is only sometimes matched by their competitors.
Experiment: Heatsink Thermal Resistance
The first thing I thought of trying was an experiment with TO-220 packages, since it seems to be a common thing to do. The first thing I wanted to do was to use one to try and determine the thermal resistance of my MOSFET test PCBs which use copper layers as heatsinks.
The first is my small Rds Test PCB which is manufactured as a two-layer, 1oz copper construction. I used a fake IRF3205 from my junk pile as the source of heat.
The ring thermistor was secured to the top surface of the tab using the existing mounting hole – no need for any additional drilling. The bead is offset by 90 degrees, so the temperature reading may be a little low, but this is acceptable for the convenience. This is not a direct reading of Tcase – that is defined usually at a central point on the rear tab, which is not accessible without disturbing the connection to the PCB heatsink itself. However, it should still be fairly close, as the tab is quite thick and often made of copper.
The test board hangs in the air, with the gate turned on and current flowed through the drain-source connection, treating it as a low-value resistor, from a Rohde & Schwarz HMP4040 Power Supply. Thermistor resistance is measured using a Keithley 2110 5.5-digit DMM with my own Raspberry Pi USB-TMC bridge.
I created a script which uses slow feedback and steps the current up to regulate the power dissipated over the MOSFET. The power would step from 0.5W to 10W in 0.5W steps, maintaining at each power level for an hour. If the temperature exceeded 100°C, the test would be aborted. The code is as below:
import pyvisa
import time
import math
rm = pyvisa.ResourceManager()
ins_k2110 = rm.open_resource("TCPIP0::xxx.xxx.xxx.xxx::5025::SOCKET")
ins_k2110.read_termination = "\n"
ins_k2110.timeout=15000
ins_hmp4040 = rm.open_resource("TCPIP0::xxx.xxx.xxx.xxx::5025::SOCKET")
ins_hmp4040.read_termination = "\n"
ins_hmp4040.timeout=15000
print("Roll Call:")
print(ins_hmp4040.query("*IDN?").strip())
print(ins_k2110.query("*IDN?").strip())
print("Setup HMP4040")
ins_hmp4040.write("*RST")
ins_hmp4040.write("INST:NSEL 1")
ins_hmp4040.write("SOUR:VOLT 3.4")
ins_hmp4040.write("SOUR:CURR 0.1")
ins_hmp4040.write("OUTP 1")
ins_hmp4040.query("*OPC?")
ins_hmp4040.write("INST:NSEL 2")
ins_hmp4040.write("SOUR:VOLT 2")
ins_hmp4040.write("SOUR:CURR 2.400")
ins_hmp4040.write("OUTP 1")
ins_hmp4040.query("*OPC?")
print ("Setup K2110")
ins_k2110.write("*RST")
ins_k2110.write("FUNC \"RES\"")
ins_k2110.write("RES:NPLC 10")
ins_k2110.write("TRIG:SOUR BUS")
ins_k2110.query("*OPC?")
print("Begin Experiment")
data_log = "moscook"+str(time.time())+".csv"
f = open(data_log,"a")
excontinue = 1
watts = 0.5
ccurr = 2400
while watts < 10.5 and excontinue == 1 :
stime = time.time()
while time.time() < stime + 3600 :
psuvolts = ins_hmp4040.query_ascii_values("MEAS:VOLT?")[0]
psucurr = ins_hmp4040.query_ascii_values("MEAS:CURR?")[0]
ins_k2110.write("INIT")
ins_k2110.write("*TRG")
mmval = ins_k2110.query_ascii_values("FETC?")[0]
thtemp = (1/(-5.25246443E-08* math.log(mmval)**5 + 2.55553497E-06* math.log(mmval)**4 - 4.92404763E-05* math.log(mmval)**3 + 4.72276476E-04* math.log(mmval)**2 - 1.99634764E-03* math.log(mmval) + 5.24166076E-03))-273.15
f.write(str(time.time())+","+str(watts)+","+str(psuvolts)+","+str(psucurr)+","+str(mmval)+","+str(thtemp)+"\r\n")
print(str(time.time())+","+str(watts)+","+str(psuvolts)+","+str(psucurr)+","+str(mmval)+","+str(thtemp))
pdiff = (psuvolts * psucurr) - watts
if pdiff < -0.005 :
if ccurr < 10000:
ccurr=ccurr+1
elif pdiff > 0.005 :
if ccurr > 1 :
ccurr=ccurr-1
if thtemp > 100 :
print("Overheated! Terminating Experiment!")
excontinue = 0
ins_hmp4040.write("SOUR:CURR "+str(ccurr/1000.0))
ins_hmp4040.query("*OPC?")
watts = watts + 0.5
f.flush()
f.close()
ins_hmp4040.write("OUTP:GEN 0")
ins_hmp4040.close()
ins_k2110.close()
One board doesn’t make a good comparison, so I took the larger board from my Aim-TTi QPX750SP Power Supply RoadTest as well.
This is also a two-layer board, but it is much larger and built using 2oz copper process. This is because the board was intended for over 50A operation.
I only populated enough to make it work, but of note is that the rear copper plane is cut because of the need to support other SMD MOSFET types with four-wire connections necessitating isolation.
Finally, I decided to test a dedicated heatsink from element14. This one is a Multicomp Pro MC33279 7.1°C/W heatsink.
For convenience, I chose another blank small test board to mount the heatsink and fake IRF3205 for testing, as this eases the connections to be made to the MOSFET.
The results may not be what you expect at face value. The small MOSFET test board overheated and shut down, while the large PCB worked just fine up to 10W. The Multicomp Pro heatsink, however, registered a temperature very similar to, or just lower than the large PCB.
Plotting this as peak temperature and linear-fitting, the small MOSFET test board was about 12°C/W with the large PCB being about 4.6°C/W. The Multicomp Pro heatsink, however, is complicated by the fact that it is basically also mounted on the small MOSFET test board, thus it also acts as a parallel heatsink. It may even work better as both surfaces (top and bottom) of the PCB are free to dissipate. If we compute the parallel resistances, we expect a value of 4.5°C/W. The measured value is 4.3°C/W which is pretty close, so it seems that the Multicomp Pro heatsink is very much in-line with expected performance.
Experiment: LED Over-Temperature Protection
A key application of thermistors is for temperature regulation and overheat protection. The ability to detect temperature rise allows the system to make changes at first to try and reduce the temperature rise (e.g. speed up fans, reduce drive-current). Upon reaching a critical threshold, it can also command the shutdown of the equipment to prevent permanent damage. This progressive response is one benefit compared to the thermal switch solution previously experimented with, but relies on more components and may be less reliable as a result.
Starting with a Few Stars
One thing that readers may not know is that I did my PhD looking at UV-C, UV-B, UV-A and visible light LEDs for water disinfection purposes. For this, I developed systems which had relatively high amounts of power for irradiating pots of water – hence the vacuum carafes that have featured earlier in this series. Now, it’s time for the LEDs to make an appearance …
The standard formula at the time for me was to use a Fischer Elektronik SK584 60 SA heatsink and three LEDEngin LZ4 quad-emitter star-base modules. This would result in an LED power of about 30W paired with a 1°C/W heatsink to keep them safe. In the above, there are three true-green LED modules.
To maintain maximum flux in my PhD experiments and avoid overheating, I ran them with an 80mm fan blowing over the rear of the heatsink, but was this really necessary? We can test this out by mounting a ring thermistor to the heatsink.
Unfortunately, I soon found that one of the modules seemed to be ESD damaged to the point that it had a very low forward current even at extreme voltages, with only three of four LEDs even showing any luminescence. As a result, I changed one of the LZ4 stars for a red one instead.
These were run at 700mA rated current from a Rohde & Schwarz HMP4040 Power Supply, for a total power of about 26W. A pyvisa script similar to that presented later in the time lag experiment was used to conduct and monitor the experiment.
The result shows that the temperature stabilised at about 57°C, a rise of about 38.5°C over actual ambient (noting the start point was not ambient as a short test was performed prior to data acquisition). This suggests the heatsink is not quite 1°C/W, at least, not in the tested condition with the bottom of the heatsink facing a chair – mounting matters!
Pushing 100W of Power
Unsatisfied with the fact that this large heatsink wasn’t pushed all that hard, I whipped out some 100W LED modules I had purchased many years back.
These modules were purchased from eBay and as per bigclivedotcom’s notes, these are likely to be rejected stock as the forward voltages of the LEDs are not particularly matched. At low current, there is a wide distribution of brightnesses, with one chip seemingly not lighting at all (shunted). At moderate current, they all do light, but some noticeably more than others. The imbalance is likely to lead to those chips failing first, eventually leading to a potential chain-reaction that causes the whole unit to fail in rapid succession. Such outcomes are not desirable, but are a side effect of the 10-series x 10-parallel design. Nevertheless, the phosphor coating on this one was a bit dirty and the chips looked a bit smaller than they should be. I received a partial refund for these, but I kept the units in case I ever had a need for them.
In this case, they would serve as a torture test for the heatsink. The unit is mounted with screws on all four corners – but due to not having a drill-press and relying on an IKEA cordless hand-held drill with horrible chuck run-out and no centre-punch, I could only get three out of four holes in strict alignment. With a bit of a bodge, launching the screw at an angle, I managed to get the top right into place as well, with the ring thermistor mounted in the top left. Thermal paste was used behind the module – just enough that it didn’t ooze out of the edges.
The LED was driven using two channels in series, as the voltage required exceeded 32V (the maximum for a single channel on the HMP4040). Three current levels of 3A, 2.5A and 2A were tested, with overheating occurring on the first two.
At 3A, a total of 109W was supplied including losses in connecting cables. The over-temperature shutdown was set to 105°C which coincides with the maximum operating temperature of the ring thermistor. The unit shut down in under 15-minutes of operation. At 2.5A, it was started with the heatsink not fully cooled down to room temperature, so an estimated time offset was used. Nevertheless, the temperature did exceed 105°C and it too shut down, likely after about 25-minutes of operation.
Only at 2A forward current, for a supplied power of 68W, did the heatsink manage to stabilise at about 96°C at an 18°C ambient. This corresponds to a T-rise of 78°C for 68W total power or about 1.147°C/W. This figure is not accurate, however, as some of the 68W of power into the fixture is leaving as light, so the thermal resistance is worse than this, but it’s due to the fact that the unit is run with the rear heatsink face resting on a chair, likely impeding free airflow.
Nevertheless, in this case, the thermistor did successfully save the LED from permanent damage. Had my code been a little more complex, I could have regulated the forward current to try maintaining a maximum temperature set-point. This is exactly what most high-power LED torches do, in a system they call ATR (Automatic Temperature Regulation).
Experiment: Time Lag of Rings vs. Beads?
This had me thinking – how long does heat take to travel through the large Fischer Elektronik SK584 60 SA heatsink and is there a measurable response time difference between the ring thermistor and bead type thermistor? Now that I had a good source of heat, I decided to turn the heatsink upside down …
… mount another ring thermistor on the other side, as well as create drill-holes to allow for a bead type thermistor to be mounted using a piece of old PCB as a pressure bar.
The thermistor chosen was the 5kΩ unit, as my 10kΩ unit has previously been measured to have noticeable deviations.
The three thermistors were then hooked into the home-built relay multiplexer for measurements with the Keithley 2110 5.5-digit DMM with the LED running at 2A forward current. A modified version of code used in prior experiments were used for this –
import pyvisa
import time
import math
rm = pyvisa.ResourceManager()
# K2110 via USB-TMC Bridge
# https://goughlui.com/2021/02/20/project-a-usb-tmc-to-ethernet-lan-bridge-with-a-difference/
# HMP4040 via LAN Socket
# Relay Multiplex via LAN Socket - N.B. Non-Standard Communications!
# https://goughlui.com/2021/04/18/project-arduino-based-lan-controlled-input-scanner-relay-multiplexer/
ins_k2110 = rm.open_resource("TCPIP0::xxx.xxx.xxx.xxx::5025::SOCKET")
ins_k2110.read_termination = "\n"
ins_k2110.timeout=15000
ins_hmp4040 = rm.open_resource("TCPIP0::xxx.xxx.xxx.xxx::5025::SOCKET")
ins_hmp4040.read_termination = "\n"
ins_hmp4040.timeout=15000
ins_gswitch = rm.open_resource("TCPIP0::xxx.xxx.xxx.xxx::5025::SOCKET")
ins_gswitch.read_termination = "\n"
ins_gswitch.timeout=15000
print("Roll Call:")
print(ins_hmp4040.query("*IDN?").strip())
print(ins_k2110.query("*IDN?").strip())
print(ins_gswitch.query("*IDN?").strip())
print("Setup HMP4040")
ins_hmp4040.write("*RST")
ins_hmp4040.write("INST:NSEL 1")
ins_hmp4040.write("SOUR:VOLT 24")
ins_hmp4040.write("SOUR:CURR 3.5")
ins_hmp4040.write("OUTP:SEL 1")
ins_hmp4040.query("*OPC?")
ins_hmp4040.write("INST:NSEL 2")
ins_hmp4040.write("SOUR:VOLT 18")
ins_hmp4040.write("SOUR:CURR 2.0")
ins_hmp4040.write("OUTP:SEL 1")
ins_hmp4040.query("*OPC?")
print ("Setup K2110")
ins_k2110.write("*RST")
ins_k2110.write("FUNC \"RES\"")
ins_k2110.write("RES:NPLC 10")
ins_k2110.write("TRIG:SOUR BUS")
ins_k2110.query("*OPC?")
print("Setup GSwitch")
ins_gswitch.query("SEL 0")
print("Begin Experiment")
data_log = "ledmcook"+str(time.time())+".csv"
f = open(data_log,"a")
excontinue = 1
ins_hmp4040.write("OUTP:GEN 1")
try:
while excontinue == 1 :
ins_gswitch.query("SEL 1") # 10k/3800K
ins_k2110.write("INIT")
ins_k2110.write("*TRG")
mmval = ins_k2110.query_ascii_values("FETC?")[0]
thtemp = (1/(-5.25246443E-08* math.log(mmval)**5 + 2.55553497E-06* math.log(mmval)**4 - 4.92404763E-05* math.log(mmval)**3 + 4.72276476E-04* math.log(mmval)**2 - 1.99634764E-03* math.log(mmval) + 5.24166076E-03))-273.15
ins_gswitch.query("SEL 2") # 5k/3892K
ins_k2110.write("INIT")
ins_k2110.write("*TRG")
mmval2 = ins_k2110.query_ascii_values("FETC?")[0]
thtemp2 = (1/(-4.33580388E-08* math.log(mmval2)**5 + 1.97478159E-06* math.log(mmval2)**4 - 3.48279889E-05* math.log(mmval2)**3 + 3.00342165E-04* math.log(mmval2)**2 - 1.02179886E-03* math.log(mmval2) + 3.33994017E-03))-273.15
ins_gswitch.query("SEL 3") # 10k/3500K
ins_k2110.write("INIT")
ins_k2110.write("*TRG")
mmval3 = ins_k2110.query_ascii_values("FETC?")[0]
thtemp3 = (1/(-8.09793196E-08* math.log(mmval3)**5 + 3.86144435E-06* math.log(mmval3)**4 - 7.28377697E-05* math.log(mmval3)**3 + 6.82498059E-04* math.log(mmval3)**2 - 2.89875788E-03* math.log(mmval3) + 6.64526916E-03))-273.15
f.write(str(time.time())+","+str(mmval)+","+str(thtemp)+","+str(mmval2)+","+str(thtemp2)+","+str(mmval3)+","+str(thtemp3)+"\r\n")
print(str(time.time())+","+str(mmval)+","+str(thtemp)+","+str(mmval2)+","+str(thtemp2)+","+str(mmval3)+","+str(thtemp3))
if thtemp > 105 :
print("Overheated! Terminating Experiment!")
excontinue = 0
except KeyboardInterrupt :
print("Interrupted!")
f.flush()
f.close()
ins_hmp4040.write("OUTP:GEN 0")
ins_hmp4040.close()
ins_k2110.close()
ins_gswitch.query("SEL 0")
ins_gswitch.close()
I realised that I had never shown just how the ensemble works and sounds like when it’s in action, so here’s a short video. Those relay noises are therapeutic at first, but quickly become annoying, especially when it runs for hours …
The data, once plotted, shows a few interesting findings.
The first thing to note is that the 5kΩ thermistor measured a significantly higher temperature than the others, by about 5°C! I don’t think this is a real effect as that is significant – the temperature at the source should still be higher. Instead, it probably reflects that I have damaged the thermistor in mounting it.
The ring thermistors track fairly well with just a bit of offset in the 1-2°C range, which makes sense as one unit is a 3500K and the other is a 3800K, each with their own tolerances.
Zooming in to the initial part of the test, it seems that it takes 32 seconds for heat to travel from the front to the back of the heatsink. The maximum time difference between the bead and ring on the opposite side of the heatsink appears to be 6 seconds, although this is likely influenced by the difference in absolute temperature accuracy as well. In reality, I’d say this is closer to 5 seconds, but this matches fairly well with the datasheet claim of approximately 10 seconds in liquid medium.
Unfortunately, if you think that the temperature conundrum can be solved by bringing in another opinion from an infrared thermometer, think again …
The infrared thermometer seems to overestimate the temperature quite a bit, probably because of the black coating and shiny surface causing emissivity mismatches.
Honey, I Crushed the Thermistor …
Given the slightly over-zealous response of the 5kΩ thermistor, I had a hunch that I had somehow damaged that one too during mounting by over-torquing the screws that held the “pressure bar” in place, thus squeezing the thermistor bead against the heatsink until it cracked.
As it turns out, that seems to be exactly what happened. The drilled-in divot which I thought would help prevent the bead from sliding out of position has been impressed into the body of the epoxy bead with a crack visible.
Given that it is already partially ruined, I decided to go all the way and shove it in my bench vice and crush it to a pancake. This way, we can see what’s inside.
Amidst the crumbly mess is the two wire ends seemingly leading nowhere. Can you spot the thermistor?
I’d have to presume it’s this rectangular chip sitting in a blob of deformed solder which has been physically flowed by the force of the vice. The material itself appears dark grey in colour and is a special blend of semiconductor materials to create the thermistor characteristics. Why do I think this is the thermistor? Because of its very uniform, regular shape and shiny solder around it. The black epoxy doesn’t crumble into such regular shapes! It’s nothing too exciting to see, sadly …
Thought Experiment: Multi-Range Thermistor Acquisition
In a previous blog, I showed how abusing the digital I/O pins on the ESP8266 allowed me to do some slightly-less-accurate measurements with four thermistors, requiring very little external hardware. Later on, I had a thought – what if we wanted more accuracy from a thermistor but keeping in line with the idea to keep parts to a minimum.
One way I thought of would be to invert the arrangement in the previous and instead measure the voltage across the thermistor when it is paired with different balance resistors. This, in essence, turns the system into a multi-range measurement device. The upside is that there should be a “more optimal” resistor to optimise the temperature resolution within a given temperature range. The downside is that with more ranges, a range-selection logic is required and changes between ranges can result in step-wise errors.
In the case of this example, we can see how each different balance resistor contributes to reduced temperature error in a certain range of temperatures.
Zooming in, for a resolution of <0.15°C, that can be achieved continuously from -21°C to 81°C with the four range resistors chosen. In fact, this could be done just with two of the four, so the choice of resistors is going to depend on the resolution required. Three of the resistors can give a resolution of <0.11°C for -10°C to 60°C.
Another possibility is to use the opamp to introduce some gain, amplifying the signal around the mid-rail point. This would improve temperature resolution but at the expense of temperature range at each measurement range. If the resistors were chosen carefully, it could be designed such that the limit of one range overlaps with the beginning of another, so high resolution and temperature range can be maintained.
The above is a simulation example of what would happen if a 4x gain was applied. The per-ADC step temperature resolution is much better, but because of ADC saturation, the temperature range covered by each resistor “range” is more limited. However, an excellent resolution of approximately 0.03°C can be achieved in this example for 10°C through to 70°C, possibly wider with careful choice of range resistors.
All of these calculations are for a “theoretically” perfect world, but still only using a 10-bit ADC, which is quite interesting. It means that for a bit more complexity, better resolution is attainable. Having only a limited amount of time, I didn’t choose to explore this any further, but note that it is a possibility.
Conclusion
Ring thermistors solve a mounting challenge of putting round things onto flat surfaces. I applied it to the tabs of packages and directly onto heatsinks to measure temperatures, in turn, characterising heatsink performance and protecting my LEDs from permanent damage by overheating. I was able to assess the heat-flow through a heatsink as well.
Unfortunately, in the process of comparing the ring thermistor with a bead thermistor, I ended up crushing the bead enough to damage its epoxy. In the name of science, I crushed this thermistor completely to reveal a small chip inside that is the thermistor itself.
In the end, I think Beyoncé said it well – “if you liked it, then you should’ve put a ring on it!” It seems that the ring form factor makes things so much easier for surface temperature measurements, allowing for easy mounting to tabs without additional holes required, to heatsinks directly without requiring much area and for interchanging when necessary. The connector and leads are an added bonus, meaning flexibility in positioning with no need to directly solder to board while maintaining robustness. The small cost differential will likely pay for itself in reduced manufacturing time and labour requirements and makes the thermistor a much more likeable temperature monitoring solution.
If you’d like to download the experimental data, an Excel Binary workbook which contains values only has been uploaded here (27MiB!) – trise-heatprop-nof-slim.zip
I also did a bit of a thought experiment on how to improve thermistor measurement accuracy, however, I don’t think I will actually implement these ideas in practice due to time limitations.
The series isn’t over yet though … I still have a few more things I want to do with the thermistors, but the time is rapidly drawing to a close. I hope to see you in the next blog, where I’ll try to build something else, stress thermistors out in different ways and (perhaps) wrap-up the series.
[[Characterising Thermistors Blog Index]]
- Blog #1: Characterising Thermistors - Introduction
- Blog #2: Characterising Thermistors - What's In The Box?
- Blog #3: Characterising Thermistors – A Quick Primer, Beta Value & Steinhart-Hart Coefficients
- Blog #4: Characterising Thermistors – An Inconvenient Truth, Taking Things to the Fifth Degree
- Blog #5: Characterising Thermistors – Measuring Resistance Is Not So Easy!
- Blog #6: Characterising Thermistors – Is Self-Heating a Problem or Not?
- Blog #7: Characterising Thermistors – Boiling, Freezing and Zapping the Truth Out of Them!
- Blog #8: Characterising Thermistors – Practically Running Multiple Thermistors
- Blog #9: Characterising Thermistors – Multi-T Results, Insulation R Redux, 5th Order Fits & Model Performance
- Blog #10: Characterising Thermistors – Multiple Thermistors on ESP8266
- Blog #11: Characterising Thermistors – Show Me Your Curves
- Blog #12: Characterising Thermistors – Sticking Rings on Tabs & Sinks, Absolutely Crushing It!
- Blog #13: Characterising Thermistors – Pulling Out, Overload, Response Time, Building a Flow Meter & Final Conclusion
