Upload 24 files

audi5_rabochi.ino

@@ -0,0 +1,81 @@
+#include <WiFi.h>
+#include <WebServer.h>
+#include <ArduinoJson.h>
+#include "engine_control.h"
+#include "idle_control.h"
+#include "settings_manager.h"
+#include "config.h"
+
+// Создаем объекты
+EngineControl engineControl;
+IdleController idleControl;
+SettingsManager settingsManager;
+WebServer server(80);
+
+void handleStatus() {
+    StaticJsonDocument<512> doc;
+    
+    doc["rpm"] = engineControl.getRPM();
+    doc["map"] = engineControl.getMAP();
+    doc["tps"] = engineControl.getTPS();
+    doc["lambda"] = engineControl.getLambda();
+    doc["knock_level"] = engineControl.knockLevel;
+    doc["knock_events"] = engineControl.getKnockEvents();
+    doc["fuel_correction"] = engineControl.getCurrentFuelCorrection();
+    doc["ignition_correction"] = engineControl.getCurrentIgnitionCorrection();
+    doc["engine_temp"] = engineControl.getEngineTemp();
+    doc["voltage"] = engineControl.getVoltage();
+    doc["learning_enabled"] = engineControl.isLearningEnabled();
+    
+    String response;
+    serializeJson(doc, response);
+    server.send(200, "application/json", response);
+}
+
+void handleIdleRPM() {
+    if (server.hasArg("rpm")) {
+        int rpm = server.arg("rpm").toInt();
+        if (rpm >= 700 && rpm <= 2000) {
+            idleControl.setTargetRPM(rpm);
+            server.send(200, "text/plain", "OK");
+            return;
+        }
+    }
+    server.send(400, "text/plain", "Invalid RPM value");
+}
+
+void setup() {
+    Serial.begin(115200);
+    
+    // Устанавливаем связь между объектами
+    idleControl.setEngineControl(&engineControl);
+    
+    // Инициализация компонентов
+    engineControl.begin();
+    idleControl.begin();
+    
+    // Настройка WiFi
+    WiFi.softAP("ECU_Config", "12345678");
+    
+    // Настройка веб-сервера
+    server.on("/status", HTTP_GET, handleStatus);
+    server.on("/idle_rpm", HTTP_POST, handleIdleRPM);
+    
+    server.begin();
+}
+
+void loop() {
+    // Обработка веб-запросов
+    server.handleClient();
+    
+    // Обновление состояния двигателя
+    engineControl.update();
+    
+    // Обновление РХХ
+    if (engineControl.getRPM() > 0) {
+        idleControl.update(engineControl.getRPM());
+    }
+    
+    // Задержка для стабильной работы
+    delay(10);
+}

classes.h

@@ -0,0 +1,247 @@
+#ifndef CLASSES_H
+#define CLASSES_H
+
+#include <Arduino.h>
+#include <SPI.h>
+#include <SD.h>
+#include <WiFi.h>
+#include <WebServer.h>
+#include <ArduinoJson.h>
+#include "structures.h"
+
+// Класс для работы с SD картой
+class SDCardManager {
+public:
+    bool init() {
+        if (!SD.begin(SD_CS_PIN, SPI, SD_SPI_SPEED)) {
+            Serial.println("Ошибка инициализации SD карты");
+            return false;
+        }
+        return true;
+    }
+
+    bool saveData(const char* filename, const void* data, size_t size) {
+        File file = SD.open(filename, FILE_WRITE);
+        if (!file) {
+            Serial.println("Ошибка открытия файла для записи");
+            return false;
+        }
+        
+        size_t written = file.write((const uint8_t*)data, size);
+        file.close();
+        
+        return written == size;
+    }
+
+    bool loadData(const char* filename, void* data, size_t size) {
+        File file = SD.open(filename, FILE_READ);
+        if (!file) {
+            Serial.println("Ошибка открытия файла для чтения");
+            return false;
+        }
+        
+        size_t read = file.read((uint8_t*)data, size);
+        file.close();
+        
+        return read == size;
+    }
+};
+
+// Класс для работы с PSRAM
+class PSRAMManager {
+private:
+    void* psramData;
+    size_t dataSize;
+    bool initialized;
+
+public:
+    PSRAMManager() : psramData(nullptr), dataSize(0), initialized(false) {}
+
+    bool init() {
+        if (!psramInit()) {
+            Serial.println("Ошибка инициализации PSRAM");
+            return false;
+        }
+        
+        // Выделяем память для всех данных
+        dataSize = sizeof(ConfigData) + sizeof(LearningData) + sizeof(RXXLearningData);
+        psramData = ps_malloc(dataSize);
+        
+        if (!psramData) {
+            Serial.println("Ошибка выделения памяти в PSRAM");
+            return false;
+        }
+        
+        initialized = true;
+        Serial.println("PSRAM инициализирован");
+        return true;
+    }
+
+    bool saveData(const void* data, size_t size, size_t offset) {
+        if (!initialized) return false;
+        
+        if (offset + size > dataSize) {
+            Serial.println("Ошибка: превышение размера PSRAM");
+            return false;
+        }
+        
+        memcpy((uint8_t*)psramData + offset, data, size);
+        return true;
+    }
+
+    bool loadData(void* data, size_t size, size_t offset) {
+        if (!initialized) return false;
+        
+        if (offset + size > dataSize) {
+            Serial.println("Ошибка: превышение размера PSRAM");
+            return false;
+        }
+        
+        memcpy(data, (uint8_t*)psramData + offset, size);
+        return true;
+    }
+
+    size_t getFreeMemory() {
+        return ESP.getFreePsram();
+    }
+
+    size_t getTotalMemory() {
+        return ESP.getPsramSize();
+    }
+};
+
+// Класс для работы с веб-сервером
+class WebServerManager {
+private:
+    WebServer server;
+    PSRAMManager psramManager;
+    
+public:
+    void init() {
+        // Инициализация WiFi
+        WiFi.mode(WIFI_AP_STA);
+        WiFi.softAP(WEB_SSID, WEB_PASSWORD);
+        
+        // Настройка маршрутов
+        server.on("/", HTTP_GET, [this]() {
+            server.send(200, "text/html", htmlPage);
+        });
+        
+        server.on("/config", HTTP_GET, [this]() {
+            StaticJsonDocument<1024> doc;
+            ConfigData config;
+            if (psramManager.loadData(&config, sizeof(ConfigData), 0)) {
+                doc["injectionTimeMin"] = config.injectionTimeMin;
+                doc["injectionTimeMax"] = config.injectionTimeMax;
+                // ... добавьте остальные поля конфигурации
+            }
+            
+            String response;
+            serializeJson(doc, response);
+            server.send(200, "application/json", response);
+        });
+        
+        server.on("/config", HTTP_POST, [this]() {
+            StaticJsonDocument<1024> doc;
+            DeserializationError error = deserializeJson(doc, server.arg("plain"));
+            
+            if (error) {
+                server.send(400, "text/plain", "Ошибка разбора JSON");
+                return;
+            }
+            
+            ConfigData config;
+            // Обновление конфигурации
+            config.injectionTimeMin = doc["injectionTimeMin"];
+            config.injectionTimeMax = doc["injectionTimeMax"];
+            // ... обновите остальные поля конфигу��ации
+            
+            if (psramManager.saveData(&config, sizeof(ConfigData), 0)) {
+                server.send(200, "text/plain", "Конфигурация сохранена");
+            } else {
+                server.send(500, "text/plain", "Ошибка сохранения конфигурации");
+            }
+        });
+        
+        server.begin();
+    }
+    
+    void handleClient() {
+        server.handleClient();
+    }
+};
+
+// Класс для управления двигателем
+class EngineManager {
+private:
+    float currentRPM;
+    float currentThrottle;
+    float currentTemp;
+    float currentLambda;
+    
+public:
+    void updateSensors(float rpm, float throttle, float temp, float lambda) {
+        currentRPM = rpm;
+        currentThrottle = throttle;
+        currentTemp = temp;
+        currentLambda = lambda;
+    }
+    
+    float calculateInjectionTime() {
+        // Базовая логика расчета времени впрыска
+        float baseTime = map(currentRPM, 0, MAX_RPM, 
+                           configData.injectionTimeMin, 
+                           configData.injectionTimeMax);
+                           
+        // Коррекция по температуре
+        if (configData.tempCorrectionEnabled) {
+            baseTime *= getTempCorrection(currentTemp);
+        }
+        
+        // Коррекция по лямбде
+        if (configData.lambdaCorrectionEnabled) {
+            baseTime *= getLambdaCorrection(currentLambda);
+        }
+        
+        return baseTime;
+    }
+    
+    float calculateAdvance() {
+        // Базовая логика расчета УОЗ
+        float baseAdvance = map(currentRPM, 0, MAX_RPM,
+                              configData.minAdvance,
+                              configData.maxAdvance);
+                              
+        // Коррекция для холостого хода
+        if (isIdle()) {
+            return getIdleAdvance();
+        }
+        
+        return baseAdvance;
+    }
+    
+private:
+    bool isIdle() {
+        return currentRPM >= configData.idleRpmMin && 
+               currentRPM <= configData.idleRpmMax &&
+               currentThrottle < THROTTLE_IDLE_THRESHOLD;
+    }
+    
+    float getTempCorrection(float temp) {
+        // Логика коррекции по температуре
+        return 1.0; // Заглушка
+    }
+    
+    float getLambdaCorrection(float lambda) {
+        // Логика коррекции по лямбде
+        return 1.0; // Заглушка
+    }
+    
+    float getIdleAdvance() {
+        // Логика расчета УОЗ на холостом ходу
+        return map(currentRPM, configData.idleRpmMin, configData.idleRpmMax,
+                  configData.idleAdvanceMin, configData.idleAdvanceMax);
+    }
+};
+
+#endif // CLASSES_H 

config.h

@@ -0,0 +1,96 @@
+#pragma once
+
+// Пины для датчиков
+#define HALL_SENSOR_PIN 36
+#define MAP_SENSOR_PIN 39
+#define TPS_PIN 34
+#define LAMBDA_SENSOR_PIN 35
+#define ENGINE_TEMP_SENSOR_PIN 32
+#define BATTERY_VOLTAGE_PIN 33
+#define KNOCK_SENSOR_1_3_PIN 25
+#define KNOCK_SENSOR_4_5_PIN 26
+
+// Пины для РХХ
+#define IDLE_VALVE_PIN_A 27
+#define IDLE_VALVE_PIN_B 14
+
+// Пороговые значения
+#define START_RPM_THRESHOLD 400
+#define DETONATION_THRESHOLD 0.8
+
+// Настройки PWM для РХХ
+#define IDLE_VALVE_PWM_FREQ 1000
+#define IDLE_VALVE_PWM_RES 8  // 8 bit resolution
+
+// Пины управления
+#define FUEL_PUMP_PIN 16  // Изменен с 27
+#define IGNITION_PIN 17   // Изменен с 14
+#define INJECTOR_PIN 12
+
+// Форсунки
+#define INJECTOR_1_PIN 5
+#define INJECTOR_2_PIN 18
+#define INJECTOR_3_PIN 19
+#define INJECTOR_4_PIN 21
+#define INJECTOR_5_PIN 22
+
+// Катушки зажигания
+#define COIL_1_PIN 23
+#define COIL_2_PIN 15
+#define COIL_3_PIN 13
+#define COIL_4_PIN 12
+#define COIL_5_PIN 4
+
+// Настройки WiFi
+#define WEB_SSID "ECU_Config"
+#define WEB_PASSWORD "12345678"
+
+// Константы двигателя
+#define NUM_CYLINDERS 5
+#define MAX_RPM 7000
+#define MIN_ADVANCE 0
+#define MAX_ADVANCE 40
+#define MECHANICAL_ADVANCE 40.0
+#define DWELL_TIME 3000
+
+// Константы впрыска
+#define MIN_INJECTION_TIME 1.0
+#define MAX_INJECTION_TIME 20.0
+#define INJECTOR_FLOW 200
+#define FUEL_PRESSURE 3.0
+
+// Константы лямбда-регулирования
+#define LAMBDA_TARGET 1.0
+#define LAMBDA_CORRECTION_MIN 0.8
+#define LAMBDA_CORRECTION_MAX 1.2
+#define LAMBDA_CORRECTION_STEP 0.01
+
+// Температурные константы
+#define COLD_START_TEMP 20.0
+#define HOT_ENGINE_TEMP 90.0
+#define TEMP_CORRECTION_MAX 1.5
+
+// Структура конфигурации
+struct ConfigData {
+    // Базовые таблицы
+    float fuelTable[16][16];        // Базовая таблица топливоподачи
+    float ignitionTable[16][16];    // Базовая таблица УОЗ
+    
+    // Таблицы обучения
+    float fuelLearning[16][16];     // Таблица коррекции топливоподачи
+    float ignitionLearning[16][16]; // Таблица коррекции УОЗ
+    
+    // Настройки холостого хода
+    float idleTargetRpm;            // Целевые обороты ХХ
+    float idleKp;                   // Коэффициент P для ПИД
+    float idleKi;                   // Коэффициент I для ПИД
+    float idleKd;                   // Коэффициент D для ПИД
+    
+    // Контрольная сумма
+    uint32_t checksum;              // Контрольная сумма конфигурации
+};
+
+// Функции конфигурации
+bool saveConfig(ConfigData* config);
+bool loadConfig(ConfigData* config);
+uint32_t calculateConfigChecksum(ConfigData* config);

engine_control.cpp

@@ -0,0 +1,108 @@
+#include "engine_control.h"
+#include "config.h"
+#include <Arduino.h>
+
+// Вспомогательные функции для преобразования значений
+float mapf(float x, float in_min, float in_max, float out_min, float out_max) {
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+EngineControl::EngineControl() :
+    rpm(0),
+    map(0),
+    tps(0),
+    lambda(0),
+    knockLevel(0),
+    engineTemp(0),
+    voltage(0),
+    learningEnabled(false),
+    knockEvents(0),
+    currentFuelCorrection(1.0),
+    currentIgnitionCorrection(0.0)
+{
+}
+
+void EngineControl::begin() {
+    // Настройка пинов
+    pinMode(HALL_SENSOR_PIN, INPUT);
+    pinMode(MAP_SENSOR_PIN, INPUT);
+    pinMode(TPS_PIN, INPUT);
+    pinMode(LAMBDA_SENSOR_PIN, INPUT);
+    pinMode(ENGINE_TEMP_SENSOR_PIN, INPUT);
+    pinMode(BATTERY_VOLTAGE_PIN, INPUT);
+    pinMode(KNOCK_SENSOR_1_3_PIN, INPUT);
+    pinMode(KNOCK_SENSOR_4_5_PIN, INPUT);
+    
+    // Загрузка таблиц обучения
+    fuelLearning.load();
+    ignitionLearning.load();
+}
+
+void EngineControl::update() {
+    // Чтение сенсоров
+    rpm = analogRead(HALL_SENSOR_PIN);
+    map = analogRead(MAP_SENSOR_PIN);
+    tps = analogRead(TPS_PIN);
+    lambda = analogRead(LAMBDA_SENSOR_PIN);
+    engineTemp = analogRead(ENGINE_TEMP_SENSOR_PIN);
+    voltage = analogRead(BATTERY_VOLTAGE_PIN);
+    
+    // Преобразование значений АЦП
+    rpm = mapf(rpm, 0, 4095, 0, 7000);
+    map = mapf(map, 0, 4095, 0, 100);
+    tps = mapf(tps, 0, 4095, 0, 100);
+    lambda = mapf(lambda, 0, 4095, 0.7, 1.3);
+    engineTemp = mapf(engineTemp, 0, 4095, -40, 150);
+    voltage = mapf(voltage, 0, 4095, 0, 15);
+    
+    if (learningEnabled && rpm > START_RPM_THRESHOLD) {
+        float engineLoad = map;  // В данном случае используем MAP как нагрузку
+        
+        // Обучение топливоподачи по лямбда-зонду
+        if (lambda < 0.98) {
+            fuelLearning.update(engineLoad, rpm, 0.98);
+        } else if (lambda > 1.02) {
+            fuelLearning.update(engineLoad, rpm, 1.02);
+        }
+        
+        // Чтение датчиков детонации
+        float knock1 = analogRead(KNOCK_SENSOR_1_3_PIN);
+        float knock2 = analogRead(KNOCK_SENSOR_4_5_PIN);
+        knockLevel = max(knock1, knock2);
+        
+        // Обучение УОЗ по детонации
+        ignitionLearning.learn(engineLoad, rpm, knockLevel);
+        
+        // Если была детонация, увеличиваем счетчик
+        if (knockLevel > DETONATION_THRESHOLD) {
+            knockEvents++;
+        }
+    }
+    
+    // Получение текущих коррекций
+    float engineLoad = map;
+    currentFuelCorrection = fuelLearning.getCorrection(engineLoad, rpm);
+    currentIgnitionCorrection = ignitionLearning.getCorrection(engineLoad, rpm);
+}
+
+float EngineControl::getLearningProgress() const {
+    return (fuelLearning.getProgress() + ignitionLearning.getProgress()) / 2.0;
+}
+
+float EngineControl::getIgnitionAdvance() {
+    float engineLoad = map;
+    float baseAdvance = 10.0; // Базовый УОЗ
+    
+    // Добавляем коррекцию от обучения
+    float ignitionCorr = ignitionLearning.getCorrection(engineLoad, rpm);
+    
+    return baseAdvance + ignitionCorr;
+}
+
+bool EngineControl::saveLearningTables() {
+    return fuelLearning.save() && ignitionLearning.save();
+}
+
+bool EngineControl::loadLearningTables() {
+    return fuelLearning.load() && ignitionLearning.load();
+}

engine_control.h

@@ -0,0 +1,49 @@
+#pragma once
+#include "Arduino.h"
+#include "structures.h"
+#include "fuel_learning_table.h"
+#include "ignition_learning_table.h"
+
+class EngineControl {
+private:
+    float rpm;
+    float map;
+    float tps;
+    float lambda;
+    float engineTemp;
+    float voltage;
+    
+    FuelLearningTable fuelLearning;
+    IgnitionLearningTable ignitionLearning;
+    bool learningEnabled;
+    uint32_t knockEvents;
+    float currentFuelCorrection;
+    float currentIgnitionCorrection;
+
+public:
+    float knockLevel; // Перемещено в public для доступа из основного кода
+    
+    EngineControl();
+    void begin();
+    void update();
+    
+    // Геттеры
+    float getRPM() const { return rpm; }
+    float getMAP() const { return map; }
+    float getTPS() const { return tps; }
+    float getLambda() const { return lambda; }
+    float getEngineTemp() const { return engineTemp; }
+    float getVoltage() const { return voltage; }
+    float getLearningProgress() const;
+    float getIgnitionAdvance();
+    uint32_t getKnockEvents() const { return knockEvents; }
+    float getCurrentFuelCorrection() const { return currentFuelCorrection; }
+    float getCurrentIgnitionCorrection() const { return currentIgnitionCorrection; }
+    
+    // Управление обучением
+    void resetLearning() { fuelLearning.reset(); ignitionLearning.reset(); }
+    bool saveLearningTables();
+    bool loadLearningTables();
+    void setLearningEnabled(bool enabled) { learningEnabled = enabled; }
+    bool isLearningEnabled() const { return learningEnabled; }
+};

fuel_learning.cpp

@@ -0,0 +1,128 @@
+#include "fuel_learning.h"
+#include <Preferences.h>
+
+FuelLearningTable::FuelLearningTable() :
+    learningRate(0.01),
+    maxCorrection(1.2),
+    minCorrection(0.8)
+{
+    // Инициализация точек нагрузки (кПа)
+    for (int i = 0; i < LOAD_POINTS; i++) {
+        loadPoints[i] = 20.0 + (i * 6.0); // 20-110 кПа
+    }
+    
+    // Инициализация точек оборотов
+    for (int i = 0; i < RPM_POINTS; i++) {
+        rpmPoints[i] = 800.0 + (i * 400.0); // 800-6800 RPM
+    }
+    
+    // Инициализация ячеек коррекции
+    reset();
+}
+
+void FuelLearningTable::begin() {
+    load(); // Загрузка сохраненных данных
+}
+
+void FuelLearningTable::reset() {
+    for (int i = 0; i < LOAD_POINTS; i++) {
+        for (int j = 0; j < RPM_POINTS; j++) {
+            cells[i][j] = 1.0; // Нейтральная коррекция
+        }
+    }
+}
+
+int FuelLearningTable::findNearestIndex(float value, const float* points, int size) {
+    if (value <= points[0]) return 0;
+    if (value >= points[size-1]) return size - 2;
+    
+    for (int i = 0; i < size - 1; i++) {
+        if (value >= points[i] && value < points[i+1]) {
+            return i;
+        }
+    }
+    return 0;
+}
+
+float FuelLearningTable::interpolate2D(float load, float rpm) {
+    // Находим ближайшие индексы
+    int loadIdx = findNearestIndex(load, loadPoints, LOAD_POINTS);
+    int rpmIdx = findNearestIndex(rpm, rpmPoints, RPM_POINTS);
+    
+    // Находим веса для интерполяции
+    float loadWeight = (load - loadPoints[loadIdx]) / 
+                      (loadPoints[loadIdx+1] - loadPoints[loadIdx]);
+    float rpmWeight = (rpm - rpmPoints[rpmIdx]) / 
+                     (rpmPoints[rpmIdx+1] - rpmPoints[rpmIdx]);
+    
+    // Билинейная интерполяция
+    float c00 = cells[loadIdx][rpmIdx];
+    float c10 = cells[loadIdx+1][rpmIdx];
+    float c01 = cells[loadIdx][rpmIdx+1];
+    float c11 = cells[loadIdx+1][rpmIdx+1];
+    
+    float c0 = c00 * (1 - loadWeight) + c10 * loadWeight;
+    float c1 = c01 * (1 - loadWeight) + c11 * loadWeight;
+    
+    return c0 * (1 - rpmWeight) + c1 * rpmWeight;
+}
+
+void FuelLearningTable::updateCell(int loadIdx, int rpmIdx, float correction) {
+    // Применяем коррекцию с учетом скорости обучения
+    cells[loadIdx][rpmIdx] += correction * learningRate;
+    
+    // Ограничиваем значение коррекции
+    cells[loadIdx][rpmIdx] = constrain(cells[loadIdx][rpmIdx], 
+                                     minCorrection, maxCorrection);
+}
+
+float FuelLearningTable::getCorrection(float load, float rpm) {
+    return interpolate2D(load, rpm);
+}
+
+void FuelLearningTable::learn(float load, float rpm, float lambdaError) {
+    // Находим ближайшие ячейки
+    int loadIdx = findNearestIndex(load, loadPoints, LOAD_POINTS);
+    int rpmIdx = findNearestIndex(rpm, rpmPoints, RPM_POINTS);
+    
+    // Обновляем основную ячейку
+    updateCell(loadIdx, rpmIdx, lambdaError);
+    
+    // Обновляем соседние ячейки с меньшим весом
+    if (loadIdx > 0) {
+        updateCell(loadIdx-1, rpmIdx, lambdaError * 0.5);
+    }
+    if (loadIdx < LOAD_POINTS-1) {
+        updateCell(loadIdx+1, rpmIdx, lambdaError * 0.5);
+    }
+    if (rpmIdx > 0) {
+        updateCell(loadIdx, rpmIdx-1, lambdaError * 0.5);
+    }
+    if (rpmIdx < RPM_POINTS-1) {
+        updateCell(loadIdx, rpmIdx+1, lambdaError * 0.5);
+    }
+}
+
+bool FuelLearningTable::save() {
+    Preferences prefs;
+    prefs.begin("fuel_learn", false);
+    
+    // Сохраняем таблицу коррекции
+    size_t written = prefs.putBytes("cells", cells, 
+                                  sizeof(float) * LOAD_POINTS * RPM_POINTS);
+    
+    prefs.end();
+    return written == sizeof(float) * LOAD_POINTS * RPM_POINTS;
+}
+
+bool FuelLearningTable::load() {
+    Preferences prefs;
+    prefs.begin("fuel_learn", true);
+    
+    // Загружаем таблицу коррекции
+    size_t readSize = prefs.getBytes("cells", cells, 
+                                   sizeof(float) * LOAD_POINTS * RPM_POINTS);
+    
+    prefs.end();
+    return readSize == sizeof(float) * LOAD_POINTS * RPM_POINTS;
+}

fuel_learning.h

@@ -0,0 +1,48 @@
+#ifndef FUEL_LEARNING_H
+#define FUEL_LEARNING_H
+
+#include <Arduino.h>
+#include "config.h"
+
+// Размеры таблиц обучения
+#define LOAD_POINTS 16    // Точки по нагрузке
+#define RPM_POINTS 16     // Точки по оборотам
+
+class FuelLearningTable {
+private:
+    float cells[LOAD_POINTS][RPM_POINTS];    // Таблица коррекции
+    float loadPoints[LOAD_POINTS];           // Точки по нагрузке (кПа)
+    float rpmPoints[RPM_POINTS];            // Точки по оборотам
+    float learningRate;                     // Скорость обучения
+    float maxCorrection;                    // Максимальная коррекция
+    float minCorrection;                    // Минимальная коррекция
+    
+    // Вспомогательные методы
+    int findNearestIndex(float value, const float* points, int size);
+    float interpolate2D(float load, float rpm);
+    void updateCell(int loadIdx, int rpmIdx, float correction);
+    
+public:
+    FuelLearningTable();
+    
+    // Основные методы
+    void begin();
+    float getCorrection(float load, float rpm);
+    void learn(float load, float rpm, float lambdaError);
+    void reset();
+    
+    // Методы сохранения/загрузки
+    bool save();
+    bool load();
+    
+    // Настройка параметров
+    void setLearningRate(float rate);
+    void setCorrectionLimits(float min, float max);
+    
+    // Доступ к данным для визуализации
+    float getCellValue(int loadIdx, int rpmIdx);
+    float getLoadPoint(int idx);
+    float getRPMPoint(int idx);
+};
+
+#endif

fuel_learning_table.cpp

@@ -0,0 +1,65 @@
+#include "fuel_learning_table.h"
+#include "SD.h"
+#include "maps.h"
+
+FuelLearningTable::FuelLearningTable() {
+    reset();
+}
+
+void FuelLearningTable::reset() {
+    for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+            corrections[i][j] = 1.0;
+            cellHits[i][j] = 0;
+        }
+    }
+}
+
+bool FuelLearningTable::save() {
+    File file = SD.open("/fuel_learning.bin", FILE_WRITE);
+    if (!file) return false;
+    
+    file.write((uint8_t*)corrections, sizeof(corrections));
+    file.write((uint8_t*)cellHits, sizeof(cellHits));
+    file.close();
+    return true;
+}
+
+bool FuelLearningTable::load() {
+    File file = SD.open("/fuel_learning.bin", FILE_READ);
+    if (!file) return false;
+    
+    file.read((uint8_t*)corrections, sizeof(corrections));
+    file.read((uint8_t*)cellHits, sizeof(cellHits));
+    file.close();
+    return true;
+}
+
+float FuelLearningTable::getCorrection(float load, float rpm) {
+    int loadIdx = constrain(mapf(load, 0, 100, 0, 15), 0, 15);
+    int rpmIdx = constrain(mapf(rpm, 0, 7000, 0, 15), 0, 15);
+    return corrections[loadIdx][rpmIdx];
+}
+
+void FuelLearningTable::update(float load, float rpm, float correction) {
+    int loadIdx = constrain(mapf(load, 0, 100, 0, 15), 0, 15);
+    int rpmIdx = constrain(mapf(rpm, 0, 7000, 0, 15), 0, 15);
+    
+    float currentCorr = corrections[loadIdx][rpmIdx];
+    float learningRate = 0.1f / (1.0f + cellHits[loadIdx][rpmIdx]);
+    corrections[loadIdx][rpmIdx] = currentCorr + (correction - currentCorr) * learningRate;
+    cellHits[loadIdx][rpmIdx]++;
+}
+
+float FuelLearningTable::getProgress() const {
+    int totalCells = 16 * 16;
+    int learnedCells = 0;
+    
+    for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+            if (cellHits[i][j] > 0) learnedCells++;
+        }
+    }
+    
+    return (float)learnedCells / totalCells;
+}

fuel_learning_table.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "Arduino.h"
+
+class FuelLearningTable {
+private:
+    float corrections[16][16];
+    uint32_t cellHits[16][16];
+    
+public:
+    FuelLearningTable();
+    void reset();
+    bool save();
+    bool load();
+    float getCorrection(float load, float rpm);
+    void update(float load, float rpm, float correction);
+    float getProgress() const;
+};

idle_control.cpp

@@ -0,0 +1,102 @@
+#include "idle_control.h"
+#include "config.h"
+#include <Arduino.h>
+#include "maps.h"
+
+IdleController::IdleController() :
+    targetRPM(800),
+    currentPosition(0),
+    lastUpdateTime(0),
+    isAirConditionerOn(false),
+    engineTemp(20.0),
+    engineControl(nullptr),
+    pid(0.1, 0.05, 0.02)  // Начальные значения коэффициентов ПИД
+{
+}
+
+void IdleController::begin() {
+    // Настройка ШИМ каналов для РХХ
+    ledcSetup(0, IDLE_VALVE_PWM_FREQ, IDLE_VALVE_PWM_RES); // Канал 0 для пина A
+    ledcSetup(1, IDLE_VALVE_PWM_FREQ, IDLE_VALVE_PWM_RES); // Канал 1 для пина B
+    
+    ledcAttachPin(IDLE_VALVE_PIN_A, 0); // Привязываем пин A к каналу 0
+    ledcAttachPin(IDLE_VALVE_PIN_B, 1); // Привязываем пин B к каналу 1
+    
+    // Начальные значения ШИМ
+    ledcWrite(0, 0);
+    ledcWrite(1, 0);
+    
+    // Инициализация ПИД-регулятора
+    pid.SetMode(true); // Включаем автоматический режим
+    pid.SetOutputLimits(0, 255);
+    pid.SetSampleTime(50);
+    
+    lastUpdateTime = millis();
+    
+    // Установка начального положения
+    updateValvePosition(0);
+}
+
+void IdleController::updateValvePosition(float position) {
+    position = constrain(position, 0, 255);
+    currentPosition = position;
+    
+    // Преобразование позиции в ШИМ
+    int pwmValue = mapf(position, 0, 255, 0, (1 << IDLE_VALVE_PWM_RES) - 1);
+    
+    // Управление моторчиком РХХ
+    ledcWrite(0, pwmValue);
+    ledcWrite(1, 0);
+}
+
+void IdleController::update(float currentRPM) {
+    unsigned long currentTime = millis();
+    float dt = (currentTime - lastUpdateTime) / 1000.0;
+    lastUpdateTime = currentTime;
+
+    // Проверяем наличие объекта управления двигателем
+    if (!engineControl) return;
+    
+    // Получаем текущую температуру двигателя
+    float engineTemp = engineControl->getEngineTemp();
+    
+    // Корректируем целевые обороты в зависимости от температуры
+    float adjustedTargetRpm = targetRPM;
+    if (engineTemp < 60) { // Если двигатель холодный
+        adjustedTargetRpm += (60 - engineTemp) * 6.67f; // Увеличиваем на 400 RPM при 0°C, линейно уменьшая до 60°C
+    }
+    
+    // Добавляем компенсацию для кондиционера
+    if (isAirConditionerOn) {
+        adjustedTargetRpm += 50; // Увеличиваем на 50 RPM при включенном кондиционере
+    }
+    
+    // Обновляем ПИД
+    pid.SetSetpoint(adjustedTargetRpm);
+    pid.SetInput(currentRPM);
+    if (pid.Compute()) {
+        // Применяем выход ПИД к положению РХХ
+        setPosition(pid.GetOutput());
+    }
+}
+
+void IdleController::setEngineTemperature(float temp) {
+    engineTemp = temp;
+}
+
+void IdleController::setAirConditioner(bool isOn) {
+    isAirConditionerOn = isOn;
+}
+
+void IdleController::loadSettings() {
+    // Здесь должна быть загрузка настроек из EEPROM или SD
+    // Пока используем значения по умолчанию
+    settings.targetRPM = 800;
+    settings.valveMinPosition = 0;
+    settings.valveMaxPosition = 255;
+    settings.rpmTolerance = 50;
+}
+
+void IdleController::saveSettings() {
+    // Здесь должно быть сохранение настроек в EEPROM или SD
+}

idle_control.h

@@ -0,0 +1,53 @@
+#pragma once
+#include "Arduino.h"
+#include "config.h"
+#include "engine_control.h"
+#include "pid_controller.h"
+
+class IdleController {
+private:
+    float targetRPM;
+    float currentPosition;
+    unsigned long lastUpdateTime;
+    bool isAirConditionerOn;
+    float engineTemp;
+    
+    // ПИД-регулятор
+    PIDController pid;
+    
+    // Указатель на объект управления двигателем для получения температуры
+    EngineControl* engineControl;
+    
+    // Вспомогательные методы
+    void updateValvePosition(float position);
+    
+public:
+    IdleController();
+    void begin();
+    void update(float currentRPM);
+    
+    // Методы для работы с целевыми оборотами
+    void setTargetRPM(float rpm) { 
+        if (rpm >= 700 && rpm <= 2000) {
+            targetRPM = rpm;
+            pid.SetSetpoint(rpm);
+        }
+    }
+    float getTargetRPM() const { return targetRPM; }
+    
+    // Методы для настройки ПИД
+    void setPIDParameters(float kp, float ki, float kd) {
+        pid.SetTunings(kp, ki, kd);
+    }
+    
+    // Методы для управления положением
+    void setPosition(float position) { updateValvePosition(position); }
+    float getCurrentPosition() const { return currentPosition; }
+    
+    // Методы для работы с температурой и кондиционером
+    void setEngineTemperature(float temp) { engineTemp = temp; }
+    void setAirConditioner(bool isOn) { isAirConditionerOn = isOn; }
+    
+    // Метод для установки указателя на объект управления двигателем
+    void setEngineControl(EngineControl* control) { engineControl = control; }
+};

ignition_learning.cpp

@@ -0,0 +1,166 @@
+#include "ignition_learning.h"
+#include <Preferences.h>
+
+IgnitionLearningTable::IgnitionLearningTable() :
+    learningRate(0.05),
+    maxCorrection(5.0),
+    minCorrection(-5.0),
+    knockThreshold(0.8),
+    knockProtectionOffset(2.0),
+    knockHistorySize(10)
+{
+    // Инициализация точек нагрузки (кПа)
+    for (int i = 0; i < LOAD_POINTS; i++) {
+        loadPoints[i] = 20.0 + (i * 6.0); // 20-110 кПа
+    }
+    
+    // Инициализация точек оборотов
+    for (int i = 0; i < RPM_POINTS; i++) {
+        rpmPoints[i] = 800.0 + (i * 400.0); // 800-6800 RPM
+    }
+    
+    // Инициализация ячеек коррекции и истории детонации
+    reset();
+}
+
+void IgnitionLearningTable::begin() {
+    load(); // Загрузка сохраненных данных
+}
+
+void IgnitionLearningTable::reset() {
+    for (int i = 0; i < LOAD_POINTS; i++) {
+        for (int j = 0; j < RPM_POINTS; j++) {
+            cells[i][j] = 0.0; // Нейтральная коррекция
+            knockHistory[i][j] = 0; // Сброс истории детонации
+        }
+    }
+}
+
+int IgnitionLearningTable::findNearestIndex(float value, const float* points, int size) {
+    if (value <= points[0]) return 0;
+    if (value >= points[size-1]) return size - 2;
+    
+    for (int i = 0; i < size - 1; i++) {
+        if (value >= points[i] && value < points[i+1]) {
+            return i;
+        }
+    }
+    return 0;
+}
+
+float IgnitionLearningTable::interpolate2D(float load, float rpm) {
+    // Находим ближайшие индексы
+    int loadIdx = findNearestIndex(load, loadPoints, LOAD_POINTS);
+    int rpmIdx = findNearestIndex(rpm, rpmPoints, RPM_POINTS);
+    
+    // Находим веса для интерполяции
+    float loadWeight = (load - loadPoints[loadIdx]) / 
+                      (loadPoints[loadIdx+1] - loadPoints[loadIdx]);
+    float rpmWeight = (rpm - rpmPoints[rpmIdx]) / 
+                     (rpmPoints[rpmIdx+1] - rpmPoints[rpmIdx]);
+    
+    // Билинейная интерполяция
+    float c00 = cells[loadIdx][rpmIdx];
+    float c10 = cells[loadIdx+1][rpmIdx];
+    float c01 = cells[loadIdx][rpmIdx+1];
+    float c11 = cells[loadIdx+1][rpmIdx+1];
+    
+    float c0 = c00 * (1 - loadWeight) + c10 * loadWeight;
+    float c1 = c01 * (1 - loadWeight) + c11 * loadWeight;
+    
+    return c0 * (1 - rpmWeight) + c1 * rpmWeight;
+}
+
+void IgnitionLearningTable::updateCell(int loadIdx, int rpmIdx, float correction) {
+    // Применяем коррекцию с учетом скорости обучения
+    cells[loadIdx][rpmIdx] += correction * learningRate;
+    
+    // Ограничиваем значение коррекции
+    cells[loadIdx][rpmIdx] = constrain(cells[loadIdx][rpmIdx], 
+                                     minCorrection, maxCorrection);
+}
+
+void IgnitionLearningTable::updateKnockHistory(int loadIdx, int rpmIdx, bool knockDetected) {
+    // Сдвигаем историю
+    knockHistory[loadIdx][rpmIdx] = (knockHistory[loadIdx][rpmIdx] << 1) | (knockDetected ? 1 : 0);
+    knockHistory[loadIdx][rpmIdx] &= ((1 << knockHistorySize) - 1); // Ограничиваем размер
+}
+
+float IgnitionLearningTable::getCorrection(float load, float rpm) {
+    return interpolate2D(load, rpm);
+}
+
+void IgnitionLearningTable::learn(float load, float rpm, float knockLevel) {
+    // Находим ближайшие ячейки
+    int loadIdx = findNearestIndex(load, loadPoints, LOAD_POINTS);
+    int rpmIdx = findNearestIndex(rpm, rpmPoints, RPM_POINTS);
+    
+    bool knockDetected = knockLevel > knockThreshold;
+    updateKnockHistory(loadIdx, rpmIdx, knockDetected);
+    
+    float correction = 0;
+    
+    if (knockDetected) {
+        // При детонации уменьшаем УОЗ
+        correction = -knockProtectionOffset;
+    } else {
+        // Если детонации нет, медленно увеличиваем УОЗ
+        // но только если в истории нет детонации
+        if (knockHistory[loadIdx][rpmIdx] == 0) {
+            correction = 0.1;
+        }
+    }
+    
+    // Обновляем основную ячейку
+    updateCell(loadIdx, rpmIdx, correction);
+    
+    // Обновляем соседние ячейки с меньшим весом
+    if (knockDetected) {
+        if (loadIdx > 0) {
+            updateCell(loadIdx-1, rpmIdx, correction * 0.5);
+        }
+        if (loadIdx < LOAD_POINTS-1) {
+            updateCell(loadIdx+1, rpmIdx, correction * 0.5);
+        }
+        if (rpmIdx > 0) {
+            updateCell(loadIdx, rpmIdx-1, correction * 0.5);
+        }
+        if (rpmIdx < RPM_POINTS-1) {
+            updateCell(loadIdx, rpmIdx+1, correction * 0.5);
+        }
+    }
+}
+
+bool IgnitionLearningTable::save() {
+    Preferences prefs;
+    prefs.begin("ign_learn", false);
+    
+    // Сохраняем таблицу коррекции
+    size_t written = prefs.putBytes("cells", cells, 
+                                  sizeof(float) * LOAD_POINTS * RPM_POINTS);
+    
+    // Сохраняем историю детонации
+    written += prefs.putBytes("knock_hist", knockHistory, 
+                            sizeof(uint8_t) * LOAD_POINTS * RPM_POINTS);
+    
+    prefs.end();
+    return written == sizeof(float) * LOAD_POINTS * RPM_POINTS + 
+                     sizeof(uint8_t) * LOAD_POINTS * RPM_POINTS;
+}
+
+bool IgnitionLearningTable::load() {
+    Preferences prefs;
+    prefs.begin("ign_learn", true);
+    
+    // Загружаем таблицу коррекции
+    size_t readSize = prefs.getBytes("cells", cells, 
+                                   sizeof(float) * LOAD_POINTS * RPM_POINTS);
+    
+    // Загружаем историю детонации
+    readSize += prefs.getBytes("knock_hist", knockHistory, 
+                             sizeof(uint8_t) * LOAD_POINTS * RPM_POINTS);
+    
+    prefs.end();
+    return readSize == sizeof(float) * LOAD_POINTS * RPM_POINTS + 
+                      sizeof(uint8_t) * LOAD_POINTS * RPM_POINTS;
+}

ignition_learning.h

@@ -0,0 +1,57 @@
+#ifndef IGNITION_LEARNING_H
+#define IGNITION_LEARNING_H
+
+#include <Arduino.h>
+#include "config.h"
+
+// Размеры таблиц обучения
+#define LOAD_POINTS 16    // Точки по нагрузке
+#define RPM_POINTS 16     // Точки по оборотам
+
+class IgnitionLearningTable {
+private:
+    float cells[LOAD_POINTS][RPM_POINTS];    // Таблица коррекции УОЗ
+    float loadPoints[LOAD_POINTS];           // Точки по нагрузке (кПа)
+    float rpmPoints[RPM_POINTS];            // Точки по оборотам
+    float learningRate;                     // Скорость обучения
+    float maxCorrection;                    // Максимальная коррекция
+    float minCorrection;                    // Минимальная коррекция
+    float knockThreshold;                   // Порог детонации
+    float knockProtectionOffset;            // Защитное смещение при детонации
+    
+    // История детонации для каждой ячейки
+    uint8_t knockHistory[LOAD_POINTS][RPM_POINTS];
+    uint8_t knockHistorySize;
+    
+    // Вспомогательные методы
+    int findNearestIndex(float value, const float* points, int size);
+    float interpolate2D(float load, float rpm);
+    void updateCell(int loadIdx, int rpmIdx, float correction);
+    void updateKnockHistory(int loadIdx, int rpmIdx, bool knockDetected);
+    
+public:
+    IgnitionLearningTable();
+    
+    // Основные методы
+    void begin();
+    float getCorrection(float load, float rpm);
+    void learn(float load, float rpm, float knockLevel);
+    void reset();
+    
+    // Методы сохранения/загрузки
+    bool save();
+    bool load();
+    
+    // Настройка параметров
+    void setLearningRate(float rate);
+    void setCorrectionLimits(float min, float max);
+    void setKnockParameters(float threshold, float protection);
+    
+    // Доступ к данным для визуализации
+    float getCellValue(int loadIdx, int rpmIdx);
+    float getLoadPoint(int idx);
+    float getRPMPoint(int idx);
+    uint8_t getKnockCount(int loadIdx, int rpmIdx);
+};
+
+#endif

ignition_learning_table.cpp

@@ -0,0 +1,68 @@
+#include "ignition_learning_table.h"
+#include "SD.h"
+#include "maps.h"
+
+IgnitionLearningTable::IgnitionLearningTable() {
+    reset();
+}
+
+void IgnitionLearningTable::reset() {
+    for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+            corrections[i][j] = 0.0;
+            cellHits[i][j] = 0;
+        }
+    }
+}
+
+bool IgnitionLearningTable::save() {
+    File file = SD.open("/ignition_learning.bin", FILE_WRITE);
+    if (!file) return false;
+    
+    file.write((uint8_t*)corrections, sizeof(corrections));
+    file.write((uint8_t*)cellHits, sizeof(cellHits));
+    file.close();
+    return true;
+}
+
+bool IgnitionLearningTable::load() {
+    File file = SD.open("/ignition_learning.bin", FILE_READ);
+    if (!file) return false;
+    
+    file.read((uint8_t*)corrections, sizeof(corrections));
+    file.read((uint8_t*)cellHits, sizeof(cellHits));
+    file.close();
+    return true;
+}
+
+float IgnitionLearningTable::getCorrection(float load, float rpm) {
+    int loadIdx = constrain(mapf(load, 0, 100, 0, 15), 0, 15);
+    int rpmIdx = constrain(mapf(rpm, 0, 7000, 0, 15), 0, 15);
+    return corrections[loadIdx][rpmIdx];
+}
+
+void IgnitionLearningTable::learn(float load, float rpm, float knockLevel) {
+    int loadIdx = constrain(mapf(load, 0, 100, 0, 15), 0, 15);
+    int rpmIdx = constrain(mapf(rpm, 0, 7000, 0, 15), 0, 15);
+    
+    if (knockLevel > 0.5) { // Если есть детонация
+        float currentCorr = corrections[loadIdx][rpmIdx];
+        float learningRate = 0.5f / (1.0f + cellHits[loadIdx][rpmIdx]);
+        corrections[loadIdx][rpmIdx] = currentCorr - learningRate; // Уменьшаем УОЗ
+    }
+    
+    cellHits[loadIdx][rpmIdx]++;
+}
+
+float IgnitionLearningTable::getProgress() const {
+    int totalCells = 16 * 16;
+    int learnedCells = 0;
+    
+    for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+            if (cellHits[i][j] > 0) learnedCells++;
+        }
+    }
+    
+    return (float)learnedCells / totalCells;
+}

ignition_learning_table.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "Arduino.h"
+
+class IgnitionLearningTable {
+private:
+    float corrections[16][16];
+    uint32_t cellHits[16][16];
+    
+public:
+    IgnitionLearningTable();
+    void reset();
+    bool save();
+    bool load();
+    float getCorrection(float load, float rpm);
+    void learn(float load, float rpm, float knockLevel);
+    float getProgress() const;
+};

learning_manager.cpp

@@ -0,0 +1,256 @@
+#include "learning_manager.h"
+#include <ArduinoJson.h>
+
+LearningManager::LearningManager() :
+    isLearningEnabled(false),
+    isFuelLearningEnabled(true),
+    isIgnitionLearningEnabled(true),
+    learningStartTime(0),
+    minLearningTime(300000), // 5 минут
+    minEngineTemp(60),       // 60°C
+    maxEngineTemp(100),      // 100°C
+    minThrottlePosition(5),  // 5%
+    maxThrottlePosition(95), // 95%
+    totalLearningPoints(0),
+    knockEvents(0),
+    richMixtureEvents(0),
+    leanMixtureEvents(0)
+{
+}
+
+void LearningManager::begin() {
+    fuelTable.begin();
+    ignitionTable.begin();
+    
+    // Загружаем сохраненные данные
+    load();
+    
+    // Устанавливаем параметры обучения
+    fuelTable.setLearningRate(0.01);
+    fuelTable.setCorrectionLimits(0.8, 1.2);
+    
+    ignitionTable.setLearningRate(0.05);
+    ignitionTable.setCorrectionLimits(-5.0, 5.0);
+    ignitionTable.setKnockParameters(0.8, 2.0);
+    
+    learningStartTime = millis();
+}
+
+bool LearningManager::checkLearningConditions(float engineTemp, float throttlePosition) {
+    // Проверка времени работы двигателя
+    if (millis() - learningStartTime < minLearningTime) {
+        return false;
+    }
+    
+    // Проверка температуры двигателя
+    if (engineTemp < minEngineTemp || engineTemp > maxEngineTemp) {
+        return false;
+    }
+    
+    // Проверка положения дросселя
+    if (throttlePosition < minThrottlePosition || throttlePosition > maxThrottlePosition) {
+        return false;
+    }
+    
+    return true;
+}
+
+void LearningManager::update(float load, float rpm, float lambda, float knockLevel,
+                           float engineTemp, float throttlePosition) {
+    if (!isLearningEnabled || !checkLearningConditions(engineTemp, throttlePosition)) {
+        return;
+    }
+    
+    // Обучение топливной карты
+    if (isFuelLearningEnabled) {
+        float lambdaError = lambda - 1.0; // Отклонение от стехиометрии
+        if (abs(lambdaError) > 0.02) {    // Порог ошибки 2%
+            fuelTable.learn(load, rpm, lambdaError);
+            if (lambdaError > 0) {
+                richMixtureEvents++;
+            } else {
+                leanMixtureEvents++;
+            }
+        }
+    }
+    
+    // Обучение карты УОЗ
+    if (isIgnitionLearningEnabled) {
+        ignitionTable.learn(load, rpm, knockLevel);
+        if (knockLevel > 0.8) { // Порог детонации
+            knockEvents++;
+        }
+    }
+    
+    totalLearningPoints++;
+}
+
+float LearningManager::getFuelCorrection(float load, float rpm) {
+    return fuelTable.getCorrection(load, rpm);
+}
+
+float LearningManager::getIgnitionCorrection(float load, float rpm) {
+    return ignitionTable.getCorrection(load, rpm);
+}
+
+void LearningManager::setLearningParameters(float minTemp, float maxTemp,
+                                          float minThrottle, float maxThrottle) {
+    minEngineTemp = minTemp;
+    maxEngineTemp = maxTemp;
+    minThrottlePosition = minThrottle;
+    maxThrottlePosition = maxThrottle;
+}
+
+void LearningManager::setLearningRates(float fuelRate, float ignitionRate) {
+    fuelTable.setLearningRate(fuelRate);
+    ignitionTable.setLearningRate(ignitionRate);
+}
+
+bool LearningManager::save() {
+    bool fuelSaved = fuelTable.save();
+    bool ignitionSaved = ignitionTable.save();
+    
+    // Сохраняем статистику
+    Preferences prefs;
+    prefs.begin("learning", false);
+    prefs.putUInt("total_points", totalLearningPoints);
+    prefs.putUInt("knock_events", knockEvents);
+    prefs.putUInt("rich_events", richMixtureEvents);
+    prefs.putUInt("lean_events", leanMixtureEvents);
+    prefs.end();
+    
+    return fuelSaved && ignitionSaved;
+}
+
+bool LearningManager::load() {
+    bool fuelLoaded = fuelTable.load();
+    bool ignitionLoaded = ignitionTable.load();
+    
+    // Загружаем статистику
+    Preferences prefs;
+    prefs.begin("learning", true);
+    totalLearningPoints = prefs.getUInt("total_points", 0);
+    knockEvents = prefs.getUInt("knock_events", 0);
+    richMixtureEvents = prefs.getUInt("rich_events", 0);
+    leanMixtureEvents = prefs.getUInt("lean_events", 0);
+    prefs.end();
+    
+    return fuelLoaded && ignitionLoaded;
+}
+
+void LearningManager::reset() {
+    fuelTable.reset();
+    ignitionTable.reset();
+    totalLearningPoints = 0;
+    knockEvents = 0;
+    richMixtureEvents = 0;
+    leanMixtureEvents = 0;
+    save();
+}
+
+void LearningManager::enable() {
+    isLearningEnabled = true;
+    learningStartTime = millis();
+}
+
+void LearningManager::disable() {
+    isLearningEnabled = false;
+}
+
+uint32_t LearningManager::getTotalLearningPoints() const {
+    return totalLearningPoints;
+}
+
+uint32_t LearningManager::getKnockEvents() const {
+    return knockEvents;
+}
+
+uint32_t LearningManager::getRichMixtureEvents() const {
+    return richMixtureEvents;
+}
+
+uint32_t LearningManager::getLeanMixtureEvents() const {
+    return leanMixtureEvents;
+}
+
+float LearningManager::getLearningProgress() const {
+    // Максимальное количество точек обучения (16x16 ячеек, минимум 10 точек на ячейку)
+    const uint32_t maxPoints = 16 * 16 * 10;
+    return (float)totalLearningPoints / maxPoints * 100.0f;
+}
+
+String LearningManager::exportToJson() {
+    DynamicJsonDocument doc(8192);
+    
+    // Основные параметры
+    doc["enabled"] = isLearningEnabled;
+    doc["fuel_enabled"] = isFuelLearningEnabled;
+    doc["ignition_enabled"] = isIgnitionLearningEnabled;
+    
+    // Статистика
+    JsonObject stats = doc.createNestedObject("statistics");
+    stats["total_points"] = totalLearningPoints;
+    stats["knock_events"] = knockEvents;
+    stats["rich_events"] = richMixtureEvents;
+    stats["lean_events"] = leanMixtureEvents;
+    stats["progress"] = getLearningProgress();
+    
+    // Топливная карта
+    JsonArray fuelMap = doc.createNestedArray("fuel_map");
+    for (int i = 0; i < 16; i++) {
+        JsonArray row = fuelMap.createNestedArray();
+        for (int j = 0; j < 16; j++) {
+            row.add(fuelTable.getCellValue(i, j));
+        }
+    }
+    
+    // Карта УОЗ
+    JsonArray ignitionMap = doc.createNestedArray("ignition_map");
+    for (int i = 0; i < 16; i++) {
+        JsonArray row = ignitionMap.createNestedArray();
+        for (int j = 0; j < 16; j++) {
+            row.add(ignitionTable.getCellValue(i, j));
+        }
+    }
+    
+    String output;
+    serializeJson(doc, output);
+    return output;
+}
+
+bool LearningManager::importFromJson(const String& json) {
+    DynamicJsonDocument doc(8192);
+    DeserializationError error = deserializeJson(doc, json);
+    
+    if (error) {
+        return false;
+    }
+    
+    // Временно отключаем обучение
+    bool wasEnabled = isLearningEnabled;
+    disable();
+    
+    // Сбрасываем текущие данные
+    reset();
+    
+    // Загружаем новые данные
+    if (doc.containsKey("enabled")) {
+        isLearningEnabled = doc["enabled"];
+    }
+    
+    if (doc.containsKey("statistics")) {
+        JsonObject stats = doc["statistics"];
+        totalLearningPoints = stats["total_points"] | 0;
+        knockEvents = stats["knock_events"] | 0;
+        richMixtureEvents = stats["rich_events"] | 0;
+        leanMixtureEvents = stats["lean_events"] | 0;
+    }
+    
+    // Восстанавливаем состояние обучения
+    if (wasEnabled) {
+        enable();
+    }
+    
+    // Сохраняем изменения
+    return save();
+}

learning_manager.h

@@ -0,0 +1,71 @@
+#ifndef LEARNING_MANAGER_H
+#define LEARNING_MANAGER_H
+
+#include "fuel_learning.h"
+#include "ignition_learning.h"
+#include <Preferences.h>
+
+class LearningManager {
+private:
+    FuelLearningTable fuelTable;
+    IgnitionLearningTable ignitionTable;
+    
+    // Параметры обучения
+    bool isLearningEnabled;
+    bool isFuelLearningEnabled;
+    bool isIgnitionLearningEnabled;
+    unsigned long learningStartTime;
+    unsigned long minLearningTime;      // Минимальное время работы для начала обучения
+    float minEngineTemp;                // Минимальная температура для обучения
+    float maxEngineTemp;                // Максимальная температура для обучения
+    float minThrottlePosition;          // Минимальное положение дросселя для обучения
+    float maxThrottlePosition;          // Максимальное положение дросселя для обучения
+    
+    // Статистика обучения
+    uint32_t totalLearningPoints;
+    uint32_t knockEvents;
+    uint32_t richMixtureEvents;
+    uint32_t leanMixtureEvents;
+    
+    // Проверка условий для обучения
+    bool checkLearningConditions(float engineTemp, float throttlePosition);
+    
+public:
+    LearningManager();
+    
+    // Инициализация и управление
+    void begin();
+    void enable();
+    void disable();
+    void reset();
+    
+    // Основные методы обучения
+    void update(float load, float rpm, float lambda, float knockLevel, 
+                float engineTemp, float throttlePosition);
+    
+    // Получение коррекций
+    float getFuelCorrection(float load, float rpm);
+    float getIgnitionCorrection(float load, float rpm);
+    
+    // Настройка параметров
+    void setLearningParameters(float minTemp, float maxTemp, 
+                             float minThrottle, float maxThrottle);
+    void setLearningRates(float fuelRate, float ignitionRate);
+    
+    // Сохранение/загрузка
+    bool save();
+    bool load();
+    
+    // Статистика и диагностика
+    uint32_t getTotalLearningPoints() const;
+    uint32_t getKnockEvents() const;
+    uint32_t getRichMixtureEvents() const;
+    uint32_t getLeanMixtureEvents() const;
+    float getLearningProgress() const;  // 0-100%
+    
+    // Экспорт данных
+    String exportToJson();
+    bool importFromJson(const String& json);
+};
+
+#endif

maps.cpp

@@ -0,0 +1,114 @@
+#include "maps.h"
+#include <Arduino.h>
+
+// Базовая карта УОЗ (16x16)
+const float baseIgnitionMap[16][16] = {
+    {10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 35, 35, 35}, // 0% нагрузки
+    {10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 35, 35, 35},
+    {8,  10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 34, 34},
+    {8,  10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 33, 33, 33},
+    {6,  8,  10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 31, 31, 31},
+    {6,  8,  10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 29, 30, 30, 30},
+    {4,  6,  8,  10, 12, 14, 16, 18, 20, 22, 24, 26, 27, 28, 28, 28},
+    {4,  6,  8,  10, 12, 14, 16, 18, 20, 22, 24, 25, 26, 27, 27, 27},
+    {2,  4,  6,  8,  10, 12, 14, 16, 18, 20, 22, 23, 24, 25, 25, 25},
+    {2,  4,  6,  8,  10, 12, 14, 16, 18, 20, 21, 22, 23, 24, 24, 24},
+    {0,  2,  4,  6,  8,  10, 12, 14, 16, 18, 19, 20, 21, 22, 22, 22},
+    {0,  2,  4,  6,  8,  10, 12, 14, 15, 16, 17, 18, 19, 20, 20, 20},
+    {0,  2,  4,  6,  8,  10, 11, 12, 13, 14, 15, 16, 17, 18, 18, 18},
+    {0,  2,  4,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 16, 16},
+    {0,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 14, 14},
+    {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 13, 13}  // 100% нагрузки
+};
+
+// Базовая карта длительности впрыска (16x16)
+const float baseInjectionMap[16][16] = {
+    {1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0}, // 0% нагрузки
+    {1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2},
+    {1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4},
+    {1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6},
+    {1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8},
+    {2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0},
+    {2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2},
+    {2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4},
+    {2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6},
+    {2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8},
+    {3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0},
+    {3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2},
+    {3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4},
+    {3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4, 6.6},
+    {3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4, 6.6, 6.8},
+    {4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4, 6.6, 6.8, 7.0}  // 100% нагрузки
+};
+
+// Вспомогательные функции для преобразования значений
+float mapf(float x, float in_min, float in_max, float out_min, float out_max) {
+    if (in_max == in_min) return out_min; // Защита от деления на ноль
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+float interpolate(float x, float in_min, float in_max, float out_min, float out_max) {
+    if (in_max == in_min) return out_min; // Защита от деления на ноль
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+int findNearestIndex(float value, float* array, int size) {
+    int idx = 0;
+    float minDiff = abs(value - array[0]);
+    for (int i = 1; i < size; i++) {
+        float diff = abs(value - array[i]);
+        if (diff < minDiff) {
+            minDiff = diff;
+            idx = i;
+        }
+    }
+    return idx;
+}
+
+float getBaseIgnition(float load, float rpm) {
+    // Находим ближайшие индексы для оборотов и нагрузки
+    float rpmMap[] = {0, 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000};
+    float mapMap[] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
+    int rpmIdx = findNearestIndex(rpm, rpmMap, 16);
+    int loadIdx = findNearestIndex(load, mapMap, 16);
+    
+    // Получаем значение из карты
+    float baseValue = baseIgnitionMap[rpmIdx][loadIdx];
+    
+    // Если нужна интерполяция и мы не на краях карты
+    if (rpmIdx < 15 && loadIdx < 15) {
+        float rpmFrac = (rpm - rpmMap[rpmIdx]) / (rpmMap[rpmIdx + 1] - rpmMap[rpmIdx]);
+        float loadFrac = (load - mapMap[loadIdx]) / (mapMap[loadIdx + 1] - mapMap[loadIdx]);
+        
+        // Билинейная интерполяция
+        float v1 = interpolate(rpmFrac, 0, 1, baseIgnitionMap[rpmIdx][loadIdx], baseIgnitionMap[rpmIdx + 1][loadIdx]);
+        float v2 = interpolate(rpmFrac, 0, 1, baseIgnitionMap[rpmIdx][loadIdx + 1], baseIgnitionMap[rpmIdx + 1][loadIdx + 1]);
+        baseValue = interpolate(loadFrac, 0, 1, v1, v2);
+    }
+    
+    return baseValue;
+}
+
+float getBaseInjection(float load, float rpm) {
+    // Находим ближайшие индексы для оборотов и нагрузки
+    float rpmMap[] = {0, 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000};
+    float mapMap[] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
+    int rpmIdx = findNearestIndex(rpm, rpmMap, 16);
+    int loadIdx = findNearestIndex(load, mapMap, 16);
+    
+    // Получаем значение из карты
+    float baseValue = baseInjectionMap[rpmIdx][loadIdx];
+    
+    // Если нужна интерполяция и мы не на краях карты
+    if (rpmIdx < 15 && loadIdx < 15) {
+        float rpmFrac = (rpm - rpmMap[rpmIdx]) / (rpmMap[rpmIdx + 1] - rpmMap[rpmIdx]);
+        float loadFrac = (load - mapMap[loadIdx]) / (mapMap[loadIdx + 1] - mapMap[loadIdx]);
+        
+        // Билинейная интерполяция
+        float v1 = interpolate(rpmFrac, 0, 1, baseInjectionMap[rpmIdx][loadIdx], baseInjectionMap[rpmIdx + 1][loadIdx]);
+        float v2 = interpolate(rpmFrac, 0, 1, baseInjectionMap[rpmIdx][loadIdx + 1], baseInjectionMap[rpmIdx + 1][loadIdx + 1]);
+        baseValue = interpolate(loadFrac, 0, 1, v1, v2);
+    }
+    
+    return baseValue;
+}

maps.h

@@ -0,0 +1,110 @@
+#ifndef MAPS_H
+#define MAPS_H
+
+// Карта оборотов для УОЗ и впрыска (RPM)
+const float rpmMap[16] = {
+    500,    // 0
+    1000,   // 1
+    1500,   // 2
+    2000,   // 3
+    2500,   // 4
+    3000,   // 5
+    3500,   // 6
+    4000,   // 7
+    4500,   // 8
+    5000,   // 9
+    5500,   // 10
+    6000,   // 11
+    6500,   // 12
+    7000,   // 13
+    7500,   // 14
+    8000    // 15
+};
+
+// Карта давления для УОЗ и впрыска (MAP в барах)
+const float mapMap[16] = {
+    0.2,    // 0
+    0.3,    // 1
+    0.4,    // 2
+    0.5,    // 3
+    0.6,    // 4
+    0.7,    // 5
+    0.8,    // 6
+    0.9,    // 7
+    1.0,    // 8
+    1.1,    // 9
+    1.2,    // 10
+    1.3,    // 11
+    1.4,    // 12
+    1.5,    // 13
+    1.6,    // 14
+    1.7     // 15
+};
+
+// Карта УОЗ (градусы)
+const float ignitionMap[16][16] = {
+    // MAP -> 0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.0  1.1  1.2  1.3  1.4  1.5  1.6  1.7
+    {5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20},  // 500 RPM
+    {6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21},  // 1000 RPM
+    {7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22},  // 1500 RPM
+    {8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23},  // 2000 RPM
+    {9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24},  // 2500 RPM
+    {10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25},  // 3000 RPM
+    {11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26},  // 3500 RPM
+    {12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27},  // 4000 RPM
+    {13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28},  // 4500 RPM
+    {14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29},  // 5000 RPM
+    {15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30},  // 5500 RPM
+    {16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31},  // 6000 RPM
+    {17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32},  // 6500 RPM
+    {18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33},  // 7000 RPM
+    {19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34},  // 7500 RPM
+    {20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35}   // 8000 RPM
+};
+
+// Карта впрыска (мс)
+const float injectionMap[16][16] = {
+    // MAP -> 0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.0  1.1  1.2  1.3  1.4  1.5  1.6  1.7
+    {1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0},  // 500 RPM
+    {1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2},  // 1000 RPM
+    {1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4},  // 1500 RPM
+    {1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6},  // 2000 RPM
+    {1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8},  // 2500 RPM
+    {2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0},  // 3000 RPM
+    {2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2},  // 3500 RPM
+    {2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4},  // 4000 RPM
+    {2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6},  // 4500 RPM
+    {2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8},  // 5000 RPM
+    {3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0},  // 5500 RPM
+    {3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2},  // 6000 RPM
+    {3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4},  // 6500 RPM
+    {3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4, 6.6},  // 7000 RPM
+    {3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4, 6.6, 6.8},  // 7500 RPM
+    {4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 6.2, 6.4, 6.6, 6.8, 7.0}   // 8000 RPM
+};
+
+// Функции для работы с картами
+float mapf(float x, float in_min, float in_max, float out_min, float out_max);
+float getBaseIgnition(float load, float rpm);
+float getBaseInjection(float load, float rpm);
+
+// Вспомогательные функции для интерполяции
+inline float interpolate(float x, float x1, float x2, float y1, float y2) {
+    return y1 + (x - x1) * (y2 - y1) / (x2 - x1);
+}
+
+inline int findNearestIndex(float value, const float* array, int size) {
+    int index = 0;
+    float minDiff = abs(value - array[0]);
+    
+    for(int i = 1; i < size; i++) {
+        float diff = abs(value - array[i]);
+        if(diff < minDiff) {
+            minDiff = diff;
+            index = i;
+        }
+    }
+    return index;
+}
+
+#endif

pid_controller.h

@@ -0,0 +1,119 @@
+#pragma once
+#include "Arduino.h"
+
+class PIDController {
+private:
+    double kp;
+    double ki;
+    double kd;
+    
+    double input;
+    double output;
+    double setpoint;
+    
+    unsigned long lastTime;
+    double outputSum;
+    double lastInput;
+    
+    double outMin;
+    double outMax;
+    int sampleTime;
+    bool inAuto;
+
+public:
+    PIDController(double Kp, double Ki, double Kd) :
+        kp(Kp),
+        ki(Ki),
+        kd(Kd),
+        input(0),
+        output(0),
+        setpoint(0),
+        lastTime(0),
+        outputSum(0),
+        lastInput(0),
+        outMin(0),
+        outMax(255),
+        sampleTime(100),
+        inAuto(false)
+    {
+    }
+    
+    bool Compute() {
+        if(!inAuto) return false;
+        
+        unsigned long now = millis();
+        unsigned long timeChange = (now - lastTime);
+        if(timeChange >= sampleTime) {
+            double error = setpoint - input;
+            
+            outputSum += (ki * error);
+            if(outputSum > outMax) outputSum = outMax;
+            else if(outputSum < outMin) outputSum = outMin;
+            
+            double dInput = (input - lastInput);
+            
+            output = kp * error + outputSum - kd * dInput;
+            
+            if(output > outMax) output = outMax;
+            else if(output < outMin) output = outMin;
+            
+            lastInput = input;
+            lastTime = now;
+            
+            return true;
+        }
+        return false;
+    }
+    
+    void SetTunings(double Kp, double Ki, double Kd) {
+        if (Kp < 0 || Ki < 0 || Kd < 0) return;
+        
+        double SampleTimeInSec = ((double)sampleTime)/1000;
+        kp = Kp;
+        ki = Ki * SampleTimeInSec;
+        kd = Kd / SampleTimeInSec;
+    }
+    
+    void SetSampleTime(int NewSampleTime) {
+        if (NewSampleTime > 0) {
+            double ratio = (double)NewSampleTime / (double)sampleTime;
+            ki *= ratio;
+            kd /= ratio;
+            sampleTime = (unsigned long)NewSampleTime;
+        }
+    }
+    
+    void SetOutputLimits(double Min, double Max) {
+        if(Min >= Max) return;
+        outMin = Min;
+        outMax = Max;
+        
+        if(inAuto) {
+            if(output > outMax) output = outMax;
+            else if(output < outMin) output = outMin;
+            
+            if(outputSum > outMax) outputSum = outMax;
+            else if(outputSum < outMin) outputSum = outMin;
+        }
+    }
+    
+    void SetMode(bool Mode) {
+        bool newAuto = Mode;
+        if(newAuto && !inAuto) {
+            Initialize();
+        }
+        inAuto = newAuto;
+    }
+    
+    void Initialize() {
+        outputSum = output;
+        lastInput = input;
+        if(outputSum > outMax) outputSum = outMax;
+        else if(outputSum < outMin) outputSum = outMin;
+    }
+
+    // Методы для установки и получения значений
+    void SetInput(double val) { input = val; }
+    void SetSetpoint(double val) { setpoint = val; }
+    double GetOutput() const { return output; }
+};

settings_manager.cpp

@@ -0,0 +1,171 @@
+#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;
+}

settings_manager.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "Arduino.h"
+#include "structures.h"
+#include "SD.h"
+#include "ArduinoJson.h"
+
+class SettingsManager {
+private:
+    SystemSettings settings;
+    static const char* NAMESPACE;
+    static const char* SETTINGS_KEY;
+    uint32_t version;
+
+    void setDefaults();
+    bool validateSettings();
+
+public:
+    SettingsManager();
+    void begin();
+    bool load();
+    bool save();
+    void reset();
+    
+    SystemSettings& getSettings() { return settings; }
+    void setSettings(const SystemSettings& newSettings);
+    
+    String exportToJson();
+    bool importFromJson(const String& json);
+    
+    bool saveToSD(const char* filename);
+    bool loadFromSD(const char* filename);
+    
+    uint32_t getVersion() const { return version; }
+    bool isCompatibleVersion(uint32_t version) const;
+};

structures.h

@@ -0,0 +1,188 @@
+#ifndef STRUCTURES_H
+#define STRUCTURES_H
+
+#include <Arduino.h>
+#include <WebServer.h>
+#include <Ticker.h>
+#include <Preferences.h>
+
+struct CylinderState {
+    unsigned long lastSparkTime;
+    bool isInjecting;
+    uint8_t pin;
+    float advance;
+    float detonationLevel;
+};
+
+struct EngineError {
+    bool detonationError;
+    bool temperatureError;
+    bool mapError;
+    bool lambdaError;
+    bool throttleError;
+    uint8_t errorCode;
+};
+
+struct EngineData {
+    float rpm;
+    float map;
+    float temp;
+    float lambda;
+    float detonationLevel1;
+    float detonationLevel2;
+    float combinedDetonationLevel;
+};
+
+struct ThrottleConfig {
+    float minPosition;
+    float maxPosition;
+    float idlePosition;
+    float speedPulseRatio;
+    float ignitionMap[16][16];
+};
+
+struct ThrottleLearnData {
+    float idlePositions[16];
+    uint16_t idleSamples[16];
+    float detonationHistory1[10];
+    float detonationHistory2[10];
+    int detonationHistoryIndex1;
+    int detonationHistoryIndex2;
+};
+
+struct ThrottleDiagnostics {
+    bool isCalibrated;
+    bool isStuck;
+    bool isOverloaded;
+    float current;
+    float voltage;
+    float detonationCorrection;
+};
+
+struct IgnitionMap {
+    float advance[16][16];
+    float rpmAxis[16];
+    float loadAxis[16];
+    float detonationMap[16][16];
+    float lambdaMap[16][16];
+};
+
+struct LearningData {
+    float advanceCorrections[16][16];
+    uint32_t samples[16][16];
+    float detonationHistory[100];
+    uint8_t detonationIndex;
+};
+
+struct EngineConfig {
+    float idleRPM;
+    float idleRPMCold;
+    float warmupTemp;
+    float maxRPM;
+    float minRPM;
+    float maxAdvance;
+    float minAdvance;
+    float maxInjection;
+    float minInjection;
+    float detonationThreshold;
+    float learningRate;
+    float maxDetonationCorrection;
+};
+
+// Структура для хранения конфигурации
+struct ConfigData {
+    uint8_t version;
+    
+    // Базовые таблицы
+    float fuelTable[16][16];        // Базовая таблица топливоподачи
+    float ignitionTable[16][16];    // Базовая таблица УОЗ
+    
+    // Таблицы обучения
+    float fuelLearning[16][16];     // Таблица коррекции топливоподачи
+    float ignitionLearning[16][16]; // Таблица коррекции УОЗ
+    
+    // Константы впрыска
+    float injectionTimeMin;
+    float injectionTimeMax;
+    float injectionPressure;
+    float injectorFlow;
+    float injectorDeadtime;
+    float injectorVoltage;
+    float injectorCorrection;
+    float startInjectionTime;
+    float startRpmThreshold;
+    
+    // Лямбда
+    float lambdaTarget;
+    float lambdaCorrectionMin;
+    float lambdaCorrectionMax;
+    float lambdaCorrectionStep;
+    
+    // Холостой ход
+    float idleRpmMin;
+    float idleRpmMax;
+    float idleAdvanceMin;
+    float idleAdvanceMax;
+    float idleAdvanceStep;
+    float idleAdvanceInterval;
+    float idleTargetRpm;            // Целевые обороты ХХ
+    float idleKp;                   // Коэффициент P для ПИД
+    float idleKi;                   // Коэффициент I для ПИД
+    float idleKd;                   // Коэффициент D для ПИД
+    
+    // Коррекции
+    bool tempCorrectionEnabled;
+    bool lambdaCorrectionEnabled;
+    bool idleAdvanceLearningEnabled;
+    bool throttleAdaptationEnabled;
+    bool hotEngineCorrectionEnabled;
+    bool accelPumpEnabled;
+    
+    // Зажигание
+    String ignitionType;
+    int coilCount;
+    float sparkDuration;
+    float maxAdvance;
+    float minAdvance;
+    float mechanicalAdvance;
+    float dwellTime;
+    
+    // Температура
+    float coldStartTemp;
+    float hotEngineTemp;
+    
+    uint32_t checksum;
+};
+
+// Настройки РХХ
+struct IdleSettings {
+    float targetRPM;
+    float valveMinPosition;
+    float valveMaxPosition;
+    float rpmTolerance;
+    float kp;
+    float ki;
+    float kd;
+};
+
+// Системные настройки
+struct SystemSettings {
+    uint32_t version;
+    IdleSettings idle;
+    float minAdvance;
+    float maxAdvance;
+    float injectionTimeMin;
+    float injectionTimeMax;
+    float idleRpmMin;
+    float idleRpmMax;
+};
+
+// Данные обучения
+struct LearningData2 {
+    float fuelCorrections[16][16];
+    float ignitionCorrections[16][16];
+    uint32_t cellHits[16][16];
+    uint32_t version;
+};
+
+#endif

web_interface.h

@@ -0,0 +1,297 @@
+#ifndef WEB_INTERFACE_H
+#define WEB_INTERFACE_H
+
+// HTML page for web interface
+const char* webPage = R"rawliteral(
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Engine Management System</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <style>
+        body { font-family: Arial; margin: 20px; }
+        .container { max-width: 1200px; margin: 0 auto; }
+        .card { 
+            border: 1px solid #ddd; 
+            padding: 15px; 
+            margin: 10px 0; 
+            border-radius: 5px;
+        }
+        .value { font-size: 24px; font-weight: bold; }
+        .label { font-size: 14px; color: #666; }
+        .progress-bar {
+            width: 100%;
+            height: 20px;
+            background: #eee;
+            border-radius: 10px;
+            overflow: hidden;
+        }
+        .progress {
+            height: 100%;
+            background: #4CAF50;
+            transition: width 0.3s;
+        }
+        button {
+            padding: 8px 16px;
+            margin: 5px;
+            border: none;
+            border-radius: 4px;
+            background: #4CAF50;
+            color: white;
+            cursor: pointer;
+        }
+        button:hover {
+            background: #45a049;
+        }
+        input[type="number"] {
+            padding: 5px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            width: 100px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Engine Management System</h1>
+        
+        <div class="card">
+            <h2>Real-time Parameters</h2>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px;">
+                <div>
+                    <div class="value" id="rpm">0</div>
+                    <div class="label">RPM</div>
+                </div>
+                <div>
+                    <div class="value" id="map">0</div>
+                    <div class="label">MAP (kPa)</div>
+                </div>
+                <div>
+                    <div class="value" id="tps">0</div>
+                    <div class="label">TPS (%)</div>
+                </div>
+                <div>
+                    <div class="value" id="lambda">0</div>
+                    <div class="label">Lambda</div>
+                </div>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>Learning System</h2>
+            <div>
+                <h3>Learning Progress</h3>
+                <div class="progress-bar">
+                    <div class="progress" id="fuelProgress" style="width: 0%"></div>
+                </div>
+                <div style="margin-top: 10px;">
+                    <button onclick="toggleLearning()" id="learningBtn">Enable Learning</button>
+                    <button onclick="resetLearning()">Reset Learning</button>
+                </div>
+                <div style="margin-top: 20px;">
+                    <div>
+                        <div class="value" id="fuelCorrection">1.00</div>
+                        <div class="label">Fuel Correction Factor</div>
+                    </div>
+                    <div>
+                        <div class="value" id="ignitionCorrection">0.0</div>
+                        <div class="label">Ignition Correction (deg)</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>Idle Control</h2>
+            <div>
+                <div>
+                    <div class="value" id="idlePosition">0</div>
+                    <div class="label">Idle Valve Position (%)</div>
+                </div>
+                <div>
+                    <div class="value" id="targetRPM">800</div>
+                    <div class="label">Target RPM</div>
+                </div>
+                <div style="margin-top: 10px;">
+                    <input type="number" id="rpmInput" value="800" min="600" max="2000">
+                    <button onclick="setTargetRPM()">Set RPM</button>
+                    <button onclick="calibrateIdle()">Calibrate</button>
+                </div>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>Diagnostics</h2>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px;">
+                <div>
+                    <div class="value" id="knockEvents">0</div>
+                    <div class="label">Knock Events</div>
+                </div>
+                <div>
+                    <div class="value" id="engineTemp">0</div>
+                    <div class="label">Engine Temp (C)</div>
+                </div>
+                <div>
+                    <div class="value" id="batteryVoltage">0</div>
+                    <div class="label">Battery Voltage (V)</div>
+                </div>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>Settings</h2>
+            <div>
+                <button onclick="saveSettings()">Save Settings</button>
+                <button onclick="loadSettings()">Load Settings</button>
+                <button onclick="exportSettings()">Export Settings</button>
+                <button onclick="importSettings()">Import Settings</button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        var rpmData = {
+            x: [],
+            y: [],
+            type: "scatter",
+            name: "RPM"
+        };
+
+        var mapData = {
+            x: [],
+            y: [],
+            type: "scatter",
+            name: "MAP"
+        };
+
+        Plotly.newPlot("rpmChart", [rpmData], {
+            title: "RPM History",
+            xaxis: { title: "Time" },
+            yaxis: { title: "RPM" }
+        });
+
+        Plotly.newPlot("mapChart", [mapData], {
+            title: "MAP History",
+            xaxis: { title: "Time" },
+            yaxis: { title: "kPa" }
+        });
+
+        function updateData() {
+            fetch("/status")
+                .then(response => response.json())
+                .then(data => {
+                    document.getElementById("rpm").textContent = Math.round(data.rpm);
+                    document.getElementById("map").textContent = data.map.toFixed(1);
+                    document.getElementById("tps").textContent = data.tps.toFixed(1);
+                    document.getElementById("lambda").textContent = data.lambda.toFixed(2);
+
+                    document.getElementById("fuelProgress").style.width = data.learning_progress + "%";
+                    document.getElementById("fuelCorrection").textContent = data.fuel_correction.toFixed(2);
+                    document.getElementById("ignitionCorrection").textContent = data.ignition_correction.toFixed(1);
+
+                    document.getElementById("idlePosition").textContent = data.idle_position.toFixed(1);
+                    document.getElementById("targetRPM").textContent = data.target_rpm;
+
+                    document.getElementById("knockEvents").textContent = data.knock_events;
+                    document.getElementById("engineTemp").textContent = data.temp.toFixed(1);
+                    document.getElementById("batteryVoltage").textContent = data.voltage.toFixed(1);
+
+                    const now = new Date();
+                    Plotly.extendTraces("rpmChart", {
+                        x: [[now]],
+                        y: [[data.rpm]]
+                    }, [0]);
+
+                    Plotly.extendTraces("mapChart", {
+                        x: [[now]],
+                        y: [[data.map]]
+                    }, [0]);
+                });
+        }
+
+        function toggleLearning() {
+            fetch("/learning/toggle", { method: "POST" })
+                .then(response => response.json())
+                .then(data => {
+                    alert(data.enabled ? "Learning enabled" : "Learning disabled");
+                });
+        }
+
+        function resetLearning() {
+            if (confirm("Are you sure you want to reset learning data?")) {
+                fetch("/learning/reset", { method: "POST" })
+                    .then(response => response.json())
+                    .then(() => {
+                        alert("Learning data reset");
+                    });
+            }
+        }
+
+        function setTargetRPM() {
+            const rpm = document.getElementById("rpmInput").value;
+            fetch("/idle/rpm", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ rpm: parseInt(rpm) })
+            });
+        }
+
+        function calibrateIdle() {
+            if (confirm("Start idle calibration?")) {
+                fetch("/idle/calibrate", { method: "POST" })
+                    .then(response => response.json())
+                    .then(() => {
+                        alert("Calibration complete");
+                    });
+            }
+        }
+
+        function saveSettings() {
+            fetch("/settings/save", { method: "POST" })
+                .then(response => response.json())
+                .then(() => {
+                    alert("Settings saved");
+                });
+        }
+
+        function loadSettings() {
+            fetch("/settings/load")
+                .then(response => response.json())
+                .then(() => {
+                    alert("Settings loaded");
+                });
+        }
+
+        function exportSettings() {
+            window.location.href = "/settings/export";
+        }
+
+        function importSettings() {
+            const input = document.createElement("input");
+            input.type = "file";
+            input.onchange = function(e) {
+                const file = e.target.files[0];
+                const formData = new FormData();
+                formData.append("settings", file);
+                fetch("/settings/import", {
+                    method: "POST",
+                    body: formData
+                })
+                .then(response => response.json())
+                .then(() => {
+                    alert("Settings imported");
+                });
+            };
+            input.click();
+        }
+
+        setInterval(updateData, 1000);
+    </script>
+</body>
+</html>
+)rawliteral";
+
+#endif