sensor_calibration_service.h

См. документацию.

#pragma once
 
#ifdef TEST_BUILD
#include "../test/stubs/esp32_stubs.h"
#else
#include <Arduino.h>
#endif
#include <ArduinoJson.h>
#include <vector>
#include <map>
#include "modbus_sensor.h"  // Для структуры SensorData
 
// ============================================================================
// КОНСТАНТЫ СТАНДАРТНЫХ РАСТВОРОВ ДЛЯ КАЛИБРОВКИ
// ============================================================================
 
namespace StandardBuffers {
    // pH буферные растворы (стандартные)
    constexpr float PH_4_01 = 4.01F;    // Кислый буфер
    constexpr float PH_6_86 = 6.86F;    // Нейтральный буфер
    constexpr float PH_7_00 = 7.00F;    // Нейтральный буфер
    constexpr float PH_9_18 = 9.18F;    // Щелочной буфер
    constexpr float PH_10_01 = 10.01F;  // Высокий щелочной буфер
    
    // EC стандартные растворы (KCl)
    constexpr float EC_1413_US = 1413.0F;    // 1413 µS/cm
    constexpr float EC_1_413_MS = 1.413F;    // 1.413 mS/cm
    constexpr float EC_12_88_MS = 12.88F;    // 12.88 mS/cm
    constexpr float EC_0_1413_MS = 0.1413F;  // 0.1413 mS/cm
    
    // Максимальное количество калибровочных точек
    constexpr size_t MAX_PH_POINTS = 6;   // pH буферные растворы
    constexpr size_t MAX_EC_POINTS = 5;   // EC стандартные растворы
    constexpr size_t MAX_NPK_POINTS = 3;  // NPK калибровка (обычно 1-3 точки)
    constexpr size_t MAX_TOTAL_POINTS = MAX_PH_POINTS + MAX_EC_POINTS + MAX_NPK_POINTS;
}
 
// ============================================================================
// СТРУКТУРЫ ДАННЫХ КАЛИБРОВКИ
// ============================================================================
 
struct CalibrationPoint
{
    float rawValue;        // Исходное значение датчика
    float referenceValue;  // Эталонное значение
 
    // Конструкторы для обратной совместимости
    CalibrationPoint() : rawValue(0), referenceValue(0) {}
    CalibrationPoint(float raw, float reference) : rawValue(raw), referenceValue(reference) {}
    
    // Методы для обратной совместимости
    float getExpected() const { return referenceValue; }
    float getMeasured() const { return rawValue; }
    void setExpected(float value) { referenceValue = value; }
    void setMeasured(float value) { rawValue = value; }
    
    // Операторы присваивания для совместимости с STL
    CalibrationPoint& operator=(const CalibrationPoint& other) {
        if (this != &other) {
            rawValue = other.rawValue;
            referenceValue = other.referenceValue;
        }
        return *this;
    }
    
    CalibrationPoint& operator=(CalibrationPoint&& other) noexcept {
        if (this != &other) {
            rawValue = other.rawValue;
            referenceValue = other.referenceValue;
        }
        return *this;
    }
    
    // Конструктор копирования
    CalibrationPoint(const CalibrationPoint& other) : rawValue(other.rawValue), referenceValue(other.referenceValue) {}
    
    // Конструктор перемещения
    CalibrationPoint(CalibrationPoint&& other) noexcept : rawValue(other.rawValue), referenceValue(other.referenceValue) {}
};
 
struct PHCalibration
{
    std::vector<CalibrationPoint> points;
    float coefficient_a;  // pH_corrected = a × pH_raw + b
    float coefficient_b;
    float r_squared;  // Коэффициент детерминации
    bool is_valid;
 
    PHCalibration() : coefficient_a(1.0f), coefficient_b(0.0f), r_squared(0.0f), is_valid(false) {}
};
 
struct ECCalibration
{
    std::vector<CalibrationPoint> points;
    float coefficient_c;  // EC_corrected = c × EC_raw + d
    float coefficient_d;
    float r_squared;
    bool is_valid;
 
    ECCalibration() : coefficient_c(1.0f), coefficient_d(0.0f), r_squared(0.0f), is_valid(false) {}
};
 
struct NPKCalibration
{
    float offset_nitrogen;    // NPK_corrected = NPK_raw + offset
    float offset_phosphorus;
    float offset_potassium;
    bool is_valid;
 
    NPKCalibration() : offset_nitrogen(0.0f), offset_phosphorus(0.0f), offset_potassium(0.0f), is_valid(false) {}
};
 
struct CalibrationTable
{
    std::vector<CalibrationPoint> temperaturePoints;
    std::vector<CalibrationPoint> humidityPoints;
    std::vector<CalibrationPoint> ecPoints;
    std::vector<CalibrationPoint> phPoints;
    std::vector<CalibrationPoint> nitrogenPoints;
    std::vector<CalibrationPoint> phosphorusPoints;
    std::vector<CalibrationPoint> potassiumPoints;
 
    bool isValid;
 
    CalibrationTable() : isValid(false) {}
};
 
struct SensorCalibration
{
    String sensor_id;
    String calibration_date;
    PHCalibration ph;
    ECCalibration ec;
    NPKCalibration npk;
    bool is_complete;
 
    SensorCalibration() : is_complete(false) {}
};
 
// ============================================================================
// ОСНОВНОЙ КЛАСС КАЛИБРОВКИ
// ============================================================================
 
class SensorCalibrationService
{
   private:
    // Текущая калибровка датчика
    SensorCalibration current_calibration;
    
    // Калибровочные таблицы для разных профилей почвы
    static std::map<int, CalibrationTable> calibrationTables;
 
    // ============================================================================
    // ПРИВАТНЫЕ МЕТОДЫ
    // ============================================================================
 
    // Расчёт коэффициентов линейной регрессии
    bool calculateLinearRegression(const std::vector<CalibrationPoint>& points, float& slope, float& intercept,
                                   float& r_squared);
 
    // Применение калибровки к сырым данным
    float applyPHCalibration(float raw_ph);
    float applyECCalibration(float raw_ec);
    void applyNPKCalibration(float& nitrogen, float& phosphorus, float& potassium);
 
    // Применение калибровки к значению с интерполяцией
    float applyCalibrationWithInterpolation(float rawValue, const std::vector<CalibrationPoint>& points) const;
 
    // Линейная интерполяция между двумя точками
    float linearInterpolation(float value, float x1, float y1, float x2, float y2) const;
 
    // Парсинг CSV данных калибровочной таблицы
    bool parseCalibrationCSV(const String& csvData, CalibrationTable& table);
 
    // Валидация калибровочных точек
    bool validateCalibrationPoints(const std::vector<CalibrationPoint>& points) const;
 
   public:
    // ============================================================================
    // КОНСТРУКТОР И ДЕСТРУКТОР
    // ============================================================================
    
    SensorCalibrationService();
    virtual ~SensorCalibrationService() = default;
 
    // ============================================================================
    // МЕТОДЫ ДОБАВЛЕНИЯ КАЛИБРОВОЧНЫХ ТОЧЕК
    // ============================================================================
 
    bool addPHCalibrationPoint(float expected, float measured);
 
    bool addECCalibrationPoint(float expected, float measured);
<<<<<<< HEAD
 
=======
    bool addTemperatureCalibrationPoint(float expected, float measured);
    bool addHumidityCalibrationPoint(float expected, float measured);
>>>>>>> develop
    bool setNPKCalibrationPoint(float measured_n, float measured_p, float measured_k);
 
    // ============================================================================
    // МЕТОДЫ РАСЧЁТА КАЛИБРОВОЧНЫХ КОЭФФИЦИЕНТОВ
    // ============================================================================
 
    bool calculatePHCalibration();
 
    bool calculateECCalibration();
 
    bool calculateNPKCalibration();
 
    // ============================================================================
    // МЕТОДЫ ПРИМЕНЕНИЯ КАЛИБРОВКИ
    // ============================================================================
 
    void applyCalibration(float& ph, float& ec, float& nitrogen, float& phosphorus, float& potassium);
 
    void applyCalibration(SensorData& data, int profile);
 
    float applySingleCalibration(float rawValue, int profile);
 
    // ============================================================================
    // МЕТОДЫ СЕРИАЛИЗАЦИИ/ДЕСЕРИАЛИЗАЦИИ
    // ============================================================================
 
    String exportCalibrationToJSON();
 
    bool importCalibrationFromJSON(const String& json_data);
 
    // ============================================================================
    // МЕТОДЫ УПРАВЛЕНИЯ КАЛИБРОВОЧНЫМИ ТАБЛИЦАМИ
    // ============================================================================
 
    bool loadCalibrationTable(const String& csvData, int profile);
 
    bool hasCalibrationTable(int profile) const;
 
    void clearCalibrationTable(int profile);
 
    static size_t getCalibrationPointsCount(int profile, const String& sensorType);
 
    static String exportCalibrationTable(int profile);
 
    // ============================================================================
    // МЕТОДЫ СТАТУСА И ВАЛИДАЦИИ
    // ============================================================================
 
    String getCalibrationStatus() const;
 
    bool isCalibrationComplete() const;
 
    void resetCalibration();
 
    bool validateCalibration() const;
 
    bool validateCalibrationData(const SensorData& data);
};
 
// ============================================================================
// ГЛОБАЛЬНЫЙ ЭКЗЕМПЛЯР
// ============================================================================
 
extern SensorCalibrationService gCalibrationService;