11 upvote00 downvotes

1K views12 pagesJul 14, 2007

© Attribution Non-Commercial (BY-NC)

PDF, TXT or read online from Scribd

Attribution Non-Commercial (BY-NC)

1K views

11 upvote00 downvotes

Attribution Non-Commercial (BY-NC)

You are on page 1of 12

Controller

James Yu

March 9, 2003

Abstract

The purpose of the project is the creation of a temperature controller through the use of

a thermistor. The thermistor resistance is modelled to have an exponential relationship

with temperature, and this relationship is confirmed through measuring the resistance of

the thermistor for different temperatures. This data is then analyzed to calibrate and assess

the error (or accuracy) of the thermistor. Finally, the thermistor is successfully used with a

computer and a heater to control the temperature around the heater to ±3◦ C of a specified

temperature.

0.1 Introduction

the alexandrite laser rod at a given temperature with an accuracy of ±3◦ C. This is done by

using a thermistor to measure the temperature of the rod and convey that information to

the computer, which will maintain a given temperature using a heater.

The thermistor is basically a resistor, and these are cheap, abundant, and useful. By taking

advantage of the fact that the resistance of a resistor varies as an exponential function of

temperature, a computer can calculate the temperature by measuring the resistance of the

thermistor. Once this is done, the computer can judge whether or not to turn on a heater

to regulate the temperature.

It is found that the thermistor conforms to the exponential relationship well enough to

achieve a ±3◦ C accuracy when used in a temperature controller. The rest of this report

discusses the theory behind the thermistor, the apparatus and methods used, and the results

obtained from the experiments. The appendix summarizes the error analysis and contains

the computer programs that are used to control the temperature.

0.2 Theory

T0

R = R0 e T (1)

where R0 and T0 are the parameters that are unique to each thermistor. The resistances

are measured in Ohms, and the temperatures in Kelvins. This relationship says that the

resistance of the thermistor varies exponentially with the inverse of the temperature. Essen-

tially, as the temperature gets larger the resistance R approaches R0 , and as the temperature

approaches absolute zero the resistance theoretically approaches infinity.

1

Solving for T in equation (2) results in

T0

T = (2)

ln R − ln R0

and thus, the computer can obtain the temperature of the thermistor by measuring its

resistance R and calculating T in equation (2). Before that can be done, the calibrating

constants R0 and T0 must be obtained.

T0

ln R = ln R0 + (3)

T

Measuring the Resistance Temperature curve of the thermistor, one can obtain the values

of T0 and R0 by applying a linear least squares fit on ln R versus T1 . After an error analysis

on these quantities, we can use error propagation to obtain the uncertainty in a measured

temperature T

Tp

∆T = (∆T0 )2 + (T ∆ ln R)2 + (T ∆ ln R0 )2 (4)

T0

This ∆T represents the uncertainty of the calculated temperature when measuring values

for R of the thermistor, based on the uncertainties in R, R0 , and T0 (which are the values in

the equation with ∆’s). It is the expected range within which the measurement will lie with

a 68% probability. A summary of the error analysis can be found in Appendix 1.

The temperature controller consists of three main components: the thermistor, the com-

puter, and the heater. Basically, the computer measures temperature information from the

thermistor, and regulates the heat using the heater. The following specific components are

needed for the temperature controller:

1. IBM-PC computer

2. Thermistor

3. Protoboard

4. Lab PC+ I/O Board

5. Heater

6. Thermometer

7. Resistors and Miscellaneous Wires

There are three main stages in building a functional temperature controller: connect the indi-

vidual components, calibrate the thermistor, and develop a computer program for temperature

regulation.

2

0.3.1 Connect and Calibrate the Thermistor

First the components are connected as shown in Figure 3, noting that the thermistor and

heater are physically in the space where the temperature needs to be controlled. To calibrate

the thermistor, the Resistance-Temperature curve for the thermistor must first be obtained.

To do this, note that the resistance RT can be calculated by measuring the voltage VT and

using the relationship

VT R1

RT = (5)

V0 − VT

A wire is connected from the node between R1 and the thermistor to the ADC0 pin on the Lab

PC+ board. Then a C++ program is written that asks the user to input a temperature, and

then calculates R0 by reading the voltage VT on the ADC0 pin. This is done by initializing

an analog to digital conversion on the ADC0 pin (refer to the AEP264 packet Exercise 3 for

more information). Then, the program simply uses eq. (2) to calculate R0 . This program

loops until a bogus temperature is inputted, and will then output the data into a text file.

A thermometer is now placed at the same location as the thermistor, and heat is applied in

the range of 30◦ C to 90◦ C while running the program. The temperatures are carefully read

by the thermometer every 3◦ C to 4◦ C and inputted into the program. The data is then used

in a Matlab script file that will finally calculate R0 and T0 .

The script file plots the ln RT versus T1 to obtain the relationship in eq. (2). It then performs

a linear least squares first order fit on this data to obtain the slope and “ln(R)”-intercept of

the straight line through the points. This was done using the function polyfit() with the ln R

and T1 data as the parameters. The slope of the line is then T0 and the intercept is ln R0 .

Once these values are obtained, the calibration is complete.

Now the push-button in Figure 3 is replaced with a Hexfet transistor (basically a switch) as

seen in Figure 4. By connecting the gate of the Hexfet to the PA0 output on the PC+ Lab

board, the computer can now turn on the heater by applying 5 volts on PA0 or turn it off

the heater by applying 0 volts on PA0.

The temperature regulating C++ program will first initialize ports A, B, and C on the Lab

PC+ board as outputs. It will then

2. Read the RT of the thermistor and calculate the temperature as was done in calibration

using R0 and T0 obtained from before.

3. If the temperature is greater than TD + 1 then apply 0 volts on PA0 to turn off the

heater, if it is less than TD − 1 then apply 5 volts on PA0 to turn on the heater, else

do nothing

3

4. Write the data point (time, temperature) to a file

5. Repeat steps 3 through 5 every 2 seconds until a key is pressed

Finally, the program is run for a few minutes set to maintain an arbitrary temperature, and

afterwards, the data is written to a file. Using Matlab, the temperature-time history of the

controller is plotted.

0.4 Results

The resistance-temperature curve obtained from our thermistor is shown in Figure 1 along

with the first order least squares fit line. As seen in this data, there is a systematic error

between the heating and the cooling data; this is a result of the thermometer “catching up”

with the actual temperature. It will be higher than the actual temperature when cooling and

lower than the actual temperature when heating. This is most easily seen in the plot of the

residuals, or the difference between the measured data and the fitted line, as seen in Figure

2. I fitted only to the heating data to eliminate this error, and obtained the calibrating

constants (with errors)

ln R0 = −4 ± 0.1955 (6)

T0 = 3600 ± 64.4789 (7)

And from this, I have obtained an average uncertainty in a given temperature measurement

of

∆T ≈ 8.4790 (8)

This temperature uncertainty is actually related to the accuracy of the temperature controller

in reading the correct temperature; it has nothing to do with the actual precision of the

controller which is dictated by the heating and cooling properties of the material. In order to

eliminate this error in actual use, I changed T0 in response to the accuracy of the temperature

reading based on the thermometer, and, by doing so, achieved a high level of temperature

accuracy using the thermistor.

When plotting the temperature versus time curve for the controller, a jagged graph seen

in Figure 5 arises. This is due to the fact that V0 is not a constant 5 volts, but actually

fluctuates in time. To eliminate this error, I adjusted the resistance calculating part of the

C++ program to measure V0 using an ADC. After obtaining V0 I use it as part of eq. (5)

instead of using 5 volts: this eliminates the said fluctuations and produces Figure 6.

4

Figure 6 shows that the temperature controller is successful in maintaining a desired tem-

perature within ±3◦ C. From the graph it is estimated that the overshoot is within 2◦ C and

the undershoot is within 1◦ C. The reason the overshoots are bigger than the undershoots is

because the element is faster in heating up than it is in cooling down.

0.5 Conclusion

The design of a temperature controller using a thermistor coupled with a heater and a

computer is precise and accurate enough to fit the criteria of the requirements. However,

there are some performance limitations to this scheme. Due to the properties of the heater

and the object being heated, there may be an uneven amount of time spent above and below

the desired temperature TD . In the specific case of Figure 6, more time is spent above TD ,

and thus the mean temperature is a little higher than TD .

A possible extension to the testings would be to test the precision for different temperatures.

Testing for the range of all temperatures that the controller would still have precision ±3◦ C

would be useful in knowing the operating range of the controller. Extending the testings

to different kinds of thermistors would also be a valuable test to determine which kind of

thermistor is best suited for the job.

A more concrete test for the controller would be to actually use it to control the temperature

of an alexandrite laser rod, and use more precise temperature instruments to measure the

temperature that is maintained in the rod. This would truly determine the overall effective-

ness of the temperature controller on the rod.

5

0.6 Appendix 1: Error Analysis

Since this experiment is based on measurements in resistances, there are uncertainties and

errors in all the quantities leading up to the uncertainty in the final temperature reading

T by the thermistor. First, the rms deviation, or probably error associated with a single

measurement, may be calculated by

s

PN 2

i=1 (δyi )

∆y = (9)

N

where the δyi = yi − yt , or the differences from the measured values yi and the theoretical

yt .

Now, when a linear least squares is applied to the plot of ln R and T1 , there are some error

estimates that may be calculated. The uncertainties in ln R0 or the intercept and T0 or

the slope will contribute to the overall uncertainty. These uncertainties are calculated using

techniques of minimum least squares fit and error propagation, which are detailed in the

AEP264 packet pages 42 through 44.

v

u N

uX δi

∆ ln R = t (10)

i=1

N

r

N

∆T0 = ∆ ln R (11)

vD

u N

u X x2

∆ ln R0 = ∆T0 t i

(12)

i=1

N

Where N is the total number of measurements made, xi are the measured values T1i , δi is

P

the residual or deviations of measurements from theoretical values, and D = N N 2

i=1 xi −

PN

( i=1 xi )2 .

propagation may be used to calculate the uncertainty in T . It can be written that the

uncertainty ∆T is the square root of the sum of the squares of the partial derivatives of each

rms value: r

∂T ∂T ∂T

∆T = ( ∆T0 )2 + ( ∆ ln R)2 + ( ∆ ln R0 )2 (13)

∂T0 ∂ ln R ∂ ln R0

Solving for ∆T obtains the uncertainty

Tp

∆T = (∆T0 )2 + (T ∆ ln R)2 + (T ∆ ln R0 )2 (14)

T0

This then is the uncertainty associated with each calculated temperature from a resistance

measurement of the thermistor.

6

0.7 Appendix 2: C++ Program

This program is the temperature regulating program. It firsts asks the user to enter a desired

temperature. It then reads and calculates the resistance of the thermistor, and through that

calculates the temperature. If the temperature is greater than the desired temperature + 1

then it will turn the heater off, if it is less than the desired temperature - 1 then it will turn

on the heater. The program loops every 2 seconds until a key is pressed.

#include <stdio.h>

#include <conio.h>

#include <windows.h>

#include <math.h>

#define FIFO_Reg base_addr + 0x0A

#define StartCnv_Reg base_addr + 0x03

#define Comm_Reg_1 base_addr

#define Comm_Reg_2 base_addr + 0x01

#define Comm_Reg_3 base_addr + 0x02

#define Comm_Reg_4 base_addr + 0x0F

#define Status_Reg base_addr

#define Count_A base_addr + 0x17

#define Count_A0 base_addr + 0x14

#define DMATC base_addr + 0x0A

#define TI_Clear base_addr + 0x0C

#define DAC0L base_addr + 0x04

#define DAC0H base_addr + 0x05

#define DAC1L base_addr + 0x06

#define DAC1H base_addr + 0x07

#define PortA_Reg base_addr + 0x10

#define DigCtrl_Reg base_addr + 0x13

int main(void) {

initboard();

_outp(DigCtrl_Reg, 0x80); /*sets ports A,B, and C as outputs */

_outp(PortA_Reg, 0); /* sets A to 0 */

7

double VOLTAGE, VOLTAGE_V0;

unsigned ADCUNITS, ADC_V0, i;

float Temp, R, TempD;

int DONE, t=0;

float T0 = 3600;

float ln_R0 = -4;

i=0;

FILE *fp;

fp = fopen("output.dat", "w");

scanf("%f", &TempD);

TempD = TempD + 273.16;

do {

_outp(StartCnv_Reg, 0x00); /* write to start conversion */

do

DONE=_inp(Status_Reg);

while((DONE & 0x01) != 0x01);

HIBYTE=_inp(FIFO_Reg); /* both bytes must be read to clear FIFO_Reg */

_outp(Comm_Reg_1, 0x01); /* selects ADC channel 1 */

_outp(StartCnv_Reg, 0x00);

/* waits for first bit of DONE to be 1 */

do

DONE=_inp(Status_Reg);

while((DONE & 0x01) != 0x01);

V0_LO=_inp(FIFO_Reg);

V0_HI=_inp(FIFO_Reg);

ADCUNITS=256*HIBYTE+LOBYTE;

VOLTAGE=10.0*ADCUNITS/4096.0;

printf("\nHIBYTE: %4d, LOBYTE: %4d", HIBYTE, LOBYTE);

8

printf(", ADCUNITS: %d, VOLTAGE %5.2f\n", ADCUNITS, VOLTAGE);

ADC_V0=256*V0_HI + V0_LO;

VOLTAGE_V0=10.0*ADC_V0/4096.0;

printf("\nHIBYTE: %4d, LOBYTE: %4d", HIBYTE_V0, LOBYTE_V0);

printf(", ADC_V0: %d, V0 %5.2f\n\n", ADC_V0, VOLTAGE_V0);

Temp = T0 / (log(R) - R0_ln);

fprintf(fp, "%5.2f\t%d\n", Temp - 273.16, t);

_outp(PortA_Reg, 4);

if(Temp > TempD + 1)

_outp(PortA_Reg, 0);

delay(2000);

t = t + 2;

} while(!kbhit()) _outp(PortA_Reg, 0); fclose(fp);

return(0); }

/*******************delay()*****************/

void delay(int dt)

{ unsigned long final;

final=dt + GetTickCount();

while(final > GetTickCount() );

return; }

/****************initialize board***********/

void initboard() {

_outp(Comm_Reg_1, 0x00);

_outp(Comm_Reg_2, 0x00);

_outp(Comm_Reg_3, 0x00);

_outp(Comm_Reg_4, 0x00);

_outp(Count_A, 0x34);

_outp(Count_A0, 0x0A);

_outp(Count_A0, 0x00);

_outp(DMATC, 0x00);

_outp(TI_Clear, 0x00);

9

_outp(AD_Clear_Reg, 0x00);

LOBYTE = _inp(FIFO_Reg);

HIBYTE = _inp(FIFO_Reg);

return; }

10

Bibliography

[1] T. Cool: Computerized Instrumentation Design: Applied and Engineering Physics 264,

School of Applied and Engineering Physics, Cornell University (2003)

11

## Much more than documents.

Discover everything Scribd has to offer, including books and audiobooks from major publishers.

Cancel anytime.