feat: Introduce profiles (#175)

* feat: Add profile edit screen

* fix: Fix merge errors

* feat: Add new profile screen

* fix: Fix PID heater

* feat: Add profile progress

* feat: Repair code after cherrypicking, finish touch ui, add migration

* feat: Tune pump control, extend protocol

* feat: Add functioning web ui

* feat: Add web ui fixes, reflect profile on screen

* feat: Add favorite function

* fix: Fix communication

* feat: Finalize profiles with pressure

Author: jniebuhr

icons/angle-left.svg

@@ -23,6 +23,8 @@ function convert() {
 
 convert "angle-down.svg" 40
 convert "angle-up.svg" 40
+convert "angle-left.svg" 40
+convert "angle-right.svg" 40
 convert "bluetooth-alt.svg" 20
 convert "check.svg" 40
 convert "coffee-bean.svg" 80
@@ -43,4 +45,6 @@ convert "wind.svg" 80
 convert "clock.svg" 40
 convert "thermometer-half.svg" 40
 convert "refresh.svg" 20
+convert "refresh.svg" 40
 convert "tap.svg" 60
+convert "settings.svg" 40

icons/angle-right.svg

@@ -31,7 +31,7 @@ void GaggiMateController::setup() {
         pressureSensor = new PressureSensor(_config.pressureSda, _config.pressureScl, [this](float pressure) { /* noop */ });
     }
     if (_config.capabilites.dimming) {
-        pump = new DimmedPump(_config.pumpPin, _config.pumpSensePin);
+        pump = new DimmedPump(_config.pumpPin, _config.pumpSensePin, pressureSensor);
     } else {
         pump = new SimplePump(_config.pumpPin, _config.pumpOn, _config.capabilites.ssrPump ? 1000.0f : 5000.0f);
     }
@@ -57,6 +57,20 @@ void GaggiMateController::setup() {
         this->valve->set(valve);
         this->heater->setSetpoint(heaterSetpoint);
     });
+    _ble.registerAdvancedOutputControlCallback(
+        [this](bool valve, float heaterSetpoint, bool pressureTarget, float pressure, float flow) {
+            this->valve->set(valve);
+            this->heater->setSetpoint(heaterSetpoint);
+            if (!_config.capabilites.dimming) {
+                return;
+            }
+            auto dimmedPump = static_cast<DimmedPump *>(pump);
+            if (pressureTarget) {
+                dimmedPump->setPressureTarget(pressure, flow);
+            } else {
+                dimmedPump->setFlowTarget(flow, pressure);
+            }
+        });
     _ble.registerAltControlCallback([this](bool state) { this->alt->set(state); });
     _ble.registerPidControlCallback([this](float Kp, float Ki, float Kd) { this->heater->setTunings(Kp, Ki, Kd); });
     _ble.registerPingCallback([this]() {

icons/convert.sh

@@ -2,25 +2,164 @@
 
 #include <GaggiMateController.h>
 
-DimmedPump::DimmedPump(uint8_t ssr_pin, uint8_t sense_pin)
-    : _ssr_pin(ssr_pin), _sense_pin(sense_pin), _psm(_sense_pin, _ssr_pin, 100, FALLING, 1, 4) {
+DimmedPump::DimmedPump(uint8_t ssr_pin, uint8_t sense_pin, PressureSensor *pressure_sensor)
+    : _ssr_pin(ssr_pin), _sense_pin(sense_pin), _psm(_sense_pin, _ssr_pin, 100, FALLING, 1, 4), _pressureSensor(pressure_sensor) {
     _psm.set(0);
+    _pressureGains.push_back(0.002f);
+    _pressureGains.push_back(0.005f);
+    _pressureGains.push_back(0.01f);
+    _pressureGains.push_back(0.02f);
+    _pressureGains.push_back(0.03f);
+    _pressureGains.push_back(0.15f);
+    _pressureGains.push_back(0.20f);
+    _pressureGains.push_back(0.15f);
+    _pressureGains.push_back(0.1f);
+    _pressureGains.push_back(0.09f);
+    _pressureGains.push_back(0.085f);
+    _pressureGains.push_back(0.08f);
+    _pressureGains.push_back(0.07f);
 }
 
-void DimmedPump::setup() { xTaskCreate(loopTask, "DimmedPump::loop", configMINIMAL_STACK_SIZE * 4, this, 1, &taskHandle); }
+void DimmedPump::setup() {
+    _cps = _psm.cps();
+    if (_cps > 70) {
+        _psm.setDivider(2);
+        _cps = _psm.cps();
+    }
+    xTaskCreate(loopTask, "DimmedPump::loop", configMINIMAL_STACK_SIZE * 4, this, 1, &taskHandle);
+}
 
-void DimmedPump::loop() {}
+void DimmedPump::loop() {
+    _currentPressure = _pressureSensor->getPressure();
+    updatePower();
+}
+
+void DimmedPump::calibrate() {
+    _pressureGains.clear();
+    _opvPressure = 0;
+    float lastPressure = 0;
+    float lastRoundedPressure = 0;
+    _currentPressure = _pressureSensor->getPressure();
+    _psm.set(10);
+    vTaskDelay(100);
+    do {
+        vTaskDelay(100);
+        lastRoundedPressure = round(_currentPressure - 0.5);
+        lastPressure = _currentPressure;
+        _currentPressure = _pressureSensor->getPressure();
+        if (round(_currentPressure - 0.5) > lastRoundedPressure) {
+            float gain = (_currentPressure - lastPressure) * 10.0f / (static_cast<float>(_cps) / 10.0f);
+            ESP_LOGI("DimmedPump", "Gain: %.6f at %.6f bar", gain, round(_currentPressure - 0.5));
+            _pressureGains.push_back(gain);
+        }
+    } while (_currentPressure > lastPressure - 0.1 || _currentPressure < 4.0f);
+    _opvPressure = _currentPressure;
+
+    ESP_LOGI("DimmedPump", "Finished calibration");
+    ESP_LOGI("DimmedPump", "Power line frequency: %d", _cps);
+    ESP_LOGI("DimmedPump", "OPV Pressure: %.2f", _opvPressure);
+    ESP_LOGI("DimmedPump", "Gains:");
+    for (auto gain : _pressureGains) {
+        ESP_LOGI("DimmedPump", "  %.6f", gain);
+    }
+    _psm.set(0);
+}
 
 void DimmedPump::setPower(float setpoint) {
     ESP_LOGV(LOG_TAG, "Setting power to %2f", setpoint);
-    _power = setpoint;
-    _psm.set(static_cast<int>(setpoint));
+    _mode = ControlMode::POWER;
+    _power = std::clamp(setpoint, 0.0f, 100.0f);
+    _psm.set(static_cast<int>(_power));
 }
 
 void DimmedPump::loopTask(void *arg) {
     auto *pump = static_cast<DimmedPump *>(arg);
     while (true) {
         pump->loop();
-        vTaskDelay(10 / portTICK_PERIOD_MS);
+        vTaskDelay(50 / portTICK_PERIOD_MS);
     }
 }
+
+void DimmedPump::updatePower() {
+    float newPower = _power;
+
+    switch (_mode) {
+    case ControlMode::PRESSURE:
+        newPower = calculatePowerForPressure(_targetPressure, _currentPressure, _flowLimit);
+        ESP_LOGI("DimmedPump", "Calculating power for pressure: %.2f", newPower);
+        break;
+
+    case ControlMode::FLOW:
+        newPower = calculatePowerForFlow(_targetFlow, _currentPressure, _pressureLimit);
+        break;
+
+    case ControlMode::POWER:
+        _psm.set(static_cast<int>(_power));
+        break;
+    }
+
+    if (newPower != _power && _mode != ControlMode::POWER) {
+        newPower = std::clamp(newPower, 0.0f, 100.0f);
+        _power = 0.8f * _power + 0.2f * newPower;
+        _psm.set(static_cast<int>(_power));
+    }
+}
+
+float DimmedPump::calculateFlowRate(float pressure) const {
+    float flow = BASE_FLOW_RATE;
+    float pressurePercentage = pressure / MAX_PRESSURE;
+    return flow * pressurePercentage;
+}
+
+float DimmedPump::calculatePowerForPressure(float targetPressure, float currentPressure, float flowLimit) {
+    float error = targetPressure - currentPressure;
+    float baseResponse = 0.0f;
+    float pressureGain = _currentPressure - _lastPressure;
+    float pressureLoss = _expectedPressureGain - pressureGain;
+    float pressureLevel = std::clamp(round(_currentPressure), 0.0f, static_cast<float>(_pressureGains.size()));
+    float pressureGainPerTick = _pressureGains[pressureLevel];
+    float maxPressureGain = pressureGainPerTick * static_cast<float>(_cps) / 20.0f;
+    ESP_LOGI("DimmedPump", "Pressure: %.2f, Gain: %.6f, Expected Gain: %.6f, Pressure Loss: %.6f, Error: %.6f, Per Tick: %.6f",
+             currentPressure, pressureGain, _expectedPressureGain, pressureLoss, error, pressureGainPerTick);
+    if (error + pressureLoss > maxPressureGain) {
+        baseResponse = 100.0f;
+    } else if (error + pressureLoss > 0.0f) {
+        float desiredGain = std::clamp(error + pressureLoss, 0.0f, maxPressureGain);
+        float gainRatio = desiredGain / maxPressureGain;
+        baseResponse = gainRatio * 100.0f;
+    }
+    _lastPressure = currentPressure;
+    _expectedPressureGain = baseResponse * static_cast<float>(_cps) / 100.0f / 20.0f * pressureGainPerTick;
+
+    if (flowLimit > 0.0f) {
+        float maxFlowPower = calculatePowerForFlow(flowLimit, currentPressure, 100.0f);
+        return std::min(baseResponse, maxFlowPower);
+    }
+
+    ESP_LOGI("DimmedPump", "Return: %f", baseResponse);
+    return baseResponse;
+}
+
+float DimmedPump::calculatePowerForFlow(float targetFlow, float currentPressure, float pressureLimit) const {
+    float maxFlow = calculateFlowRate(currentPressure) * _cps;
+    float powerRatio = std::clamp(targetFlow / maxFlow, 0.0f, 1.0f);
+    float basePower = powerRatio * 100.0f;
+
+    if (pressureLimit > 0 && currentPressure > pressureLimit) {
+        return 0.0f;
+    }
+
+    return basePower;
+}
+
+void DimmedPump::setFlowTarget(float targetFlow, float pressureLimit) {
+    _mode = ControlMode::FLOW;
+    _targetFlow = targetFlow;
+    _pressureLimit = pressureLimit;
+}
+
+void DimmedPump::setPressureTarget(float targetPressure, float flowLimit) {
+    _mode = ControlMode::PRESSURE;
+    _targetPressure = targetPressure;
+    _flowLimit = flowLimit;
+}

icons/settings.svg

@@ -4,22 +4,56 @@
 #include "Pump.h"
 #include <Arduino.h>
 
+#include "PressureSensor.h"
+
 class DimmedPump : public Pump {
   public:
-    DimmedPump(uint8_t ssr_pin, uint8_t sense_pin);
+    enum class ControlMode { POWER, PRESSURE, FLOW };
+
+    DimmedPump(uint8_t ssr_pin, uint8_t sense_pin, PressureSensor *pressureSensor);
     ~DimmedPump() = default;
 
     void setup() override;
     void loop() override;
+    void calibrate();
     void setPower(float setpoint) override;
 
+    void setFlowTarget(float targetFlow, float pressureLimit);
+    void setPressureTarget(float targetPressure, float flowLimit);
+    void stop();
+    void fullPower();
+
   private:
     uint8_t _ssr_pin;
     uint8_t _sense_pin;
-    float _power = 0.0f;
     PSM _psm;
+    PressureSensor *_pressureSensor;
     xTaskHandle taskHandle;
 
+    ControlMode _mode = ControlMode::POWER;
+    float _power = 0.0f;
+    float _targetFlow = 0.0f;
+    float _targetPressure = 0.0f;
+    float _pressureLimit = 0.0f;
+    float _flowLimit = 0.0f;
+    float _currentPressure = 0.0f;
+    float _lastPressure = 0.0f;
+    float _expectedPressureGain = 0.0f;
+    int _cps = MAX_FREQ;
+
+    float _opvPressure = 0.0f;
+    std::vector<float> _pressureGains;
+
+    static constexpr float BASE_FLOW_RATE = 0.25f;
+    static constexpr float MAX_PRESSURE = 15.0f;
+    static constexpr float MAX_FREQ = 60.0f;
+
+    [[nodiscard]] float calculateFlowRate(float pressure) const;
+    [[nodiscard]] float calculatePowerForPressure(float targetPressure, float currentPressure, float flowLimit);
+    [[nodiscard]] float calculatePowerForFlow(float targetFlow, float currentPressure, float pressureLimit) const;
+    void updatePower();
+    void onPressureUpdate(float pressure);
+
     const char *LOG_TAG = "DimmedPump";
     static void loopTask(void *arg);
 };

lib/GaggiMateController/src/GaggiMateController.cpp

@@ -1,12 +1,10 @@
 #include "Heater.h"
 #include <Arduino.h>
-#include <algorithm> 
-
+#include <algorithm>
 
 Heater::Heater(TemperatureSensor *sensor, uint8_t heaterPin, const heater_error_callback_t &error_callback,
                const pid_result_callback_t &pid_callback)
-    : sensor(sensor), heaterPin(heaterPin), taskHandle(nullptr), error_callback(error_callback),
-      pid_callback(pid_callback) {
+    : sensor(sensor), heaterPin(heaterPin), taskHandle(nullptr), error_callback(error_callback), pid_callback(pid_callback) {
 
     simplePid = new SimplePID(&output, &temperature, &setpoint);
     autotuner = new Autotune();
@@ -119,8 +117,10 @@ void Heater::loopAutotune() {
     // simplePid->setSetpointRateLimits(-INFINITY, autotuner->getSystemGain() * 0.8);
     // simplePid->setSetpointFilterFrequency(autotuner->getCrossoverFreq()/2);
 
-    ESP_LOGI(LOG_TAG, "Autotuning finished: Kp=%.4f, Ki=%.4f, Kd=%.4f, Kff=%.4f\n", autotuner->getKp()*1000.0f, autotuner->getKi()*1000.0f, autotuner->getKd()*1000.0f, autotuner->getKff()*1000.0f);
-    ESP_LOGI(LOG_TAG, "System delay: %.2f s, System gain: %.4f Setpoint Freq: %.4f Hz\n", autotuner->getSystemDelay(), autotuner->getSystemGain(), autotuner->getCrossoverFreq()/2);
+    ESP_LOGI(LOG_TAG, "Autotuning finished: Kp=%.4f, Ki=%.4f, Kd=%.4f, Kff=%.4f\n", autotuner->getKp() * 1000.0f,
+             autotuner->getKi() * 1000.0f, autotuner->getKd() * 1000.0f, autotuner->getKff() * 1000.0f);
+    ESP_LOGI(LOG_TAG, "System delay: %.2f s, System gain: %.4f Setpoint Freq: %.4f Hz\n", autotuner->getSystemDelay(),
+             autotuner->getSystemGain(), autotuner->getCrossoverFreq() / 2);
 }
 
 float Heater::softPwm(uint32_t windowSize) {
@@ -151,7 +151,9 @@ float Heater::softPwm(uint32_t windowSize) {
 void Heater::plot(float optimumOutput, float outputScale, uint8_t everyNth) {
     if (plotCount >= everyNth) {
         plotCount = 1;
-        ESP_LOGI(LOG_TAG, "Setpoint: %.2f, Input: %.2f, Output: %.2f, Kp: %.2f, Ki: %.2f, Kd: %.2f, Filtered Setpoint: %.2f", setpoint, temperature, optimumOutput * outputScale, simplePid->getKp(), simplePid->getKi(), simplePid->getKd(), simplePid->getSetpointFiltered());
+        ESP_LOGI(LOG_TAG, "Setpoint: %.2f, Input: %.2f, Output: %.2f, Kp: %.2f, Ki: %.2f, Kd: %.2f, Filtered Setpoint: %.2f",
+                 setpoint, temperature, optimumOutput * outputScale, simplePid->getKp(), simplePid->getKi(), simplePid->getKd(),
+                 simplePid->getSetpointFiltered());
     } else
         plotCount++;
 }