GS32SensorHub.cpp

#include "GS32SensorHub.h"

GS32SensorHub::GS32SensorHub() 
    : _updateInterval(2000), _lastTickTime(0), _currentSensorIndex(0) {
}

GS32SensorHub::~GS32SensorHub() {
    _sensors.clear();
}

int8_t GS32SensorHub::addDHT(DHTType type, uint8_t pin) {
    GS32_SensorData sensor;
    sensor.id = _sensors.size();
    sensor.pin = pin;
    sensor.type = type;
    sensor.temperature = NAN;
    sensor.humidity = NAN;
    sensor.isValid = false;
    sensor.lastReadTime = 0;

    _sensors.push_back(sensor);
    return sensor.id;
}

void GS32SensorHub::begin() {
    for (auto &s : _sensors) {
        pinMode(s.pin, INPUT_PULLUP);
    }
}

void GS32SensorHub::setUpdateInterval(uint32_t intervalMs) {
    // DHT11/22 не рекомендуются опрашивать чаще раза в 1000-2000 мс
    if (intervalMs < 1000) intervalMs = 1000;
    _updateInterval = intervalMs;
}

uint8_t GS32SensorHub::getSensorCount() const {
    return _sensors.size();
}

void GS32SensorHub::tick() {
    if (_sensors.empty()) return;

    uint32_t currentMillis = millis();

    // Опрос распределен по времени или по истечении общего интервала
    if (currentMillis - _lastTickTime >= _updateInterval) {
        _lastTickTime = currentMillis;

        // Поочередно или пакетом опрашиваем все датчики
        for (auto &sensor : _sensors) {
            float t = NAN;
            float h = NAN;

            // Читаем датчик. Метод гарантированно вернется быстро благодаря таймаутам
            bool success = _readDHTRaw(sensor.pin, sensor.type, t, h);

            if (success) {
                sensor.temperature = t;
                sensor.humidity = h;
                sensor.isValid = true;
                sensor.lastReadTime = currentMillis;
            } else {
                // В случае сбоя НЕ сбрасываем плату, а лишь помечаем статус
                sensor.isValid = false;
                sensor.temperature = NAN;
                sensor.humidity = NAN;
            }
        }
    }
}

// 1. Получить данные конкретного датчика
bool GS32SensorHub::getSensorData(uint8_t sensorId, GS32_SensorData &outData) const {
    if (sensorId < _sensors.size()) {
        outData = _sensors[sensorId];
        return outData.isValid;
    }
    return false;
}

// 2. Получить данные всех зарегистрированных датчиков
const std::vector<GS32_SensorData>& GS32SensorHub::getAllSensorsData() const {
    return _sensors;
}

// Измерение длительности импульса с микросекундным таймаутом (защита от зависания)
int32_t GS32SensorHub::_expectPulse(uint8_t pin, bool level, uint32_t timeoutMicros) {
    uint32_t startMicros = micros();
    while (digitalRead(pin) == level) {
        if ((micros() - startMicros) > timeoutMicros) {
            return -1; // Таймаут! Выходим, не вешая ядро
        }
    }
    return micros() - startMicros;
}

bool GS32SensorHub::_readDHTRaw(uint8_t pin, DHTType type, float &temp, float &hum) {
    uint8_t data[5] = {0, 0, 0, 0, 0};

    // 1. Старт-сигнал
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
    
    // DHT11 требует ~18-20 мс прижатия к земле, DHT22 ~1-10 мс
    delay(type == DHT_11 ? 20 : 2); 
    
    digitalWrite(pin, HIGH);
    delayMicroseconds(30);
    pinMode(pin, INPUT_PULLUP);

    // 2. Ожидание ответа от датчика (80 мкс LOW, затем 80 мкс HIGH)
    if (_expectPulse(pin, LOW, 100) < 0) return false;
    if (_expectPulse(pin, HIGH, 100) < 0) return false;

    // 3. Чтение 40 бит (5 байт) данных
    // Вход в критическую секцию на время чтения ~4 мс для точности таймингов ESP32
    portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
    portENTER_CRITICAL(&mux);

    for (int i = 0; i < 40; ++i) {
        // Каждый бит начинается с LOW длительностью ~50 мкс
        if (_expectPulse(pin, LOW, 80) < 0) {
            portEXIT_CRITICAL(&mux);
            return false;
        }

        // Длительность HIGH определяет значение: ~26-28 мкс = 0, ~70 мкс = 1
        int32_t highDuration = _expectPulse(pin, HIGH, 100);
        if (highDuration < 0) {
            portEXIT_CRITICAL(&mux);
            return false;
        }

        data[i / 8] <<= 1;
        if (highDuration > 45) {
            data[i / 8] |= 1;
        }
    }

    portEXIT_CRITICAL(&mux);

    // 4. Проверка контрольной суммы (байт 4 == сумма первых 4 байт)
    if (data[4] != ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
        return false;
    }

    // 5. Конвертация данных в зависимости от модели
    if (type == DHT_11) {
        hum = (float)data[0];
        temp = (float)data[2];
        if (data[3] != 0) {
            // Для некоторых вариаций DHT11 с десятыми долями
            temp += (float)data[3] * 0.1f;
        }
    } else { // DHT22 / AM2302
        hum = ((data[0] << 8) | data[1]) * 0.1f;
        int16_t rawTemp = ((data[2] & 0x7F) << 8) | data[3];
        temp = rawTemp * 0.1f;
        if (data[2] & 0x80) { // Отрицательная температура
            temp = -temp;
        }
    }

    return true;
}