Thermocouple/RTD Family Guide

Overview

This family is NAI’s line of temperature-measurement smart function modules. They all answer one question — “what temperature is it?” — by reading a temperature sensor, measuring the small electrical signal it produces, linearizing and compensating it, and handing your software a temperature in °C. Each module has 8 channels.

The family covers the two dominant temperature-sensor technologies, plus a module that does both:

TC1 reads thermocouples (naibrd_TC_*).
RT1 reads RTDs — Resistance Temperature Detectors (naibrd_RTD_*).
TR1 reads either, per channel — each of its 8 channels is individually configurable as thermocouple or RTD.

A thermocouple is two dissimilar metal wires joined at a point; the junction produces a tiny voltage (the Seebeck effect) that varies with how much hotter it is than the wires’ open ends. A resistance temperature detector (RTD) is a metal element — classically platinum — whose electrical resistance rises predictably with temperature. Both are read here into a digital temperature; the Thermocouple vs RTD section below details how they differ.

In a real system, these modules are the temperature-monitoring front-end. Concretely, they read temperature from: engine and exhaust-gas (EGT) / turbine points, bearings, oil, and hydraulic-fluid temperatures, environmental-control and cabin/avionics-bay air, battery and power-electronics thermal monitoring, and process/industrial points — anywhere a controller needs to know a temperature to run a loop, trend a trend, or trip a safety limit. Thermocouple measurement reaches the extreme, high-temperature points (jet-engine and gas-turbine exhaust); RTD measurement covers the precision, moderate-temperature points.

(NAI’s other measurement families read different physical quantities: SD reads shaft angle from synchros/resolvers, LD reads displacement from LVDTs/RVDTs, and AD reads voltage/current. This family reads temperature.)

Thermocouple/RTD modules at a glance

All three are 8-channel, individually isolated measurement modules. They differ by which sensor type each channel reads:

Module	Channels	Sensor type	API
TC1	8	Thermocouple (NIST types J, K, T, E, N, B, R, S)	`naibrd_TC_*`
RT1	up to 8	RTD — 2-, 3-, or 4-wire platinum (Pt100/Pt500/Pt1000)	`naibrd_RTD_*`
TR1	8	Thermocouple or RTD, selectable per channel	both

Choosing a member:

All thermocouple inputs — TC1 (8 thermocouple channels, all NIST types, up to ~2300 °C).
All RTD inputs — RT1 (8 RTD channels, 2/3/4-wire platinum, high accuracy below ~600 °C).
A mix of both on one card — TR1 (each channel is set to thermocouple or RTD in software).

Note

The same naibrd_TC_* and naibrd_RTD_* calls drive these modules everywhere they appear — on TR1 you use the TC calls on channels you’ve put in thermocouple mode and the RTD calls on channels in RTD mode. TR1 also supports an optional thermo-block accessory (ACC-ISO-THERM-BLK2) for cold-junction compensation; with it, channel 8 auto-configures to RTD as the reference sensor. Confirm exact specs on each module’s manual: TC1 Manual, RT1 Manual, TR1 Manual.

Thermocouple vs RTD — how they relate

Because this family spans both sensor types, it’s worth being precise about how they differ. Both measure temperature; the physics differs, and everything else follows from it.

	Thermocouple (TC1)	RTD (RT1)
Sensing principle	Two dissimilar metals produce a voltage proportional to the temperature difference between the junction and the open ends (Seebeck effect)	A platinum element’s electrical resistance rises predictably with temperature
What’s measured	A small voltage (µV–mV)	A resistance (excitation current applied, voltage measured)
Module must compensate for	Cold-junction — the terminal-block temperature, added back to get an absolute reading (`naibrd_TC_SetCJCEnable`)	Lead-wire resistance — cancelled with 3- or 4-wire connections (`naibrd_RTD_SetWireMode`)
Linearity / standards	Nonlinear; metal-pair-specific — NIST types J, K, T, E, N, B, R, S	Highly linear; platinum, specified by 0 °C resistance — Pt100 / Pt500 / Pt1000
Temperature range	Very wide and very high (up to ~2300 °C)	Moderate (best below ~600 °C)
Accuracy / stability	±0.2 °C with thermo-block compensation; drifts more over time	Higher accuracy and repeatability; very stable
Response / robustness	Fast; rugged, tiny, inexpensive	Slower; precise but more fragile, watch self-heating

On TC1 every channel is a thermocouple; on RT1 every channel is an RTD; on TR1 each channel is set to one or the other in software. The rest of this guide applies to both, with the thermocouple-only and RTD-only specifics called out where they differ.

Physical setup

A channel connects to its sensor through the channel’s input terminals; the wiring depends on the sensor type. The exact pins are per-module, so always get them from the module’s manual or overlay card; the pattern is the same for every channel:

Identify the module’s slot number on your NAI motherboard or system.
Bring the channel’s lines out through the breakout board, where the slot’s pins appear as generic IO# numbers.
Map IO# pins to the channel’s sensor terminals per the pinout in the TC1 Manual / RT1 Manual / TR1 Manual.
On TR1, set the channel’s mode first (thermocouple or RTD) so the inputs are configured for the sensor you’re wiring.

Wiring a thermocouple (TC1, or a TC-mode TR1 channel):

Connect the thermocouple’s two leads to the channel’s + and − inputs, observing polarity — thermocouples are polarized, and reversing the leads flips the sign of the reading.
The point where the leads land on the module is the cold junction; the module’s thermo-block cold-junction compensation measures that temperature and corrects for it. Use the correct thermocouple or extension wire all the way to the terminal — introducing a different metal in the path creates an unintended junction and an error.
Set the channel’s thermocouple type (naibrd_TC_SetThermocoupleType) to match the sensor (J/K/T/E/N/B/R/S), and enable CJC (naibrd_TC_SetCJCEnable).

Wiring an RTD (RT1, or an RTD-mode TR1 channel):

Connect the RTD per its wire mode and set it with naibrd_RTD_SetWireMode — 2-wire (simplest, lead resistance included in the reading), 3-wire (a third lead lets the module subtract lead resistance), or 4-wire (separate drive and sense leads fully cancel lead resistance — most accurate).
Set the element’s zero-temperature resistance (naibrd_RTD_SetZeroTempResistance: Pt100 / Pt500 / Pt1000) to match the sensor.

A few things hold for the whole family:

Channels are individually isolated — you can wire 8 sensors in different electrical environments on one module without ground loops.
The module detects an open sensor. Each channel flags an open-circuit (and out-of-range) condition in status, so a broken or disconnected sensor lead shows up rather than reading as a bogus temperature.
Match the model/mode to the sensor. Thermocouple points go to TC1 or TC-mode TR1 channels; RTD points to RT1 or RTD-mode TR1 channels.

Software

There’s nothing platform-specific about which software you run. The NAI SSK (naibrd library) is identical across every OS and architecture — PetaLinux, VxWorks, DEOS, Windows. What OS you’re on is determined by your motherboard/SBC, not by the module. The family-specific part is which API you call: thermocouple channels use naibrd_TC_*; RTD channels use naibrd_RTD_*. On TR1 you use the TC calls on channels set to thermocouple mode and the RTD calls on channels set to RTD mode.

These calls are stateless — every function takes (cardIndex, module, channel) and acts immediately; there is no Open/Init/Free lifecycle to manage. Where to find what you need:

Which functions/registers to call — the TC1 Manual, RT1 Manual, and TR1 Manual document every naibrd_TC_* / naibrd_RTD_* register (sensor type / wire mode, CJC, sample rate, thresholds, BIT, and temperature/voltage/resistance reads).
Building and deploying on your platform — Connecting to Boards covers the toolchain, deployment, and terminal access for PetaLinux/ARM Linux, VxWorks, DEOS, and Windows.
Launching the app on the board itself — Running Applications from the Target walks through loading and launching your executable on the target.

Example — a 68ARM2 SBC with a TC1 module: pull the naibrd_TC_* calls from the TC1 Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch a thermocouple sample on the target per Running Applications from the Target.

Confirm communication

These modules measure an external sensor, so the quickest proof of life is a power-on BIT check plus a single temperature read — and you can sanity-check a channel with a known resistor or a shorted input before any real sensor is attached.

Built-in test (no wiring). Every module runs a power-on self-test plus continuous background BIT. Confirm the power-on BIT completed and that no BIT fault is latched (use the API for the channel’s sensor type):

bool_t pbitComplete = NAI_FALSE;
naibrd_TC_CheckPowerOnBITComplete(cardIndex, module, &pbitComplete);     /* or naibrd_RTD_CheckPowerOnBITComplete */
 
nai_status_bit_t bitStatus;
naibrd_TC_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_TC_STATUS_BIT_LATCHED, &bitStatus);                            /* LO = normal */

Read a channel (proves the measurement path). Configure the channel for its sensor and read the temperature:

/* Thermocouple channel (TC1 / TC-mode TR1) */
naibrd_TC_SetThermocoupleType(cardIndex, module, channel, NAIBRD_TC_THERMOCOUPLE_TYPE_K);
naibrd_TC_SetCJCEnable(cardIndex, module, NAI_TRUE);
float64_t tcTempC;
naibrd_TC_GetTemperature(cardIndex, module, channel, NAIBRD_TC_TEMP_TYPE_CELSIUS, &tcTempC);
 
/* RTD channel (RT1 / RTD-mode TR1) */
naibrd_RTD_SetWireMode(cardIndex, module, channel, NAIBRD_RTD_GEN5_WIRE_MODE_4);
naibrd_RTD_SetZeroTempResistance(cardIndex, module, channel, NAIBRD_RTD_ZERO_TEMP_RESISTANCE_100);  /* Pt100 */
float64_t rtdOhms, rtdTempC;
naibrd_RTD_GetResistance(cardIndex, module, channel, &rtdOhms);
naibrd_RTD_GetTemperature(cardIndex, module, channel, &rtdTempC);

Minimal-wiring sanity checks (no real sensor):

RTD — connect a precision resistor to the channel and confirm the expected temperature: on a Pt100 channel, 100 Ω ≈ 0 °C and ~138.5 Ω ≈ 100 °C. The decoded temperature should match the resistor.
Thermocouple — with the input shorted, the channel reads the cold-junction (terminal-block) temperature, which should be close to ambient. A reasonable ambient reading confirms the channel and its CJC.

If power-on BIT is complete, status is clean, and a known resistor / shorted input reads the expected value, your board connection, the SSK, and the module’s measurement path are all confirmed. The TC BasicOps and RTD BasicOps samples drive exactly these flows — type/wire-mode, CJC, thresholds, BIT, and reading temperature across channels.

Features

Each operation works per channel through the naibrd_TC_* (thermocouple) and naibrd_RTD_* (RTD) APIs — on TR1 you use whichever matches the channel’s mode. The blocks below group the calls by what you’re doing — think of them like the controls on ESP2’s TC/RTD panel — with the SSK 1.x and 2.x signatures side by side. (The 1.x → 2.x rename is visible throughout: nai_tc_*/nai_rtd_* enum types became naibrd_tc_*/naibrd_rtd_*, GetStatus/ClearStatus became per-channel GetChanMappedStatus/ClearChanMappedStatus, and out-parameters gained the p_out prefix.)

Read temperature, voltage & resistance

What it does: read the converted temperature (°C or °F), or the raw underlying quantity — the thermocouple voltage or the RTD resistance. “All channels” variants read the whole module in one call.

Applies to: thermocouple reads on TC1 / TC-mode TR1 channels; resistance reads on RT1 / RTD-mode TR1 channels.

Relevant APIs:

/* SSK 1.x */
/* Thermocouple */
nai_status_t naibrd_TC_GetTemperature(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_temperature_type_t tempType, float64_t* outTemperature);
nai_status_t naibrd_TC_GetVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outVoltage);
nai_status_t naibrd_TC_GetAllTemperatures(int32_t cardIndex, int32_t module, nai_tc_temperature_type_t tempType, int32_t arraysize, float64_t outTemperatures[]);
/* RTD */
nai_status_t naibrd_RTD_GetTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outtemperature);
nai_status_t naibrd_RTD_GetResistance(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outresistance);
nai_status_t naibrd_RTD_GetAllTemperatures(int32_t cardIndex, int32_t module, int32_t arraysize, float64_t outtemperatures[]);

/* SSK 2.x */
/* Thermocouple */
nai_status_t naibrd_TC_GetTemperature(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_temperature_type_t tempType, float64_t* p_outTemperature);
nai_status_t naibrd_TC_GetVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outVoltage);
nai_status_t naibrd_TC_GetAllTemperatures(int32_t cardIndex, int32_t module, naibrd_tc_temperature_type_t tempType, int32_t arraysize, float64_t outTemperatures[]);
/* RTD */
nai_status_t naibrd_RTD_GetTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outtemperature);
nai_status_t naibrd_RTD_GetResistance(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outresistance);
nai_status_t naibrd_RTD_GetTemperatureEx(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_temperature_type_t tempType, float64_t* p_outtemperature);

Exercise it: TC BasicOps / RTD BasicOps · TC BasicOps / RTD BasicOps (1.x) · ESP2 TC/RTD panel.

Configure a thermocouple channel

What it does: set up a thermocouple channel before reading — its NIST type, cold-junction compensation, the compensation type/temperature, and overall configuration.

Applies to: TC1 and TC-mode TR1 channels.

Also here: naibrd_TC_SetThermocoupleType takes NAIBRD_TC_THERMOCOUPLE_TYPE_J/K/T/E/N/B/R/S; CJC is module-level (naibrd_TC_SetCJCEnable); temperatures read in NAIBRD_TC_TEMP_TYPE_CELSIUS / _FAHRENHEIT.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_TC_SetThermocoupleType(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_thermocouple_type_t tcType);
nai_status_t naibrd_TC_SetCJCEnable(int32_t cardIndex, int32_t module, bool_t enable);
nai_status_t naibrd_TC_SetCompType(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_comp_type_t compType);
nai_status_t naibrd_TC_SetCompTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t temperature);
nai_status_t naibrd_TC_SetConfiguration(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_config_type_t configType);

/* SSK 2.x */
nai_status_t naibrd_TC_SetThermocoupleType(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_thermocouple_type_t tcType);
nai_status_t naibrd_TC_SetCJCEnable(int32_t cardIndex, int32_t module, bool_t enable);
nai_status_t naibrd_TC_SetCompType(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_comp_type_t compType);
nai_status_t naibrd_TC_SetCompTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t temperature);
nai_status_t naibrd_TC_SetConfiguration(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_config_type_t configType);

Exercise it: TC BasicOps · TC BasicOps (1.x).

Configure an RTD channel

What it does: set up an RTD channel before reading — its wire mode (lead-resistance handling), the element’s zero-temperature resistance (Pt100/Pt500/Pt1000), a lead/comp resistance, and overall configuration.

Applies to: RT1 and RTD-mode TR1 channels.

Also here: naibrd_RTD_SetWireMode takes NAIBRD_RTD_GEN5_WIRE_MODE_2/_3/_4; zero-temp resistance is NAIBRD_RTD_ZERO_TEMP_RESISTANCE_100/_500/_1000.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_RTD_SetWireMode(int32_t cardIndex, int32_t module, int32_t channel, nai_rtd_wire_mode_t wiremode);
nai_status_t naibrd_RTD_SetZeroTempResistance(int32_t cardIndex, int32_t module, int32_t channel, nai_rtd_zero_temp_resistance_type_t zeroTempResistance);
nai_status_t naibrd_RTD_SetCompResistance(int32_t cardIndex, int32_t module, int32_t channel, float64_t resistance);
nai_status_t naibrd_RTD_SetConfiguration(int32_t cardIndex, int32_t module, int32_t channel, nai_rtd_config_type_t configType);

/* SSK 2.x */
nai_status_t naibrd_RTD_SetWireMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_wire_mode_t wiremode);
nai_status_t naibrd_RTD_SetZeroTempResistance(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_zero_temp_resistance_type_t zeroTempResistance);
nai_status_t naibrd_RTD_SetCompResistance(int32_t cardIndex, int32_t module, int32_t channel, float64_t resistance);
nai_status_t naibrd_RTD_SetConfiguration(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_config_type_t configType);

Exercise it: RTD BasicOps · RTD BasicOps (1.x).

Sampling & calibration

What it does: control conversion rate and trim the reading — set the per-channel sample rate, apply an offset temperature for calibration, and suspend the channel’s background conversion (so reads come from a known point in time). On thermocouples you can also trigger a background operation on demand.

Applies to: all modules (per channel).

Relevant APIs:

/* SSK 1.x */
/* Thermocouple */
nai_status_t naibrd_TC_SetSampleRate(int32_t cardIndex, int32_t module, int32_t channel, float64_t sampleRate);
nai_status_t naibrd_TC_SetOffsetTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t offsetTemperature);
nai_status_t naibrd_TC_SetBackgroundOpSuspend(int32_t cardIndex, int32_t module, int32_t channel, bool_t disable);
nai_status_t naibrd_TC_TriggerBackgroundOperation(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_background_op_type_t opType);
/* RTD */
nai_status_t naibrd_RTD_SetSampleRate(int32_t cardIndex, int32_t module, int32_t channel, float64_t sampleRate);
nai_status_t naibrd_RTD_SetOffsetTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t offsetTemperature);
nai_status_t naibrd_RTD_SetBackgroundOpSuspend(int32_t cardIndex, int32_t module, int32_t channel, bool_t disable);

/* SSK 2.x */
/* Thermocouple */
nai_status_t naibrd_TC_SetSampleRate(int32_t cardIndex, int32_t module, int32_t channel, float64_t sampleRate);
nai_status_t naibrd_TC_SetOffsetTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t offsetTemperature);
nai_status_t naibrd_TC_SetBackgroundOpSuspend(int32_t cardIndex, int32_t module, int32_t channel, bool_t disable);
nai_status_t naibrd_TC_TriggerBackgroundOperation(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_background_op_type_t opType);
/* RTD */
nai_status_t naibrd_RTD_SetSampleRate(int32_t cardIndex, int32_t module, int32_t channel, float64_t sampleRate);
nai_status_t naibrd_RTD_SetOffsetTemperature(int32_t cardIndex, int32_t module, int32_t channel, float64_t offsetTemperature);
nai_status_t naibrd_RTD_SetBackgroundOpSuspend(int32_t cardIndex, int32_t module, int32_t channel, bool_t disable);

Exercise it: TC BasicOps / RTD BasicOps · TC Summary.

Health, BIT & status

What it does: check Built-In Test and read the channel’s fault flags — BIT, open sensor, and programmable alert/alarm (hi/lo) thresholds, each in real-time and latched form. Set the threshold levels and enable per-channel status reporting.

Applies to: all modules (BIT/status per channel; power-on BIT per module).

Also here: TC status types are NAIBRD_TC_STATUS_{BIT,OPEN,ALERT_LO,ALARM_LO,ALERT_HI,ALARM_HI,SUMMARY}_{REALTIME,LATCHED}; RTD status types are the parallel NAIBRD_RTD_CHAN_MAPPED_STATUS_*.

Relevant APIs:

/* SSK 1.x */
/* Thermocouple */
nai_status_t naibrd_TC_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_TC_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_thresh_type_t type, float64_t threshold);
nai_status_t naibrd_TC_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_status_type_t type, nai_status_bit_t* outStatus);
nai_status_t naibrd_TC_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_tc_status_type_t type);
nai_status_t naibrd_TC_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
/* RTD */
nai_status_t naibrd_RTD_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_RTD_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, nai_rtd_thresh_type_t type, float64_t threshold);
nai_status_t naibrd_RTD_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_rtd_status_type_t type, uint32_t* outstatus);
nai_status_t naibrd_RTD_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_rtd_status_type_t type);
nai_status_t naibrd_RTD_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

/* SSK 2.x */
/* Thermocouple */
nai_status_t naibrd_TC_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_TC_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_thresh_type_t type, float64_t threshold);
nai_status_t naibrd_TC_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_chan_mapped_status_type_t type, nai_status_bit_t* p_outStatus);
nai_status_t naibrd_TC_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_tc_chan_mapped_status_type_t type);
nai_status_t naibrd_TC_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
/* RTD */
nai_status_t naibrd_RTD_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_RTD_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_thresh_type_t type, float64_t threshold);
nai_status_t naibrd_RTD_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_chan_mapped_status_type_t type, nai_status_bit_t* p_outstatusBit);
nai_status_t naibrd_RTD_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_rtd_chan_mapped_status_type_t type);
nai_status_t naibrd_RTD_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

Exercise it: TC BasicOps / RTD BasicOps (BIT/status) · TC BasicOps / RTD BasicOps (1.x).

Try it

The snippets below show the order of calls for each task — drop them into the body of an NAI sample app (after the standard connection flow: naiapp_RunBoardMenu() → naiapp_query_CardIndex() / naiapp_query_ModuleNumber() → cardIndex/module, see Opening a Software Handle to Your Board) and you have a working read. Each is the conceptual sequence, not a fully-buildable program; the TC BasicOps and RTD BasicOps samples are the full reference. These calls are stateless — there is no Open/Init/Free.

Try it — Read a thermocouple channel

Set the channel’s NIST type, enable cold-junction compensation, then read the temperature in °C.

/* SSK 1.x — Type-K thermocouple, °C */
naibrd_TC_SetThermocoupleType(cardIndex, module, channel, NAI_TC_THERMOCOUPLE_TYPE_K);
naibrd_TC_SetCJCEnable(cardIndex, module, TRUE);
 
float64_t tempC;
naibrd_TC_GetTemperature(cardIndex, module, channel, NAI_TC_TEMP_TYPE_CELSIUS, &tempC);

/* SSK 2.x — Type-K thermocouple, °C */
naibrd_TC_SetThermocoupleType(cardIndex, module, channel, NAIBRD_TC_THERMOCOUPLE_TYPE_K);
naibrd_TC_SetCJCEnable(cardIndex, module, NAI_TRUE);
 
float64_t tempC;
naibrd_TC_GetTemperature(cardIndex, module, channel, NAIBRD_TC_TEMP_TYPE_CELSIUS, &tempC);

Try it — Read an RTD channel

Set the wire mode and the element’s zero-temperature resistance, then read resistance and temperature.

/* SSK 1.x — 4-wire Pt100 */
naibrd_RTD_SetWireMode(cardIndex, module, channel, NAI_RTD_GEN5_WIRE_MODE_4);
naibrd_RTD_SetZeroTempResistance(cardIndex, module, channel, NAI_RTD_ZERO_TEMP_RESISTANCE_100);
 
float64_t ohms, tempC;
naibrd_RTD_GetResistance(cardIndex, module, channel, &ohms);
naibrd_RTD_GetTemperature(cardIndex, module, channel, &tempC);

/* SSK 2.x — 4-wire Pt100 */
naibrd_RTD_SetWireMode(cardIndex, module, channel, NAIBRD_RTD_GEN5_WIRE_MODE_4);
naibrd_RTD_SetZeroTempResistance(cardIndex, module, channel, NAIBRD_RTD_ZERO_TEMP_RESISTANCE_100);
 
float64_t ohms, tempC;
naibrd_RTD_GetResistance(cardIndex, module, channel, &ohms);
naibrd_RTD_GetTemperature(cardIndex, module, channel, &tempC);

Try it — Scan all channels and check for an open sensor

Read all eight temperatures in one call, then check each channel’s open-sensor status so a disconnected lead doesn’t pass as a reading.

/* SSK 1.x — read all temps, check open status per channel */
float64_t temps[8];
naibrd_TC_GetAllTemperatures(cardIndex, module, NAI_TC_TEMP_TYPE_CELSIUS, 8, temps);
 
for (int32_t ch = 1; ch <= 8; ch++) {
   nai_status_bit_t open;
   naibrd_TC_GetStatus(cardIndex, module, ch, NAI_TC_STATUS_OPEN_LATCHED, &open);
}

/* SSK 2.x — read all temps, check open status per channel */
float64_t temps[8];
naibrd_TC_GetAllTemperatures(cardIndex, module, NAIBRD_TC_TEMP_TYPE_CELSIUS, 8, temps);
 
for (int32_t ch = 1; ch <= 8; ch++) {
   nai_status_bit_t open;
   naibrd_TC_GetChanMappedStatus(cardIndex, module, ch, NAIBRD_TC_STATUS_OPEN_LATCHED, &open);
}

Building and running the SSK samples. The snippets above are condensed for orientation. For full, buildable programs see the “Exercise it:” links under each block in Features — TC BasicOps / RTD BasicOps / TC Summary (2.x) and TC BasicOps / RTD BasicOps (1.x) — and Using NAI SSK 2.x Sample Applications · Using NAI SSK 1.x Sample Applications for build/run instructions across platforms.

Hardware capabilities and status monitoring

This section covers what the hardware provides and what you can monitor — for how to read and configure each channel, see Features and Try it above.

What the hardware provides:

8 individually isolated channels — each floats independently, so mixed grounds and long sensor runs don’t create ground loops.
Thermocouple measurement (TC1, TR1) — all NIST types (J/K/T/E/N/B/R/S), thermo-block cold-junction compensation to ±0.2 °C, a very wide range up to ~2300 °C, and self-powered operation. Channels can also serve as low-voltage A/D inputs.
RTD measurement (RT1, TR1) — 2-/3-/4-wire platinum (Pt100/Pt500/Pt1000), high accuracy and repeatability below ~600 °C.
Per-channel sensor selection (TR1) — each channel is thermocouple or RTD; an optional thermo-block accessory (ACC-ISO-THERM-BLK2) provides CJC, with channel 8 auto-configured as the RTD reference.
Background conversion — channels convert continuously in the background at a programmable sample rate; conversion can be suspended or (thermocouple) triggered on demand.
Calibration — per-channel offset temperature, plus thermocouple comp type/temperature and RTD comp resistance.
Built-in test — power-on self-test and continuous background BIT, with a per-channel BIT error indication.

Statuses you can monitor programmatically (per channel, each in real-time and latched form via naibrd_TC_GetChanMappedStatus / naibrd_RTD_GetChanMappedStatus):

Status	What it tells you
BIT	A built-in-test fault on the channel
Open sensor	An open circuit — broken or disconnected sensor lead
Alert (hi / lo)	The temperature crossed a programmable warning threshold
Alarm (hi / lo)	The temperature crossed a programmable critical threshold
Summary	A roll-up of the channel’s fault flags

Set the alert/alarm levels with SetThreshold, and disable a channel’s status reporting with SetChanStatusEnable. ESP2’s status panel shows temperature and status interactively if you’d rather watch it in a GUI first.

Common pitfalls

Thermocouple leads reversed. Thermocouples are polarized — swapping + and − flips the sign of the reading. Match the lead colors/polarity to the channel terminals.
Cold-junction compensation off (or wrong). A thermocouple reads a difference; without CJC enabled (naibrd_TC_SetCJCEnable) the result is off by the terminal-block temperature. CJC is fundamental, not optional, for an absolute reading.
Wrong thermocouple type. The linearization is type-specific — reading a Type-K probe as Type-J gives a plausible-but-wrong number. Set SetThermocoupleType to match the probe.
Stray junction in the thermocouple path. Splicing ordinary copper wire into a thermocouple run creates an unintended junction and an error — use matching thermocouple/extension wire all the way to the terminal.
RTD wire mode mismatch. A 2-wire connection read as 4-wire (or vice-versa) mis-handles lead resistance. Set SetWireMode to match how the sensor is actually wired; prefer 3- or 4-wire for accuracy.
Wrong RTD zero-temperature resistance. Reading a Pt1000 as a Pt100 (or vice-versa) scales the temperature wrongly. Set SetZeroTempResistance to the element.
Open sensor read as a temperature. A disconnected sensor can produce a bogus value — check the channel’s open status, not just the temperature.
(TR1) Reading a channel with the wrong API. Use naibrd_TC_* only on channels in thermocouple mode and naibrd_RTD_* only on channels in RTD mode.

TC1 Manual — thermocouple module manual (registers, full naibrd_TC_* API)
RT1 Manual — RTD module manual (registers, full naibrd_RTD_* API)
TR1 Manual — combined thermocouple/RTD module manual
Download the SSK — get the library and sample apps
Connecting to Boards — power, network, terminal, and file transfer to your board
Opening a Software Handle to Your Board — establish the connection your naibrd_TC_* / naibrd_RTD_* calls run against
Running Applications from the Target — load and launch a built sample on the board
Sample applications — TC BasicOps · TC Summary · RTD BasicOps (2.x) · TC BasicOps · RTD BasicOps (1.x)
ESP2 Quick Start — read temperature channels with no code via the Embedded Soft Panel

NAI Documentation

Explorer

Thermocouple/RTD Module Guide

Thermocouple/RTD Family Guide

Overview

Thermocouple/RTD modules at a glance

Thermocouple vs RTD — how they relate

Physical setup

Software

Confirm communication

Features

Read temperature, voltage & resistance

Configure a thermocouple channel

Configure an RTD channel

Sampling & calibration

Health, BIT & status

Try it

Try it — Read a thermocouple channel

Try it — Read an RTD channel

Try it — Scan all channels and check for an open sensor

Hardware capabilities and status monitoring

Common pitfalls

Table of Contents

NAI Documentation

Explorer

Thermocouple/RTD Module Guide

Thermocouple/RTD Family Guide

Overview

Thermocouple/RTD modules at a glance

Thermocouple vs RTD — how they relate

Physical setup

Software

Confirm communication

Features

Read temperature, voltage & resistance

Configure a thermocouple channel

Configure an RTD channel

Sampling & calibration

Health, BIT & status

Try it

Try it — Read a thermocouple channel

Try it — Read an RTD channel

Try it — Scan all channels and check for an open sensor

Hardware capabilities and status monitoring

Common pitfalls

Related resources

Table of Contents