diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7cb76c65..a172f9ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,12 +8,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Added Webpage for Shifting.
+- Added /shift server on backend.
+- Split userConfig into userConfig and rtConfig.
+- Added ERG testing to btsimulator.html
+- Broke out ERG computation into it's own task.
 - Added image for wiki.
 
 ### Changed
 - Adjusted the order of "Submit" "Reboot" and "Reset to Defaults" on the settings page. 
 - Adjusted the setting webpage so "reset to defaults" is harder to accidentally press. 
 - Increased the amount of free stack by removing the default Arduino loop();
+- Updated /shift server on to rtConfig.
+- Fixed redeclaring global targetposition in moveStepper().
+- Renamed Settings page "Submit" button to "Save Setting"
 
 ### Hardware
 - Increased hex head and nut size to 13mm.
diff --git a/data/btsimulator.html b/data/btsimulator.html
index 3d5a2933..5dbba903 100644
--- a/data/btsimulator.html
+++ b/data/btsimulator.html
@@ -23,44 +23,72 @@ <h1>BLE Device Simulator</h1>
 
     <h2>Sim Heart Rate</h2>
     <p><span id="hrValue"></span></p>
-    <p><input type="range" onload="requestConfigValues()" onchange="updateHRSlider(this)" id="HRSlider" min="40"
+    <p><input type="range" onload="requestConfigValues()" onchange="updateHrSlider()" id="hrSlider" min="40"
         max="250" value="0" step="1" class="slider2"></p>
     <p><label class="switch"><input type="checkbox" onload="toggleHRCheckbox(this, true)"
           onchange="toggleHRCheckbox(this,true)" id="hrOutput"><span class="slider"></span></label></p>
 
     <h2>Sim Power Output</h2>
     <p><span id="wattsValue"></span></p>
-    <p><input type="range" onload="requestConfigValues()" onchange="updateWattsSlider(this)" id="WattsSlider" min="0"
-        max="2000" value="0" step="1" class="slider2"></p>
+    <p><input type="range" onload="requestConfigValues()" onchange="updateWattsSlider()" id="wattsSlider" min="0"
+        max="600" value="0" step="1" class="slider2"></p>
     <p><label class="switch"><input type="checkbox" onload="toggleWattsCheckbox(this,true)"
           onchange="toggleWattsCheckbox(this,true)" id="wattsOutput"><span class="slider"></span></label></p>
 
     <h2>Sim CAD Output</h2>
     <p><span id="cadValue"></span></p>
-    <p><input type="range" onload="requestConfigValues()" onchange="updateCadSlider(this)" id="CadSlider" min="0"
+    <p><input type="range" onload="requestConfigValues()" onchange="updateCadSlider()" id="cadSlider" min="0"
         max="180" value="0" step="1" class="slider2"></p>
     <p><label class="switch"><input type="checkbox" onload="toggleCadCheckbox(this,true)"
           onchange="toggleCadCheckbox(this,true)" id="cadOutput"><span class="slider"></span></label></p>
+
+    <h1>Trainer Simulator</h1>
+    <h2>Enable ERG</h2>
+    <p>
+      <label class="switch">
+        <input type="checkbox" onload="toggleEnableErgCheckbox(this)" onchange="toggleEnableErgCheckbox(this)"
+          id="enableErgCheckbox">
+        <span class="slider"></span>
+      </label>
+    </p>
+    <h2>ERG Target Watts</h2>
+    <p><span id="targetWattsValue"></span></p>
+    <p><input type="range" onload="requestConfigValues()" onchange="updateTargetWattsSlider()"
+        id="targetWattsSlider" min="0" max="600" value="0" step="1" class="slider2"></p>
+    <p>
+      <label class="switch">
+        <input type="checkbox" onload="toggleTargetWattsCheckbox(this,true)"
+          onchange="toggleTargetWattsCheckbox(this,true)" id="targetWattsOutput">
+        <span class="slider"></span>
+      </label>
+    </p>
 </body>
 <script>
+  //Update values on specified interval
+  setInterval(function () {
+    requestConfigValues();
+
+  }, 2000);
+
+  let pwrTimer;
 
   function toggleHRCheckbox(element, updateServer) {
     if (element.checked) {
-      document.getElementById("HRSlider").hidden = false;
+      document.getElementById("hrSlider").hidden = false;
       document.getElementById("hrValue").hidden = false;
     }
     else {
-      document.getElementById("HRSlider").hidden = true;
+      document.getElementById("hrSlider").hidden = true;
       document.getElementById("hrValue").hidden = true;
     }
     if (updateServer) {
       var xhr = new XMLHttpRequest();
       if (element.checked) {
-        xhr.open("GET", "/hrslider?value=enable", true);
+        xhr.open("GET", "/hrSlider?value=enable", true);
         xhr.send();
       }
       else {
-        xhr.open("GET", "/hrslider?value=disable", true);
+        xhr.open("GET", "/hrSlider?value=disable", true);
         xhr.send();
       }
     }
@@ -68,12 +96,15 @@ <h2>Sim CAD Output</h2>
 
   function toggleWattsCheckbox(element, updateServer) {
     if (element.checked) {
-      document.getElementById("WattsSlider").hidden = false;
+      document.getElementById("wattsSlider").hidden = false;
       document.getElementById("wattsValue").hidden = false;
     }
     else {
-      document.getElementById("WattsSlider").hidden = true;
+      document.getElementById("wattsSlider").hidden = true;
       document.getElementById("wattsValue").hidden = true;
+      if (!!pwrTimer) {
+        clearInterval(pwrTimer);
+      }
     }
 
     if (updateServer) {
@@ -91,11 +122,11 @@ <h2>Sim CAD Output</h2>
 
   function toggleCadCheckbox(element, updateServer) {
     if (element.checked) {
-      document.getElementById("CadSlider").hidden = false;
+      document.getElementById("cadSlider").hidden = false;
       document.getElementById("cadValue").hidden = false;
     }
     else {
-      document.getElementById("CadSlider").hidden = true;
+      document.getElementById("cadSlider").hidden = true;
       document.getElementById("cadValue").hidden = true;
     }
 
@@ -112,36 +143,72 @@ <h2>Sim CAD Output</h2>
     }
   }
 
-  function updateHRSlider(element) {
-    var sliderValue = document.getElementById("HRSlider").value;
+  function updateHrSlider() {
+    var sliderValue = document.getElementById("hrSlider").value;
     document.getElementById("hrValue").innerHTML = sliderValue + " BPM";
     var xhr = new XMLHttpRequest();
-    xhr.open("GET", "/hrslider?value=" + sliderValue, true);
+    xhr.open("GET", "/hrSlider?value=" + sliderValue, true);
     xhr.send();
   }
 
-  function updateWattsSlider(element) {
-    var sliderValue = document.getElementById("WattsSlider").value;
+  function updateWattsSlider() {
+    var sliderValue = document.getElementById("wattsSlider").value;
     document.getElementById("wattsValue").innerHTML = sliderValue + " Watts";
     var xhr = new XMLHttpRequest();
     xhr.open("GET", "/wattsslider?value=" + sliderValue, true);
     xhr.send();
   }
 
-  function updateCadSlider(element) {
-    var sliderValue = document.getElementById("CadSlider").value;
+  function updateCadSlider() {
+    var sliderValue = document.getElementById("cadSlider").value;
     document.getElementById("cadValue").innerHTML = sliderValue + " RPM";
     var xhr = new XMLHttpRequest();
     xhr.open("GET", "/cadslider?value=" + sliderValue, true);
     xhr.send();
   }
 
-  //Update values on specified interval
-  setInterval(function () {
+  function updateTargetWattsSlider() {
+    var sliderValue = document.getElementById("targetWattsSlider").value;
+    document.getElementById("targetWattsValue").innerHTML = sliderValue + " Watts";
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", "/targetwattsslider?value=" + sliderValue, true);
+    xhr.send();
+  }
 
-    requestConfigValues();
+  function toggleTargetWattsCheckbox(element, updateServer) {
+    if (element.checked) {
+      document.getElementById("targetWattsSlider").hidden = false;
+      document.getElementById("targetWattsValue").hidden = false;
+    }
+    else {
+      document.getElementById("targetWattsSlider").hidden = true;
+      document.getElementById("targetWattsValue").hidden = true;
+    }
 
-  }, 2000);
+    if (updateServer) {
+      var xhr = new XMLHttpRequest();
+      if (element.checked) {
+        xhr.open("GET", "/targetwattsslider?value=enable", true);
+        xhr.send();
+      }
+      else {
+        xhr.open("GET", "/targetwattsslider?value=disable", true);
+        xhr.send();
+      }
+    }
+  }
+
+  function toggleEnableErgCheckbox(element) {
+    var xhr = new XMLHttpRequest();
+    if (element.checked) {
+      xhr.open("GET", "/ergmode?value=enable", true);
+      xhr.send();
+    }
+    else {
+      xhr.open("GET", "/ergmode?value=disable", true);
+      xhr.send();
+    }
+  }
 
   function requestConfigValues() {
     var xhttp = new XMLHttpRequest();
@@ -149,27 +216,40 @@ <h2>Sim CAD Output</h2>
       if (this.readyState == 4 && this.status == 200) {
         var obj = JSON.parse(this.responseText);
         document.getElementById("wattsValue").innerHTML = obj.simulatedWatts + " Watts";
-        document.getElementById("WattsSlider").value = obj.simulatedWatts;
+        document.getElementById("wattsSlider").value = obj.simulatedWatts;
         document.getElementById("wattsOutput").checked = obj.simulateWatts;
-        document.getElementById("WattsSlider").hidden = !obj.simulateWatts;
+        document.getElementById("wattsSlider").hidden = !obj.simulateWatts;
         document.getElementById("wattsValue").hidden = !obj.simulateWatts;
 
         document.getElementById("hrValue").innerHTML = obj.simulatedHr + " BPM";
-        document.getElementById("HRSlider").value = obj.simulatedHr;
+        document.getElementById("hrSlider").value = obj.simulatedHr;
         document.getElementById("hrOutput").checked = obj.simulateHr;
-        document.getElementById("HRSlider").hidden = !obj.simulateHr;
+        document.getElementById("hrSlider").hidden = !obj.simulateHr;
         document.getElementById("hrValue").hidden = !obj.simulateHr;
 
         document.getElementById("cadValue").innerHTML = obj.simulatedCad + " RPM";
-        document.getElementById("CadSlider").value = obj.simulatedCad;
+        document.getElementById("cadSlider").value = obj.simulatedCad;
         document.getElementById("cadOutput").checked = obj.simulateCad;
-        document.getElementById("CadSlider").hidden = !obj.simulateCad;
+        document.getElementById("cadSlider").hidden = !obj.simulateCad;
         document.getElementById("cadValue").hidden = !obj.simulateCad;
 
-        setTimeout(function () { document.getElementById("loadingWatermark").remove(); }, 1000);
+        document.getElementById("enableErgCheckbox").checked = obj.ERGMode;
+
+        document.getElementById("targetWattsValue").innerHTML = obj.targetWatts + " Watts";
+        document.getElementById("targetWattsSlider").value = obj.targetWatts == null ? 0 : obj.targetWatts;
+        document.getElementById("targetWattsOutput").checked = obj.simulateTargetWatts;
+        document.getElementById("targetWattsSlider").hidden = !obj.simulateTargetWatts;
+        document.getElementById("targetWattsValue").hidden = !obj.simulateTargetWatts;
+
+        setTimeout(function () {
+          const watermark = document.getElementById("loadingWatermark");
+          if (!!watermark) {
+            document.getElementById("loadingWatermark")?.remove();
+          }
+        }, 1000);
       }
     };
-    xhttp.open("GET", "/configJSON", true);
+    xhttp.open("GET", "/runtimeConfigJSON", true);
     xhttp.send();
   }
 
diff --git a/data/settings.html b/data/settings.html
index 3eb1e491..01577682 100644
--- a/data/settings.html
+++ b/data/settings.html
@@ -97,8 +97,8 @@ <h2>
                 <input type='button' onclick="clickStep(document.getElementById('ERGSensitivity'), this.value)"
                   value="-">
                 <input style="width:50%; position: relative; top: 5px;" type="range" id="ERGSensitivity"
-                  name="ERGSensitivity" value="1.0" min=".5" max="5" step=".1" class="slider1"
-                  onchange="updateSlider(this, document.getElementById('ERGSensitivityValue'))" />
+                  name="ERGSensitivity" value="1.0" min=".5" max="20" step=".1" class="slider1"
+                  onchange="updateSlider(this.value, document.getElementById('ERGSensitivityValue'))" />
                 <input type='button' onclick="clickStep(document.getElementById('ERGSensitivity'), this.value)"
                   value="+">
               </td>
@@ -140,7 +140,7 @@ <h2>
             </tr>
           </tbody>
         </table>
-        <input type="submit" value="Submit" />
+        <input type="submit" value="Save Settings" />
       </form>
       <p></p>
       <form action="/reboot.html">
diff --git a/data/shift.html b/data/shift.html
index b33cf77a..a44f0307 100644
--- a/data/shift.html
+++ b/data/shift.html
@@ -68,7 +68,7 @@ <h1>Shift</h1>
                 }
             }
         };
-        xhttp.open("GET", "/configJSON", true);
+        xhttp.open("GET", "/runtimeConfigJSON", true);
         xhttp.send();
     }
 
diff --git a/include/BLE_Common.h b/include/BLE_Common.h
index c3f34290..c6d93149 100644
--- a/include/BLE_Common.h
+++ b/include/BLE_Common.h
@@ -77,7 +77,7 @@ extern SpinBLEServer spinBLEServer;
 
 void startBLEServer();
 bool spinDown();
-void computeERG(int = 0);
+// void computeERG(int = 0);
 void computeCSC();
 void logCharacteristic(char *buffer, const size_t bufferCapacity, const byte *data, const size_t dataLength, const NimBLEUUID serviceUUID, const NimBLEUUID charUUID,
                        const char *format, ...);
diff --git a/include/ERG_Mode.h b/include/ERG_Mode.h
new file mode 100644
index 00000000..f78e8023
--- /dev/null
+++ b/include/ERG_Mode.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2020  Anthony Doud & Joel Baranick
+ * All rights reserved
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ */
+
+#pragma once
+
+#include "settings.h"
+#include "SmartSpin_parameters.h"
+
+#define ERG_MODE_LOG_TAG     "ERG_Mode"
+#define ERG_MODE_LOG_CSV_TAG "ERG_Mode_CSV"
+#define POWERTABLE_LOG_TAG   "PowTab"
+#define ERG_MODE_DELAY       700
+
+extern TaskHandle_t ErgTask;
+void setupERG();
+void ergTaskLoop(void *pvParameters);
+
+class ErgMode {
+ public:
+  void computErg(int newSetpoint);
+  void _writeLogHeader();
+  void _writeLog(int cycles, float currentIncline, float newIncline, int currentSetPoint, int newSetPoint, int currentWatts, int newWatts, int currentCadence, int newCadence);
+
+ private:
+  bool engineStopped  = false;
+  bool initialized    = false;
+  int setPoint        = 0;
+  int cycles          = 0;
+  int offsetMuliplier = 0;
+  Measurement watts   = Measurement(0);
+  int cadence         = 0;
+
+  bool _userIsSpinning(int cadence, float incline);
+};
+
+class PowerEntry {
+ public:
+  int watts;
+  int32_t targetPosition;
+  int cad;
+  int readings;
+
+  PowerEntry() {
+    this->watts    = 0;
+    this->targetPosition = 0;
+    this->cad      = 0;
+    this->readings = 0;
+  }
+};
+
+class PowerBuffer {
+  public:
+  PowerEntry powerEntry[POWER_SAMPLES];
+  void set(int);
+  void reset();
+};
+
+class PowerTable {
+ public:
+  PowerEntry powerEntry[POWERTABLE_SIZE];
+  
+  // Catalogs a new entry into the power table.
+  void newEntry(PowerBuffer powerBuffer);
+  
+  // returns incline for wattTarget. Null if not found.
+  int32_t lookup(int watts, int cad);
+  
+  // load power table from spiffs
+  bool load();
+  
+  // save powertable from spiffs
+  bool save();
+  
+  // Display power table in log
+  void toLog();
+};
diff --git a/include/Main.h b/include/Main.h
index 0eee8a5b..d1ab833b 100644
--- a/include/Main.h
+++ b/include/Main.h
@@ -27,13 +27,27 @@ void updateStepperPower();
 void updateStealthchop();
 void checkDriverTemperature();
 void motorStop(bool releaseTension = false);
+void startTasks();
+void stopTasks();
 
 // Main program variable that stores most everything
 extern userParameters userConfig;
-extern int32_t targetPosition;
-extern bool externalControl;
-extern bool syncMode;
+extern RuntimeParameters rtConfig;
+
+class SS2K {
+ public:
+  int32_t targetPosition;
+  bool externalControl;
+  bool syncMode;
+
+  SS2K() {
+    targetPosition  = 0;
+    externalControl = false;
+    syncMode        = false;
+  }
+};
 
 // Users Physical Working Capacity Calculation Parameters (heartrate to Power
 // calculation)
 extern physicalWorkingCapacity userPWC;
+extern SS2K ss2k;
diff --git a/include/SS2KLog.h b/include/SS2KLog.h
index a792f7fc..5daa82e0 100644
--- a/include/SS2KLog.h
+++ b/include/SS2KLog.h
@@ -7,6 +7,8 @@
 
 #pragma once
 
+#ifndef UNIT_TEST
+
 #include "sdkconfig.h"
 #include "esp_log.h"
 #include <stdio.h>
@@ -103,3 +105,6 @@ void ss2k_log_write(esp_log_level_t level, const char *format, ...);
 
 void ss2k_log_writev(esp_log_level_t level, const char *format, va_list args);
 
+#else
+
+#endif
\ No newline at end of file
diff --git a/include/SmartSpin_parameters.h b/include/SmartSpin_parameters.h
index a770bf35..fd812f04 100644
--- a/include/SmartSpin_parameters.h
+++ b/include/SmartSpin_parameters.h
@@ -7,88 +7,133 @@
 
 #pragma once
 
+#ifndef UNIT_TEST
 #include <Arduino.h>
+#else
+#include <ArduinoFake.h>
+#endif
 
 #define CONFIG_LOG_TAG "Config"
 
+class Measurement {
+ public:
+  int value;
+  long timestamp;
+
+  Measurement(int value) {
+    this->value     = value;
+    this->timestamp = millis();
+  }
+};
+
+class RuntimeParameters {
+ private:
+  float targetIncline        = 0.0;
+  float currentIncline       = 0.0;
+  int targetWatts            = 0;
+  Measurement simulatedWatts = Measurement(0);
+  int simulatedHr            = 0;
+  int simulatedCad           = 0;
+  float simulatedSpeed       = 0.0;
+  bool simulateHr            = false;
+  bool simulateWatts         = false;
+  bool simulateTargetWatts   = false;
+  bool simulateCad           = false;
+  bool ERGMode               = false;
+  int shifterPosition        = 0;
+  String foundDevices        = " ";
+
+ public:
+  void setTargetIncline(float inc) { targetIncline = inc; }
+  float getTargetIncline() { return targetIncline; }
+
+  void setCurrentIncline(float inc) { currentIncline = inc; }
+  float getCurrentIncline() { return currentIncline; }
+
+  void setTargetWatts(int w) { targetWatts = w; }
+  int getTargetWatts() { return targetWatts; }
+
+  void setSimulatedWatts(int w) { simulatedWatts = Measurement(w); }
+  Measurement getSimulatedWatts() { return simulatedWatts; }
+
+  void setSimulatedHr(int hr) { simulatedHr = hr; }
+  int getSimulatedHr() { return simulatedHr; }
+
+  void setSimulatedCad(float cad) { simulatedCad = cad; }
+  int getSimulatedCad() { return simulatedCad; }
+
+  void setSimulatedSpeed(float spd) { simulatedSpeed = spd; }
+  float getSimulatedSpeed() { return simulatedSpeed; }
+
+  void setSimulateHr(bool shr) { simulateHr = shr; }
+  bool getSimulateHr() { return simulateHr; }
+
+  void setSimulateWatts(bool swt) { simulateWatts = swt; }
+  bool getSimulateWatts() { return simulateWatts; }
+
+  void setSimulateTargetWatts(bool swt) { simulateTargetWatts = swt; }
+  bool getSimulateTargetWatts() { return simulateTargetWatts; }
+
+  void setSimulateCad(bool scd) { simulateCad = scd; }
+  bool getSimulateCad() { return simulateCad; }
+
+  void setERGMode(bool erg) { ERGMode = erg; }
+  bool getERGMode() { return ERGMode; }
+
+  void setShifterPosition(int sp) { shifterPosition = sp; }
+  int getShifterPosition() { return shifterPosition; }
+
+  void setFoundDevices(String fdev) { foundDevices = fdev; }
+  const char* getFoundDevices() { return foundDevices.c_str(); }
+
+  String returnJSON(bool includeDebugLog = false);
+};
+
 class userParameters {
  private:
   String firmwareUpdateURL;
-  float incline;
-  int simulatedWatts;
-  int simulatedHr;
-  int simulatedCad;
-  float simulatedSpeed;
   String deviceName;
   int shiftStep;
-  int stepperPower;
   bool stealthchop;
   float inclineMultiplier;
   float powerCorrectionFactor;
-  bool simulateHr;
-  bool simulateWatts;
-  bool simulateCad;
-  bool ERGMode;
   float ERGSensitivity;
   bool autoUpdate;
+  int stepperPower;
   String ssid;
   String password;
-  String foundDevices          = " ";
   String connectedPowerMeter   = "any";
   String connectedHeartMonitor = "any";
-  int shifterPosition;
 
  public:
   const char* getFirmwareUpdateURL() { return firmwareUpdateURL.c_str(); }
-  float getIncline() { return incline; }
-  int getSimulatedWatts() { return simulatedWatts; }
-  int getSimulatedHr() { return simulatedHr; }
-  int getSimulatedCad() { return simulatedCad; }
-  float getSimulatedSpeed() { return simulatedSpeed; }
   const char* getDeviceName() { return deviceName.c_str(); }
   int getShiftStep() { return shiftStep; }
-  int getStepperPower() { return stepperPower; }
   bool getStealthchop() { return stealthchop; }
   float getInclineMultiplier() { return inclineMultiplier; }
   float getPowerCorrectionFactor() { return powerCorrectionFactor; }
-  bool getSimulateHr() { return simulateHr; }
-  bool getSimulateWatts() { return simulateWatts; }
-  bool getSimulateCad() { return simulateCad; }
-  bool getERGMode() { return ERGMode; }
   float getERGSensitivity() { return ERGSensitivity; }
   bool getautoUpdate() { return autoUpdate; }
   const char* getSsid() { return ssid.c_str(); }
   const char* getPassword() { return password.c_str(); }
-  const char* getFoundDevices() { return foundDevices.c_str(); }
   const char* getconnectedPowerMeter() { return connectedPowerMeter.c_str(); }
   const char* getconnectedHeartMonitor() { return connectedHeartMonitor.c_str(); }
-  int getShifterPosition() { return shifterPosition; }
+  int getStepperPower() { return stepperPower; }
 
   void setDefaults();
   void setFirmwareUpdateURL(String fURL) { firmwareUpdateURL = fURL; }
-  void setIncline(float inc) { incline = inc; }
-  void setSimulatedWatts(int w) { simulatedWatts = w; }
-  void setSimulatedHr(int hr) { simulatedHr = hr; }
-  void setSimulatedCad(float cad) { simulatedCad = cad; }
-  void setSimulatedSpeed(float spd) { simulatedSpeed = spd; }
   void setDeviceName(String dvcn) { deviceName = dvcn; }
   void setShiftStep(int ss) { shiftStep = ss; }
-  void setStepperPower(int sp) { stepperPower = sp; }
   void setStealthChop(bool sc) { stealthchop = sc; }
   void setInclineMultiplier(float im) { inclineMultiplier = im; }
   void setPowerCorrectionFactor(float pm) { powerCorrectionFactor = pm; }
-  void setSimulateHr(bool shr) { simulateHr = shr; }
-  void setSimulateWatts(bool swt) { simulateWatts = swt; }
-  void setSimulateCad(bool scd) { simulateCad = scd; }
-  void setERGMode(bool erg) { ERGMode = erg; }
   void setERGSensitivity(float ergS) { ERGSensitivity = ergS; }
   void setAutoUpdate(bool atupd) { autoUpdate = atupd; }
   void setSsid(String sid) { ssid = sid; }
   void setPassword(String pwd) { password = pwd; }
-  void setFoundDevices(String fdev) { foundDevices = fdev; }
   void setConnectedPowerMeter(String cpm) { connectedPowerMeter = cpm; }
   void setConnectedHeartMonitor(String cHr) { connectedHeartMonitor = cHr; }
-  void setShifterPosition(int sp) { shifterPosition = sp; }
+  void setStepperPower(int sp) { stepperPower = sp; }
 
   String returnJSON(bool includeDebugLog = false);
   void saveToSPIFFS();
diff --git a/include/settings.h b/include/settings.h
index b05c2f7e..87f924b6 100644
--- a/include/settings.h
+++ b/include/settings.h
@@ -122,7 +122,7 @@
 #define MAX_SCAN_RETRIES 1
 
 // loop speed for the SmartSpin2k BLE communications
-#define BLE_NOTIFY_DELAY 701
+#define BLE_NOTIFY_DELAY 700
 
 // loop speed for the SmartSpin2k BLE Client reconnect
 #define BLE_CLIENT_DELAY 1000
@@ -154,6 +154,17 @@
 // Max size of userconfig
 #define USERCONFIG_JSON_SIZE 768 + DEBUG_LOG_BUFFER_SIZE
 
+#define RUNTIMECONFIG_JSON_SIZE 512
+
+// Number of entries in the ERG Power Lookup Table
+#define POWERTABLE_SIZE 20
+
+// Size of increments (in watts) for the ERG Lookup Table. Needs to be one decimal place for proper calculations i.e. 50.0
+#define POWERTABLE_INCREMENT 50.0
+
+//Number of similar power samples to take before writing to the Power Table
+#define POWER_SAMPLES 5 
+
 // Uncomment to enable sending Telegram debug messages back to the chat
 // specified in telegram_token.h
 // #define USE_TELEGRAM
diff --git a/platformio.ini b/platformio.ini
index 54fbc48d..4c7e626a 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -54,6 +54,7 @@ check_skip_packages = true
 [env:native]
 platform = native
 lib_deps = 
+    ArduinoFake
 	lib/ArduinoCompat
 	lib/SS2K
 build_flags =
diff --git a/src/BLE_Client.cpp b/src/BLE_Client.cpp
index 4dc118b2..9a1e8c18 100644
--- a/src/BLE_Client.cpp
+++ b/src/BLE_Client.cpp
@@ -211,7 +211,7 @@ bool SpinBLEClient::connectToServer() {
   pClient->setConnectTimeout(5);
   pClient->connect(myDevice->getAddress());  // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
   SS2K_LOG(BLE_CLIENT_LOG_TAG, " - Connected to server");
-  SS2K_LOG(BLE_CLIENT_LOG_TAG, " - RSSI %d", pClient->getRssi());
+  //SS2K_LOG(BLE_CLIENT_LOG_TAG, " - RSSI %d", pClient->getRssi());
   // Obtain a reference to the service we are after in the remote BLE server.
   BLERemoteService *pRemoteService = pClient->getService(serviceUUID);
   if (pRemoteService == nullptr) {
@@ -420,7 +420,7 @@ void SpinBLEClient::scanProcess() {
 #ifdef USE_TELEGRAM
   SEND_TO_TELEGRAM("Bluetooth Client Found Devices: " + output);
 #endif
-  userConfig.setFoundDevices(output);
+  rtConfig.setFoundDevices(output);
   pBLEScan = nullptr;  // free up memory
 }
 
diff --git a/src/BLE_Common.cpp b/src/BLE_Common.cpp
index 164f8020..96cd1aec 100644
--- a/src/BLE_Common.cpp
+++ b/src/BLE_Common.cpp
@@ -68,27 +68,27 @@ void BLECommunications(void *pvParameters) {
                       pRemoteBLECharacteristic->getUUID(), (uint64_t)pRemoteBLECharacteristic->getRemoteService()->getClient()->getPeerAddress(), pData, length);
 
                   logBufLength += snprintf(logBuf + logBufLength, kLogBufMaxLength - logBufLength, " | %s[", sensorData->getId().c_str());
-                  if (sensorData->hasHeartRate() && !userConfig.getSimulateHr()) {
+                  if (sensorData->hasHeartRate() && !rtConfig.getSimulateHr()) {
                     int heartRate = sensorData->getHeartRate();
-                    userConfig.setSimulatedHr(heartRate);
+                    rtConfig.setSimulatedHr(heartRate);
                     spinBLEClient.connectedHR |= true;
                     logBufLength += snprintf(logBuf + logBufLength, kLogBufMaxLength - logBufLength, " HR(%d)", heartRate % 1000);
                   }
-                  if (sensorData->hasCadence() && !userConfig.getSimulateCad()) {
+                  if (sensorData->hasCadence() && !rtConfig.getSimulateCad()) {
                     float cadence = sensorData->getCadence();
-                    userConfig.setSimulatedCad(cadence);
+                    rtConfig.setSimulatedCad(cadence);
                     spinBLEClient.connectedCD |= true;
                     logBufLength += snprintf(logBuf + logBufLength, kLogBufMaxLength - logBufLength, " CD(%.2f)", fmodf(cadence, 1000.0));
                   }
-                  if (sensorData->hasPower() && !userConfig.getSimulateWatts()) {
+                  if (sensorData->hasPower() && !rtConfig.getSimulateWatts()) {
                     int power = sensorData->getPower() * userConfig.getPowerCorrectionFactor();
-                    userConfig.setSimulatedWatts(power);
+                    rtConfig.setSimulatedWatts(power);
                     spinBLEClient.connectedPM |= true;
                     logBufLength += snprintf(logBuf + logBufLength, kLogBufMaxLength - logBufLength, " PW(%d)", power % 10000);
                   }
                   if (sensorData->hasSpeed()) {
                     float speed = sensorData->getSpeed();
-                    userConfig.setSimulatedSpeed(speed);
+                    rtConfig.setSimulatedSpeed(speed);
                     logBufLength += snprintf(logBuf + logBufLength, kLogBufMaxLength - logBufLength, " SD(%.2f)", fmodf(speed, 1000.0));
                   }
                   strncat(logBuf + logBufLength, " ]", kLogBufMaxLength - logBufLength);
@@ -111,7 +111,7 @@ void BLECommunications(void *pvParameters) {
     }
 
     // ***********************************SERVER**************************************
-    if ((spinBLEClient.connectedHR || userConfig.getSimulateHr()) && !spinBLEClient.connectedPM && !userConfig.getSimulateWatts() && (userConfig.getSimulatedHr() > 0) &&
+    if ((spinBLEClient.connectedHR || rtConfig.getSimulateHr()) && !spinBLEClient.connectedPM && !rtConfig.getSimulateWatts() && (rtConfig.getSimulatedHr() > 0) &&
         userPWC.hr2Pwr) {
       calculateInstPwrFromHR();
       hr2p = true;
@@ -122,12 +122,12 @@ void BLECommunications(void *pvParameters) {
     calculateInstPwrFromHR();
 #endif  // DEBUG_HR_TO_PWR
 
-    if (!spinBLEClient.connectedPM && !hr2p && !userConfig.getSimulateWatts() && !userConfig.getSimulateCad()) {
-      userConfig.setSimulatedCad(0);
-      userConfig.setSimulatedWatts(0);
+    if (!spinBLEClient.connectedPM && !hr2p && !rtConfig.getSimulateWatts() && !rtConfig.getSimulateCad()) {
+      rtConfig.setSimulatedCad(0);
+      rtConfig.setSimulatedWatts(0);
     }
-    if (!spinBLEClient.connectedHR && !userConfig.getSimulateHr()) {
-      userConfig.setSimulatedHr(0);
+    if (!spinBLEClient.connectedHR && !rtConfig.getSimulateHr()) {
+      rtConfig.setSimulatedHr(0);
     }
 
     if (connectedClientCount() > 0) {
@@ -142,18 +142,15 @@ void BLECommunications(void *pvParameters) {
       }
 
       processFTMSWrite();
-      computeERG();
+      // computeERG();
 
       if (updateConnParametersFlag) {
         vTaskDelay(100 / portTICK_PERIOD_MS);
         BLEDevice::getServer()->updateConnParams(bleConnDesc, 20, 100, 0, 2000);
         updateConnParametersFlag = false;
       }
-    } else {
-    }
-    if (connectedClientCount() == 0) {
-      digitalWrite(LED_PIN, LOW);  // blink if no client connected
     }
+
     if (BLEDevice::getAdvertising()) {
       if (!(BLEDevice::getAdvertising()->isAdvertising()) && (BLEDevice::getServer()->getConnectedCount() < CONFIG_BT_NIMBLE_MAX_CONNECTIONS - NUM_BLE_DEVICES)) {
         SS2K_LOG(BLE_COMMON_LOG_TAG, "Starting Advertising From Communication Loop");
@@ -161,9 +158,18 @@ void BLECommunications(void *pvParameters) {
       }
     }
 
-    vTaskDelay((BLE_NOTIFY_DELAY / 2) / portTICK_PERIOD_MS);
-    digitalWrite(LED_PIN, HIGH);
-    vTaskDelay((BLE_NOTIFY_DELAY / 2) / portTICK_PERIOD_MS);
+    // blink if no client connected
+    if (connectedClientCount() == 0) {
+      if ((millis() / 500) % 2 == 0) {
+        digitalWrite(LED_PIN, LOW);
+      } else {
+        digitalWrite(LED_PIN, HIGH);
+      }
+    } else {
+      digitalWrite(LED_PIN, HIGH);
+    }
+
+    vTaskDelay((BLE_NOTIFY_DELAY) / portTICK_PERIOD_MS);
 #ifdef DEBUG_STACK
     Serial.printf("BLEComm: %d \n", uxTaskGetStackHighWaterMark(BLECommunicationTask));
 #endif  // DEBUG_STACK
diff --git a/src/BLE_Server.cpp b/src/BLE_Server.cpp
index 3f454f6f..f74b2abe 100644
--- a/src/BLE_Server.cpp
+++ b/src/BLE_Server.cpp
@@ -206,72 +206,16 @@ bool spinDown() {
   return true;
 }
 
-// as a note, Trainer Road sends 50w target whenever the app is connected.
-void computeERG(int newSetPoint) {
-  // SS2K_LOG(BLE_SERVER_LOG_TAG, "ComputeERG. Setpoint: %d", newSetPoint);
-  if (userConfig.getERGMode() && spinBLEClient.connectedPM) {
-    // continue
-  } else {
-    // SS2K_LOG(BLE_SERVER_LOG_TAG, "ERG request but ERG off or no connected PM");
-    return;
-  }
-  static bool userIsPedaling = true;
-  static int setPoint        = 0;
-  float incline              = userConfig.getIncline();
-  float newIncline           = incline;
-  int amountToChangeIncline  = 0;
-  int wattChange             = userConfig.getSimulatedWatts() - setPoint;
-
-  if (newSetPoint > 0) {  // only update the value if new value is sent
-    setPoint = newSetPoint;
-  }
-  if (setPoint < 50) {  // minumum setPoint
-    setPoint = 50;
-  }
-
-  if (userConfig.getSimulatedCad() <= 20) {
-    if (!userIsPedaling) {  // Test so motor stop command only happens once.
-      motorStop();     // release tension
-      return;
-    }
-    userIsPedaling = false;
-    userConfig.setIncline(incline-userConfig.getShiftStep()*2);
-    // Cadence too low, nothing to do here
-    return;
-  }
-  userIsPedaling = true;
-
-  amountToChangeIncline = wattChange * userConfig.getERGSensitivity();
-  if (abs(wattChange) < WATTS_PER_SHIFT) {
-    // As the desired value gets closer, make smaller changes for a smoother experience
-    amountToChangeIncline *= SUB_SHIFT_SCALE;
-  }
-  // limit to 10 shifts at a time
-  if (abs(amountToChangeIncline) > userConfig.getShiftStep() * 2) {
-    if (amountToChangeIncline > 5) {
-      amountToChangeIncline = userConfig.getShiftStep() * 2;
-    }
-    if (amountToChangeIncline < -5) {
-      amountToChangeIncline = -(userConfig.getShiftStep() * 2);
-    }
-  }
-
-  // Reduce the amount per loop (don't try to oneshot it) and scale the movement the higher the watt target is as higher wattages require less knob movement.
-  // amountToChangeIncline = amountToChangeIncline / ((userConfig.getSimulatedWatts() / 100) + .1);  // +.1 to eliminate possible divide by zero.
-  newIncline            = incline - amountToChangeIncline;
-  userConfig.setIncline(newIncline);
-  // SS2K_LOG(BLE_SERVER_LOG_TAG, "newincline: %f", newIncline);
-}
 
 void updateIndoorBikeDataChar() {
-  float cadRaw = userConfig.getSimulatedCad();
+  float cadRaw = rtConfig.getSimulatedCad();
   int cad      = static_cast<int>(cadRaw * 2);
 
-  int watts = userConfig.getSimulatedWatts();
-  int hr    = userConfig.getSimulatedHr();
+  int watts = rtConfig.getSimulatedWatts().value;
+  int hr    = rtConfig.getSimulatedHr();
 
   int speed      = 0;
-  float speedRaw = userConfig.getSimulatedSpeed();
+  float speedRaw = rtConfig.getSimulatedSpeed();
   if (speedRaw <= 0) {
     float gearRatio = 1;
     speed           = ((cad * 2.75 * 2.08 * 60 * gearRatio) / 10);
@@ -299,7 +243,7 @@ void updateIndoorBikeDataChar() {
 }  // ^^Using the New Way of setting Bytes.
 
 void updateCyclingPowerMeasurementChar() {
-  int power = userConfig.getSimulatedWatts();
+  int power = rtConfig.getSimulatedWatts().value;
   int remainder, quotient;
   quotient                   = power / 256;
   remainder                  = power % 256;
@@ -307,7 +251,7 @@ void updateCyclingPowerMeasurementChar() {
   cyclingPowerMeasurement[3] = quotient;
   cyclingPowerMeasurementCharacteristic->setValue(cyclingPowerMeasurement, 9);
 
-  float cadence = userConfig.getSimulatedCad();
+  float cadence = rtConfig.getSimulatedCad();
   if (cadence > 0) {
     float crankRevPeriod = (60 * 1024) / cadence;
     spinBLEClient.cscCumulativeCrankRev++;
@@ -321,7 +265,7 @@ void updateCyclingPowerMeasurementChar() {
     remainder                  = spinBLEClient.cscLastCrankEvtTime % 256;
     cyclingPowerMeasurement[7] = remainder;
     cyclingPowerMeasurement[8] = quotient;
-  } 
+  }
 
   cyclingPowerMeasurementCharacteristic->notify();
 
@@ -334,7 +278,7 @@ void updateCyclingPowerMeasurementChar() {
 }
 
 void updateHeartRateMeasurementChar() {
-  int hr                  = userConfig.getSimulatedHr();
+  int hr                  = rtConfig.getSimulatedHr();
   heartRateMeasurement[1] = hr;
   heartRateMeasurementCharacteristic->setValue(heartRateMeasurement, 2);
   heartRateMeasurementCharacteristic->notify();
@@ -366,9 +310,7 @@ void MyServerCallbacks::onDisconnect(BLEServer *pServer) {
   BLEDevice::startAdvertising();
 }
 
-void MyCallbacks::onWrite(BLECharacteristic *pCharacteristic) {  
-  FTMSWrite = pCharacteristic->getValue();
-  }
+void MyCallbacks::onWrite(BLECharacteristic *pCharacteristic) { FTMSWrite = pCharacteristic->getValue(); }
 
 void processFTMSWrite() {
   if (FTMSWrite == "") {
@@ -394,7 +336,7 @@ void processFTMSWrite() {
       case 0x00:  // request control
         logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Control Request");
         returnValue[2] = 0x01;
-        //userConfig.setERGMode(false);
+        // userConfig.setERGMode(false);
         pCharacteristic->setValue(returnValue, 3);
         ftmsTrainingStatus[1] = 0x01;
         fitnessMachineTrainingStatus->setValue(ftmsTrainingStatus, 2);
@@ -405,9 +347,9 @@ void processFTMSWrite() {
       case 0x03: {  // inclination level setting - differs from sim mode as no negative numbers
         port = (rxValue[2] << 8) + rxValue[1];
         port *= 10;
-        userConfig.setIncline(port);
-        userConfig.setERGMode(false);
-        logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Incline Mode: %2f", userConfig.getIncline() / 100);
+        rtConfig.setTargetIncline(port);
+        rtConfig.setERGMode(false);
+        logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Incline Mode: %2f", rtConfig.getTargetIncline() / 100);
         returnValue[2]           = 0x01;
         uint8_t inclineStatus[3] = {0x06, (uint8_t)rxValue[1], (uint8_t)rxValue[2]};
         fitnessMachineStatusCharacteristic->setValue(inclineStatus, 3);
@@ -419,9 +361,9 @@ void processFTMSWrite() {
 
       case 0x04: {  // Resistance level setting
         int targetResistance = rxValue[1];
-        userConfig.setShifterPosition(targetResistance);
-        userConfig.setERGMode(false);
-        logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Resistance Mode: %d", userConfig.getShifterPosition());
+        rtConfig.setShifterPosition(targetResistance);
+        rtConfig.setERGMode(false);
+        logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Resistance Mode: %d", rtConfig.getShifterPosition());
         returnValue[2]              = 0x01;
         uint8_t resistanceStatus[2] = {0x07, rxValue[1]};
         fitnessMachineStatusCharacteristic->setValue(resistanceStatus, 3);
@@ -432,12 +374,14 @@ void processFTMSWrite() {
       } break;
 
       case 0x05: {  // Power Level Mode
-        if (spinBLEClient.connectedPM || userConfig.getSimulateWatts()) {
+        if (spinBLEClient.connectedPM || rtConfig.getSimulateWatts()) {
           int targetWatts = bytes_to_u16(rxValue[2], rxValue[1]);
-          userConfig.setERGMode(true);
-          computeERG(targetWatts);
+          rtConfig.setERGMode(true);
+          rtConfig.setTargetWatts(targetWatts);
+
+          // computeERG(targetWatts);
           logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> ERG Mode Target: %d Current: %d Incline: %2f", targetWatts,
-                                   userConfig.getSimulatedWatts(), userConfig.getIncline() / 100);
+                                   rtConfig.getSimulatedWatts().value, rtConfig.getTargetIncline() / 100);
           returnValue[2]       = 0x01;
           uint8_t ERGStatus[3] = {0x08, (uint8_t)rxValue[1], 0x01};
           fitnessMachineStatusCharacteristic->setValue(ERGStatus, 3);
@@ -468,9 +412,9 @@ void processFTMSWrite() {
         // int8_t rollingResistance = rxValue[5];
         // int8_t windResistance    = rxValue[6];
         port = bytes_to_u16(buf[1], buf[0]);
-        userConfig.setIncline(port);
-        logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Sim Mode Incline %2f", userConfig.getIncline() / 100);
-        userConfig.setERGMode(false);
+        rtConfig.setTargetIncline(port);
+        logBufLength += snprintf(logBuf + logBufLength, kLogBufCapacity - logBufLength, "-> Sim Mode Incline %2f", rtConfig.getTargetIncline() / 100);
+        rtConfig.setERGMode(false);
         returnValue[2]       = 0x01;
         uint8_t simStatus[7] = {0x12, (uint8_t)rxValue[1], (uint8_t)rxValue[2], (uint8_t)rxValue[3], (uint8_t)rxValue[4], (uint8_t)rxValue[5], (uint8_t)rxValue[6]};
         fitnessMachineStatusCharacteristic->setValue(simStatus, 7);
@@ -501,7 +445,7 @@ void processFTMSWrite() {
     SS2K_LOG(BLE_SERVER_LOG_TAG, "App wrote nothing ");
     SS2K_LOG(BLE_SERVER_LOG_TAG, "assuming it's a Control request");
     uint8_t controlPoint[3] = {0x80, 0x00, 0x01};
-    //userConfig.setERGMode(true);
+    // userConfig.setERGMode(true);
     pCharacteristic->setValue(controlPoint, 3);
     ftmsTrainingStatus[1] = 0x01;
     fitnessMachineTrainingStatus->setValue(ftmsTrainingStatus, 2);
@@ -522,11 +466,11 @@ int connectedClientCount() {
 }
 
 void calculateInstPwrFromHR() {
-  static int oldHR    = userConfig.getSimulatedHr();
-  static int newHR    = userConfig.getSimulatedHr();
+  static int oldHR    = rtConfig.getSimulatedHr();
+  static int newHR    = rtConfig.getSimulatedHr();
   static double delta = 0;
   oldHR               = newHR;  // Copying HR from Last loop
-  newHR               = userConfig.getSimulatedHr();
+  newHR               = rtConfig.getSimulatedHr();
 
   delta = (newHR - oldHR) / (BLE_CLIENT_DELAY / 1000);
 
@@ -547,8 +491,8 @@ void calculateInstPwrFromHR() {
   }
 
 #ifndef DEBUG_HR_TO_PWR
-  userConfig.setSimulatedWatts(avgP);
-  userConfig.setSimulatedCad(90);
+  rtConfig.setSimulatedWatts(avgP);
+  rtConfig.setSimulatedCad(90);
 #endif  // DEBUG_HR_TO_PWR
 
   SS2K_LOG(BLE_SERVER_LOG_TAG, "Power From HR: %d", avgP);
@@ -608,62 +552,62 @@ void ss2kCustomCharacteristicCallbacks::onWrite(BLECharacteristic *pCharacterist
     case BLE_incline: {  // 0x02
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        int inc        = userConfig.getIncline() * 100;
+        int inc        = rtConfig.getTargetIncline() * 100;
         returnValue[2] = (uint8_t)(inc & 0xff);
         returnValue[3] = (uint8_t)(inc >> 8);
         returnLength += 2;
       }
       if (rxValue[0] == write) {
-        userConfig.setIncline(bytes_to_u16(rxValue[3], rxValue[2]) / 100);
+        rtConfig.setTargetIncline(bytes_to_u16(rxValue[3], rxValue[2]) / 100);
       }
     } break;
 
     case BLE_simulatedWatts:  // 0x03
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getSimulatedWatts() & 0xff);
-        returnValue[3] = (uint8_t)(userConfig.getSimulatedWatts() >> 8);
+        returnValue[2] = (uint8_t)(rtConfig.getSimulatedWatts().value & 0xff);
+        returnValue[3] = (uint8_t)(rtConfig.getSimulatedWatts().value >> 8);
         returnLength += 2;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulatedWatts(bytes_to_u16(rxValue[3], rxValue[2]));
+        rtConfig.setSimulatedWatts(bytes_to_u16(rxValue[3], rxValue[2]));
       }
       break;
 
     case BLE_simulatedHr:  // 0x04
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getSimulatedHr() & 0xff);
-        returnValue[3] = (uint8_t)(userConfig.getSimulatedHr() >> 8);
+        returnValue[2] = (uint8_t)(rtConfig.getSimulatedHr() & 0xff);
+        returnValue[3] = (uint8_t)(rtConfig.getSimulatedHr() >> 8);
         returnLength += 2;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulatedHr(bytes_to_u16(rxValue[3], rxValue[2]));
+        rtConfig.setSimulatedHr(bytes_to_u16(rxValue[3], rxValue[2]));
       }
       break;
 
     case BLE_simulatedCad:  // 0x05
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getSimulatedCad() & 0xff);
-        returnValue[3] = (uint8_t)(userConfig.getSimulatedCad() >> 8);
+        returnValue[2] = (uint8_t)(rtConfig.getSimulatedCad() & 0xff);
+        returnValue[3] = (uint8_t)(rtConfig.getSimulatedCad() >> 8);
         returnLength += 2;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulatedCad(bytes_to_u16(rxValue[3], rxValue[2]));
+        rtConfig.setSimulatedCad(bytes_to_u16(rxValue[3], rxValue[2]));
       }
       break;
 
     case BLE_simulatedSpeed: {  // 0x06
       returnValue[0] = success;
-      int spd        = userConfig.getSimulatedSpeed() * 10;
+      int spd        = rtConfig.getSimulatedSpeed() * 10;
       if (rxValue[0] == read) {
         returnValue[2] = (uint8_t)(spd & 0xff);
         returnValue[3] = (uint8_t)(spd >> 8);
         returnLength += 2;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulatedSpeed(bytes_to_u16(rxValue[3], rxValue[2]) / 10);
+        rtConfig.setSimulatedSpeed(bytes_to_u16(rxValue[3], rxValue[2]) / 10);
       }
     } break;
 
@@ -737,44 +681,44 @@ void ss2kCustomCharacteristicCallbacks::onWrite(BLECharacteristic *pCharacterist
     case BLE_simulateHr:  // 0x0D
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getSimulateHr());
+        returnValue[2] = (uint8_t)(rtConfig.getSimulateHr());
         returnLength += 1;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulateHr(rxValue[2]);
+        rtConfig.setSimulateHr(rxValue[2]);
       }
       break;
 
     case BLE_simulateWatts:  // 0x0E
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getSimulateWatts());
+        returnValue[2] = (uint8_t)(rtConfig.getSimulateWatts());
         returnLength += 1;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulateWatts(rxValue[2]);
+        rtConfig.setSimulateWatts(rxValue[2]);
       }
       break;
 
     case BLE_simulateCad:  // 0x0F
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getSimulateCad());
+        returnValue[2] = (uint8_t)(rtConfig.getSimulateCad());
         returnLength += 1;
       }
       if (rxValue[0] == write) {
-        userConfig.setSimulateCad(rxValue[2]);
+        rtConfig.setSimulateCad(rxValue[2]);
       }
       break;
 
     case BLE_ERGMode:  // 0x10
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getERGMode());
+        returnValue[2] = (uint8_t)(rtConfig.getERGMode());
         returnLength += 1;
       }
       if (rxValue[0] == write) {
-        userConfig.setERGMode(rxValue[2]);
+        rtConfig.setERGMode(rxValue[2]);
       }
       break;
 
@@ -812,12 +756,12 @@ void ss2kCustomCharacteristicCallbacks::onWrite(BLECharacteristic *pCharacterist
     case BLE_shifterPosition:  // 0x17
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(userConfig.getShifterPosition() & 0xff);
-        returnValue[3] = (uint8_t)(userConfig.getShifterPosition() >> 8);
+        returnValue[2] = (uint8_t)(rtConfig.getShifterPosition() & 0xff);
+        returnValue[3] = (uint8_t)(rtConfig.getShifterPosition() >> 8);
         returnLength += 2;
       }
       if (rxValue[0] == write) {
-        userConfig.setShifterPosition(bytes_to_u16(rxValue[3], rxValue[2]));
+        rtConfig.setShifterPosition(bytes_to_u16(rxValue[3], rxValue[2]));
       }
       break;
 
@@ -829,36 +773,36 @@ void ss2kCustomCharacteristicCallbacks::onWrite(BLECharacteristic *pCharacterist
     case BLE_targetPosition:  // 0x19
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(targetPosition & 0xff);
-        returnValue[3] = (uint8_t)(targetPosition >> 8);
-        returnValue[4] = (uint8_t)(targetPosition >> 16);
-        returnValue[5] = (uint8_t)(targetPosition >> 24);
+        returnValue[2] = (uint8_t)(ss2k.targetPosition & 0xff);
+        returnValue[3] = (uint8_t)(ss2k.targetPosition >> 8);
+        returnValue[4] = (uint8_t)(ss2k.targetPosition >> 16);
+        returnValue[5] = (uint8_t)(ss2k.targetPosition >> 24);
         returnLength += 4;
       }
       if (rxValue[0] == write) {
-        targetPosition = (int32_t((uint8_t)(rxValue[2]) << 0 | (uint8_t)(rxValue[3]) << 8 | (uint8_t)(rxValue[4]) << 16 | (uint8_t)(rxValue[5]) << 24));
+        ss2k.targetPosition = (int32_t((uint8_t)(rxValue[2]) << 0 | (uint8_t)(rxValue[3]) << 8 | (uint8_t)(rxValue[4]) << 16 | (uint8_t)(rxValue[5]) << 24));
       }
       break;
 
     case BLE_externalControl:  // 0x1A
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(externalControl);
+        returnValue[2] = (uint8_t)(ss2k.externalControl);
         returnLength += 1;
       }
       if (rxValue[0] == write) {
-        externalControl = static_cast<bool>(rxValue[2]);
+        ss2k.externalControl = static_cast<bool>(rxValue[2]);
       }
       break;
 
     case BLE_syncMode:  // 0x1B
       returnValue[0] = success;
       if (rxValue[0] == read) {
-        returnValue[2] = (uint8_t)(syncMode);
+        returnValue[2] = (uint8_t)(ss2k.syncMode);
         returnLength += 1;
       }
       if (rxValue[0] == write) {
-        syncMode = static_cast<bool>(rxValue[2]);
+        ss2k.syncMode = static_cast<bool>(rxValue[2]);
       }
       break;
   }
@@ -871,8 +815,8 @@ void SpinBLEServer::notifyShift(bool upDown) {
   uint8_t returnValue[4];
   returnValue[0] = 0x80;
   returnValue[1] = BLE_shifterPosition;
-  returnValue[2] = (uint8_t)(userConfig.getShifterPosition() & 0xff);
-  returnValue[3] = (uint8_t)(userConfig.getShifterPosition() >> 8);
+  returnValue[2] = (uint8_t)(rtConfig.getShifterPosition() & 0xff);
+  returnValue[3] = (uint8_t)(rtConfig.getShifterPosition() >> 8);
   smartSpin2kCharacteristic->setValue(returnValue, 4);
   smartSpin2kCharacteristic->notify(true);
 }
diff --git a/src/ERG_Mode.cpp b/src/ERG_Mode.cpp
new file mode 100644
index 00000000..dd66c34f
--- /dev/null
+++ b/src/ERG_Mode.cpp
@@ -0,0 +1,383 @@
+/*
+ * Copyright (C) 2020  Anthony Doud & Joel Baranick
+ * All rights reserved
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ */
+
+#include "ERG_Mode.h"
+#include "SS2KLog.h"
+#include "Main.h"
+
+TaskHandle_t ErgTask;
+PowerTable powerTable;
+
+// Create a power table representing 0w-1000w in 50w increments.
+// i.e. powerTable[1] corresponds to the incline required for 50w. powerTable[2] is the incline required for 100w and so on.
+
+void setupERG() {
+  TaskHandle_t task_handle;
+  SS2K_LOG(ERG_MODE_LOG_TAG, "Starting ERG Mode task...");
+  xTaskCreatePinnedToCore(ergTaskLoop,   /* Task function. */
+                          "ERGModeTask", /* name of task. */
+                          6500,          /* Stack size of task*/
+                          NULL,          /* parameter of the task */
+                          1,             /* priority of the task*/
+                          &ErgTask,      /* Task handle to keep track of created task */
+                          0);            /* pin task to core 0 */
+
+  SS2K_LOG(ERG_MODE_LOG_TAG, "ERG Mode task started");
+}
+
+void ergTaskLoop(void* pvParameters) {
+  ErgMode ergMode;
+  PowerBuffer powerBuffer;
+
+  ergMode._writeLogHeader();
+  int newSetPoint             = rtConfig.getTargetWatts();
+  bool isInErgMode            = rtConfig.getERGMode();
+  bool hasConnectedPowerMeter = spinBLEClient.connectedPM;
+  bool simulationRunning      = rtConfig.getSimulateTargetWatts();
+  while (true) {
+    vTaskDelay(ERG_MODE_DELAY / portTICK_PERIOD_MS);
+    newSetPoint            = rtConfig.getTargetWatts();
+    isInErgMode            = rtConfig.getERGMode();
+    hasConnectedPowerMeter = spinBLEClient.connectedPM;
+    simulationRunning      = rtConfig.getSimulateTargetWatts();
+
+    if ((rtConfig.getSimulatedCad() > 50) && (rtConfig.getSimulatedWatts().value > 10) && (rtConfig.getSimulatedWatts().value < POWERTABLE_SIZE * POWERTABLE_INCREMENT)) {
+      if (powerBuffer.powerEntry[0].readings == 0) {
+        powerBuffer.set(0);  // Take Initial reading
+      } else if (abs(powerBuffer.powerEntry[0].watts - rtConfig.getSimulatedWatts().value) < POWERTABLE_INCREMENT) {
+        for (int i = 1; i < POWER_SAMPLES; i++) {
+          if (powerBuffer.powerEntry[i].readings == 0) {
+            powerBuffer.set(i);  // Add additional readings to the buffer.
+            break;
+          }
+        }
+        if (powerBuffer.powerEntry[POWER_SAMPLES - 1].readings == 1) {  // If buffer is full, create a new table entry and clear the buffer.
+          powerTable.newEntry(powerBuffer);
+          powerTable.toLog();
+          powerBuffer.reset();
+        }
+      } else {  // Reading was outside the range - clear the buffer and start over.
+        powerBuffer.reset();
+      }
+    }
+
+    if (isInErgMode && (hasConnectedPowerMeter || simulationRunning)) {
+      ergMode.computErg(newSetPoint);
+    } else {
+      if (newSetPoint > 0) {  // reset ERG state
+        SS2K_LOG(ERG_MODE_LOG_TAG, "Resetting Target Watts to 0");
+        rtConfig.setTargetWatts(0);
+        rtConfig.setERGMode(false);
+      }
+    }
+
+#ifdef DEBUG_STACK
+    Serial.printf("ERG Task: %d \n", uxTaskGetStackHighWaterMark(ErgTask));
+#endif  // DEBUG_STACK
+
+    // collect bike charateristics
+    // if (hasConnectedPowerMeter) {
+    //   float incline = rtConfig.getCurrentIncline();
+    //   int cadence   = rtConfig.getSimulatedCad();
+    //   int power     = rtConfig.getSimulatedWatts().value;
+    //   SS2K_LOG(ERG_MODE_LOG_TAG, "Bike characteristics: INC: %f; CAD: %d; PWR: %d", incline, cadence, power);
+    // }
+  }
+}
+
+void PowerBuffer::set(int i) {
+  this->powerEntry[i].readings       = 1;
+  this->powerEntry[i].watts          = rtConfig.getSimulatedWatts().value;
+  this->powerEntry[i].cad            = rtConfig.getSimulatedCad();
+  this->powerEntry[i].targetPosition = ss2k.targetPosition;
+}
+
+void PowerBuffer::reset() {
+  for (int i = 0; i < POWER_SAMPLES; i++) {
+    this->powerEntry[i].readings       = 0;
+    this->powerEntry[i].watts          = 0;
+    this->powerEntry[i].cad            = 0;
+    this->powerEntry[i].targetPosition = 0;
+  }
+}
+
+// Accepts new data into the table and averages input by number of readings in the power entry.
+void PowerTable::newEntry(PowerBuffer powerBuffer) {
+  int watts              = 0;
+  int cad                = 0;
+  int32_t targetPosition = 0;
+
+  for (int i = 0; i < POWER_SAMPLES; i++) {
+    if (powerBuffer.powerEntry[i].readings == 0) {
+      // break if powerEntry is not set
+      break;
+    }
+
+    if (i == 0) {  // first loop -> assign values
+      watts          = powerBuffer.powerEntry[i].watts;
+      targetPosition = powerBuffer.powerEntry[i].targetPosition;
+      cad            = powerBuffer.powerEntry[i].cad;
+      continue;
+    }
+
+    // calculate average
+    watts          = (watts + powerBuffer.powerEntry[i].watts) / 2;
+    targetPosition = (targetPosition + powerBuffer.powerEntry[i].targetPosition) / 2;
+    cad            = (cad + powerBuffer.powerEntry[i].cad) / 2;
+  }
+
+  int i = round(watts / POWERTABLE_INCREMENT);
+
+  if (this->powerEntry[i].readings == 0) {  // if first reading in this entry
+    this->powerEntry[i].watts          = watts;
+    this->powerEntry[i].cad            = cad;
+    this->powerEntry[i].targetPosition = targetPosition;
+    this->powerEntry[i].readings       = 1;
+  } else {  // Average and update the readings.
+    this->powerEntry[i].watts          = (watts + (this->powerEntry[i].watts * this->powerEntry[i].readings)) / (this->powerEntry[i].readings + 1);
+    this->powerEntry[i].cad            = (cad + (this->powerEntry[i].cad * this->powerEntry[i].readings)) / (this->powerEntry[i].readings + 1);
+    this->powerEntry[i].targetPosition = (targetPosition + (this->powerEntry[i].targetPosition * this->powerEntry[i].readings)) / (this->powerEntry[i].readings + 1);
+    this->powerEntry[i].readings++;
+    if (this->powerEntry[i].readings > 10) {
+      this->powerEntry[i].readings = 10;  // keep from diluting recent readings too far.
+    }
+  }
+}
+
+// looks up an incline for the requested power and cadence and interpolates the result.
+// Returns -99 if no entry matched.
+int32_t PowerTable::lookup(int watts, int cad) {
+#define RETURN_ERROR -99
+  struct entry {
+    float power;
+    int32_t targetPosition;
+    float cad;
+  };
+
+  int i         = round(watts / POWERTABLE_INCREMENT);  // find the closest entry
+  float scale   = watts / POWERTABLE_INCREMENT - i;     // Should we look at the next higher or next lower index for comparison?
+  int indexPair = -1;                                   // The next closes index with data for interpolation
+  entry above;
+  entry below;
+  above.power = 0;
+  below.power = 0;
+
+  if (this->powerEntry[i].readings == 0) {  // If matching entry is empty, find the next closest index with data
+    for (int x = 1; x < POWERTABLE_SIZE; x++) {
+      if (i + x < POWERTABLE_SIZE) {
+        if (this->powerEntry[i + x].readings > 0) {
+          i += x;
+          break;
+        }
+      }
+      if (i - x >= 0) {
+        if (this->powerEntry[i - x].readings > 0) {
+          i -= x;
+          break;
+        }
+      }
+      if ((i - x <= 0) || (i + x >= POWERTABLE_SIZE)) {
+        SS2K_LOG(ERG_MODE_LOG_TAG, "No data found in powertable.");
+        return RETURN_ERROR;
+      }
+    }
+  }
+  if (scale > 0) {  // select the paired element (preferably) above the entry for interpolation
+    for (int x = 1; x < POWERTABLE_SIZE; x++) {
+      if (i + x < POWERTABLE_SIZE) {
+        if (this->powerEntry[i + x].readings > 0) {
+          indexPair = i + x;
+          break;
+        }
+      }
+      if (i - x >= 0) {
+        if (this->powerEntry[i - x].readings > 0) {
+          indexPair = i - x;
+          break;
+        }
+      }
+      if ((i - x <= 0) || (i + x >= POWERTABLE_SIZE)) {
+        SS2K_LOG(ERG_MODE_LOG_TAG, "No pair found in powertable.");
+        indexPair = -1;
+        break;
+      }
+    }
+  } else if (scale < 0) {  // select the paired element (preferably) below the entry for interpolation
+    for (int x = 1; x < POWERTABLE_SIZE; x++) {
+      if (i - x < POWERTABLE_SIZE) {
+        if (this->powerEntry[i + x].readings > 0) {
+          indexPair = i - x;
+          break;
+        }
+      }
+      if (i + x >= 0) {
+        if (this->powerEntry[i - x].readings > 0) {
+          indexPair = i + x;
+          break;
+        }
+      }
+      if ((i - x <= 0) || (i + x >= POWERTABLE_SIZE)) {
+        SS2K_LOG(ERG_MODE_LOG_TAG, "No pair found in powertable.");
+        indexPair = -1;
+        break;
+      }
+    }
+  }
+
+  if (indexPair != -1) {
+    if (i > indexPair) {
+      below.power          = this->powerEntry[indexPair].watts;
+      below.targetPosition = this->powerEntry[indexPair].targetPosition;
+      below.cad            = this->powerEntry[indexPair].cad;
+      above.power          = this->powerEntry[i].watts;
+      above.targetPosition = this->powerEntry[i].targetPosition;
+      above.cad            = this->powerEntry[i].cad;
+    } else if (i < indexPair) {
+      below.power          = this->powerEntry[i].watts;
+      below.targetPosition = this->powerEntry[i].targetPosition;
+      below.cad            = this->powerEntry[i].cad;
+      above.power          = this->powerEntry[indexPair].watts;
+      above.targetPosition = this->powerEntry[indexPair].targetPosition;
+      above.cad            = this->powerEntry[indexPair].cad;
+    }
+  } else {  // no pair so no interpolation and no CAD correction
+    return (this->powerEntry[i].targetPosition);
+  }
+
+  // @MarkusSchneider's data shows a linear relationship between CAD and Watts for a given resistance level.
+  // It looks like for every 20 CAD increase there is ~50w increase in power. This may need to be adjusted later
+  // as higher resistance levels have a steeper slope (bigger increase in power/cad) than low resistance levels.
+  float averageCAD = (below.cad + above.cad) / 2;
+  float deltaCAD   = abs(averageCAD - cad);
+
+  if (deltaCAD > 10) {
+    if (cad > averageCAD) {  // cad is higher than the table so we need to target a lower wattage (and targetPosition)
+      watts -= (deltaCAD / 20) * 50;
+    }
+    if (cad < averageCAD) {  // cad is lower than the table so we need to target a higher wattage (and targetPosition)
+      watts += (deltaCAD / 20) * 50;
+    }
+  }
+  // actual interpolation
+  int32_t rTargetPosition = below.targetPosition + ((watts - below.power) / (above.power - below.power)) * (above.targetPosition - below.targetPosition);
+
+  return rTargetPosition;
+}
+
+bool PowerTable::load() {
+  // load power table from spiffs
+  return false;  // return unsuccessful
+}
+
+bool PowerTable::save() {
+  // save powertable from spiffs
+  return false;  // return unsuccessful
+}
+
+// Display power table in log
+void PowerTable::toLog() {
+  char buffer[8];  // add code here to truncate the uint32_t value for display. Or change the value system wide to be a regular int since we probaby dont need that much anymore.
+  String oString = "";
+  int n;
+  char oFormat[5] = "|%6d";
+
+  for (int i = 0; i < POWERTABLE_SIZE; i++) {
+    n = sprintf(buffer, oFormat, this->powerEntry[i].watts);
+    oString += buffer;
+  }
+  SS2K_LOG(POWERTABLE_LOG_TAG, "%s|", oString.c_str());
+  oString = "";
+  for (int i = 0; i < POWERTABLE_SIZE; i++) {
+    n = sprintf(buffer, oFormat, this->powerEntry[i].cad);
+    oString += buffer;
+  }
+  SS2K_LOG(POWERTABLE_LOG_TAG, "%s|", oString.c_str());
+  oString = "";
+  for (int i = 0; i < POWERTABLE_SIZE; i++) {
+    n = sprintf(buffer, oFormat, this->powerEntry[i].targetPosition);
+    oString += buffer;
+  }
+  SS2K_LOG(POWERTABLE_LOG_TAG, "%s|", oString.c_str());
+}
+
+// as a note, Trainer Road sends 50w target whenever the app is connected.
+void ErgMode::computErg(int newSetPoint) {
+  Measurement newWatts = rtConfig.getSimulatedWatts();
+  float currentIncline = rtConfig.getCurrentIncline();
+  int newCadance       = rtConfig.getSimulatedCad();
+  int wattChange       = newSetPoint - newWatts.value;  // setpoint_form_trainer - current_power => Amount to increase or decrease incline
+  float diviation      = ((float)wattChange * 100.0) / ((float)newSetPoint);
+
+  if (watts.timestamp == newWatts.timestamp && this->setPoint == newSetPoint) {
+    return;  // no new power measurement.
+  }
+
+  // set minimum SetPoint to 50 watt if trainer sends setpoints lower than 50 watt.
+  if (newSetPoint < 50) {
+    newSetPoint = 50;
+  }
+
+  bool isUserSpinning = this->_userIsSpinning(newCadance, currentIncline);
+  if (!isUserSpinning) {
+    return;
+  }
+
+  // reset cycle counter to start new erg calculation cycle
+  if (this->setPoint != newSetPoint) {
+    this->cycles        = 0;
+    int32_t tableResult = powerTable.lookup(newSetPoint, newCadance);
+    if (tableResult != -99) {
+      SS2K_LOG(ERG_MODE_LOG_TAG, "Using PowerTable Result %d", tableResult);
+      rtConfig.setTargetIncline(tableResult);
+      // store for next cycle for timestamp and value compare
+      this->watts    = newWatts;
+      this->setPoint = newSetPoint;
+      this->cadence  = newCadance;
+      this->cycles++;
+      while (rtConfig.getTargetIncline() != rtConfig.getCurrentIncline()) {  // wait while the knob moves to target position.
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+      }
+      return;
+    }
+  }
+
+  float factor     = abs(diviation) > 10 ? userConfig.getERGSensitivity() : userConfig.getERGSensitivity() / 2;
+  float newIncline = currentIncline + (wattChange * factor);
+
+  rtConfig.setTargetIncline(newIncline);
+  _writeLog(this->cycles, currentIncline, newIncline, setPoint, newSetPoint, this->watts.value, newWatts.value, this->cadence, newCadance);
+
+  // store for next cycle for timestamp and value compare
+  this->watts    = newWatts;
+  this->setPoint = newSetPoint;
+  this->cadence  = newCadance;
+  this->cycles++;
+}
+
+bool ErgMode::_userIsSpinning(int cadance, float incline) {
+  if (cadance <= 20) {
+    if (!this->engineStopped) {                              // Test so motor stop command only happens once.
+      motorStop();                                           // release tension
+      rtConfig.setTargetIncline(incline - WATTS_PER_SHIFT);  // release incline
+      this->engineStopped = true;
+    }
+    return false;  // Cadence too low, nothing to do here
+  }
+
+  this->engineStopped = false;
+  return true;
+}
+
+void ErgMode::_writeLogHeader() {
+  SS2K_LOG(ERG_MODE_LOG_CSV_TAG, "cycles;current incline;new incline;current setpoint;new setpoint;current watts;new watts;current cadence;new cadence;");
+}
+
+void ErgMode::_writeLog(int cycles, float currentIncline, float newIncline, int currentSetPoint, int newSetPoint, int currentWatts, int newWatts, int currentCadence,
+                        int newCadence) {
+  SS2K_LOG(ERG_MODE_LOG_CSV_TAG, "%d;%.2f;%.2f;%d;%d;%d;%d;%d;%d", cycles, currentIncline, newIncline, currentSetPoint, newSetPoint, currentWatts, newWatts, currentCadence,
+           newCadence);
+}
diff --git a/src/HTTP_Server_Basic.cpp b/src/HTTP_Server_Basic.cpp
index c0d1fee6..bae43360 100644
--- a/src/HTTP_Server_Basic.cpp
+++ b/src/HTTP_Server_Basic.cpp
@@ -172,16 +172,16 @@ void startHttpServer() {
   server.on("/hrslider", []() {
     String value = server.arg("value");
     if (value == "enable") {
-      userConfig.setSimulateHr(true);
+      rtConfig.setSimulateHr(true);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "HR Simulator turned on");
     } else if (value == "disable") {
-      userConfig.setSimulateHr(false);
+      rtConfig.setSimulateHr(false);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "HR Simulator turned off");
     } else {
-      userConfig.setSimulatedHr(value.toInt());
-      SS2K_LOG(HTTP_SERVER_LOG_TAG, "HR is now: %d", userConfig.getSimulatedHr());
+      rtConfig.setSimulatedHr(value.toInt());
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "HR is now: %d", rtConfig.getSimulatedHr());
       server.send(200, "text/plain", "OK");
     }
   });
@@ -189,16 +189,16 @@ void startHttpServer() {
   server.on("/wattsslider", []() {
     String value = server.arg("value");
     if (value == "enable") {
-      userConfig.setSimulateWatts(true);
+      rtConfig.setSimulateWatts(true);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "Watt Simulator turned on");
     } else if (value == "disable") {
-      userConfig.setSimulateWatts(false);
+      rtConfig.setSimulateWatts(false);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "Watt Simulator turned off");
     } else {
-      userConfig.setSimulatedWatts(value.toInt());
-      SS2K_LOG(HTTP_SERVER_LOG_TAG, "Watts are now: %d", userConfig.getSimulatedWatts());
+      rtConfig.setSimulatedWatts(value.toInt());
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "Watts are now: %d", rtConfig.getSimulatedWatts().value);
       server.send(200, "text/plain", "OK");
     }
   });
@@ -206,16 +206,46 @@ void startHttpServer() {
   server.on("/cadslider", []() {
     String value = server.arg("value");
     if (value == "enable") {
-      userConfig.setSimulateCad(true);
+      rtConfig.setSimulateCad(true);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "CAD Simulator turned on");
     } else if (value == "disable") {
-      userConfig.setSimulateCad(false);
+      rtConfig.setSimulateCad(false);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "CAD Simulator turned off");
     } else {
-      userConfig.setSimulatedCad(value.toInt());
-      SS2K_LOG(HTTP_SERVER_LOG_TAG, "CAD is now: %f", userConfig.getSimulatedCad());
+      rtConfig.setSimulatedCad(value.toInt());
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "CAD is now: %d", rtConfig.getSimulatedCad());
+      server.send(200, "text/plain", "OK");
+    }
+  });
+
+  server.on("/ergmode", []() {
+    String value = server.arg("value");
+    if (value == "enable") {
+      rtConfig.setERGMode(true);
+      server.send(200, "text/plain", "OK");
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "ERG Mode turned on");
+    } else {
+      rtConfig.setERGMode(false);
+      server.send(200, "text/plain", "OK");
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "ERG Mode turned off");
+    }
+  });
+
+  server.on("/targetwattsslider", []() {
+    String value = server.arg("value");
+    if (value == "enable") {
+      rtConfig.setSimulateTargetWatts(true);
+      server.send(200, "text/plain", "OK");
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "Target Watts Simulator turned on");
+    } else if (value == "disable") {
+      rtConfig.setSimulateTargetWatts(false);
+      server.send(200, "text/plain", "OK");
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "Target Watts Simulator turned off");
+    } else {
+      rtConfig.setTargetWatts(value.toInt());
+      SS2K_LOG(HTTP_SERVER_LOG_TAG, "Target Watts are now: %d", rtConfig.getTargetWatts());
       server.send(200, "text/plain", "OK");
     }
   });
@@ -223,11 +253,11 @@ void startHttpServer() {
   server.on("/shift", []() {
     int value = server.arg("value").toInt();
     if ((value > -10) && (value < 10)) {
-      userConfig.setShifterPosition(userConfig.getShifterPosition() + value);
+      rtConfig.setShifterPosition(rtConfig.getShifterPosition() + value);
       server.send(200, "text/plain", "OK");
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "Shift From HTML");
     } else {
-      userConfig.setShifterPosition(value);
+      rtConfig.setShifterPosition(value);
       SS2K_LOG(HTTP_SERVER_LOG_TAG, "Invalid HTML Shift");
       server.send(200, "text/plain", "OK");
     }
@@ -239,6 +269,12 @@ void startHttpServer() {
     server.send(200, "text/plain", tString);
   });
 
+  server.on("/runtimeConfigJSON", []() {
+    String tString;
+    tString = rtConfig.returnJSON(!server.arg("includeDebugLog").isEmpty());
+    server.send(200, "text/plain", tString);
+  });
+
   server.on("/PWCJSON", []() {
     String tString;
     tString = userPWC.returnJSON();
@@ -268,6 +304,7 @@ void startHttpServer() {
         if (upload.filename == String("firmware.bin").c_str()) {
           if (upload.status == UPLOAD_FILE_START) {
             SS2K_LOG(HTTP_SERVER_LOG_TAG, "Update: %s", upload.filename.c_str());
+            stopTasks();
             if (!Update.begin(UPDATE_SIZE_UNKNOWN)) {  // start with max
                                                        // available size
               Update.printError(Serial);
@@ -423,7 +460,7 @@ void settingsProcessor() {
   }
   if (!server.arg("ERGSensitivity").isEmpty()) {
     float ERGSensitivity = server.arg("ERGSensitivity").toFloat();
-    if (ERGSensitivity >= .5 && ERGSensitivity <= 3) {
+    if (ERGSensitivity >= .5 && ERGSensitivity <= 20) {
       userConfig.setERGSensitivity(ERGSensitivity);
     }
   }
diff --git a/src/Main.cpp b/src/Main.cpp
index 5d7b5fdf..41ed8595 100644
--- a/src/Main.cpp
+++ b/src/Main.cpp
@@ -12,6 +12,7 @@
 #include <SPIFFS.h>
 #include <HardwareSerial.h>
 #include "FastAccelStepper.h"
+#include "ERG_Mode.h"
 
 bool lastDir = true;  // Stepper Last Direction
 
@@ -21,10 +22,8 @@ uint64_t debounceDelay    = 500;  // the debounce time; increase if the output f
 
 // Stepper Speed - Lower is faster
 int maxStepperSpeed     = 500;
-int32_t targetPosition  = 0;
 int lastShifterPosition = 0;
-bool externalControl    = false;
-bool syncMode           = false;
+
 HardwareSerial stepperSerial(2);
 TMC2208Stepper driver(&SERIAL_PORT, R_SENSE);  // Hardware Serial
 FastAccelStepperEngine engine = FastAccelStepperEngine();
@@ -42,11 +41,34 @@ TaskHandle_t moveStepperTask;
 TaskHandle_t shifterCheckTask;
 
 ///////////// Initialize the Config /////////////
+SS2K ss2k;
 userParameters userConfig;
+RuntimeParameters rtConfig;
 physicalWorkingCapacity userPWC;
 
 ///////////// BEGIN SETUP /////////////
 #ifndef UNIT_TEST
+
+void startTasks() {
+  SS2K_LOG(MAIN_LOG_TAG, "Start BLE + ERG Tasks");
+  if (BLECommunicationTask == NULL) {
+    setupBLE();
+  }
+  if (ErgTask == NULL) {
+    setupERG();
+  }
+}
+
+void stopTasks() {
+  SS2K_LOG(MAIN_LOG_TAG, "Stop BLE + ERG Tasks");
+  if (BLECommunicationTask != NULL) {
+    vTaskDelete(BLECommunicationTask);
+  }
+  if (ErgTask != NULL) {
+    vTaskDelete(ErgTask);
+  }
+}
+
 void setup() {
   // Serial port for debugging purposes
   Serial.begin(512000);
@@ -106,10 +128,11 @@ void setup() {
   // Check for firmware update. It's important that this stays before BLE &
   // HTTP setup because otherwise they use too much traffic and the device
   // fails to update which really sucks when it corrupts your settings.
-  FirmwareUpdate();
+  // FirmwareUpdate();
 
-  setupBLE();
+  startTasks();
   startHttpServer();
+
   resetIfShiftersHeld();
   SS2K_LOG(MAIN_LOG_TAG, "Creating Shifter Interrupts");
   // Setup Interrups so shifters work anytime
@@ -124,6 +147,7 @@ void setup() {
                           1,                      /* priority of the task */
                           &shifterCheckTask,      /* Task handle to keep track of created task */
                           1);                     /* pin task to core 0 */
+
 }
 
 void loop() {  // Delete this task so we can make one that's more memory efficient.
@@ -135,16 +159,17 @@ void shifterCheck(void *pvParameters) {
   while (true) {
     vTaskDelay(200 / portTICK_RATE_MS);
 
-    if (userConfig.getShifterPosition() > lastShifterPosition) {
-      SS2K_LOG(MAIN_LOG_TAG, "Shift UP: %l", userConfig.getShifterPosition());
-      Serial.println(targetPosition);
-      spinBLEServer.notifyShift(1);
-    } else if (userConfig.getShifterPosition() < lastShifterPosition) {
-      SS2K_LOG(MAIN_LOG_TAG, "Shift DOWN: %l", userConfig.getShifterPosition());
-      Serial.println(targetPosition);
-      spinBLEServer.notifyShift(0);
-    }
-    lastShifterPosition = userConfig.getShifterPosition();
+  if (rtConfig.getShifterPosition() > lastShifterPosition) {
+    SS2K_LOG(MAIN_LOG_TAG, "Shift UP: %l", rtConfig.getShifterPosition());
+    Serial.println(ss2k.targetPosition);
+    spinBLEServer.notifyShift(1);
+  } else if (rtConfig.getShifterPosition() < lastShifterPosition) {
+    SS2K_LOG(MAIN_LOG_TAG, "Shift DOWN: %l", rtConfig.getShifterPosition());
+    Serial.println(ss2k.targetPosition);
+    spinBLEServer.notifyShift(0);
+  }
+  lastShifterPosition = rtConfig.getShifterPosition();
+
 
     if (loopCounter > 4) {
       scanIfShiftersHeld();
@@ -174,24 +199,36 @@ void moveStepper(void *pvParameters) {
   stepper->setDelayToDisable(1000);
 
   while (1) {
-    if (!externalControl) {
-      targetPosition = (userConfig.getShifterPosition() * userConfig.getShiftStep()) + (userConfig.getIncline() * userConfig.getInclineMultiplier());
-    }
-    if (syncMode) {
-      stepper->stopMove();
-      vTaskDelay(100 / portTICK_PERIOD_MS);
-      stepper->setCurrentPosition(targetPosition);
-      vTaskDelay(100 / portTICK_PERIOD_MS);
-    }
     if (stepper) {
-      stepper->moveTo(targetPosition);
-    }
-    vTaskDelay(100 / portTICK_PERIOD_MS);
-    if (connectedClientCount() > 0) {
-      stepper->setAutoEnable(false);  // Keep the stepper from rolling back due to head tube slack. Motor Driver still lowers power between moves
-      stepper->enableOutputs();
-    } else {
-      stepper->setAutoEnable(true);  // disable output FETs between moves so stepper can cool. Can still shift.
+      ss2k.targetPosition = rtConfig.getShifterPosition() * userConfig.getShiftStep();
+      if (!ss2k.externalControl) {
+        if (rtConfig.getERGMode()) {
+          // ERG Mode
+          // Shifter not used.
+          ss2k.targetPosition = rtConfig.getTargetIncline();
+        } else {
+          // Simulation Mode
+          ss2k.targetPosition += rtConfig.getTargetIncline() * userConfig.getInclineMultiplier();
+        }
+      }
+
+      if (ss2k.syncMode) {
+        stepper->stopMove();
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+        stepper->setCurrentPosition(ss2k.targetPosition);
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+      }
+      stepper->moveTo(ss2k.targetPosition);
+      vTaskDelay(100 / portTICK_PERIOD_MS);
+
+      rtConfig.setCurrentIncline((float)stepper->getCurrentPosition());
+
+      if (connectedClientCount() > 0) {
+        stepper->setAutoEnable(false);  // Keep the stepper from rolling back due to head tube slack. Motor Driver still lowers power between moves
+        stepper->enableOutputs();
+      } else {
+        stepper->setAutoEnable(true);  // disable output FETs between moves so stepper can cool. Can still shift.
+      }
     }
   }
 }
@@ -210,7 +247,7 @@ bool IRAM_ATTR deBounce() {
 void IRAM_ATTR shiftUp() {  // Handle the shift up interrupt IRAM_ATTR is to keep the interrput code in ram always
   if (deBounce()) {
     if (!digitalRead(SHIFT_UP_PIN)) {  // double checking to make sure the interrupt wasn't triggered by emf
-      userConfig.setShifterPosition(userConfig.getShifterPosition() + 1);
+      rtConfig.setShifterPosition(rtConfig.getShifterPosition() + 1);
     } else {
       lastDebounceTime = 0;
     }  // Probably Triggered by EMF, reset the debounce
@@ -220,7 +257,7 @@ void IRAM_ATTR shiftUp() {  // Handle the shift up interrupt IRAM_ATTR is to kee
 void IRAM_ATTR shiftDown() {  // Handle the shift down interrupt
   if (deBounce()) {
     if (!digitalRead(SHIFT_DOWN_PIN)) {  // double checking to make sure the interrupt wasn't triggered by emf
-      userConfig.setShifterPosition(userConfig.getShifterPosition() - 1);
+      rtConfig.setShifterPosition(rtConfig.getShifterPosition() - 1);
     } else {
       lastDebounceTime = 0;
     }  // Probably Triggered by EMF, reset the debounce
@@ -329,8 +366,8 @@ void checkDriverTemperature() {
 
 void motorStop(bool releaseTension) {
   stepper->stopMove();
-  stepper->setCurrentPosition(targetPosition);
+  stepper->setCurrentPosition(ss2k.targetPosition);
   if (releaseTension) {
-    stepper->moveTo(targetPosition - userConfig.getShiftStep() * 4);
+    stepper->moveTo(ss2k.targetPosition - userConfig.getShiftStep() * 4);
   }
 }
diff --git a/src/SmartSpin_parameters.cpp b/src/SmartSpin_parameters.cpp
index 0e7ac5de..d2ebbad9 100644
--- a/src/SmartSpin_parameters.cpp
+++ b/src/SmartSpin_parameters.cpp
@@ -12,32 +12,51 @@
 #include <ArduinoJson.h>
 #include <SPIFFS.h>
 
+String RuntimeParameters::returnJSON(bool includeDebugLog) {
+  // Allocate a temporary JsonDocument
+  // Don't forget to change the capacity to match your requirements.
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<RUNTIMECONFIG_JSON_SIZE> doc;
+  // Set the values in the document
+
+  doc["targetIncline"]       = targetIncline;
+  doc["currentIncline"]      = currentIncline;
+  doc["targetWatts"]         = targetWatts;
+  doc["simulatedWatts"]      = simulatedWatts.value;
+  doc["simulatedHr"]         = simulatedHr;
+  doc["simulatedCad"]        = simulatedCad;
+  doc["simulatedSpeed"]      = simulatedSpeed;
+  doc["simulateHr"]          = simulateHr;
+  doc["simulateWatts"]       = simulateWatts;
+  doc["simulateTargetWatts"] = simulateTargetWatts;
+  doc["simulateCad"]         = simulateCad;
+  doc["ERGMode"]             = ERGMode;
+  doc["shifterPosition"]     = shifterPosition;
+  doc["foundDevices"]        = foundDevices;
+  if (includeDebugLog) {
+    doc["debug"] = DebugInfo::get_and_clear_logs();
+  }
+
+  String output;
+  serializeJson(doc, output);
+  return output;
+}
+
 // Default Values
 void userParameters::setDefaults() {  // Move these to set the values as #define
                                       // in main.h
   firmwareUpdateURL     = FW_UPDATEURL;
-  incline               = 0.0;
-  simulatedWatts        = 00;
-  simulatedHr           = 00;
-  simulatedCad          = 00;
   deviceName            = DEVICE_NAME;
   shiftStep             = 600;
-  stepperPower          = STEPPER_POWER;
   stealthchop           = STEALTHCHOP;
   inclineMultiplier     = 3.0;
   powerCorrectionFactor = 1.0;
-  simulateHr            = false;
-  simulateWatts         = false;
-  simulateCad           = false;
-  ERGMode               = false;
   ERGSensitivity        = ERG_SENSITIVITY;
   autoUpdate            = AUTO_FIRMWARE_UPDATE;
   ssid                  = DEVICE_NAME;
   password              = DEFAULT_PASSWORD;
-  foundDevices          = "";
   connectedPowerMeter   = CONNECTED_POWER_METER;
   connectedHeartMonitor = CONNECTED_HEART_MONITOR;
-  shifterPosition       = 0;
 }
 
 //---------------------------------------------------------------------------------
@@ -49,30 +68,21 @@ String userParameters::returnJSON(bool includeDebugLog) {
   StaticJsonDocument<USERCONFIG_JSON_SIZE> doc;
   // Set the values in the document
 
-  doc["firmwareUpdateURL"]     = firmwareUpdateURL;
-  doc["firmwareVersion"]       = FIRMWARE_VERSION;
-  doc["incline"]               = incline;
-  doc["simulatedWatts"]        = simulatedWatts;
-  doc["simulatedHr"]           = simulatedHr;
-  doc["simulatedCad"]          = simulatedCad;
-  doc["deviceName"]            = deviceName;
-  doc["shiftStep"]             = shiftStep;
-  doc["stepperPower"]          = stepperPower;
+  doc["firmwareUpdateURL"] = firmwareUpdateURL;
+  doc["firmwareVersion"]   = FIRMWARE_VERSION;
+  doc["deviceName"]        = deviceName;
+  doc["shiftStep"]         = shiftStep;
+  doc["stepperPower"]      = stepperPower;
+
   doc["stealthchop"]           = stealthchop;
   doc["inclineMultiplier"]     = inclineMultiplier;
   doc["powerCorrectionFactor"] = powerCorrectionFactor;
-  doc["simulateHr"]            = simulateHr;
-  doc["simulateWatts"]         = simulateWatts;
-  doc["simulateCad"]           = simulateCad;
-  doc["ERGMode"]               = ERGMode;
   doc["ERGSensitivity"]        = ERGSensitivity;
   doc["autoUpdate"]            = autoUpdate;
   doc["ssid"]                  = ssid;
   doc["password"]              = password;
-  doc["foundDevices"]          = foundDevices;
   doc["connectedPowerMeter"]   = connectedPowerMeter;
   doc["connectedHeartMonitor"] = connectedHeartMonitor;
-  doc["shifterPosition"]       = shifterPosition;
   if (includeDebugLog) {
     doc["debug"] = DebugInfo::get_and_clear_logs();
   }
@@ -102,30 +112,20 @@ void userParameters::saveToSPIFFS() {
   // Set the values in the document
   // commented items are not needed in save file
 
-  doc["firmwareUpdateURL"] = firmwareUpdateURL;
-  // doc["incline"]           = incline;
-  // doc["simulatedWatts"]       = simulatedWatts;
-  // doc["simulatedHr"]          = simulatedHr;
-  // doc["simulatedCad"]         = simulatedCad;
+  doc["firmwareUpdateURL"]     = firmwareUpdateURL;
   doc["deviceName"]            = deviceName;
   doc["shiftStep"]             = shiftStep;
   doc["stepperPower"]          = stepperPower;
   doc["stealthchop"]           = stealthchop;
   doc["inclineMultiplier"]     = inclineMultiplier;
   doc["powerCorrectionFactor"] = powerCorrectionFactor;
-  // doc["simulateHr"]            = simulateHr;
-  // doc["simulateWatts"]         = simulateWatts;
-  // doc["simulateCad"]           = simulateCad;
-  // doc["ERGMode"]               = ERGMode;
-  doc["ERGSensitivity"] = ERGSensitivity;
-  doc["autoUpdate"]     = autoUpdate;
-  doc["ssid"]           = ssid;
-  doc["password"]       = password;
-  // doc["foundDevices"]         = foundDevices; //I don't see a need
+  doc["ERGSensitivity"]        = ERGSensitivity;
+  doc["autoUpdate"]            = autoUpdate;
+  doc["ssid"]                  = ssid;
+  doc["password"]              = password;
   // currently in keeping this boot to boot
   doc["connectedPowerMeter"]   = connectedPowerMeter;
   doc["connectedHeartMonitor"] = connectedHeartMonitor;
-  // doc["shifterPosition"]       = shifterPosition;
 
   // Serialize JSON to file
   if (serializeJson(doc, file) == 0) {
@@ -162,10 +162,6 @@ void userParameters::loadFromSPIFFS() {
 
   // Copy values from the JsonDocument to the Config
   setFirmwareUpdateURL(doc["firmwareUpdateURL"]);
-  // setIncline(doc["incline"]);
-  // setSimulatedWatts     (doc["simulatedWatts"]);
-  // setSimulatedHr        (doc["simulatedHr"]);
-  // setSimulatedCad       (doc["simulatedCad"]);
   setDeviceName(doc["deviceName"]);
   setShiftStep(doc["shiftStep"]);
   setStepperPower(doc["stepperPower"]);
@@ -177,20 +173,14 @@ void userParameters::loadFromSPIFFS() {
       setPowerCorrectionFactor(1);
     }
   }
-  setSimulateHr(false);  // Set these false because previous config versions may return true and these values are no longer saved.
-  setSimulateWatts(false);
-  setSimulateCad(false);
-  // setERGMode(doc["ERGMode"]);
   if (doc["ERGSensitivity"]) {
     setERGSensitivity(doc["ERGSensitivity"]);
   }
   setAutoUpdate(doc["autoUpdate"]);
   setSsid(doc["ssid"]);
   setPassword(doc["password"]);
-  // setfoundDevices       (doc["foundDevices"]);
   setConnectedPowerMeter(doc["connectedPowerMeter"]);
   setConnectedHeartMonitor(doc["connectedHeartMonitor"]);
-  // setShifterPosition[doc["shifterPosition"]);
 
   SS2K_LOG(CONFIG_LOG_TAG, "Config File Loaded: %s", configFILENAME);
   file.close();
diff --git a/test/native/test.cpp b/test/native/test.cpp
index 1e514be5..6dbbc860 100644
--- a/test/native/test.cpp
+++ b/test/native/test.cpp
@@ -18,14 +18,21 @@ void process() {
     RUN_TEST(test.test_parses_cadence);
     RUN_TEST(test.test_parses_power);
   }
+
   // Cycle Power Tests
-  test_cyclePowerData test;
   {
+    test_cyclePowerData test;
     RUN_TEST(test.test_parses_power);
     RUN_TEST(test.test_parses_cadence);
     RUN_TEST(test.test_parses_heartrate);
     RUN_TEST(test.test_parses_speed);
   }
+
+  // ERG Mode
+  {
+    TestPowerBuffer testPowerBuffer;
+    RUN_TEST(testPowerBuffer.set__should_set_values__expect_values_added_to_correct_index);
+  }
   UNITY_END();
 }
 
diff --git a/test/native/test.h b/test/native/test.h
index e6d71274..a3e2edd4 100644
--- a/test/native/test.h
+++ b/test/native/test.h
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: GPL-2.0-only
  */
 
-#pragma once 
+#pragma once
 
 class test_fitnessMachineIndoorBikeData {
  public:
@@ -21,3 +21,8 @@ class test_cyclePowerData {
   static void test_parses_heartrate(void);
   static void test_parses_speed(void);
 };
+
+class TestPowerBuffer {
+ public:
+  static void set__should_set_values__expect_values_added_to_correct_index(void);
+};
diff --git a/test/native/test_PowerBuffer.cpp b/test/native/test_PowerBuffer.cpp
new file mode 100644
index 00000000..b16cdad0
--- /dev/null
+++ b/test/native/test_PowerBuffer.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020  Anthony Doud & Joel Baranick
+ * All rights reserved
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ */
+
+#include <unity.h>
+#include "test.h"
+#include "ERG_Mode.h"
+
+void TestPowerBuffer::set__should_set_values__expect_values_added_to_correct_index(void) {
+  const PowerBuffer powerBuffer;
+  // // Pre parse state
+  // TEST_ASSERT_FALSE(sensor.hasPower());
+  // TEST_ASSERT_EQUAL_INT(INT_MIN, sensor.getPower());
+
+  // // Power is instantaneous, not much calculation to do so skipping some samples
+  // sensor.decode(t0, sizeof(t0));
+  // TEST_ASSERT_TRUE(sensor.hasPower());
+  // TEST_ASSERT_EQUAL_INT(0, sensor.getPower());
+
+  // sensor.decode(t3, sizeof(t0));
+  // TEST_ASSERT_TRUE(sensor.hasPower());
+  // TEST_ASSERT_EQUAL_INT(45, sensor.getPower());
+
+  // sensor.decode(t7, sizeof(t0));
+  // TEST_ASSERT_EQUAL_INT(57, sensor.getPower());
+}