Published December 20, 2023 © CC BY

PID Temperature Control of a Miniature Thermal Chamber

The PID Temperature Control of a miniature thermal chamber is a system designed for teaching the fundamentals of Process Control.

AdvancedFull instructions provided10 hours329

Things used in this project

Hardware components

Arduino Nano R3

Rotary Potentiometer, 10 kohm

36 Ohm Resistor 5 Watt Cement Resistor

Resistor, 30 ohm

N Channel Power Mosfet IRF540N

IN4001 Diode

5 mm LED: Red

5 mm LED: Yellow

Resistor 220 ohm

Alphanumeric LCD, 20 x 4

With I2C Interface

LeMoTech Project Box 100x68x50

Fan 12V 50x50x10mm

Gikfun 2 pin 3 pin screw terminals

Yungui 12 Pcs 50x100mm Universal PCB Boards

Binding Posts

Jumper wires (generic)

Resistor 10k ohm

LM35DZ

Rotary Potentiometer, 5 kohm

Story

The PID Temperature Control of a miniature thermal chamber is a system designed for educational purposes. It can be used as an inexpensive lab for developing an understanding of process control and the effects of process dynamics on selecting the optimum PID (proportional, integral, and derivative) tuning constants. The system can be implemented inexpensively and would be ideal for a student doing an on-line course in process control systems. The system allows operating, PI, or PID control with reverse or forward (direct) acting control., by using selectable final control elements (resistive heater, or variable fan speed). The system provides 2 sets of process dynamics by tightly coupling a temperature sensor to the resistive heater or alternatively using a sensor in the centre of the chamber. These very different process dynamics require very different sets of PID tuning.

The system hardware consists of the miniature (100x68x50mm) thermal chamber, a control board and an interface board.

The control board consists of an Arduino Nano, a setpoint potentiometer for setting desire temperature in deg C and a disturbance potentiometer, selectable for either heater or fan. The outputs from the Nano are 2 pulse width modulated signals that produce a variable DC voltage that drives the fan and heater.

The interface board utilizes 2 N Channel power Mosfets and uses the PWM signals from the Nano to produce a PWM output with a maximum voltage of 12VDC to supply the thermal chamber heaters and fan.

The thermal chamber consists or 2 Cement resistor heaters of 5 watts each, a 12VDC fan, and 2 LM35DZ temperature sensors. One of the sensors measures the air temperature of the Chamber, while the other sensor is firmly attached to one of the temperature resistor heaters.

The following 2 images displays the hardware.

Control Board, Interface Board, Thermal Chamber and Display

Internal of Miniature Thermal Chamber showing 2 cement resistor heaters and 2 sensors

The following image shows a block diagram for the system. Note that the Arduino Serial Plotter is used to display the Temperatures and Setpoints. The following are the commands that are set from the Arduino IDE Serial Plotter:

LM35_1 - Sets the PID controlled variable as the temperature of one of the cement resistor heaters. In the phot, it is the cement resistor on the right. Tuning Constants are optimal using Ziegler Nichols Open Loop method.

LM35_2 - Sets the PID Controlled variable as the temperature of the sensor in the middle of the chamber. Tuning Constants are optimal using Ziegler Nichols Open Loop method.

LM35_1Fast - Sets PID controlled variable to heater temperature sensor, PID tuning constants for a fast oscillatory response

LM35_1Slow - Sets PID controlled variable to heater temperature sensor, PID tuning constants for a slow stable response

LM35_2Fast - Sets PID controlled variable to air temperature sensor, PID tuning constants for a fast oscillatory response

LM35_2Slow - Sets PID controlled variable to air temperature sensor, PID tuning constants for a slow stable response

Reverse sets the PID controller to Reverse acting, where the temperature is controlled by the PID adjusting the voltage to the cement resistor heater. The fan then can be manually adjusted by the potentiometer to act as a disturbance.

Forward sets the PID controller to Forward(Direct) acting where the temperature is controlled by adjusting the fan voltage, and therefor air flow to the chamber. The heater then can be manually adjusted by the potentiometer to act as a disturbance.

Manual disables the PID controller and allows the the setpoint potentiometer to fix either the heater or fan setting from 0 to 100%. There is no feed back. This is referred to as open loop.

Auto enables the PID controller, either Reverse or Forward acting.

The block diagram below shows the interconnection of the boards and thermal chamber:

The features of the PID Temperature Control of a miniature thermal chamber are as follows:

Chamber

·Small volume chamber 100mmx68mmx50m
Heater Temperature sensor affixed to resistive heater
Air temperature sensor
·2 resistive heaters (30 and 36 ohms), 12 VDC supply to heaters
·Maximum heater temperature approx. 135 deg C
Maximum air temp about 60 deg C
·2 distinctly different sets of process dynamics

PID Controller

Standard (sometimes called Mixed) algorithm
Most commonly used in industry
Select Reverse or Forward (Direct) acting
Reverse uses heater as final control element
Forward uses fan as final control element
2 sets of PID tuning constants for 2 different process dynamic cases
Auto/Manual selection

Display

Runs independently with LCD display or along with Arduino Serial Plotter

LCD

Heater temperature deg C
Air temperature deg C
Setpoint in deg C
Fan or Heater manual setting 0 to 100%
PID components displayed in real time
Proportional component
Integral component
Derivative component
Cout - total of three PID components

Plotting

Uses Arduino IDE serial plotter
Plots Heater and air temperatures
Plots Setpoint or Manual setting
Generates the following commands
Auto – sets PID controller to automatic
Manual – sets system to manual open loop operation
Reverse – sets PID to reverse acting using heater as controller output
Forward – sets PID to forward acting using fan as controller output
LM35_1 – sets PID controlled variable to heater temperature sensor, using optimal Ziegler Nichols tuning constants
LM35_2 – sets PID controlled variable to air temperature sensor, using optimal Ziegler Nichols tuning constants
LM35_1Fast - Sets PID controlled variable to heater temperature sensor, PID tuning constants for a fast oscillatory response
LM35_1Slow - Sets PID controlled variable to heater temperature sensor, PID tuning constants for a slow stable response
LM35_2Fast - Sets PID controlled variable to air temperature sensor, PID tuning constants for a fast oscillatory response
LM35_2Slow - Sets PID controlled variable to air temperature sensor, PID tuning constants for a slow stable response

Electronics

Arduino Nano microcontroller

Connects to LCD Display via I2C bus
Generates 2 PWM outputs to Power Mosfet Interface board
C Code generated from Arduino IDE
Setpoint and disturbance generated from 2 potentiometers connected to Nano analog inputs
Temperature sensors – LM35 – generate 0 to 1.5 volts for 0 to 150 deg C

· Interface Board

Power Mosfets IRF540N are switched at 490 Hz and operate via Pulse Width Modulation to vary the voltage on the heaters
Red LED intensity varies with Voltage supplied to the heater
Yellow LED intensity varies with Voltage supplied to the fan

How Does the PID Work?

Before the use of microcontrollers and computers PID controllers were implemented with analog electronic devices, the principle one being the operational amplifier.

Implementing PID control digitally uses an algorithm. There are several versions of the PID controller. The one implemented in this project is sometimes referred to as the Mixed or Standard implementation.

The mathematics of the PID mixed PID controller can be represented as the following.

Mixed PID

Where:

Kc is the controller gain, Ti is the integral time, Td is the derivative time, and e is the error. Sometimes controller gain is represented as Kc = 100%/PB where PB is referred to as Proportional Band. A smaller PB then results in a larger gain .

The following is pseudo code for implementing the PID algorithm. It is not in the form of an actual programming language but more in the form of a flow diagram.

Pseudo Code For PID Algorithm

The following is a simplified implementation for PID using C language:

Simplified C Code Implementation of PID Algorithm

Open Loop Response for the Thermal Chamber.

When the PID Controller is put into Manual mode, that is the PID controller is disabled and a fixed value set by the potentiometer, an open loop response can be generated. This is very useful, because the open loop response yields valuable information about the dynamics of the process. For the Thermal Chamber suddenly changing the fixed heater setting to another fixed heater setting (called a Step Change), we can observe how, and how quickly the temperature changes. For the Air temperature, we would expect a much slower and smaller response than for the cement resistor temperature. These different responses characterize the process dynamics of the system. Getting the "best response by our PID controller will require different Proportional, Band Integral time and Derivative time settings. Theses settings are known as the tuning constants. Using the open loop response, and a method called Ziegler Nichols we can generate a set of tuning constants by analyzing the plot of the open loop response.

The following plot is an open loop response for the temperature sensor attached to the cement resistor heater. Superimposed on the plot is the Ziegler Nichols calculations for determining the 'best" tuning constants.

The following chart is from an Excel spread sheet for using the information from the plot to calculate a set of PID and PI tuning constants:

When these tuning constants are used they yield a response sometimes referred to as Quarter Decay. That is, the temperature will overshoot and undershoot several times with each successive overshoot being reduce to a quarter of the previous cycle. After several of these cycles, the temperature will reach the desired setpoint, referred to as steady state.

An example of Quarter Decay Response generated from the PID Temperature Control of the Thermal Chamber is shown below.

Controlled Temperature of Sensor Attached to Heater

Why is the PID Temperature Control of a Miniature Thermal Chamber So Useful as an Educational Platform?

Because of the flexibility of the system ( 2 sets of very different process dynamics, a reverse and forward acting controller, open loop and closed loop control) many labs can be set up to calculate tuning constants and then demonstrate operation of a process control system using these tuning constants for the 2 processes and for Reverse and Forward acting controllers. This would enable a student to have a working knowledge of process control and make adapting to controlling industrial processes much more quickly and confidently.

Lab Experiments

The following are 9 lab experiments designed to develop an understanding process dynamics and how it influences choice of tuning constants.

The labs will use the heater and fan as final control elements.

When the heater is the final control element, the controller will be in Reverse Acting mode.

When the fan is the final control element, the controller will be in Forward (Direct) acting.

The experiment has an initial temperature and a final temperature shown.

The disturbance is a fan setting in % for Reverse Acting and a heater setting in % for Forward (Direct) acting. The disturbance potentiometer sets this value.

The Setpoint potentiometer adjusts a Temperature setting from ambient to 150 deg C. In manual mode, the Setpoint potentiometer sets a manual value from0 to 100%

Selection of the sensing temperature LM35 and the tuning constants are shown with an x.. For the sensor attached to the heater resistor, it is LM35_1 for optimum tuning constants, LM35_1Fast for low low proportional band tuning constants, and LM35_1Slow for high proportional band settings. For the sensor measuring air temperature it is LM35_2, for optimum tuning constants, LM35_2Fast for low low proportional band tuning constants, and LM35_2Slow for high proportional band settings. The integral and derivative values are also changed when the proportional band is changed.

To change settings the serial plotter is used. The command is entered at the bottom of the plotter screen. The plotter should remain open for the experiments. Closing the serial plotter places all the tuning constants into the LM35_1 Auto mode, Reverse Acting, with Optimum tuning constants.

Experiment 1

Experiment 2

Experiment 3

Experiment 4

Experiment 5 and 6

Experiment 7

Experiment 8

Experiment 9

Schematics

Code

PWM_2_D11_D10.ino

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 , 4

//#define C_Variable TR_C_Filtered
float C_Variable;
float propBand;
float integralTime;
float derivativeTime;

bool LM35_1=true;
bool LM35_2;
bool Forward=false;
bool Reverse=true;
bool controlAction;

String command;

int tempLocal;// read from analog pin A0
int tempRemote;// read from analog pin A3
int potA1;// pot setting  from analog pin A1
int potA3;//pot setting  from analog pin A3



float TR_C;// Remote temperature in deg C, normalized in argument for PI Controller
float TL_C;//Local temperature in deg C
float TR_C_Filtered;
float TL_C_Filtered;

bool Auto=true;
bool Manual=false;

void LM35_A2();//Read the Remote LM35 on analog input A3 and display on LCD
void LM35_A7();//Read the Local LM35 on analog input A1 and display to LCD

void Potentiometer(bool action);// Read the potentiometer setting as an analog input A3 and display as 0 to 100%

void printText();// Print static text to display
void SerialPlotter();

float PID_output(float process, float setpoint, float Prop, float Integ, float deriv, int Interval, bool action); // PID Controller

float SetpointGenerator();// generate setpoint for PID
float TR_C_filterFunction(float timeConstant, float processGain,float blockIn, float intervalTime);// filtered Heater temp sensor reading
float TL_C_filterFunction(float timeConstant, float processGain,float blockIn, float intervalTime);//filtered Air Temp sensor reading
float DerivativefilterFunction(float timeConstant, float processGain,float blockIn, float intervalTime);// filtered derivative    

void setup()
{
    lcd.init(); //initialize the lcd
    lcd.backlight(); //open the backlight
  
    //********** Set the PWM pins output.***********************
    pinMode(10, OUTPUT);//switchable to either heater or fan
    pinMode(11, OUTPUT);//switchable to either heater or fan
    // reverse acting 10 connected to heater, 11 to fan
    // forward acting 10 connected to fan, 11 to heater
    
    //***********Serial Monitor*******************************
    Serial.begin(9600);
    printText();//Print Static Text on LCD
    
    C_Variable=TR_C_Filtered;//default controlled variable is heater temp
   // ********default PID Settings******** 
    propBand = 7;
    integralTime=40;
    derivativeTime=10;
    
}

//*************Looping Code********************************
void loop()
{
    float heaterSetting;// Normalized PI Controller Set Point
    float contOutNorm;//Normalized PI Controller Output
    
// ***code for commands set from Arduino serial plotter***
    if (Serial.available()) 
    {
      command = Serial.readStringUntil('\n');
      command.trim();
      
      if (command.equals("Auto")) 
      {
        Auto=true;
        Manual=false;
      }
  
      else if (command.equals("Manual")) 
      {
        Manual =true;
        Auto=false;
      }

      else if (command.equals("LM35_1")) 
      {
        LM35_1=true;
        LM35_2=false;
        propBand = 11.38;
        integralTime=43.4;
        derivativeTime=10.85;
      }
      else if (command.equals("LM35_1Fast")) 
      {
        LM35_1=true;
        LM35_2=false;
        propBand = 3.5;
        integralTime=16;
        derivativeTime=4;
      }
      else if (command.equals("LM35_1Slow")) 
      {
        LM35_1=true;
        LM35_2=false;
        propBand = 40;
        integralTime=100;
        derivativeTime=25;
      }
      else if (command.equals("LM35_2")) 
      {
        LM35_2=true;
        LM35_1=false;
        propBand = 3.43;
        integralTime=98.6;
        derivativeTime=24.65;
      }
      else if (command.equals("LM35_2Fast")) 
      {
        LM35_2=true;
        LM35_1=false;
        propBand = 1;
        integralTime=24;
        derivativeTime=6;
      }
      else if (command.equals("LM35_2Slow")) 
      {
        LM35_2=true;
        LM35_1=false;
        propBand = 10;
        integralTime=250;
        derivativeTime=62.5;
      }


      else if (command.equals("Forward")) 
      {
        Forward=true;
        Reverse=false;
      }

      else if (command.equals("Reverse")) 
      {
        Forward=false;
        Reverse=true;
      }
      else 
      {
      Serial.println("bad command");
      }
    Serial.print("Command: ");
    Serial.println(command);
   }
    
    LM35_A7();// read LM35 connected to A7
    LM35_A2();// read LM35 connected to A2
    
    Potentiometer();// manually set motor speed 
    
    
    //********PI Controller Code******************************
    if(Reverse==true)
    {
      controlAction =true;// PID control action to reverse acting
    }
    else if(Forward==true)
    {
      controlAction=false;//PID control action to forward (direct) acting
    }
    if(LM35_1 ==true)
    {
     C_Variable=TR_C_Filtered;//PID controlled variable, heater temp
    }
    else if (LM35_2==true)
    {
     C_Variable =TL_C_Filtered;//PID controlled variable, air temp
    }
    
    if(Auto==true )
    {
      //set the PID controller setpoint temperature range
      heaterSetting=SetpointGenerator();
      //execute the PID control, output is normalized 0 to 1.0
      contOutNorm=PID_output(C_Variable/500, heaterSetting/500,propBand, integralTime,         derivativeTime, 2000, controlAction); 
      
      if (controlAction==true)
      {
       // reverse acting output to pin 10 heater
      analogWrite(10,255*contOutNorm);// denormalize controller output 
      }
       // forward(direct) acting output to pin 11
      else if(controlAction==false)
      {
      analogWrite(11,255*contOutNorm);// denormalize controller output 
      }
      
      lcd.setCursor(0, 3);// to LCD display
      lcd.print("Set Pt C ");
    } 
    if (Manual==true )
     {
     potA1=analogRead(A1);//read potentiometer connected to A1
     if (controlAction==true)
      {
      analogWrite(10,((float)potA1/1023*255*2.90));// sets heater output
      } else if (controlAction==false)
      {
      analogWrite(11,((float)potA1/1023*255));// sets fan output
      }
     
    lcd.setCursor(9 , 3); 
    lcd.print("    ");    
    lcd.setCursor(9 , 3); 
    lcd.print (int((float)potA1/1023*100*2.90));

     lcd.setCursor(0, 3);
     lcd.print("Manual % ");
    }
    //***********End of PID Controller Code*********************
    
    delay(2000);// sets interval delay for PID and filters
    
    SerialPlotter(contOutNorm);//plot values on Serial plotter
}
//***********End of Looping*****************************

void printText()
  {
 
  lcd.setCursor(0, 0);
  lcd.print("Temp R C "); 
  lcd.setCursor(0, 1);
  lcd.print("Temp L C ");
  lcd.setCursor(0, 2);
  lcd.print("C Out  % ");
  lcd.setCursor(0, 3);
  lcd.print("Set Pt C  ");
  lcd.setCursor(13, 0);
  lcd.print("P "); 
  lcd.setCursor(13, 1);
  lcd.print("I ");
  lcd.setCursor(13, 2);
  lcd.print("D ");
  lcd.setCursor(13, 3);
  lcd.print("Fn% ");
  }
void SerialPlotter()// plots variables on Arduino IDE serial plotter
{
   if (Auto==true & Manual==false) 
      {
        Serial.print(150.0);//plot horizontal line at 150
        Serial.print(",");
        Serial.print(0.0);//plot horizontal line at 0
        Serial.print(",");
        Serial.print(((float)potA1*0.4887585));//plot value of potA1,
        Serial.print(",");
        Serial.print(TR_C_Filtered);// plot heater temperature deg C
        Serial.print(",");
        Serial.println(TL_C_Filtered);// Plot air temperature deg C
      }
  
   else if (Manual==true & Auto==false) 
      {
        Serial.print(150.0);//plot horizontal line at 150
        Serial.print(",");
        Serial.print(0.0);//plot horizontal line at 0
        Serial.print(",");
        Serial.print(int((float)potA1*0.09775*2.90));//plot potA1 value
        Serial.print(",");
        Serial.print(TL_C_Filtered);// plot heater temp
        Serial.print(",");
        Serial.println(TR_C_Filtered);// Plot air temp
        
      }

          
     
}
void LM35_A2()
{
  tempRemote=analogRead(A2);//Raw heater temp in counts
  TR_C=(float)tempRemote*0.4887585; // heater temp in deg C 
  TR_C_Filtered=TR_C_filterFunction(5, 1.0,TR_C, 2000);//filtered temp
  
  lcd.setCursor(9, 0); 
  lcd.print("    ");
  lcd.setCursor(9, 0); 
  lcd.print((int)TR_C_Filtered); 
}
void LM35_A7()
{ 
  tempLocal=analogRead(A7);//Raw air temp in counts
  TL_C= (float)tempLocal*0.4887585;//air temp in deg C
  TL_C_Filtered=TL_C_filterFunction(25, 1.0,TL_C, 2000 );//filtered temp
  
   //Display on LCD
  lcd.setCursor(9, 1); 
  lcd.print("    ");
  lcd.setCursor(9, 1); 
  lcd.print((int)TL_C_Filtered); 
   
}

void Potentiometer(bool action)// fan setting 0 to 100%
{
  float speedPercent;
  potA3=analogRead(A3);

  speedPercent=(float)potA3*100/1023;
  if (action==false)// forward(direct) acting
  {
   analogWrite(10,speedPercent/100*255); // output to heater
  } else if (action==true)// reverse acting
  {
   analogWrite(11,speedPercent/100*255);  //output to fan 
  }
  //Display on LCD
  lcd.setCursor(17, 3); 
  lcd.print("   ");
  lcd.setCursor(17, 3); 
  lcd.print ((int) (speedPercent));
  
}

float SetpointGenerator()// Set Point 0 to 150dg C
{
  float setTemp;
  
  potA1=analogRead(A1);// read setpoint pot
 // while setpoint range is 0 to 500, heater can generate heat to about
  // 140 deg C. Range is set to 500 due to calibration requirement of
  // LM35s  
  /
    setTemp=(float)potA1*0.4887585;
   
   // display to LCD 
    lcd.print("    ");
    lcd.setCursor(9 , 3); 
    lcd.print((int)setTemp); 
    return setTemp;
}

//*********Start of PID Controller algorithm*****************
float PID_output(float process, float setpoint, float Prop, float Integ, float deriv, int Interval, bool action)
{
float Er;
static float Olderror, Cont;
static int Limiter_Switch;
static float Integral;
float derivative;
float proportional;
float deltaT;
float filteredDerivative;
deltaT=float(Interval)/1000;
Limiter_Switch = 1;// prevents integral windup when output reaches 
//0.0 or 1.0 (normalized)


if (action==false)
  {
  Er = (process-setpoint);// forward or direct acting
  } else if (action==true)
  {
  Er=(setpoint-process); //reverse acting
  }

//Limiter switch turns integration OFF if controller is already at 
//100% output or 0% output
//Prevents integral windup, where controller keeps integrating 
//when controller output can no longer affect the process.

// 2 is the interval time in seconds

if ((Cont >= 1 && Er > 0) || (Cont <= 0 && Er < 0) || (Integ >= 3600)) 
        Limiter_Switch = 0;
else
        Limiter_Switch = 1;     
  
// Integ of 3600 secs esentially turns integration off
// Integral calculator
Integral = Integral + 100 / Prop / Integ * Er *deltaT * Limiter_Switch;// Integral calculator
// Derivative calculator
derivative = 100 / Prop * deriv * (Er - Olderror) / deltaT;// Derivative calculator
// derivative filtering
filteredDerivative=DerivativefilterFunction(5, 1.0,derivative, 1000);
//proportional calculator
proportional = 100 / Prop * Er;// Proportional calculator
        
Cont = proportional + Integral + filteredDerivative;
Olderror = Er;// retains previous error for deriative calculator

if (Cont > 1) // limit controller output between 0.0 and 1.0, nomalization
    Cont = 1;

if (Cont < 0) 
    Cont = 0;
//display controller components to LCD display
lcd.setCursor(9 , 2); 
lcd.print("    ");    
lcd.setCursor(9 , 2); 
lcd.print((int)(Cont*100.0));

lcd.setCursor(15 , 0); 
lcd.print("     ");    
lcd.setCursor(15 , 0);
lcd.print((int)(proportional*100.0));
lcd.setCursor(15 , 1); 
lcd.print("    ");    
lcd.setCursor(15 , 1); 
lcd.print((int)(Integral*100.0));

lcd.setCursor(15 , 2); 
lcd.print("     ");    
lcd.setCursor(15 , 2); 
lcd.print((int)(filteredDerivative*100.0));

return  Cont;
}
//*****************End of PID***********************


//************Exponential Filter Functions*****************
float TR_C_filterFunction(float timeConstant, float processGain,float blockIn, float intervalTime)
{
float static blockOut;
blockOut=blockOut+(intervalTime/1000/(timeConstant+intervalTime/1000))*(processGain*blockIn-blockOut);
return blockOut;  
}

float TL_C_filterFunction(float timeConstant, float processGain,float blockIn, float intervalTime)
{
float static blockOut;
blockOut=blockOut+(intervalTime/1000/(timeConstant+intervalTime/1000))*(processGain*blockIn-blockOut);
return blockOut;  
}

float DerivativefilterFunction(float timeConstant, float processGain,float blockIn, float intervalTime)
{
float static blockOut;
blockOut=blockOut+(intervalTime/1000/(timeConstant+intervalTime/1000))*(processGain*blockIn-blockOut);
return blockOut;  
}

Credits

LenFromToronto

2 projects • 1 follower

Retired Electrical Engineer. Worked in Process Control and Instrumentation Systems. Taught Electronics Technology - Automation Systems

PID Temperature Control of a Miniature Thermal Chamber

Things used in this project

Hardware components

Story

Custom parts and enclosures

Schematic

Schematics

Temperature Control System

Code

PWM_2_D11_D10.ino

Credits

LenFromToronto

Comments

Embed the widget on your own site

PID Temperature Control of a Miniature Thermal Chamber

PID Temperature Control of a Miniature Thermal Chamber

Things used in this project

Hardware components

Story

Custom parts and enclosures

Schematic

Schematics

Temperature Control System

Code

PWM_2_D11_D10.ino

Credits

LenFromToronto

Comments

Related channels and tags