settings_manager.cpp

#include "settings_manager.h"

const char* SettingsManager::NAMESPACE = "ecu";
const char* SettingsManager::SETTINGS_KEY = "settings";

SettingsManager::SettingsManager() : version(1) {
    setDefaults();
}

void SettingsManager::setDefaults() {
    settings.version = version;
    
    // Настройки РХХ
    settings.idle.targetRPM = 800;
    settings.idle.valveMinPosition = 0;
    settings.idle.valveMaxPosition = 255;
    settings.idle.rpmTolerance = 50;
    settings.idle.kp = 0.1;
    settings.idle.ki = 0.05;
    settings.idle.kd = 0.02;
    
    // Общие настройки
    settings.minAdvance = 0;
    settings.maxAdvance = 40;
    settings.injectionTimeMin = 1.0;
    settings.injectionTimeMax = 20.0;
    settings.idleRpmMin = 700;
    settings.idleRpmMax = 900;
}

void SettingsManager::begin() {
    if (!load()) {
        setDefaults();
        save();
    }
}

bool SettingsManager::load() {
    // Здесь должна быть загрузка из EEPROM или SD
    // Пока просто используем значения по умолчанию
    setDefaults();
    return true;
}

bool SettingsManager::save() {
    // Здесь должно быть сохранение в EEPROM или SD
    return true;
}

void SettingsManager::reset() {
    setDefaults();
    save();
}

bool SettingsManager::validateSettings() {
    if (settings.version != version) return false;
    
    // Проверка настроек РХХ
    if (settings.idle.targetRPM < 500 || settings.idle.targetRPM > 2000) return false;
    if (settings.idle.valveMinPosition < 0 || settings.idle.valveMinPosition > 255) return false;
    if (settings.idle.valveMaxPosition < 0 || settings.idle.valveMaxPosition > 255) return false;
    if (settings.idle.valveMaxPosition <= settings.idle.valveMinPosition) return false;
    if (settings.idle.rpmTolerance < 10 || settings.idle.rpmTolerance > 200) return false;
    if (settings.idle.kp < 0 || settings.idle.ki < 0 || settings.idle.kd < 0) return false;
    
    // Проверка общих настроек
    if (settings.minAdvance < -10 || settings.minAdvance > 20) return false;
    if (settings.maxAdvance < 20 || settings.maxAdvance > 60) return false;
    if (settings.maxAdvance <= settings.minAdvance) return false;
    if (settings.injectionTimeMin < 0.5 || settings.injectionTimeMin > 5.0) return false;
    if (settings.injectionTimeMax < 5.0 || settings.injectionTimeMax > 30.0) return false;
    if (settings.injectionTimeMax <= settings.injectionTimeMin) return false;
    if (settings.idleRpmMin < 500 || settings.idleRpmMin > 1000) return false;
    if (settings.idleRpmMax < 800 || settings.idleRpmMax > 1500) return false;
    if (settings.idleRpmMax <= settings.idleRpmMin) return false;
    
    return true;
}

void SettingsManager::setSettings(const SystemSettings& newSettings) {
    settings = newSettings;
    if (validateSettings()) {
        save();
    } else {
        setDefaults();
    }
}

String SettingsManager::exportToJson() {
    StaticJsonDocument<1024> doc;
    
    doc["version"] = settings.version;
    
    JsonObject idle = doc.createNestedObject("idle");
    idle["targetRPM"] = settings.idle.targetRPM;
    idle["valveMinPosition"] = settings.idle.valveMinPosition;
    idle["valveMaxPosition"] = settings.idle.valveMaxPosition;
    idle["rpmTolerance"] = settings.idle.rpmTolerance;
    idle["kp"] = settings.idle.kp;
    idle["ki"] = settings.idle.ki;
    idle["kd"] = settings.idle.kd;
    
    doc["minAdvance"] = settings.minAdvance;
    doc["maxAdvance"] = settings.maxAdvance;
    doc["injectionTimeMin"] = settings.injectionTimeMin;
    doc["injectionTimeMax"] = settings.injectionTimeMax;
    doc["idleRpmMin"] = settings.idleRpmMin;
    doc["idleRpmMax"] = settings.idleRpmMax;
    
    String output;
    serializeJson(doc, output);
    return output;
}

bool SettingsManager::importFromJson(const String& json) {
    StaticJsonDocument<1024> doc;
    DeserializationError error = deserializeJson(doc, json);
    
    if (error) return false;
    
    SystemSettings newSettings;
    
    newSettings.version = doc["version"] | version;
    
    JsonObject idle = doc["idle"];
    if (idle) {
        newSettings.idle.targetRPM = idle["targetRPM"] | 800;
        newSettings.idle.valveMinPosition = idle["valveMinPosition"] | 0;
        newSettings.idle.valveMaxPosition = idle["valveMaxPosition"] | 255;
        newSettings.idle.rpmTolerance = idle["rpmTolerance"] | 50;
        newSettings.idle.kp = idle["kp"] | 0.1;
        newSettings.idle.ki = idle["ki"] | 0.05;
        newSettings.idle.kd = idle["kd"] | 0.02;
    }
    
    newSettings.minAdvance = doc["minAdvance"] | 0;
    newSettings.maxAdvance = doc["maxAdvance"] | 40;
    newSettings.injectionTimeMin = doc["injectionTimeMin"] | 1.0;
    newSettings.injectionTimeMax = doc["injectionTimeMax"] | 20.0;
    newSettings.idleRpmMin = doc["idleRpmMin"] | 700;
    newSettings.idleRpmMax = doc["idleRpmMax"] | 900;
    
    setSettings(newSettings);
    return true;
}

bool SettingsManager::saveToSD(const char* filename) {
    File file = SD.open(filename, FILE_WRITE);
    if (!file) return false;
    
    String json = exportToJson();
    file.print(json);
    file.close();
    
    return true;
}

bool SettingsManager::loadFromSD(const char* filename) {
    File file = SD.open(filename);
    if (!file) return false;
    
    String json = file.readString();
    file.close();
    
    return importFromJson(json);
}

bool SettingsManager::isCompatibleVersion(uint32_t ver) const {
    // В данной версии поддерживаем только версию 1
    return ver == 1;
}