diff --git a/conf.hpp b/conf.hpp
index f3811e4..0e26f55 100644
--- a/conf.hpp
+++ b/conf.hpp
@@ -3,12 +3,14 @@
 #include "pid/ec/pid.hpp"
 #include "pid/ec/stepwise.hpp"
 
+#include <limits>
 #include <map>
 #include <string>
 #include <vector>
 
 namespace pid_control
 {
+
 namespace conf
 {
 
@@ -31,12 +33,23 @@
 };
 
 /*
+ * Structure for decorating an input sensor's name with additional
+ * information, to help out with TempToMargin conversion.
+ */
+struct SensorInput
+{
+    std::string name;
+    double convertMarginZero = std::numeric_limits<double>::quiet_NaN();
+    bool convertTempToMargin = false;
+};
+
+/*
  * Structure for holding the configuration of a PID.
  */
 struct ControllerInfo
 {
     std::string type;                // fan or margin or temp?
-    std::vector<std::string> inputs; // one or more sensors.
+    std::vector<SensorInput> inputs; // one or more sensors.
     double setpoint;                 // initial setpoint for thermal.
     ec::pidinfo pidInfo;             // pid details
     ec::StepwiseInfo stepwiseInfo;
@@ -74,4 +87,5 @@
 constexpr bool DEBUG = false; // enable to print found configuration
 
 } // namespace conf
+
 } // namespace pid_control
diff --git a/dbus/dbusconfiguration.cpp b/dbus/dbusconfiguration.cpp
index d784b2c..2473252 100644
--- a/dbus/dbusconfiguration.cpp
+++ b/dbus/dbusconfiguration.cpp
@@ -338,7 +338,13 @@
         {
             interface = thresholds::criticalInterface;
         }
-        const std::string& path = sensorConfig.at(info.inputs.front()).readPath;
+
+        // Although this checks only the first vector element for the
+        // named threshold, it is OK, because the SetPointOffset parser
+        // splits up the input into individual vectors, each with only a
+        // single element, if it detects that SetPointOffset is in use.
+        const std::string& path =
+            sensorConfig.at(info.inputs.front().name).readPath;
 
         DbusHelper helper(sdbusplus::bus::new_system());
         std::string service = helper.getService(interface, path);
@@ -848,19 +854,32 @@
                     }
                 }
 
+                std::vector<double> inputTempToMargin;
+
+                auto findTempToMargin = base.find("TempToMargin");
+                if (findTempToMargin != base.end())
+                {
+                    inputTempToMargin =
+                        std::get<std::vector<double>>(findTempToMargin->second);
+                }
+
+                std::vector<pid_control::conf::SensorInput> sensorInputs =
+                    spliceInputs(inputSensorNames, inputTempToMargin);
+
                 if (offsetType.empty())
                 {
                     conf::ControllerInfo& info = conf[pidName];
-                    info.inputs = std::move(inputSensorNames);
+                    info.inputs = std::move(sensorInputs);
                     populatePidInfo(bus, base, info, nullptr, sensorConfig);
                 }
                 else
                 {
                     // we have to split up the inputs, as in practice t-control
                     // values will differ, making setpoints differ
-                    for (const std::string& input : inputSensorNames)
+                    for (const pid_control::conf::SensorInput& input :
+                         sensorInputs)
                     {
-                        conf::ControllerInfo& info = conf[input];
+                        conf::ControllerInfo& info = conf[input.name];
                         info.inputs.emplace_back(input);
                         populatePidInfo(bus, base, info, &offsetType,
                                         sensorConfig);
@@ -932,7 +951,17 @@
                     continue;
                 }
                 conf::ControllerInfo& info = conf[pidName];
-                info.inputs = std::move(inputs);
+
+                std::vector<double> inputTempToMargin;
+
+                auto findTempToMargin = base.find("TempToMargin");
+                if (findTempToMargin != base.end())
+                {
+                    inputTempToMargin =
+                        std::get<std::vector<double>>(findTempToMargin->second);
+                }
+
+                info.inputs = spliceInputs(inputs, inputTempToMargin);
 
                 info.type = "stepwise";
                 info.stepwiseInfo.ts = 1.0; // currently unused
diff --git a/pid/builder.cpp b/pid/builder.cpp
index 8525073..bae0e81 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -23,6 +23,7 @@
 #include "pid/thermalcontroller.hpp"
 #include "pid/zone.hpp"
 #include "pid/zone_interface.hpp"
+#include "util.hpp"
 
 #include <sdbusplus/bus.hpp>
 
@@ -82,7 +83,7 @@
         // For each PID create a Controller and a Sensor.
         for (const auto& [name, info] : pidConfig)
         {
-            std::vector<std::string> inputs;
+            std::vector<pid_control::conf::SensorInput> inputs;
             std::cerr << "PID name: " << name << "\n";
 
             /*
@@ -94,11 +95,11 @@
                 for (const auto& i : info.inputs)
                 {
                     inputs.push_back(i);
-                    zone->addFanInput(i);
+                    zone->addFanInput(i.name);
                 }
 
-                auto pid = FanController::createFanPid(zone.get(), name, inputs,
-                                                       info.pidInfo);
+                auto pid = FanController::createFanPid(
+                    zone.get(), name, splitNames(inputs), info.pidInfo);
                 zone->addFanPID(std::move(pid));
                 zone->addPidFailSafePercent(name, info.failSafePercent);
             }
@@ -107,7 +108,7 @@
                 for (const auto& i : info.inputs)
                 {
                     inputs.push_back(i);
-                    zone->addThermalInput(i);
+                    zone->addThermalInput(i.name);
                 }
 
                 auto pid = ThermalController::createThermalPid(
@@ -125,10 +126,10 @@
                 for (const auto& i : info.inputs)
                 {
                     inputs.push_back(i);
-                    zone->addThermalInput(i);
+                    zone->addThermalInput(i.name);
                 }
                 auto stepwise = StepwiseController::createStepwiseController(
-                    zone.get(), name, inputs, info.stepwiseInfo);
+                    zone.get(), name, splitNames(inputs), info.stepwiseInfo);
                 zone->addThermalPID(std::move(stepwise));
                 zone->addPidControlProcess(
                     name, info.type, info.setpoint, modeControlBus,
@@ -139,7 +140,12 @@
             std::cerr << "inputs: ";
             for (const auto& i : inputs)
             {
-                std::cerr << i << ", ";
+                std::cerr << i.name;
+                if (i.convertTempToMargin)
+                {
+                    std::cerr << "[" << i.convertMarginZero << "]";
+                }
+                std::cerr << ", ";
             }
             std::cerr << "\n";
         }
diff --git a/pid/buildjson.cpp b/pid/buildjson.cpp
index 57ea943..8396338 100644
--- a/pid/buildjson.cpp
+++ b/pid/buildjson.cpp
@@ -17,10 +17,12 @@
 #include "pid/buildjson.hpp"
 
 #include "conf.hpp"
+#include "util.hpp"
 
 #include <nlohmann/json.hpp>
 
 #include <iostream>
+#include <limits>
 #include <map>
 #include <tuple>
 
@@ -31,12 +33,25 @@
 
 namespace conf
 {
+
 void from_json(const json& j, conf::ControllerInfo& c)
 {
+    std::vector<std::string> inputNames;
+
     j.at("type").get_to(c.type);
-    j.at("inputs").get_to(c.inputs);
+    j.at("inputs").get_to(inputNames);
     j.at("setpoint").get_to(c.setpoint);
 
+    std::vector<double> inputTempToMargin;
+
+    auto findTempToMargin = j.find("tempToMargin");
+    if (findTempToMargin != j.end())
+    {
+        findTempToMargin->get_to(inputTempToMargin);
+    }
+
+    c.inputs = spliceInputs(inputNames, inputTempToMargin);
+
     /* TODO: We need to handle parsing other PID controller configurations.
      * We can do that by checking for different keys and making the decision
      * accordingly.
@@ -135,6 +150,7 @@
         c.stepwiseInfo.negativeHysteresis = negativeHysteresisValue;
     }
 }
+
 } // namespace conf
 
 inline void getCycleTimeSetting(const auto& zone, const int id,
diff --git a/pid/ec/pid.hpp b/pid/ec/pid.hpp
index 378f93c..9dac6a4 100644
--- a/pid/ec/pid.hpp
+++ b/pid/ec/pid.hpp
@@ -15,14 +15,14 @@
 } limits_t;
 
 /* Note: If you update these structs you need to update the copy code in
- * pid/util.cpp.
+ * pid/util.cpp and the initialization code in pid/buildjson.hpp files.
  */
 typedef struct
 {
     bool initialized;         // has pid been initialized
 
     double ts;                // sample time in seconds
-    double integral;          // intergal of error
+    double integral;          // integral of error
     double lastOutput;        // value of last output
     double lastError;         // value of last error
 
diff --git a/pid/pidcontroller.hpp b/pid/pidcontroller.hpp
index c3e9999..05cbd71 100644
--- a/pid/pidcontroller.hpp
+++ b/pid/pidcontroller.hpp
@@ -29,6 +29,7 @@
         _pid_info.lastOutput = static_cast<double>(0.0);
         _pid_info.proportionalCoeff = static_cast<double>(0.0);
         _pid_info.integralCoeff = static_cast<double>(0.0);
+        _pid_info.derivativeCoeff = static_cast<double>(0.0);
         _pid_info.feedFwdOffset = static_cast<double>(0.0);
         _pid_info.feedFwdGain = static_cast<double>(0.0);
         _pid_info.integralLimit.min = static_cast<double>(0.0);
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
index 357437b..ddb5893 100644
--- a/pid/thermalcontroller.cpp
+++ b/pid/thermalcontroller.cpp
@@ -55,7 +55,7 @@
 
 std::unique_ptr<PIDController> ThermalController::createThermalPid(
     ZoneInterface* owner, const std::string& id,
-    const std::vector<std::string>& inputs, double setpoint,
+    const std::vector<pid_control::conf::SensorInput>& inputs, double setpoint,
     const ec::pidinfo& initial, const ThermalType& type)
 {
     // ThermalController requires at least 1 input
@@ -101,12 +101,12 @@
         throw ControllerBuildException("Unrecognized ThermalType");
     }
 
-    std::string leaderName = *(_inputs.begin());
+    std::string leaderName = _inputs.begin()->name;
 
     bool acceptable = false;
     for (const auto& in : _inputs)
     {
-        double cachedValue = _owner->getCachedValue(in);
+        double cachedValue = _owner->getCachedValue(in.name);
 
         // Less than 0 is perfectly OK for temperature, but must not be NAN
         if (!(std::isfinite(cachedValue)))
@@ -114,6 +114,30 @@
             continue;
         }
 
+        // Perform TempToMargin conversion before further processing
+        if (type == ThermalType::margin)
+        {
+            if (in.convertTempToMargin)
+            {
+                if (!(std::isfinite(in.convertMarginZero)))
+                {
+                    throw ControllerBuildException("Unrecognized TempToMargin");
+                }
+
+                double marginValue = in.convertMarginZero - cachedValue;
+
+                if (debugEnabled)
+                {
+                    std::cerr << "Converting temp to margin: temp "
+                              << cachedValue << ", Tjmax "
+                              << in.convertMarginZero << ", margin "
+                              << marginValue << "\n";
+                }
+
+                cachedValue = marginValue;
+            }
+        }
+
         double oldValue = value;
 
         if (doSummation)
@@ -127,7 +151,7 @@
 
         if (oldValue != value)
         {
-            leaderName = in;
+            leaderName = in.name;
             _owner->updateThermalPowerDebugInterface(_id, leaderName, value, 0);
         }
 
@@ -136,8 +160,11 @@
 
     if (!acceptable)
     {
-        // While not optimal, zero is better than garbage
-        value = 0;
+        // If none of the inputs were acceptable, use the setpoint as
+        // the input value. This will continue to run the PID loop, but
+        // make it a no-op, as the error will be zero. This provides safe
+        // behavior until the inputs become acceptable.
+        value = setptProc();
     }
 
     if (debugEnabled)
diff --git a/pid/thermalcontroller.hpp b/pid/thermalcontroller.hpp
index 752c105..ac551d2 100644
--- a/pid/thermalcontroller.hpp
+++ b/pid/thermalcontroller.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "conf.hpp"
 #include "ec/pid.hpp"
 #include "pidcontroller.hpp"
 
@@ -44,14 +45,13 @@
 class ThermalController : public PIDController
 {
   public:
-    static std::unique_ptr<PIDController>
-        createThermalPid(ZoneInterface* owner, const std::string& id,
-                         const std::vector<std::string>& inputs,
-                         double setpoint, const ec::pidinfo& initial,
-                         const ThermalType& type);
+    static std::unique_ptr<PIDController> createThermalPid(
+        ZoneInterface* owner, const std::string& id,
+        const std::vector<pid_control::conf::SensorInput>& inputs,
+        double setpoint, const ec::pidinfo& initial, const ThermalType& type);
 
     ThermalController(const std::string& id,
-                      const std::vector<std::string>& inputs,
+                      const std::vector<pid_control::conf::SensorInput>& inputs,
                       const ThermalType& type, ZoneInterface* owner) :
         PIDController(id, owner),
         _inputs(inputs), type(type)
@@ -62,7 +62,7 @@
     void outputProc(double value) override;
 
   private:
-    std::vector<std::string> _inputs;
+    std::vector<pid_control::conf::SensorInput> _inputs;
     ThermalType type;
 };
 
diff --git a/test/meson.build b/test/meson.build
index 966334e..2513278 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -42,7 +42,8 @@
                               '../dbus/dbusutil.cpp'],
     'dbus_util_unittest': ['../dbus/dbusutil.cpp'],
     'json_parse_unittest': ['../buildjson/buildjson.cpp'],
-    'pid_json_unittest': ['../pid/buildjson.cpp'],
+    'pid_json_unittest': ['../pid/buildjson.cpp',
+                          '../util.cpp'],
     'pid_fancontroller_unittest': ['../pid/ec/pid.cpp',
                                    '../pid/ec/logging.cpp',
                                    '../pid/fancontroller.cpp',
diff --git a/test/pid_json_unittest.cpp b/test/pid_json_unittest.cpp
index c76849a..59db343 100644
--- a/test/pid_json_unittest.cpp
+++ b/test/pid_json_unittest.cpp
@@ -73,6 +73,71 @@
     EXPECT_DOUBLE_EQ(zoneConfig[1].minThermalOutput, 3000.0);
 }
 
+TEST(ZoneFromJson, marginZone)
+{
+    // Parse a valid configuration with one zone and one PID.
+    // This is a margin zone, and has both kinds of temperature
+    // sensors in it, absolute temperature and margin temperature.
+    // Tests that TempToMargin is parsed correctly.
+
+    std::map<int64_t, conf::PIDConf> pidConfig;
+    std::map<int64_t, conf::ZoneConfig> zoneConfig;
+
+    auto j2 = R"(
+      {
+        "zones" : [{
+          "id": 1,
+          "minThermalOutput": 3000.0,
+          "failsafePercent": 75.0,
+          "pids": [{
+            "name": "myPid",
+            "type": "margin",
+            "inputs": ["absolute0", "absolute1", "margin0", "margin1"],
+            "tempToMargin": [
+              85.0,
+              100.0
+            ],
+            "setpoint": 10.0,
+            "pid": {
+              "samplePeriod": 0.1,
+              "proportionalCoeff": 0.0,
+              "integralCoeff": 0.0,
+              "feedFwdOffsetCoeff": 0.0,
+              "feedFwdGainCoeff": 0.010,
+              "integralLimit_min": 0.0,
+              "integralLimit_max": 0.0,
+              "outLim_min": 30.0,
+              "outLim_max": 100.0,
+              "slewNeg": 0.0,
+              "slewPos": 0.0
+            }
+          }]
+        }]
+      }
+    )"_json;
+
+    std::tie(pidConfig, zoneConfig) = buildPIDsFromJson(j2);
+    EXPECT_EQ(pidConfig.size(), static_cast<u_int64_t>(1));
+    EXPECT_EQ(zoneConfig.size(), static_cast<u_int64_t>(1));
+
+    EXPECT_EQ(pidConfig[1]["myPid"].type, "margin");
+    EXPECT_DOUBLE_EQ(zoneConfig[1].minThermalOutput, 3000.0);
+
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[0].name, "absolute0");
+    EXPECT_DOUBLE_EQ(pidConfig[1]["myPid"].inputs[0].convertMarginZero, 85.0);
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[0].convertTempToMargin, true);
+
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[1].name, "absolute1");
+    EXPECT_DOUBLE_EQ(pidConfig[1]["myPid"].inputs[1].convertMarginZero, 100.0);
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[1].convertTempToMargin, true);
+
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[2].name, "margin0");
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[2].convertTempToMargin, false);
+
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[3].name, "margin1");
+    EXPECT_EQ(pidConfig[1]["myPid"].inputs[3].convertTempToMargin, false);
+}
+
 TEST(ZoneFromJson, oneZoneOnePidWithHysteresis)
 {
     // Parse a valid configuration with one zone and one PID and the PID uses
diff --git a/test/pid_thermalcontroller_unittest.cpp b/test/pid_thermalcontroller_unittest.cpp
index 6069154..7aee1e1 100644
--- a/test/pid_thermalcontroller_unittest.cpp
+++ b/test/pid_thermalcontroller_unittest.cpp
@@ -1,3 +1,4 @@
+#include "conf.hpp"
 #include "pid/ec/logging.hpp"
 #include "pid/ec/pid.hpp"
 #include "pid/thermalcontroller.hpp"
@@ -25,7 +26,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -41,7 +42,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {};
+    std::vector<pid_control::conf::SensorInput> inputs = {};
     double setpoint = 10.0;
     ec::pidinfo initial;
     std::unique_ptr<PIDController> p;
@@ -60,7 +61,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -79,7 +80,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -96,7 +97,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -117,7 +118,8 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0", "fleeting1"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"},
+                                                          {"fleeting1"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -138,7 +140,8 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0", "fleeting1"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"},
+                                                          {"fleeting1"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -159,7 +162,8 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0", "fleeting1"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"},
+                                                          {"fleeting1"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -173,6 +177,29 @@
     EXPECT_EQ(15.0, p->inputProc());
 }
 
+TEST(ThermalControllerTest, InputProc_MultipleInputsTempToMargin)
+{
+    // This test verifies inputProc behaves as expected with multiple margin
+    // inputs and TempToMargin in use.
+
+    ZoneMock z;
+
+    std::vector<pid_control::conf::SensorInput> inputs = {
+        {"absolute0", 85.0, true}, {"margin1"}};
+    double setpoint = 10.0;
+    ec::pidinfo initial;
+
+    std::unique_ptr<PIDController> p = ThermalController::createThermalPid(
+        &z, "therm1", inputs, setpoint, initial, ThermalType::margin);
+    EXPECT_FALSE(p == nullptr);
+
+    EXPECT_CALL(z, getCachedValue(StrEq("absolute0"))).WillOnce(Return(82.0));
+    EXPECT_CALL(z, getCachedValue(StrEq("margin1"))).WillOnce(Return(5.0));
+
+    // 82 degrees temp, 85 degrees Tjmax => 3 degrees of safety margin
+    EXPECT_EQ(3.0, p->inputProc());
+}
+
 TEST(ThermalControllerTest, NegHysteresis_BehavesAsExpected)
 {
     // This test verifies Negative hysteresis behaves as expected by
@@ -181,7 +208,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
     initial.negativeHysteresis = 4.0;
@@ -214,7 +241,7 @@
 
     ZoneMock z;
 
-    std::vector<std::string> inputs = {"fleeting0"};
+    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
     initial.positiveHysteresis = 5.0;
diff --git a/util.cpp b/util.cpp
index 411b761..87c4deb 100644
--- a/util.cpp
+++ b/util.cpp
@@ -69,7 +69,12 @@
             std::cout << "\t\t\t{";
             for (const auto& input : pidconf.second.inputs)
             {
-                std::cout << "\n\t\t\t" << input << ",\n";
+                std::cout << "\n\t\t\t" << input.name;
+                if (input.convertTempToMargin)
+                {
+                    std::cout << "[" << input.convertMarginZero << "]";
+                }
+                std::cout << ",\n";
             }
             std::cout << "\t\t\t}\n";
             std::cout << "\t\t\t" << pidconf.second.setpoint << ",\n";
@@ -96,4 +101,51 @@
     std::cout << "}\n\n";
 }
 
+std::vector<conf::SensorInput>
+    spliceInputs(const std::vector<std::string>& inputNames,
+                 const std::vector<double>& inputTempToMargin)
+{
+    std::vector<conf::SensorInput> results;
+
+    // Default to the TempToMargin feature disabled
+    for (const auto& inputName : inputNames)
+    {
+        conf::SensorInput newInput{
+            inputName, std::numeric_limits<double>::quiet_NaN(), false};
+
+        results.emplace_back(newInput);
+    }
+
+    size_t resultSize = results.size();
+    size_t marginSize = inputTempToMargin.size();
+
+    for (size_t index = 0; index < resultSize; ++index)
+    {
+        // If fewer doubles than strings, and vice versa, ignore remainder
+        if (index >= marginSize)
+        {
+            break;
+        }
+
+        // Both vectors have this index, combine both into SensorInput
+        results[index].convertMarginZero = inputTempToMargin[index];
+        results[index].convertTempToMargin = true;
+    }
+
+    return results;
+}
+
+std::vector<std::string>
+    splitNames(const std::vector<conf::SensorInput>& sensorInputs)
+{
+    std::vector<std::string> results;
+
+    for (const auto& sensorInput : sensorInputs)
+    {
+        results.emplace_back(sensorInput.name);
+    }
+
+    return results;
+}
+
 } // namespace pid_control
diff --git a/util.hpp b/util.hpp
index 362d517..0588934 100644
--- a/util.hpp
+++ b/util.hpp
@@ -41,6 +41,20 @@
 std::string FixupPath(std::string original);
 
 /*
+ * Splice together two vectors, "Inputs" and "TempToMargin" from JSON,
+ * into one vector of SensorInput structures containing info from both.
+ */
+std::vector<conf::SensorInput>
+    spliceInputs(const std::vector<std::string>& inputNames,
+                 const std::vector<double>& inputTempToMargin);
+
+/*
+ * Recovers the original "Inputs" vector from spliceInputs().
+ */
+std::vector<std::string>
+    splitNames(const std::vector<conf::SensorInput>& sensorInputs);
+
+/*
  * Dump active configuration.
  */
 void debugPrint(const std::map<std::string, conf::SensorConfig>& sensorConfig,