esp32_stringPot firmware supports calibration from aruidno IDE

1 files changed, 247 insertions, 35 deletions

diff --git a/api_layers/firmware/esp32_stringPot/esp32_stringPot.ino b/api_layers/firmware/esp32_stringPot/esp32_stringPot.ino
index 3fde958..63d4349 100644
--- a/api_layers/firmware/esp32_stringPot/esp32_stringPot.ino
+++ b/api_layers/firmware/esp32_stringPot/esp32_stringPot.ino
@@ -1,5 +1,5 @@
 /*
-  LabUI ESP32 Firmware v1.0
+  LabUI ESP32 Firmware v1.1
   ─────────────────────────────────────────────────────────────────────────
   Author: Adam Shatila
   Co-Author: Christian Kolset
@@ -8,36 +8,69 @@
 
   Required library: esp32 by Espressif Systems
 
-  Calibration:
-    1. Flash board with calibrationMODE = true.
-    2. Set to position #1 and record actual position (measuredRange[0]) and
-       output position (readingRange[0]).
-    3. Move to position #2 and record actual position (measuredRange[1])
-       and output position (readingRange[1]).
-    4. Flash board with calibrationMODE = false.
+  Calibration procedure:
+    Send  calibrate  and follow the prompts (recommended — pauses the data
+    stream and walks through both points). Or drive it manually:
+      1. Move sensor to known position #1, send  CAL:0:<actual_position>
+         Board captures its current raw reading and pairs it with that position.
+      2. Move sensor to known position #2, send  CAL:1:<actual_position>
+         Board recomputes calibration_factor / calibration_offset and saves
+         to EEPROM.
+    Send  FILT:<cutoffHz>  to change the Butterworth low-pass cutoff
+    (also saved to EEPROM). Send  config  at any time to print the current
+    calibration and filter configuration.
+
+  Serial commands (newline-terminated):
+    calibrate       Guided calibration wizard (recommended)
+    CAL:0:<pos>     Capture current raw reading as calibration point 0
+    CAL:1:<pos>     Capture current raw reading as calibration point 1
+    FILT:<hz>       Set Butterworth cutoff frequency
+    config          Print current calibration + filter configuration
+    help            Print this command list
+
+  Replies:
+    ACK:<command>\n   Command executed
+    ERR:<message>\n   Command failed / not recognized
 
   ─────────────────────────────────────────────────────────────────────────
  */
+#include <EEPROM.h>
 
 const int sensorPin = A0;
 const unsigned long sampleInterval = 2000;
 unsigned long lastSampleTime = 0;
 
-//Calibration
-float calibration_factor = 1.0;
-float calibration_offset;
-// 2 point calibration used for scaling factor
-bool calibrationMODE = false;
-float measuredRange[2] = {0, 150};
-float readingRange[2] = {260.26, 421.3};
+// EEPROM-persisted configuration
+#define EEPROM_SIZE 64
+#define EEPROM_MAGIC 0xC1
+
+struct StoredConfig {
+  uint8_t magic;
+  float calibrationPosition[2];
+  float calibrationRange[2];
+  float butterworth_cutoffHz;
+};
 
+StoredConfig cfg = {
+  EEPROM_MAGIC,
+  {0, 150},
+  {260.26, 421.3},
+  0.5
+};
+
+// Calibration (mirrors cfg, kept as separate globals for fast access in loop())
+float calibration_factor = 1.0;
+float calibration_offset = 0.0;
 
 // 2nd-order Butterworth low-pass (biquad, direct form II transposed)
-float butterworth_cutoffHz = 0.5;
 const float butterworth_sampleHz = 1000000.0 / sampleInterval;
 float butter_b0, butter_b1, butter_b2, butter_a1, butter_a2;
 float butter_z1 = 0.0, butter_z2 = 0.0;
 
+String serialLine;
+bool streamingEnabled = true;
+bool calibPointSet[2] = {false, false};
+
 void setup() {
   Serial.begin(115200);
 
@@ -46,10 +79,11 @@ void setup() {
   }
 
   analogReadResolution(12);
-  computeButterworthCoeffs(butterworth_cutoffHz, butterworth_sampleHz);
-  if (calibrationMODE == false){
-    computeCalibrationParameters(measuredRange, readingRange);
-  }
+
+  EEPROM.begin(EEPROM_SIZE);
+  loadConfig();
+  computeButterworthCoeffs(cfg.butterworth_cutoffHz, butterworth_sampleHz);
+  computeCalibrationParameters(cfg.calibrationPosition, cfg.calibrationRange);
 }
 
 void loop() {
@@ -58,28 +92,103 @@ void loop() {
   if (currentTime - lastSampleTime >= sampleInterval) {
     lastSampleTime = currentTime;
 
-    uint32_t millivolts = analogReadMilliVolts(sensorPin);
-    float displacement = convert_mV_to_mm(millivolts);
-    float filtered_displacement = butterworthLowPass(displacement);
-    float volts = filtered_displacement;
+    float filtered_displacement = butterworthLowPass(readCalibratedPosition());
+    if (streamingEnabled) {
+      Serial.println(filtered_displacement, 2);
+    }
+  }
+
+  readSerialCommands();
+}
+
+void readSerialCommands() {
+  while (Serial.available()) {
+    char c = Serial.read();
+    if (c == '\n') {
+      serialLine.trim();
+      if (serialLine.length() > 0) {
+        handleCommand(serialLine);
+      }
+      serialLine = "";
+    } else if (c != '\r') {
+      serialLine += c;
+    }
+  }
+}
+
+void handleCommand(String line) {
+  if (line.startsWith("CAL:0:") || line.startsWith("CAL:1:")) {
+    int idx = line.charAt(4) - '0';
+    float actualPos = line.substring(6).toFloat();
+    float rawReading = readRawPosition();
+    int otherIdx = 1 - idx;
+
+    if (calibPointSet[otherIdx] && rawReading == cfg.calibrationRange[otherIdx]) {
+      Serial.println("ERR:Calibration points cannot have equal raw reading");
+      return;
+    }
+
+    cfg.calibrationPosition[idx] = actualPos;
+    cfg.calibrationRange[idx] = rawReading;
+    calibPointSet[idx] = true;
+
+    if (!calibPointSet[otherIdx]) {
+      Serial.println("ACK:" + line + " (waiting on CAL:" + String(otherIdx) + ")");
+      return;
+    }
+
+    computeCalibrationParameters(cfg.calibrationPosition, cfg.calibrationRange);
+    saveConfig();
 
-    // Output the voltage to the serial monitor with 3 decimal places
-    //Serial.print(displacement, 3);
-    //Serial.print(",   ");
-    Serial.println(filtered_displacement, 2);
-    //Serial.println(millivolts);
+    Serial.println("ACK:" + line);
+  } else if (line.startsWith("FILT:")) {
+    float hz = line.substring(5).toFloat();
+    if (hz <= 0) {
+      Serial.println("ERR:Invalid cutoff frequency");
+      return;
+    }
+    cfg.butterworth_cutoffHz = hz;
+    computeButterworthCoeffs(cfg.butterworth_cutoffHz, butterworth_sampleHz);
+    saveConfig();
+
+    Serial.println("ACK:" + line);
+  } else if (line == "config") {
+    printConfig();
+  } else if (line == "help") {
+    printHelp();
+  } else if (line == "calibrate") {
+    calibrationWizard();
+  } else {
+    Serial.println("ERR:Unknown command");
+  }
+}
+
+void loadConfig() {
+  EEPROM.get(0, cfg);
+  if (cfg.magic != EEPROM_MAGIC) {
+    cfg = { EEPROM_MAGIC, {0, 150}, {260.26, 421.3}, 0.5 };
+    saveConfig();
   }
 }
 
-float convert_mV_to_mm(float mVolts){
-  // Reads mV from sensor and output in mm from lower limit
-  float voltage = mVolts / 1000.0;
+void saveConfig() {
+  EEPROM.put(0, cfg);
+  EEPROM.commit();
+}
+
+// Fixed sensor scaling, pre calibration_factor/offset
+float readRawPosition() {
+  uint32_t millivolts = analogReadMilliVolts(sensorPin);
+  float voltage = millivolts / 1000.0;
   float raw_val = voltage * (635.0 / 2.863);
-  float volts = raw_val * (635.0 / 637.0);
-  return calibration_factor * volts + calibration_offset;
+  return raw_val * (635.0 / 637.0);
 }
 
-void computeCalibrationParameters(float x[2], float y[2]){
+float readCalibratedPosition() {
+  return calibration_factor * readRawPosition() + calibration_offset;
+}
+
+void computeCalibrationParameters(float x[2], float y[2]) {
   calibration_factor = (x[1] - x[0]) / (y[1] - y[0]);
   calibration_offset = x[0] - calibration_factor * y[0];
 }
@@ -105,3 +214,106 @@ float butterworthLowPass(float newSample) {
   butter_z2 = butter_b2 * newSample - butter_a2 * output;
   return output;
 }
+
+void printConfig() {
+  Serial.println("Calibration:");
+  Serial.print("\tPosition:\t");
+  Serial.print(cfg.calibrationPosition[0], 3);
+  Serial.print(",\t");
+  Serial.println(cfg.calibrationPosition[1], 3);
+  Serial.print("\tRaw values:\t");
+  Serial.print(cfg.calibrationRange[0], 3);
+  Serial.print(",\t");
+  Serial.println(cfg.calibrationRange[1], 3);
+  Serial.print("\tFactor:\t");
+  Serial.println(calibration_factor, 6);
+  Serial.print("\tOffset:\t");
+  Serial.println(calibration_offset, 6);
+  Serial.print("Butterworth cutoff (Hz):\t");
+  Serial.println(cfg.butterworth_cutoffHz, 3);
+}
+
+void printHelp() {
+  Serial.println("Commands:");
+  Serial.println("\tcalibrate     Guided calibration wizard (recommended)");
+  Serial.println("\tCAL:0:<pos>   Capture current raw reading as calibration point 0");
+  Serial.println("\tCAL:1:<pos>   Capture current raw reading as calibration point 1");
+  Serial.println("\tFILT:<hz>     Set Butterworth cutoff frequency");
+  Serial.println("\tconfig        Print current calibration + filter configuration");
+  Serial.println("\thelp          Print this command list");
+  interruptibleDelay(10000);
+}
+
+// Waits up to ms, returns early (without consuming input) if a command starts arriving.
+void interruptibleDelay(unsigned long ms) {
+  unsigned long start = millis();
+  while (millis() - start < ms) {
+    if (Serial.available()) {
+      return;
+    }
+  }
+}
+
+// Blocks until a newline-terminated line arrives; used only inside calibrationWizard(),
+// where halting loop() to walk the user through steps is the point.
+String blockingReadLine() {
+  String buf = "";
+  while (true) {
+    if (Serial.available()) {
+      char c = Serial.read();
+      if (c == '\n') {
+        buf.trim();
+        return buf;
+      } else if (c != '\r') {
+        buf += c;
+      }
+    }
+  }
+}
+
+void calibrationWizard() {
+  bool wasStreaming = streamingEnabled;
+  streamingEnabled = false;
+
+  Serial.println("=== Calibration wizard (type 'cancel' anytime to abort) ===");
+
+  float pos[2];
+  float raw[2];
+
+  for (int i = 0; i < 2; i++) {
+    Serial.println("Move sensor to known position #" + String(i + 1) + ", enter actual position, press Enter:");
+    String input = blockingReadLine();
+
+    if (input.equalsIgnoreCase("cancel")) {
+      Serial.println("Calibration cancelled. Previous calibration unchanged.");
+      streamingEnabled = wasStreaming;
+      return;
+    }
+
+    pos[i] = input.toFloat();
+    raw[i] = readRawPosition();
+
+    if (i == 1 && raw[1] == raw[0]) {
+      Serial.println("ERR:Calibration points cannot have equal raw reading. Wizard aborted, previous calibration unchanged.");
+      streamingEnabled = wasStreaming;
+      return;
+    }
+
+    Serial.println("Point " + String(i) + " captured: position=" + String(pos[i], 3) + " raw=" + String(raw[i], 3));
+  }
+
+  cfg.calibrationPosition[0] = pos[0];
+  cfg.calibrationPosition[1] = pos[1];
+  cfg.calibrationRange[0] = raw[0];
+  cfg.calibrationRange[1] = raw[1];
+  calibPointSet[0] = true;
+  calibPointSet[1] = true;
+
+  computeCalibrationParameters(cfg.calibrationPosition, cfg.calibrationRange);
+  saveConfig();
+
+  Serial.println("Calibration saved.");
+  printConfig();
+
+  streamingEnabled = wasStreaming;
+}