diff --git a/pid/ec/pid.cpp b/pid/ec/pid.cpp
index 10db1dd..6222f1a 100644
--- a/pid/ec/pid.cpp
+++ b/pid/ec/pid.cpp
@@ -16,6 +16,9 @@
 
 #include "pid.hpp"
 
+#include "../tuning.hpp"
+#include "logging.hpp"
+
 namespace pid_control
 {
 namespace ec
@@ -42,8 +45,30 @@
  *  pid code
  *  Note: Codes assumes the ts field is non-zero
  */
-double pid(pid_info_t* pidinfoptr, double input, double setpoint)
+double pid(pid_info_t* pidinfoptr, double input, double setpoint,
+           const std::string* nameptr)
 {
+    if (nameptr)
+    {
+        if (!(pidinfoptr->initialized))
+        {
+            LogInit(*nameptr, pidinfoptr);
+        }
+    }
+
+    auto logPtr = nameptr ? LogPeek(*nameptr) : nullptr;
+
+    PidCoreContext coreContext;
+    std::chrono::milliseconds msNow;
+
+    if (logPtr)
+    {
+        msNow = LogTimestamp();
+    }
+
+    coreContext.input = input;
+    coreContext.setpoint = setpoint;
+
     double error;
 
     double proportionalTerm;
@@ -59,26 +84,47 @@
     error = setpoint - input;
     proportionalTerm = pidinfoptr->proportionalCoeff * error;
 
+    coreContext.error = error;
+    coreContext.proportionalTerm = proportionalTerm;
+    coreContext.integralTerm1 = 0.0;
+
     // pId
     if (0.0f != pidinfoptr->integralCoeff)
     {
         integralTerm = pidinfoptr->integral;
         integralTerm += error * pidinfoptr->integralCoeff * pidinfoptr->ts;
+
+        coreContext.integralTerm1 = integralTerm;
+
         integralTerm = clamp(integralTerm, pidinfoptr->integralLimit.min,
                              pidinfoptr->integralLimit.max);
     }
 
+    coreContext.integralTerm2 = integralTerm;
+
     // piD
     derivativeTerm = pidinfoptr->derivativeCoeff *
                      ((error - pidinfoptr->lastError) / pidinfoptr->ts);
 
+    coreContext.derivativeTerm = derivativeTerm;
+
     // FF
     feedFwdTerm =
         (setpoint + pidinfoptr->feedFwdOffset) * pidinfoptr->feedFwdGain;
 
+    coreContext.feedFwdTerm = feedFwdTerm;
+
     output = proportionalTerm + integralTerm + derivativeTerm + feedFwdTerm;
+
+    coreContext.output1 = output;
+
     output = clamp(output, pidinfoptr->outLim.min, pidinfoptr->outLim.max);
 
+    coreContext.output2 = output;
+
+    coreContext.minOut = 0.0;
+    coreContext.maxOut = 0.0;
+
     // slew rate
     // TODO(aarena) - Simplify logic as Andy suggested by creating dynamic
     // outLim_min/max that are affected by slew rate control and just clamping
@@ -90,6 +136,9 @@
             // Don't decrease too fast
             double minOut =
                 pidinfoptr->lastOutput + pidinfoptr->slewNeg * pidinfoptr->ts;
+
+            coreContext.minOut = minOut;
+
             if (output < minOut)
             {
                 output = minOut;
@@ -100,6 +149,9 @@
             // Don't increase too fast
             double maxOut =
                 pidinfoptr->lastOutput + pidinfoptr->slewPos * pidinfoptr->ts;
+
+            coreContext.maxOut = maxOut;
+
             if (output > maxOut)
             {
                 output = maxOut;
@@ -114,6 +166,9 @@
         }
     }
 
+    coreContext.output3 = output;
+    coreContext.integralTerm3 = integralTerm;
+
     // Clamp again because having limited the output may result in a
     // larger integral term
     integralTerm = clamp(integralTerm, pidinfoptr->integralLimit.min,
@@ -123,6 +178,14 @@
     pidinfoptr->lastError = error;
     pidinfoptr->lastOutput = output;
 
+    coreContext.integralTerm = pidinfoptr->integral;
+    coreContext.output = pidinfoptr->lastOutput;
+
+    if (logPtr)
+    {
+        LogContext(*logPtr, msNow, coreContext);
+    }
+
     return output;
 }