MAX6675 Thermocouple Library for Proteus V1.0: K-Type Temperature

Hello friends, I hope you all are doing great. Today, I am going to share the new MAX6675 Thermocouple Library for Proteus V1.0. The MAX6675 and a K-type thermocouple measure what other sensors cannot touch: ovens, kilns, soldering irons, 3D printer nozzles, smokers, exhaust pipes and furnaces, from room temperature up to 1023.75 C. Now you can build and test them in Proteus, with the red MAX6675 module and the stainless K-type probe on its braided cable.

Behind the parts sit our own models, not a part that shows a number. The probe is a real thermocouple in the analog simulation: it puts the microvolts of the type K table between its two leads. The MAX6675 reads those microvolts, adds the cold junction, the temperature of its own board, and sends the result to the Arduino as a 16-bit word bit by bit on SO, with the real conversion time and the open thermocouple flag. You get three devices: the MAX6675 as a Simple device with a live STATUS panel and as an Advance device with a pop-up window and three test tools, and the K-type probe with its TEMPERATURE panel. The demo runs the Adafruit MAX6675 library on our Arduino UNO V4.0.

NOTICE: a thermocouple is easy to fake: read a temperature from a property and hand it to the Arduino. We wanted more. Our probe makes the real thermocouple voltage, our MAX6675 compensates the cold junction and answers the SCK pulses bit by bit, so the Adafruit library reads it exactly as on your desk, and the classic mistakes fail exactly as they do there. It took our team a lot of hard work. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the MAX6675 board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the MAX6675 Thermocouple Library for Proteus V1.0:

What is the MAX6675?

The MAX6675 from Maxim (now Analog Devices) is a cold-junction-compensated K-type thermocouple-to-digital converter. It amplifies the tiny voltage of a thermocouple, measures the temperature of its own package with a diode, adds the two and converts the result into a 12-bit number: 0.25 C a step, from 0 to 1023.75 C. It has no registers to set and nothing to write: the microcontroller only reads it on three wires, SO, SCK and CS. The cheap red module carries the chip in its SO-8 package, a 0.1 uF capacitor, a blue screw terminal for the thermocouple and a five-pin header. For temperature sensors in general, read our What are Temperature Sensors?

How a Thermocouple Works

A thermocouple is two wires of different metals welded together at the tip. For type K they are chromel (the + lead) and alumel (the - lead). When the tip is hotter than the other ends of the wires, a small voltage appears between those ends, about 41 uV per C of difference. The relation is not quite a straight line, so it is given as a table, the NIST ITS-90 table for type K: 4.096 mV at 100 C, 8.138 mV at 200 C and 41.276 mV at 1000 C, all measured against 0 C. A thermocouple needs no power and survives temperatures that would melt any chip, which is why ovens and kilns use them.

The Cold Junction

The catch is in the word difference. A thermocouple measures the tip against the place where its wires meet the copper of the circuit, the cold junction: the screw terminal of the module. If the module sits at 25 C, a tip at 200 C gives only E(200) - E(25) = 7.138 mV. The MAX6675 measures the cold junction with its own diode and adds it back, which is called cold-junction compensation. That is why the module should stay at the room's temperature, away from the heat it measures.

How the MAX6675 Sends a Reading

While CS is HIGH, the MAX6675 converts, one conversion every 170 ms. To read it, the Arduino pulls CS LOW: that stops the conversion and puts the first bit on SO. Each SCK falling edge puts the next bit on SO, 16 bits in all: D15 is a dummy 0, D14 to D3 the temperature in 0.25 C steps, D2 goes HIGH when the thermocouple is open, D1 is 0 (the device ID) and D0 is three-state. When CS goes HIGH again, a new conversion starts. So a word of 0x1900 is 800 x 0.25 = 200.00 C.

What's New in MAX6675 Thermocouple Library for Proteus V1.0

• Real parts: the red MAX6675 module drawn at about twice its real size, and the K-type probe with its stainless tip, M6 thread, nut, spring, braided cable and the yellow and red leads.
• Two styles: the MAX6675 as a Simple device with a STATUS panel and as an Advance device with a pop-up window; the LEDs and the panel button sit on the board itself.
• A real thermocouple: the probe's EMF follows the NIST type K table for the tip against the cold junction, in the analog simulation.
• The real converter: cold-junction compensation, 12 bits from 0 to 1023.75 C, a conversion every 170 ms while CS is HIGH, CS LOW stopping it, the 16-bit word with D2 for an open thermocouple.
• Temperature controls: - / + buttons, six presets from ICE 0 C to KILN 1000 C and a wire you can break, on the probe's panel or in the pop-up; the board's temperature in the pop-up.
• Mistake detection: reads faster than a conversion, a read before the first one, an open thermocouple, reversed leads, a tip below 0 C or above 1023.75 C, a board outside -20 to +85 C.
• Three test tools on the Advance device: Timing, Readings and Thermocouple.
• A two-node demo on our Arduino UNO V4.0 with the Adafruit library: a probe at room temperature on node 1 and one in a 200 C oven on node 2.
• A compact package: about 1.26 MB, without the C++ source code of the model.

Three Devices: the Module and the Probe

The parts look like the ones in your kit. The module is the red board with the blue two-way screw terminal for the thermocouple (T+ and T-), the MAX6675 in its SO-8 package, the bypass capacitor C1 and the gold pads of the header GND, VCC, SCK, CS and SO. The probe is the common M6 screw thermocouple: the stainless tip, the threaded stud and its nut, the spring, the braided cable and the two leads, yellow for + and red for - in the US colour code. During the simulation the tip changes colour with its temperature, from blue below 0 C to a white-hot glow above 1000 C.

Download MAX6675 Thermocouple Library for Proteus

Click the button below to download MAX6675-Thermocouple-Library-for-Proteus-v1.0.zip (about 1.26 MB, without the C++ source code of the model):

MAX6675 Thermocouple Library for Proteus V1.0: K-Type Temperature

• README.txt: the devices, installation, the demo, wiring, the test tools and real hardware.
• Proteus Library Files: TEPMAX6675.LIB and ArduinoV4TEP.LIB from our Arduino Library for Proteus V4.0.
• Proteus Model Files: TEPMAX6675.DLL and TEPARDUINO.DLL.
• Proteus Simulation: MAX6675-Thermocouple-ArduinoUnoV4.pdsprj, MAX6675_Demo.hex and copies of the two DLLs.
• Arduino Code: MAX6675_Demo.ino. It needs the MAX6675 library by Adafruit from the Library Manager of the Arduino IDE, only if you want to change the sketch.

No Proteus yet? Read How to Download and Install Proteus 7 and 8. New to libraries? Follow How to Install a New Library in Proteus.

How to Install MAX6675 Thermocouple Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy the two files from Proteus Library Files into the LIBRARY folder of Proteus (usually C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY).
3. Copy TEPMAX6675.DLL and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder.
4. Delete TEPMAX6675.IDX from the LIBRARY folder if it is there.
5. Start Proteus, press P and search for MAX6675 or THERMOCOUPLE.

Tip: keep the Proteus Simulation folder together, because the project needs its .hex file and the DLLs beside it. The library is tested in Proteus 8.5; Proteus 7 is not supported.

The MAX6675 Parts in Proteus

Three LEDs sit on the board: PWR while VCC is there, CONV, which flashes when a conversion finishes, and OPEN, which lights when the chip reports an open thermocouple. Next to the SIMPLE or ADVANCE badge is the panel button. The LEDs, the badge, the button and the panels are TEP additions; the real module has none of them.

The Simple device adds the STATUS panel. Its banner says what happened last, for example "READ OK - 0x7D00 = 1000.00 C - 68 READS", and turns red with a warning. Ten readouts follow: the state, the temperature the sketch read, the last word in hex, the conversions, the reads, the probe on T+ and T- with its tip, the cold junction, the EMF in millivolts, VCC and the shortest gap between two reads. At the bottom are the last four events.

The probe has its own TEMPERATURE panel. The - and + buttons change the tip by 5 C a click, and six presets put it at once into ICE 0 C, ROOM 25 C, BOILING 100 C, OVEN 200 C, SOLDER 350 C or KILN 1000 C. Under them are the EMF between T+ and T-, the COLD JUNCTION the module reports and READ BY, the module on the other end, and the wire button, which breaks the thermocouple and mends it again. Two properties set the start: TEMPERATURE and WIRE.

The red X closes the MAX6675's STATUS panel, and the PANEL button on the board opens it again, so a big project stays readable:

The Advance device keeps the schematic clean: only the module. Its live data opens in a pop-up window at Run, and the OPEN PANEL button on the board brings the window back if you close it. The module has two properties of its own: AMBIENT, the board's temperature, which is the cold junction (25 C by default), and NOISE, the converter's noise in LSB (0.5 by default, 0 for none).

The Demo Circuit

The demo project has two nodes. Each one is an Arduino UNO V4.0 from our Arduino UNO Library for Proteus V4.0 with a MAX6675 module on D4 (SO), D5 (CS) and D6 (SCK), the pins of the Adafruit example, and a K-type probe in its screw terminal. Both UNOs run the same MAX6675_Demo.hex. Node 1 uses the Simple MAX6675 with its probe at 25 C; node 2 uses the Advance MAX6675 with its probe in a 200 C oven.

Wiring

In Proteus the probe's two leads go straight to the module's screw terminal. SO, CS and SCK reach their UNO through wires with net labels, D4_1, D5_1 and D6_1 for node 1 and D4_2, D5_2 and D6_2 for node 2, and VCC and GND go to the +5V and GND terminals. T- is grounded on the module, as the datasheet asks. The serial monitor needs no wires at all, because it is built into the UNO V4.0.

Node 1 Up Close

Here you see the whole chain: the probe's yellow and red leads into T+ and T-, and the module's GND, VCC, SCK, CS and SO to the UNO. The THERMOCOUPLE readout on the STATUS panel shows which probe sits on T+ and T-, and the probe's READ BY readout shows the module, so the pop-up and the tools can show the tip next to the reading.

The Arduino Code

The demo sketch uses the Adafruit MAX6675 library (version 1.1.2), the simplest library for the MAX6675. New to Arduino? Start with Arduino Tutorial for Beginners and Introduction to Arduino UNO. The sketch begins with the library:

#include <max6675.h>

Then the three pins and the MAX6675 object (the library takes SCK, CS and SO in that order):

const int SO_PIN = 4;                          // the module's SO (data out)
const int CS_PIN = 5;                          // the module's CS (chip select)
const int SCK_PIN = 6;                         // the module's SCK (clock)

MAX6675 thermocouple(SCK_PIN, CS_PIN, SO_PIN);

A reading is one call. readCelsius() pulls CS LOW, clocks out the 16 bits, pulls CS HIGH and returns NAN when D2 says the thermocouple is open. The sketch prints the temperature in C and F:

void readTemp() {
  const float c = thermocouple.readCelsius();
  Serial.print('#'); Serial.print(++count);
  if (isnan(c)) {
    Serial.println(F("  no thermocouple - the input is open (D2 = 1)"));
    return;
  }
  Serial.print(F("  ")); Serial.print(c, 2); Serial.print(F(" C   "));
  Serial.print(c * 9.0 / 5.0 + 32.0, 2); Serial.println(F(" F"));
}

RAW reads the 16-bit word by hand, the same way the library does, so you can see every bit:

uint16_t readWord() {
  uint16_t v = 0;
  digitalWrite(CS_PIN, LOW);
  delayMicroseconds(10);
  for (int8_t i = 15; i >= 0; i--) {
    digitalWrite(SCK_PIN, LOW);
    delayMicroseconds(10);
    if (digitalRead(SO_PIN)) v |= (1u << i);
    digitalWrite(SCK_PIN, HIGH);
    delayMicroseconds(10);
  }
  digitalWrite(CS_PIN, HIGH);
  return v;
}

FAST sets the time between readings to 100 ms, which is faster than a conversion, and SLOW sets it back to a second:

  else if (!strcmp(s, "FAST")) {               // faster than a conversion (170 - 220 ms)
    period = 100; running = true;
    Serial.println(F("FAST: a reading every 100 ms"));
  } else if (!strcmp(s, "SLOW")) {
    period = 1000; running = true;
    Serial.println(F("SLOW: a reading every second"));
  } else if (!strcmp(s, "RAW")) raw();

In setup() the sketch waits 500 ms before the first reading, like the Adafruit example, because the first conversion takes 170 to 220 ms:

  delay(500);                                  // the first conversion takes 170 - 220 ms

The HEX file is in the package, so you do not need the Arduino IDE to run the demo. To change the sketch, install "MAX6675 library" by Adafruit from the Library Manager, open the sketch in the Arduino IDE and export the compiled binary, as in How to get the HEX file from Arduino. It needs 6,630 bytes of flash and 279 bytes of RAM.

The Serial Monitor

Both UNOs have the serial monitor built in, and it opens at Run. The screenshots use its Simple interface. Node 1 starts like this:

TEP MAX6675 - demo (Adafruit MAX6675 library)
SO on D4, CS on D5, SCK on D6
Commands: RUN | STOP | FAST | SLOW
          RAW | HELP
#1  24.75 C   76.55 F
#2  25.00 C   77.00 F
#3  25.25 C   77.45 F

The probe sits at 25 C, the same as the board, so the thermocouple gives no voltage at all and the whole reading comes from the cold junction. The last 0.25 C step comes and goes with the converter's noise, as on a real MAX6675. Type a command in the monitor and press Enter: STOP stops the readings, RUN starts them again, and FAST, SLOW and RAW are explained below. HELP lists them all.

Change the Temperature

Now let's heat the probe while the simulation runs. We clicked OVEN 200 C on TC1's TEMPERATURE panel with the mouse:

Then we clicked + twice and finally the wire button, which breaks the thermocouple:

#37  25.00 C   77.00 F
#38  200.00 C   392.00 F
#39  200.00 C   392.00 F
#40  200.00 C   392.00 F
#41  200.00 C   392.00 F
#42  209.75 C   409.55 F
#43  210.00 C   410.00 F
#44  210.00 C   410.00 F
#45  no thermocouple - the input is open (D2 = 1)
#46  no thermocouple - the input is open (D2 = 1)

Both + clicks fell between two readings, so the reading went from 200.00 straight to 209.75 and 210.00 C. With the wire broken there is nothing between T+ and T-, the MAX6675 sets D2, and readCelsius() returns NAN. The OPEN LED on the board lights up, the STATUS panel turns red, and the probe's label says WIRE BROKEN:

A click on the wire button mends it, and the readings come back. Up close, we clicked KILN 1000 C:

#57  210.00 C   410.00 F
#58  210.00 C   410.00 F
#59  999.75 C   1831.55 F
#60  1000.00 C   1832.00 F
#61  1000.00 C   1832.00 F
#62  999.75 C   1831.55 F

At 1000 C the probe gives 40.27 mV: E(1000) 41.276 mV minus E(25) 1.000 mV of the type K table. The MAX6675 adds the board's 25 C back and reads 1000.00 C.

The Advance Pop-Up Window

At Run, the Advance MAX6675 opens its own window, MAX6675 Module, with the look of our TEP Serial Monitor Advance for Proteus. It has three tabs, Sensor, Event log and Tests, plus Settings and Help behind the gear and question mark icons. The status bar at the bottom always shows the tip, the board, the last reading and the state.

The Sensor Page

The toolbar carries the probe's presets and the Break the wire button. The top card is the thermocouple: the tip with -50, -5, +5 and +50 C, a scale with the MAX6675's range in green, and on the right the cold junction, the board, with its own -5 and +5 C, and the EMF worked out: E(tip) - E(board) of the type K table. The middle card is the MAX6675: the banner, the hot junction the chip sees, the last word, the conversions and the reads.

The bottom card draws the last read, bit by bit: the Arduino's CS and SCK, the MAX6675's SO, and the 16 bits in their groups: D15, the 12 bits of the temperature, D2, D1 and the three-state D0. Under it the word is worked out: 0x0C80 is 400 x 0.25 = 100.00 C, D2 = 0, the thermocouple is there. RAW shows the same word in the monitor:

#5  200.00 C   392.00 F
#6  100.00 C   212.00 F
#7  100.00 C   212.00 F
#8  100.00 C   212.00 F
RAW
RAW: 0x0C89  D14-D3 401 x 0.25 = 100.25 C  D2 0

The word is 0x0C89. D14 to D3 hold 401, and 401 x 0.25 = 100.25 C, one noise step above the 100.00 C of the readings. The last bit, D0, is three-state: the chip does not drive it, and the UNO's input read it as a 1. That is why the library throws away the lowest three bits.

The Event Log

The Event log lists everything that happened, newest first: the power, the first conversion, every read with its word, the probe's changes with where they came from, notes and warnings. Filter it by reads or warnings, pause it, or clear it.

Classic MAX6675 Mistakes, Simulated

The demo can make the most common thermocouple mistakes on purpose, so you can see what they look like before they happen on your desk. All of them were run in the final test.

Reading Faster Than a Conversion

A conversion takes 170 to 220 ms, and CS LOW stops it. So a sketch that reads more often never lets a conversion finish, and gets the same word again and again. We typed FAST on node 2 and then clicked OVEN 200 C in the pop-up:

#59  100.00 C   212.00 F
#60  100.00 C   212.00 F
#61  100.00 C   212.00 F
#62  100.00 C   212.00 F
#63  100.00 C   212.00 F
SLOW
SLOW: a reading every second
#64  200.00 C   392.00 F
#65  200.00 C   392.00 F

The tip was at 200 C, but every reading said 100.00 C: it was the same word, 0x0C80, every time, without even the noise of a new conversion. One SLOW later, the first reading said 200.00 C. The Timing tool catches it in red:

The Timing tool is the one to open for a temperature that never changes, 0.00 C right after power-up, or wrong bits. It shows the shortest gap between reads against the conversion time, the reads that got an old result, the empty reads before the first conversion, the conversions done and stopped by CS, SCK HIGH and LOW against the datasheet's 100 ns and the bits a read. The Readings tool shows the same story read by read:

The Cold Junction at Work

What if the board gets warm? In U2's pop-up we raised the cold junction from 25 to 50 C with +5, five times, while the probe stayed at 200 C:

#64  200.00 C   392.00 F
#65  200.00 C   392.00 F
#66  200.00 C   392.00 F
#67  200.25 C   392.45 F
#68  200.00 C   392.00 F

The thermocouple's voltage fell from 7.138 to 6.115 mV, because the tip is now only 150 C warmer than the terminal. The MAX6675 measured the warmer board with its diode and added it back, so the reading did not move. That is cold-junction compensation, and it is why a reading off by the room temperature points to a cold junction that is not where the chip thinks it is. The Thermocouple tool lays it out:

It shows the probe on T+ and T-, the EMF, the cold junction and its range, the hot junction by the type K table next to what the datasheet's straight line of 41 uV/C would say, the range of 0 to 1023.75 C, and the last word. Open it for NAN, a reading off by the room temperature, a reading that drops when the tip heats, or 0.00 and 1023.75 for ever.

An Open Thermocouple

A broken or loose thermocouple is the most common failure in the field. We clicked Break the wire in U2's pop-up:

The word becomes 0x0004: only D2 is set, the open thermocouple flag. Always check for NAN in your sketch, the way the demo does, instead of printing a wrong number. Two more mistakes are modelled, without a screenshot here: reversed leads (yellow on T-) make the EMF negative, so the reading drops as the tip heats, and a tip below 0 C or above 1023.75 C reads 0.00 or 1023.75, the ends of the MAX6675's range.

The Simulation Log

Every MAX6675 and probe also writes to the simulation log of Proteus, with the exact simulation time. This part shows the start:

TC2: TEP K-Type Thermocouple Probe (M6 screw) V1.0 - the tip at 200.0 C, the wire ok, 2 ohm loop - TEPMAX6675.DLL
U2: TEP MAX6675 Module V1.0 - the cold junction (the board) at 25.0 C, noise 0.50 LSB RMS - TEPMAX6675.DLL v1.0
U2: a TEP K-type probe on T+ / T-: TC2, the tip at 200.0 C at 0.0200 s
U2: POWER ON - VCC 5.00 V: a conversion every 170 ms while CS is HIGH; the cold junction (the board) at 25.0 C at 0.0200 s
U2: CS LOW for 14.9 us without SCK pulses (the sketch setting up its pins) - a conversion stopped, no data read at 0.0651 s
U2: the first conversion: 200.00 C (215 ms after power-on) at 0.2351 s

Each part reports its setup when the simulation starts. At 0.0651 s the Adafruit library sets up its pins: CS goes LOW for 15 us before it goes HIGH, which stops the conversion that runs, and the model notes it without calling it a read. So the first result comes 170 ms later, at 0.2351 s, and U2 reads 200.00 C from its first word.

How the Model Works

The probe is an analog part: a voltage source with the EMF of the type K table, E(tip) - E(cold junction), behind its 2 ohm loop, between T+ and T- in the SPICE simulation of Proteus. The module grounds T-, gives T+ the chip's 60 kohm input and tells the probe its cold junction. At the end of each conversion the MAX6675 reads T+ - T- from the analog simulation, adds the type K value of the board's temperature and turns the sum back into degrees, rounded to 0.25 C.

Proteus runs the Arduino's writes to CS and SCK as digital events, each with its exact time. CS LOW stops the conversion and puts D15 on SO 100 ns later; each SCK falling edge after a rising edge puts the next bit on SO 100 ns later, from a simulator callback; D0 floats, and CS HIGH floats SO and starts a new conversion, which ends 170 ms later.

Troubleshooting

• NAN or "no thermocouple": nothing on T+ and T-, a broken wire, or the probe on the wrong pins; the OPEN LED on the board is lit.
• The temperature never changes: the sketch reads faster than a conversion. Read every 250 ms or slower.
• 0.00 C right after Run: a read before the first conversion. Wait about 250 ms.
• The reading drops when the tip heats: the leads are reversed.
• 0.00 or 1023.75 for ever: the tip is below 0 C or above 1023.75 C, outside the MAX6675's range.
• No part, no reading at all or no monitor: TEPMAX6675.DLL or TEPARDUINO.DLL is missing from MODELS and the project folder; a closed monitor opens again with a click on the UNO's USB port.

Things to Know Before Using a Real MAX6675

• Colour codes: in the US code yellow is + and red is -; in the IEC code green is + and white is -. If the reading drops as the probe heats, swap the leads.
• Grounding: T- is grounded on the module, so the thermocouple must not touch another ground, for example a grounded metal part, or the reading goes wild.
• The cold junction: keep the module at room temperature, away from the oven and from hot parts on the board.
• Response time: a real probe needs seconds to follow a change; the model follows at once.
• Lower temperatures: the MAX6675 cannot read below 0 C; for -55 to 125 C our DS18B20 Library for Proteus is a better choice.

Limitations of the Simulation

• Not modelled: the MAX6675's conversion error (the datasheet allows +-9 LSB, +-2.25 C, from 0 to 700 C at 5 V; the model converts exactly) and its cold-junction error (+-3 C), the spread of the conversion time (always 170 ms), self-heating, the probe's thermal lag and the pick-up noise of long wires.
• The LEDs, the badge, the panel button and the panels are TEP additions.
• The models are our own, written from the MAX6675 datasheet and the NIST ITS-90 type K tables. This library is not made or endorsed by Maxim Integrated, Analog Devices, Adafruit, the makers of these modules and probes or Labcenter.
• Licences: the demo sketch uses the MAX6675 library 1.1.2 by Adafruit (BSD), which is not shipped; install it from the Library Manager. The demo's HEX file contains it and the Arduino AVR core 1.8.6 with LGPL-licensed code; the licence texts and the source links are in the README.
• Tested in Proteus 8.5 in October 2026 (the demo as shipped on two Arduino UNO V4.0 boards with their built-in monitors: both nodes reading, the presets, the + button and the wire with the mouse, KILN up close, BOILING, RAW, FAST, SLOW, the board at 50 C and the broken wire in the pop-up, the red X and PANEL, the three tools; 76.2 s of simulation took 140 s, about 0.5 x real time with the pop-up and both monitors open). Proteus 7 is not supported.

So, that was all about the MAX6675 Thermocouple Library for Proteus V1.0. I hope the thermocouple's microvolts, the cold junction and the 16-bit word are clear now, so your oven or kiln reads the right temperature from the first run. If you use the MAX6675 Thermocouple Library for Proteus in a project, please share it in the comments or in our forum, and if you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!