diff --git a/src/MCUTempSensor.cpp b/src/MCUTempSensor.cpp
new file mode 100644
index 0000000..fd45327
--- /dev/null
+++ b/src/MCUTempSensor.cpp
@@ -0,0 +1,312 @@
+/*
+// Copyright (c) 2019 Intel Corporation
+//
+// 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 "MCUTempSensor.hpp"
+
+#include "Utils.hpp"
+#include "VariantVisitors.hpp"
+
+#include <math.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <chrono>
+#include <iostream>
+#include <limits>
+#include <numeric>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+#include <vector>
+
+extern "C" {
+#include <i2c/smbus.h>
+#include <linux/i2c-dev.h>
+}
+
+constexpr const bool debug = false;
+
+constexpr const char* configInterface =
+    "xyz.openbmc_project.Configuration.MCUTempSensor";
+static constexpr double mcuTempMaxReading = 0xFF;
+static constexpr double mcuTempMinReading = 0;
+
+boost::container::flat_map<std::string, std::unique_ptr<MCUTempSensor>> sensors;
+
+MCUTempSensor::MCUTempSensor(std::shared_ptr<sdbusplus::asio::connection>& conn,
+                             boost::asio::io_service& io,
+                             const std::string& sensorName,
+                             const std::string& sensorConfiguration,
+                             sdbusplus::asio::object_server& objectServer,
+                             std::vector<thresholds::Threshold>&& thresholdData,
+                             uint8_t busId, uint8_t mcuAddress,
+                             uint8_t tempReg) :
+    Sensor(boost::replace_all_copy(sensorName, " ", "_"),
+           std::move(thresholdData), sensorConfiguration,
+           "xyz.openbmc_project.Configuration.ExitAirTemp", mcuTempMaxReading,
+           mcuTempMinReading),
+    objectServer(objectServer), dbusConnection(conn), waitTimer(io),
+    busId(busId), mcuAddress(mcuAddress), tempReg(tempReg)
+{
+    sensorInterface = objectServer.add_interface(
+        "/xyz/openbmc_project/sensors/temperature/" + name,
+        "xyz.openbmc_project.Sensor.Value");
+
+    if (thresholds::hasWarningInterface(thresholds))
+    {
+        thresholdInterfaceWarning = objectServer.add_interface(
+            "/xyz/openbmc_project/sensors/temperature/" + name,
+            "xyz.openbmc_project.Sensor.Threshold.Warning");
+    }
+    if (thresholds::hasCriticalInterface(thresholds))
+    {
+        thresholdInterfaceCritical = objectServer.add_interface(
+            "/xyz/openbmc_project/sensors/temperature/" + name,
+            "xyz.openbmc_project.Sensor.Threshold.Critical");
+    }
+    association = objectServer.add_interface(
+        "/xyz/openbmc_project/sensors/temperature/" + name,
+        "org.openbmc.Associations");
+}
+
+MCUTempSensor::~MCUTempSensor()
+{
+    waitTimer.cancel();
+    objectServer.remove_interface(thresholdInterfaceWarning);
+    objectServer.remove_interface(thresholdInterfaceCritical);
+    objectServer.remove_interface(sensorInterface);
+    objectServer.remove_interface(association);
+}
+
+void MCUTempSensor::init(void)
+{
+    setInitialProperties(dbusConnection);
+    read();
+}
+
+void MCUTempSensor::checkThresholds(void)
+{
+    thresholds::checkThresholds(this);
+}
+
+int MCUTempSensor::getMCURegsInfoWord(uint8_t regs, int16_t* pu16data)
+{
+    std::string i2cBus = "/dev/i2c-" + std::to_string(busId);
+    int fd = open(i2cBus.c_str(), O_RDWR);
+    size_t i = 0;
+
+    if (fd < 0)
+    {
+        std::cerr << " unable to open i2c device" << i2cBus << "  err=" << fd
+                  << "\n";
+        return -1;
+    }
+
+    if (ioctl(fd, I2C_SLAVE_FORCE, mcuAddress) < 0)
+    {
+        std::cerr << " unable to set device address\n";
+        close(fd);
+        return -1;
+    }
+
+    unsigned long funcs = 0;
+    if (ioctl(fd, I2C_FUNCS, &funcs) < 0)
+    {
+        std::cerr << " not support I2C_FUNCS\n";
+        close(fd);
+        return -1;
+    }
+
+    if (!(funcs & I2C_FUNC_SMBUS_READ_WORD_DATA))
+    {
+        std::cerr << " not support I2C_FUNC_SMBUS_READ_WORD_DATA\n";
+        close(fd);
+        return -1;
+    }
+
+    *pu16data = i2c_smbus_read_word_data(fd, regs);
+    close(fd);
+
+    if (*pu16data < 0)
+    {
+        std::cerr << " read word data failed at " << static_cast<int>(regs)
+                  << "\n";
+        return -1;
+    }
+
+    return 0;
+}
+
+void MCUTempSensor::read(void)
+{
+    static constexpr size_t pollTime = 1; // in seconds
+
+    waitTimer.expires_from_now(boost::posix_time::seconds(pollTime));
+    waitTimer.async_wait([this](const boost::system::error_code& ec) {
+        if (ec == boost::asio::error::operation_aborted)
+        {
+            return; // we're being cancelled
+        }
+        // read timer error
+        else if (ec)
+        {
+            std::cerr << "timer error\n";
+            return;
+        }
+        int16_t temp;
+        int ret = getMCURegsInfoWord(tempReg, &temp);
+        if (ret >= 0)
+        {
+            double v = static_cast<double>(temp) / 1000;
+            if constexpr (debug)
+            {
+                std::cerr << "Value update to " << (double)v << "raw reading "
+                          << static_cast<int>(temp) << "\n";
+            }
+            updateValue(v);
+        }
+        else
+        {
+            std::cerr << "Invalid read getMCURegsInfoWord\n";
+            updateValue(-1);
+        }
+        read();
+    });
+}
+
+void createSensors(
+    boost::asio::io_service& io, sdbusplus::asio::object_server& objectServer,
+    boost::container::flat_map<std::string, std::unique_ptr<MCUTempSensor>>&
+        sensors,
+    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection)
+{
+    if (!dbusConnection)
+    {
+        std::cerr << "Connection not created\n";
+        return;
+    }
+
+    dbusConnection->async_method_call(
+        [&io, &objectServer, &dbusConnection, &sensors](
+            boost::system::error_code ec, const ManagedObjectType& resp) {
+            if (ec)
+            {
+                std::cerr << "Error contacting entity manager\n";
+                return;
+            }
+            for (const auto& pathPair : resp)
+            {
+                for (const auto& entry : pathPair.second)
+                {
+                    if (entry.first != configInterface)
+                    {
+                        continue;
+                    }
+                    std::string name =
+                        loadVariant<std::string>(entry.second, "Name");
+
+                    std::vector<thresholds::Threshold> sensorThresholds;
+                    if (!parseThresholdsFromConfig(pathPair.second,
+                                                   sensorThresholds))
+                    {
+                        std::cerr << "error populating thresholds for " << name
+                                  << "\n";
+                    }
+
+                    uint8_t busId = loadVariant<uint8_t>(entry.second, "Bus");
+
+                    uint8_t mcuAddress =
+                        loadVariant<uint8_t>(entry.second, "Address");
+
+                    uint8_t tempReg = loadVariant<uint8_t>(entry.second, "Reg");
+
+                    std::string sensorClass =
+                        loadVariant<std::string>(entry.second, "Class");
+
+                    if constexpr (debug)
+                    {
+                        std::cerr
+                            << "Configuration parsed for \n\t" << entry.first
+                            << "\n"
+                            << "with\n"
+                            << "\tName: " << name << "\n"
+                            << "\tBus: " << static_cast<int>(busId) << "\n"
+                            << "\tAddress: " << static_cast<int>(mcuAddress)
+                            << "\n"
+                            << "\tReg: " << static_cast<int>(tempReg) << "\n"
+                            << "\tClass: " << sensorClass << "\n";
+                    }
+
+                    auto& sensor = sensors[name];
+
+                    sensor = std::make_unique<MCUTempSensor>(
+                        dbusConnection, io, name, pathPair.first, objectServer,
+                        std::move(sensorThresholds), busId, mcuAddress,
+                        tempReg);
+
+                    sensor->init();
+                }
+            }
+        },
+        entityManagerName, "/", "org.freedesktop.DBus.ObjectManager",
+        "GetManagedObjects");
+}
+
+int main(int argc, char** argv)
+{
+    boost::asio::io_service io;
+    auto systemBus = std::make_shared<sdbusplus::asio::connection>(io);
+    systemBus->request_name("xyz.openbmc_project.MCUTempSensor");
+    sdbusplus::asio::object_server objectServer(systemBus);
+
+    io.post([&]() { createSensors(io, objectServer, sensors, systemBus); });
+
+    boost::asio::deadline_timer configTimer(io);
+
+    std::function<void(sdbusplus::message::message&)> eventHandler =
+        [&](sdbusplus::message::message& message) {
+            configTimer.expires_from_now(boost::posix_time::seconds(1));
+            // create a timer because normally multiple properties change
+            configTimer.async_wait([&](const boost::system::error_code& ec) {
+                if (ec == boost::asio::error::operation_aborted)
+                {
+                    return; // we're being canceled
+                }
+                // config timer error
+                else if (ec)
+                {
+                    std::cerr << "timer error\n";
+                    return;
+                }
+                createSensors(io, objectServer, sensors, systemBus);
+                if (sensors.empty())
+                {
+                    std::cout << "Configuration not detected\n";
+                }
+            });
+        };
+
+    sdbusplus::bus::match::match configMatch(
+        static_cast<sdbusplus::bus::bus&>(*systemBus),
+        "type='signal',member='PropertiesChanged',"
+        "path_namespace='" +
+            std::string(inventoryPath) +
+            "',"
+            "arg0namespace='" +
+            configInterface + "'",
+        eventHandler);
+
+    io.run();
+}