PID Objects & Algo

These are the PID controller implementations for fans,
and thermals.  This also includes the PID algorithm used.

Change-Id: I30471fbf7a8a7ed65f78bf105970d62815fedc56
Signed-off-by: Patrick Venture <venture@google.com>

16 files changed, 1463 insertions, 0 deletions

diff --git a/pid/README b/pid/README
new file mode 100644
index 0000000..93e48f3
--- /dev/null
+++ b/pid/README
@@ -0,0 +1,11 @@
+ThermalControllers and FanControllers are derived objects from a common PID
+Controller object.  The design implemented in this structure is a facsimile of
+what was published in the Chrome OS source.
+
+One has any number of ThermalControllers that run through a PID step to
+generate a set-point RPM to reach its thermal set-point.  The maximum ouput
+from the set of ThermalControllers is taken as the input to all the
+FanController PID loops.
+
+Each group of these controllers is managed within a zone.  A PIDZone object
+helps manage them by providing a sensor value cache and overall execution.
diff --git a/pid/controller.cpp b/pid/controller.cpp
new file mode 100644
index 0000000..a5360fe
--- /dev/null
+++ b/pid/controller.cpp
@@ -0,0 +1,48 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <chrono>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "controller.hpp"
+#include "ec/pid.hpp"
+
+
+void PIDController::pid_process(void)
+{
+    float input;
+    float setpt;
+    float output;
+
+    // Get setpt value
+    setpt = setpt_proc();
+
+    // Get input value
+    input = input_proc();
+
+    // Calculate new output
+    output = ec::pid(get_pid_info(), input, setpt);
+
+    // Output new value
+    output_proc(output);
+
+    return;
+}
diff --git a/pid/controller.hpp b/pid/controller.hpp
new file mode 100644
index 0000000..0b1de3c
--- /dev/null
+++ b/pid/controller.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "fan.hpp"
+#include "ec/pid.hpp"
+
+class PIDZone;
+
+/*
+ * Base class for PID controllers.  Each PID that implements this needs to
+ * provide an input_proc, setpt_proc, and output_proc.
+ */
+class PIDController
+{
+    public:
+        PIDController(const std::string& id, std::shared_ptr<PIDZone> owner)
+            : _owner(owner),
+              _id(id)
+        { }
+
+        virtual ~PIDController() { }
+
+        virtual float input_proc(void) = 0;
+        virtual float setpt_proc(void) = 0;
+        virtual void output_proc(float value) = 0;
+
+        void pid_process(void);
+
+        std::string get_id(void)
+        {
+            return _id;
+        }
+        float get_setpoint(void)
+        {
+            return _setpoint;
+        }
+        void set_setpoint(float setpoint)
+        {
+            _setpoint = setpoint;
+        }
+
+        ec::pid_info_t* get_pid_info(void)
+        {
+            return &_pid_info;
+        }
+
+    protected:
+        std::shared_ptr<PIDZone> _owner;
+
+    private:
+        // parameters
+        ec::pid_info_t  _pid_info;
+        float           _setpoint;
+        std::string     _id;
+};
+
diff --git a/pid/ec/pid.cpp b/pid/ec/pid.cpp
new file mode 100644
index 0000000..a1c4e41
--- /dev/null
+++ b/pid/ec/pid.cpp
@@ -0,0 +1,118 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pid.hpp"
+
+namespace ec
+{
+
+/********************************
+ *  clamp
+ *
+ */
+static float clamp(float x, float min, float max)
+{
+    if (x < min)
+    {
+        return min;
+    }
+    else if (x > max)
+    {
+        return max;
+    }
+    return x;
+}
+
+/********************************
+ *  pid code
+ *  Note: Codes assumes the ts field is non-zero
+ */
+float pid(pid_info_t* pidinfoptr, float input, float setpoint)
+{
+    float error;
+
+    float p_term = 0.0f;
+    float i_term = 0.0f;
+    float ff_term = 0.0f;
+
+    float output;
+
+    // calculate P, I, D, FF
+
+    // Pid
+    error   = setpoint - input;
+    p_term  = pidinfoptr->p_c * error;
+
+    // pId
+    if (0.0f != pidinfoptr->i_c)
+    {
+        i_term  = pidinfoptr->integral;
+        i_term  += error * pidinfoptr->i_c * pidinfoptr->ts;
+        i_term  = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
+    }
+
+    // FF
+    ff_term = (setpoint + pidinfoptr->ff_off) * pidinfoptr->ff_gain;
+
+    output = p_term + i_term + ff_term;
+    output = clamp(output, pidinfoptr->out_lim.min, pidinfoptr->out_lim.max);
+
+    // slew rate
+    // TODO(aarena) - Simplify logic as Andy suggested by creating dynamic
+    // out_lim_min/max that are affected by slew rate control and just clamping
+    // to those instead of effectively clamping twice.
+    if (pidinfoptr->initialized)
+    {
+        if (pidinfoptr->slew_neg != 0.0f)
+        {
+            // Don't decrease too fast
+            float min_out = pidinfoptr->last_output + pidinfoptr->slew_neg *
+                            pidinfoptr->ts;
+            if (output < min_out)
+            {
+                output = min_out;
+            }
+        }
+        if (pidinfoptr->slew_pos != 0.0f)
+        {
+            // Don't increase too fast
+            float max_out = pidinfoptr->last_output + pidinfoptr->slew_pos *
+                            pidinfoptr->ts;
+            if (output > max_out)
+            {
+                output = max_out;
+            }
+        }
+
+        if (pidinfoptr->slew_neg != 0.0f || pidinfoptr->slew_pos != 0.0f)
+        {
+            // Back calculate integral term for the cases where we limited the
+            // output
+            i_term = output - p_term;
+        }
+    }
+
+    // Clamp again because having limited the output may result in a
+    // larger integral term
+    i_term  = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
+    pidinfoptr->integral = i_term;
+    pidinfoptr->initialized    = true;
+    pidinfoptr->last_output    = output;
+
+    return output;
+}
+
+}
diff --git a/pid/ec/pid.hpp b/pid/ec/pid.hpp
new file mode 100644
index 0000000..e138933
--- /dev/null
+++ b/pid/ec/pid.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <cstdint>
+
+namespace ec
+{
+
+typedef struct
+{
+    float       min;
+    float       max;
+} limits_t;
+
+/* Note: If you update these structs you need to update the copy code in
+ * pid/util.cpp.
+ */
+typedef struct
+{
+    bool        initialized;        // has pid been initialized
+
+    float       ts;                 // sample time in seconds
+    float       integral;           // intergal of error
+    float       last_output;        // value of last output
+
+    float       p_c;                // coeff for P
+    float       i_c;                // coeff for I
+    float       ff_off;             // offset coeff for feed-forward term
+    float       ff_gain;            // gain for feed-forward term
+
+    limits_t    i_lim;              // clamp of integral
+    limits_t    out_lim;            // clamp of output
+    float       slew_neg;
+    float       slew_pos;
+} pid_info_t;
+
+float pid(pid_info_t* pidinfoptr, float input, float setpoint);
+
+/* Condensed version for use by the configuration. */
+struct pidinfo
+{
+    float        ts;                 // sample time in seconds
+    float        p_c;                // coeff for P
+    float        i_c;                // coeff for I
+    float        ff_off;             // offset coeff for feed-forward term
+    float        ff_gain;            // gain for feed-forward term
+    ec::limits_t i_lim;              // clamp of integral
+    ec::limits_t out_lim;            // clamp of output
+    float        slew_neg;
+    float        slew_pos;
+};
+
+
+}
diff --git a/pid/fan.hpp b/pid/fan.hpp
new file mode 100644
index 0000000..7792d04
--- /dev/null
+++ b/pid/fan.hpp
@@ -0,0 +1,9 @@
+
+#pragma once
+
+enum class FanSpeedDirection
+{
+    DOWN,
+    UP,
+    NEUTRAL, /* not sure this will ever happen, but for completeness. */
+};
diff --git a/pid/fancontroller.cpp b/pid/fancontroller.cpp
new file mode 100644
index 0000000..b5949a8
--- /dev/null
+++ b/pid/fancontroller.cpp
@@ -0,0 +1,146 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <iostream>
+
+#include "fancontroller.hpp"
+#include "util.hpp"
+#include "zone.hpp"
+
+std::unique_ptr<PIDController> FanController::CreateFanPid(
+    std::shared_ptr<PIDZone> owner,
+    const std::string& id,
+    std::vector<std::string>& inputs,
+    ec::pidinfo initial)
+{
+    auto fan = std::make_unique<FanController>(id, inputs, owner);
+    ec::pid_info_t* info = fan->get_pid_info();
+
+    InitializePIDStruct(info, &initial);
+
+    return fan;
+}
+
+float FanController::input_proc(void)
+{
+    float sum = 0;
+    double value = 0;
+    std::vector<int64_t> values;
+    std::vector<int64_t>::iterator result;
+
+    try
+    {
+        for (const auto& name : _inputs)
+        {
+            value = _owner->getCachedValue(name);
+            /* If we have a fan we can't read, its value will be 0 for at least
+             * some boards, while others... the fan will drop off dbus (if
+             * that's how it's being read and in that case its value will never
+             * be updated anymore, which is relatively harmless, except, when
+             * something tries to read its value through IPMI, and can't, they
+             * sort of have to guess -- all the other fans are reporting, why
+             * not this one?  Maybe it's unable to be read, so it's "bad."
+             */
+            if (value > 0)
+            {
+                values.push_back(value);
+                sum += value;
+            }
+        }
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "exception on input_proc.\n";
+        throw;
+    }
+
+    if (values.size() > 0)
+    {
+        /* When this is a configuration option in a later update, this code
+         * will be updated.
+         */
+        //value = sum / _inputs.size();
+
+        /* the fan PID algorithm was unstable with average, and seemed to work
+         * better with minimum.  I had considered making this choice a variable
+         * in the configuration, and I will.
+         */
+        result = std::min_element(values.begin(), values.end());
+        value = *result;
+    }
+
+    return static_cast<float>(value);
+}
+
+float FanController::setpt_proc(void)
+{
+    float maxRPM = _owner->getMaxRPMRequest();
+
+    // store for reference, and check if more or less.
+    float prev = get_setpoint();
+
+    if (maxRPM > prev)
+    {
+        setFanDirection(FanSpeedDirection::UP);
+    }
+    else if (prev > maxRPM)
+    {
+        setFanDirection(FanSpeedDirection::DOWN);
+    }
+    else
+    {
+        setFanDirection(FanSpeedDirection::NEUTRAL);
+    }
+
+    set_setpoint(maxRPM);
+
+    return (maxRPM);
+}
+
+void FanController::output_proc(float value)
+{
+    float percent = value;
+
+    /* If doing tuning logging, don't go into failsafe mode. */
+#ifndef __TUNING_LOGGING__
+    if (_owner->getFailSafeMode())
+    {
+        /* In case it's being set to 100% */
+        if (percent < _owner->getFailSafePercent())
+        {
+            percent = _owner->getFailSafePercent();
+        }
+    }
+#endif
+
+    // value and kFanFailSafeDutyCycle are 10 for 10% so let's fix that.
+    percent /= 100;
+
+    // PidSensorMap for writing.
+    for (auto& it : _inputs)
+    {
+        auto& sensor = _owner->getSensor(it);
+        sensor->write(static_cast<double>(percent));
+    }
+
+#ifdef __TUNING_LOGGING__
+    _owner->getLogHandle() << "," << percent;
+#endif
+
+    return;
+}
+
diff --git a/pid/fancontroller.hpp b/pid/fancontroller.hpp
new file mode 100644
index 0000000..0816991
--- /dev/null
+++ b/pid/fancontroller.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "controller.hpp"
+#include "fan.hpp"
+#include "ec/pid.hpp"
+
+
+/*
+ * A FanController is a PID controller that reads a number of fans and given
+ * the output then tries to set them to the goal values set by the thermal
+ * controllers.
+ */
+class FanController : public PIDController
+{
+    public:
+        static std::unique_ptr<PIDController> CreateFanPid(
+            std::shared_ptr<PIDZone> owner,
+            const std::string& id,
+            std::vector<std::string>& inputs,
+            ec::pidinfo initial);
+
+        FanController(const std::string& id,
+                      std::vector<std::string>& inputs,
+                      std::shared_ptr<PIDZone> owner)
+            : PIDController(id, owner),
+              _inputs(inputs),
+              _direction(FanSpeedDirection::NEUTRAL)
+        { }
+
+        float input_proc(void) override;
+        float setpt_proc(void) override;
+        void output_proc(float value) override;
+
+        void setFanDirection(FanSpeedDirection direction)
+        {
+            _direction = direction;
+        };
+
+    private:
+        std::vector<std::string> _inputs;
+        FanSpeedDirection _direction;
+};
diff --git a/pid/pidthread.cpp b/pid/pidthread.cpp
new file mode 100644
index 0000000..38b2516
--- /dev/null
+++ b/pid/pidthread.cpp
@@ -0,0 +1,107 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <chrono>
+#include <map>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "pidthread.hpp"
+
+#include "pid/controller.hpp"
+#include "sensors/sensor.hpp"
+
+
+static void ProcessThermals(std::shared_ptr<PIDZone> zone)
+{
+    // Get the latest margins.
+    zone->updateSensors();
+    // Zero out the RPM set point goals.
+    zone->clearRPMSetPoints();
+    // Run the margin PIDs.
+    zone->process_thermals();
+    // Get the maximum RPM set-point.
+    zone->determineMaxRPMRequest();
+}
+
+
+void PIDControlThread(std::shared_ptr<PIDZone> zone)
+{
+    int ms100cnt = 0;
+    /*
+     * This should sleep on the conditional wait for the listen thread to tell
+     * us it's in sync.  But then we also need a timeout option in case
+     * phosphor-hwmon is down, we can go into some weird failure more.
+     *
+     * Another approach would be to start all sensors in worst-case values,
+     * and fail-safe mode and then clear out of fail-safe mode once we start
+     * getting values.  Which I think it is a solid approach.
+     *
+     * For now this runs before it necessarily has any sensor values.  For the
+     * host sensors they start out in fail-safe mode.  For the fans, they start
+     * out as 0 as input and then are adjusted once they have values.
+     *
+     * If a fan has failed, it's value will be whatever we're told or however
+     * we retrieve it.  This program disregards fan values of 0, so any code
+     * providing a fan speed can set to 0 on failure and that fan value will be
+     * effectively ignored.  The PID algorithm will be unhappy but nothing bad
+     * will happen.
+     *
+     * TODO(venture): If the fan value is 0 should that loop just be skipped?
+     * Right now, a 0 value is ignored in FanController::input_proc()
+     */
+#ifdef __TUNING_LOGGING__
+    zone->initializeLog();
+#endif
+    zone->initializeCache();
+    ProcessThermals(zone);
+
+    while (true)
+    {
+        using namespace std::literals::chrono_literals;
+        std::this_thread::sleep_for(0.1s);
+
+        // Check if we should just go back to sleep.
+        if (zone->getManualMode())
+        {
+            continue;
+        }
+
+        // Get the latest fan speeds.
+        zone->updateFanTelemetry();
+
+        if (10 <= ms100cnt)
+        {
+            ms100cnt = 0;
+
+            ProcessThermals(zone);
+        }
+
+        // Run the fan PIDs every iteration.
+        zone->process_fans();
+
+#ifdef __TUNING_LOGGING__
+        zone->getLogHandle() << std::endl;
+#endif
+
+        ms100cnt += 1;
+    }
+
+    return;
+}
+
+
diff --git a/pid/pidthread.hpp b/pid/pidthread.hpp
new file mode 100644
index 0000000..670d558
--- /dev/null
+++ b/pid/pidthread.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "pid/zone.hpp"
+
+/* Given a zone, run through the loops. */
+void PIDControlThread(std::shared_ptr<PIDZone> zone);
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
new file mode 100644
index 0000000..c44503f
--- /dev/null
+++ b/pid/thermalcontroller.cpp
@@ -0,0 +1,76 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "thermalcontroller.hpp"
+#include "util.hpp"
+#include "zone.hpp"
+
+
+std::unique_ptr<PIDController> ThermalController::CreateThermalPid(
+    std::shared_ptr<PIDZone> owner,
+    const std::string& id,
+    std::vector<std::string>& inputs,
+    float setpoint,
+    ec::pidinfo initial)
+{
+    auto thermal = std::make_unique<ThermalController>(id, inputs, owner);
+
+    ec::pid_info_t* info = thermal->get_pid_info();
+    thermal->set_setpoint(setpoint);
+
+    InitializePIDStruct(info, &initial);
+
+    return thermal;
+}
+
+//bmc_host_sensor_value_float
+float ThermalController::input_proc(void)
+{
+    /*
+     * This only supports one thermal input because it doesn't yet know how to
+     * handle merging them, probably max?
+     */
+    double value = _owner->getCachedValue(_inputs.at(0));
+    return static_cast<float>(value);
+}
+
+// bmc_get_setpt
+float ThermalController::setpt_proc(void)
+{
+    float setpoint = get_setpoint();
+
+    /* TODO(venture): Thermal setpoint invalid? */
+#if 0
+    if (-1 == setpoint)
+    {
+        return 0.0f;
+    }
+    else
+    {
+        return setpoint;
+    }
+#endif
+    return setpoint;
+}
+
+// bmc_set_pid_output
+void ThermalController::output_proc(float value)
+{
+    _owner->addRPMSetPoint(value);
+
+    return;
+}
+
diff --git a/pid/thermalcontroller.hpp b/pid/thermalcontroller.hpp
new file mode 100644
index 0000000..32616ac
--- /dev/null
+++ b/pid/thermalcontroller.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "controller.hpp"
+#include "ec/pid.hpp"
+
+
+/*
+ * A ThermalController is a PID controller that reads a number of sensors and
+ * provides the set-points for the fans.
+ */
+class ThermalController : public PIDController
+{
+    public:
+        static std::unique_ptr<PIDController> CreateThermalPid(
+            std::shared_ptr<PIDZone> owner,
+            const std::string& id,
+            std::vector<std::string>& inputs,
+            float setpoint,
+            ec::pidinfo initial);
+
+        ThermalController(const std::string& id,
+                          std::vector<std::string>& inputs,
+                          std::shared_ptr<PIDZone> owner)
+            : PIDController(id, owner),
+              _inputs(inputs)
+        { }
+
+        float input_proc(void) override;
+        float setpt_proc(void) override;
+        void output_proc(float value) override;
+
+    private:
+        std::vector<std::string> _inputs;
+};
+
diff --git a/pid/util.cpp b/pid/util.cpp
new file mode 100644
index 0000000..79da7e1
--- /dev/null
+++ b/pid/util.cpp
@@ -0,0 +1,57 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstring>
+#include <iostream>
+
+#include "ec/pid.hpp"
+
+void InitializePIDStruct(ec::pid_info_t* info, ec::pidinfo* initial)
+{
+    std::memset(info, 0x00, sizeof(ec::pid_info_t));
+
+    info->ts = initial->ts;
+    info->p_c = initial->p_c;
+    info->i_c = initial->i_c;
+    info->ff_off = initial->ff_off;
+    info->ff_gain = initial->ff_gain;
+    info->i_lim.min = initial->i_lim.min;
+    info->i_lim.max = initial->i_lim.max;
+    info->out_lim.min = initial->out_lim.min;
+    info->out_lim.max = initial->out_lim.max;
+    info->slew_neg = initial->slew_neg;
+    info->slew_pos = initial->slew_pos;
+}
+
+void DumpPIDStruct(ec::pid_info_t *info)
+{
+    std::cerr << " ts: " << info->ts
+              << " p_c: " << info->p_c
+              << " i_c: " << info->i_c
+              << " ff_off: " << info->ff_off
+              << " ff_gain: " << info->ff_gain
+              << " i_lim.min: " << info->i_lim.min
+              << " i_lim.max: " << info->i_lim.max
+              << " out_lim.min: " << info->out_lim.min
+              << " out_lim.max: " << info->out_lim.max
+              << " slew_neg: " << info->slew_neg
+              << " slew_pos: " << info->slew_pos
+              << " last_output: " << info->last_output
+              << " integral: " << info->integral
+              << std::endl;
+
+    return;
+}
diff --git a/pid/util.hpp b/pid/util.hpp
new file mode 100644
index 0000000..eb6e713
--- /dev/null
+++ b/pid/util.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "ec/pid.hpp"
+
+
+/*
+ * Given a configuration structure, fill out the information we use within the
+ * PID loop.
+ */
+void InitializePIDStruct(ec::pid_info_t* info, ec::pidinfo* initial);
+
+void DumpPIDStruct(ec::pid_info_t *info);
diff --git a/pid/zone.cpp b/pid/zone.cpp
new file mode 100644
index 0000000..04b3176
--- /dev/null
+++ b/pid/zone.cpp
@@ -0,0 +1,553 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Configuration. */
+#include "conf.hpp"
+
+#include "zone.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <libconfig.h++>
+#include <memory>
+
+#include "pid/controller.hpp"
+#include "pid/fancontroller.hpp"
+#include "pid/thermalcontroller.hpp"
+#include "pid/ec/pid.hpp"
+
+
+using tstamp = std::chrono::high_resolution_clock::time_point;
+using namespace std::literals::chrono_literals;
+
+static constexpr bool deferSignals = true;
+static constexpr auto objectPath = "/xyz/openbmc_project/settings/fanctrl/zone";
+
+float PIDZone::getMaxRPMRequest(void) const
+{
+    return _maximumRPMSetPt;
+}
+
+bool PIDZone::getManualMode(void) const
+{
+    return _manualMode;
+}
+
+void PIDZone::setManualMode(bool mode)
+{
+    _manualMode = mode;
+}
+
+bool PIDZone::getFailSafeMode(void) const
+{
+    // If any keys are present at least one sensor is in fail safe mode.
+    return !_failSafeSensors.empty();
+}
+
+int64_t PIDZone::getZoneId(void) const
+{
+    return _zoneId;
+}
+
+void PIDZone::addRPMSetPoint(float setpoint)
+{
+    _RPMSetPoints.push_back(setpoint);
+}
+
+void PIDZone::clearRPMSetPoints(void)
+{
+    _RPMSetPoints.clear();
+}
+
+float PIDZone::getFailSafePercent(void) const
+{
+    return _failSafePercent;
+}
+
+float PIDZone::getMinThermalRpmSetPt(void) const
+{
+    return _minThermalRpmSetPt;
+}
+
+void PIDZone::addFanPID(std::unique_ptr<PIDController> pid)
+{
+    _fans.push_back(std::move(pid));
+}
+
+void PIDZone::addThermalPID(std::unique_ptr<PIDController> pid)
+{
+    _thermals.push_back(std::move(pid));
+}
+
+double PIDZone::getCachedValue(const std::string& name)
+{
+    return _cachedValuesByName.at(name);
+}
+
+void PIDZone::addFanInput(std::string fan)
+{
+    _fanInputs.push_back(fan);
+}
+
+void PIDZone::addThermalInput(std::string therm)
+{
+    _thermalInputs.push_back(therm);
+}
+
+void PIDZone::determineMaxRPMRequest(void)
+{
+    float max = 0;
+    std::vector<float>::iterator result;
+
+    if (_RPMSetPoints.size() > 0)
+    {
+        result = std::max_element(_RPMSetPoints.begin(), _RPMSetPoints.end());
+        max = *result;
+    }
+
+    /*
+     * If the maximum RPM set-point output is below the minimum RPM
+     * set-point, set it to the minimum.
+     */
+    max = std::max(getMinThermalRpmSetPt(), max);
+
+#ifdef __TUNING_LOGGING__
+    /*
+     * We received no set-points from thermal sensors.
+     * This is a case experienced during tuning where they only specify
+     * fan sensors and one large fan PID for all the fans.
+     */
+    static constexpr auto setpointpath = "/etc/thermal.d/set-point";
+    try
+    {
+        int value;
+        std::ifstream ifs;
+        ifs.open(setpointpath);
+        if (ifs.good()) {
+            ifs >> value;
+            max = value; // expecting RPM set-point, not pwm%
+        }
+    }
+    catch (const std::exception& e)
+    {
+        /* This exception is uninteresting. */
+        std::cerr << "Unable to read from '" << setpointpath << "'\n";
+    }
+#endif
+
+    _maximumRPMSetPt = max;
+    return;
+}
+
+#ifdef __TUNING_LOGGING__
+void PIDZone::initializeLog(void)
+{
+    /* Print header for log file. */
+
+    _log << "epoch_ms,setpt";
+
+    for (auto& f : _fanInputs)
+    {
+        _log << "," << f;
+    }
+    _log << std::endl;
+
+    return;
+}
+
+std::ofstream& PIDZone::getLogHandle(void)
+{
+    return _log;
+}
+#endif
+
+/*
+ * TODO(venture) This is effectively updating the cache and should check if the
+ * values they're using to update it are new or old, or whatnot.  For instance,
+ * if we haven't heard from the host in X time we need to detect this failure.
+ *
+ * I haven't decided if the Sensor should have a lastUpdated method or whether
+ * that should be for the ReadInterface or etc...
+ */
+
+/**
+ * We want the PID loop to run with values cached, so this will get all the
+ * fan tachs for the loop.
+ */
+void PIDZone::updateFanTelemetry(void)
+{
+    /* TODO(venture): Should I just make _log point to /dev/null when logging
+     * is disabled?  I think it's a waste to try and log things even if the
+     * data is just being dropped though.
+     */
+#ifdef __TUNING_LOGGING__
+    tstamp now = std::chrono::high_resolution_clock::now();
+    _log << std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+    _log << "," << _maximumRPMSetPt;
+#endif
+
+    for (auto& f : _fanInputs)
+    {
+        auto& sensor = _mgr->getSensor(f);
+        ReadReturn r = sensor->read();
+        _cachedValuesByName[f] = r.value;
+
+        /*
+         * TODO(venture): We should check when these were last read.
+         * However, these are the fans, so if I'm not getting updated values
+         * for them... what should I do?
+         */
+#ifdef __TUNING_LOGGING__
+        _log << "," << r.value;
+#endif
+    }
+
+    return;
+}
+
+void PIDZone::updateSensors(void)
+{
+    using namespace std::chrono;
+    /* margin and temp are stored as temp */
+    tstamp now = high_resolution_clock::now();
+
+    for (auto& t : _thermalInputs)
+    {
+        auto& sensor = _mgr->getSensor(t);
+        ReadReturn r = sensor->read();
+        int64_t timeout = sensor->GetTimeout();
+
+        _cachedValuesByName[t] = r.value;
+        tstamp then = r.updated;
+
+        /* Only go into failsafe if the timeout is set for
+         * the sensor.
+         */
+        if (timeout > 0)
+        {
+            auto duration = duration_cast<std::chrono::seconds>
+                    (now - then).count();
+            auto period = std::chrono::seconds(timeout).count();
+            if (duration >= period)
+            {
+                //std::cerr << "Entering fail safe mode.\n";
+                _failSafeSensors.insert(t);
+            }
+            else
+            {
+                // Check if it's in there: remove it.
+                auto kt = _failSafeSensors.find(t);
+                if (kt != _failSafeSensors.end())
+                {
+                    _failSafeSensors.erase(kt);
+                }
+            }
+        }
+    }
+
+    return;
+}
+
+void PIDZone::initializeCache(void)
+{
+    for (auto& f : _fanInputs)
+    {
+        _cachedValuesByName[f] = 0;
+    }
+
+    for (auto& t : _thermalInputs)
+    {
+        _cachedValuesByName[t] = 0;
+
+        // Start all sensors in fail-safe mode.
+        _failSafeSensors.insert(t);
+    }
+}
+
+void PIDZone::dumpCache(void)
+{
+    std::cerr << "Cache values now: \n";
+    for (auto& k : _cachedValuesByName)
+    {
+        std::cerr << k.first << ": " << k.second << "\n";
+    }
+}
+
+void PIDZone::process_fans(void)
+{
+    for (auto& p : _fans)
+    {
+        p->pid_process();
+    }
+}
+
+void PIDZone::process_thermals(void)
+{
+    for (auto& p : _thermals)
+    {
+        p->pid_process();
+    }
+}
+
+std::unique_ptr<Sensor>& PIDZone::getSensor(std::string name)
+{
+    return _mgr->getSensor(name);
+}
+
+bool PIDZone::manual(bool value)
+{
+    std::cerr << "manual: " << value << std::endl;
+    setManualMode(value);
+    return ModeObject::manual(value);
+}
+
+bool PIDZone::failSafe() const
+{
+    return getFailSafeMode();
+}
+
+static std::string GetControlPath(int64_t zone)
+{
+    return std::string(objectPath) + std::to_string(zone);
+}
+
+std::map<int64_t, std::shared_ptr<PIDZone>> BuildZones(
+            std::map<int64_t, PIDConf>& ZonePids,
+            std::map<int64_t, struct zone>& ZoneConfigs,
+            std::shared_ptr<SensorManager> mgr,
+            sdbusplus::bus::bus& ModeControlBus)
+{
+    std::map<int64_t, std::shared_ptr<PIDZone>> zones;
+
+    for (auto& zi : ZonePids)
+    {
+        auto zoneId = static_cast<int64_t>(zi.first);
+        /* The above shouldn't be necessary but is, and I am having trouble
+         * locating my notes on why.  If I recall correctly it was casting it
+         * down to a byte in at least some cases causing weird behaviors.
+         */
+
+        auto zoneConf = ZoneConfigs.find(zoneId);
+        if (zoneConf == ZoneConfigs.end())
+        {
+            /* The Zone doesn't have a configuration, bail. */
+            static constexpr auto err =
+                "Bailing during load, missing Zone Configuration";
+            std::cerr << err << std::endl;
+            throw std::runtime_error(err);
+        }
+
+        PIDConf& PIDConfig = zi.second;
+
+        auto zone = std::make_shared<PIDZone>(
+                        zoneId,
+                        zoneConf->second.minthermalrpm,
+                        zoneConf->second.failsafepercent,
+                        mgr,
+                        ModeControlBus,
+                        GetControlPath(zi.first).c_str(),
+                        deferSignals);
+
+        zones[zoneId] = zone;
+
+        std::cerr << "Zone Id: " << zone->getZoneId() << "\n";
+
+        // For each PID create a Controller and a Sensor.
+        PIDConf::iterator pit = PIDConfig.begin();
+        while (pit != PIDConfig.end())
+        {
+            std::vector<std::string> inputs;
+            std::string name = pit->first;
+            struct controller_info* info = &pit->second;
+
+            std::cerr << "PID name: " << name << "\n";
+
+            /*
+             * TODO(venture): Need to check if input is known to the
+             * SensorManager.
+             */
+            if (info->type == "fan")
+            {
+                for (auto i : info->inputs)
+                {
+                    inputs.push_back(i);
+                    zone->addFanInput(i);
+                }
+
+                auto pid = FanController::CreateFanPid(
+                               zone,
+                               name,
+                               inputs,
+                               info->info);
+                zone->addFanPID(std::move(pid));
+            }
+            else if (info->type == "temp" || info->type == "margin")
+            {
+                for (auto i : info->inputs)
+                {
+                    inputs.push_back(i);
+                    zone->addThermalInput(i);
+                }
+
+                auto pid = ThermalController::CreateThermalPid(
+                               zone,
+                               name,
+                               inputs,
+                               info->setpoint,
+                               info->info);
+                zone->addThermalPID(std::move(pid));
+            }
+
+            std::cerr << "inputs: ";
+            for (auto& i : inputs)
+            {
+                std::cerr << i << ", ";
+            }
+            std::cerr << "\n";
+
+            ++pit;
+        }
+
+        zone->emit_object_added();
+    }
+
+    return zones;
+}
+
+std::map<int64_t, std::shared_ptr<PIDZone>> BuildZonesFromConfig(
+            std::string& path,
+            std::shared_ptr<SensorManager> mgr,
+            sdbusplus::bus::bus& ModeControlBus)
+{
+    using namespace libconfig;
+    // zone -> pids
+    std::map<int64_t, PIDConf> pidConfig;
+    // zone -> configs
+    std::map<int64_t, struct zone> zoneConfig;
+
+    std::cerr << "entered BuildZonesFromConfig\n";
+
+    Config cfg;
+
+    /* The load was modeled after the example source provided. */
+    try
+    {
+        cfg.readFile(path.c_str());
+    }
+    catch (const FileIOException& fioex)
+    {
+        std::cerr << "I/O error while reading file: " << fioex.what() << std::endl;
+        throw;
+    }
+    catch (const ParseException& pex)
+    {
+        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
+                  << " - " << pex.getError() << std::endl;
+        throw;
+    }
+
+    try
+    {
+        const Setting& root = cfg.getRoot();
+        const Setting& zones = root["zones"];
+        int count = zones.getLength();
+
+        /* For each zone. */
+        for (int i = 0; i < count; ++i)
+        {
+            const Setting& zoneSettings = zones[i];
+
+            int id;
+            PIDConf thisZone;
+            struct zone thisZoneConfig;
+
+            zoneSettings.lookupValue("id", id);
+
+            thisZoneConfig.minthermalrpm =
+                    zoneSettings.lookup("minthermalrpm");
+            thisZoneConfig.failsafepercent =
+                    zoneSettings.lookup("failsafepercent");
+
+            const Setting& pids = zoneSettings["pids"];
+            int pidCount = pids.getLength();
+
+            for (int j = 0; j < pidCount; ++j)
+            {
+                const Setting& pid = pids[j];
+
+                std::string name;
+                controller_info info;
+
+                /*
+                 * Mysteriously if you use lookupValue on these, and the type
+                 * is float.  It won't work right.
+                 *
+                 * If the configuration file value doesn't look explicitly like
+                 * a float it won't let you assign it to one.
+                 */
+                name = pid.lookup("name").c_str();
+                info.type = pid.lookup("type").c_str();
+                /* set-point is only required to be set for thermal. */
+                /* TODO(venture): Verify this works optionally here. */
+                info.setpoint = pid.lookup("set-point");
+                info.info.ts = pid.lookup("pid.sampleperiod");
+                info.info.p_c = pid.lookup("pid.p_coefficient");
+                info.info.i_c = pid.lookup("pid.i_coefficient");
+                info.info.ff_off = pid.lookup("pid.ff_off_coefficient");
+                info.info.ff_gain = pid.lookup("pid.ff_gain_coefficient");
+                info.info.i_lim.min = pid.lookup("pid.i_limit.min");
+                info.info.i_lim.max = pid.lookup("pid.i_limit.max");
+                info.info.out_lim.min = pid.lookup("pid.out_limit.min");
+                info.info.out_lim.max = pid.lookup("pid.out_limit.max");
+                info.info.slew_neg = pid.lookup("pid.slew_neg");
+                info.info.slew_pos = pid.lookup("pid.slew_pos");
+
+                std::cerr << "out_lim.min: " << info.info.out_lim.min << "\n";
+                std::cerr << "out_lim.max: " << info.info.out_lim.max << "\n";
+
+                const Setting& inputs = pid["inputs"];
+                int icount = inputs.getLength();
+
+                for (int z = 0; z < icount; ++z)
+                {
+                    std::string v;
+                    v = pid["inputs"][z].c_str();
+                    info.inputs.push_back(v);
+                }
+
+                thisZone[name] = info;
+            }
+
+            pidConfig[static_cast<int64_t>(id)] = thisZone;
+            zoneConfig[static_cast<int64_t>(id)] = thisZoneConfig;
+        }
+    }
+    catch (const SettingTypeException &setex)
+    {
+        std::cerr << "Setting '" << setex.getPath() << "' type exception!" << std::endl;
+        throw;
+    }
+    catch (const SettingNotFoundException& snex)
+    {
+        std::cerr << "Setting '" << snex.getPath() << "' not found!" << std::endl;
+        throw;
+    }
+
+    return BuildZones(pidConfig, zoneConfig, mgr, ModeControlBus);
+}
diff --git a/pid/zone.hpp b/pid/zone.hpp
new file mode 100644
index 0000000..d75bf59
--- /dev/null
+++ b/pid/zone.hpp
@@ -0,0 +1,124 @@
+#pragma once
+
+#include <fstream>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "conf.hpp"
+#include "controller.hpp"
+#include "sensors/sensor.hpp"
+#include "sensors/manager.hpp"
+
+#include "xyz/openbmc_project/Control/FanCtrl/Mode/server.hpp"
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server.hpp>
+
+
+template <typename... T>
+using ServerObject = typename sdbusplus::server::object::object<T...>;
+using ModeInterface =
+    sdbusplus::xyz::openbmc_project::Control::FanCtrl::server::Mode;
+using ModeObject = ServerObject<ModeInterface>;
+
+/*
+ * The PIDZone inherits from the Mode object so that it can listen for control
+ * mode changes.  It primarily holds all PID loops and holds the sensor value
+ * cache that's used per iteration of the PID loops.
+ */
+class PIDZone : public ModeObject
+{
+    public:
+        PIDZone(int64_t zone,
+                float minThermalRpm,
+                float failSafePercent,
+                std::shared_ptr<SensorManager> mgr,
+                sdbusplus::bus::bus& bus,
+                const char* objPath,
+                bool defer)
+            : ModeObject(bus, objPath, defer),
+              _zoneId(zone),
+              _maximumRPMSetPt(),
+              _minThermalRpmSetPt(minThermalRpm),
+              _failSafePercent(failSafePercent),
+              _mgr(mgr)
+        {
+#ifdef __TUNING_LOGGING__
+            _log.open("/tmp/swampd.log");
+#endif
+        }
+
+        float getMaxRPMRequest(void) const;
+        bool getManualMode(void) const;
+
+        /* Could put lock around this since it's accessed from two threads, but
+         * only one reader/one writer.
+         */
+        void setManualMode(bool mode);
+        bool getFailSafeMode(void) const;
+        int64_t getZoneId(void) const;
+        void addRPMSetPoint(float setpoint);
+        void clearRPMSetPoints(void);
+        float getFailSafePercent(void) const;
+        float getMinThermalRpmSetPt(void) const;
+
+        std::unique_ptr<Sensor>& getSensor(std::string name);
+        void determineMaxRPMRequest(void);
+        void updateFanTelemetry(void);
+        void updateSensors(void);
+        void initializeCache(void);
+        void dumpCache(void);
+        void process_fans(void);
+        void process_thermals(void);
+
+        void addFanPID(std::unique_ptr<PIDController> pid);
+        void addThermalPID(std::unique_ptr<PIDController> pid);
+        double getCachedValue(const std::string& name);
+        void addFanInput(std::string fan);
+        void addThermalInput(std::string therm);
+
+#ifdef __TUNING_LOGGING__
+        void initializeLog(void);
+        std::ofstream& getLogHandle(void);
+#endif
+
+        /* Method for setting the manual mode over dbus */
+        bool manual(bool value) override;
+        /* Method for reading whether in fail-safe mode over dbus */
+        bool failSafe() const override;
+
+    private:
+#ifdef __TUNING_LOGGING__
+        std::ofstream _log;
+#endif
+
+        const int64_t _zoneId;
+        float _maximumRPMSetPt = 0;
+        bool _manualMode = false;
+        const float _minThermalRpmSetPt;
+        const float _failSafePercent;
+
+        std::set<std::string> _failSafeSensors;
+
+        std::vector<float> _RPMSetPoints;
+        std::vector<std::string> _fanInputs;
+        std::vector<std::string> _thermalInputs;
+        std::map<std::string, double> _cachedValuesByName;
+        std::shared_ptr<SensorManager> _mgr;
+
+        std::vector<std::unique_ptr<PIDController>> _fans;
+        std::vector<std::unique_ptr<PIDController>> _thermals;
+};
+
+std::map<int64_t, std::shared_ptr<PIDZone>> BuildZones(
+            std::map<int64_t, PIDConf>& ZonePids,
+            std::map<int64_t, struct zone>& ZoneConfigs,
+            std::shared_ptr<SensorManager> mgmr,
+            sdbusplus::bus::bus& ModeControlBus);
+
+std::map<int64_t, std::shared_ptr<PIDZone>> BuildZonesFromConfig(
+            std::string& path,
+            std::shared_ptr<SensorManager> mgmr,
+            sdbusplus::bus::bus& ModeControlBus);