board_flags_events.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
 
#include "back_proto_prototype.hpp"

namespace proto::back_board_proto {
 
enum class BoardFlagsEvent : uint8_t {
  DOOR_OPEN,
  DOOR_CLOSE,
  INER_WATER_SET,
  INER_WATER_UNSET,
  BREWING_UNIT_SET,
  BREWING_UNIT_UNSET,
  BUNK_BULK_SET,
  BUNK_BULK_UNSET,
  L_BUNK_FULL,
  L_BUNK_EMPTY,
  R_BUNK_FULL,
  R_BUNK_EMPTY,
  L_BUNK_SET,
  L_BUNK_UNSET,
  R_BUNK_SET,
  R_BUNK_UNSET,
  L_BUNK_BULK_FULL,
  L_BUNK_BULK_EMPTY,
  R_BUNK_BULK_FULL,
  R_BUNK_BULK_EMPTY,
  WATER_FILLED,
  WATER_LACK,
  NORM_PRESSURE,
  OVER_PRESSURE,
  BOILER_TEMP_OK,
  BOILER_TEMP_TOO_LOW,
  STEAM_BOILER_TEMP_OK,
  STEAM_BOILER_TEMP_TOO_LOW,
  MILK_PRESENT,
  MILK_EMPTY,
  DONE_DIAGNOSIS_BREWING_UNIT,
  NEED_DIAGNOSIS_BREWING_UNIT,
  BOILER_HEATING_TIME_OK,
  BOILER_HEATING_TIME_TOO_LONG,
  BOILER_STEAM_HEATING_TIME_OK,
  BOILER_STEAM_HEATING_TIME_TOO_LONG,
  HOT_STEAM_BOILER_SENSOR_OK,
  HOT_STEAM_BOILER_SENSOR_ERROR,
  HOT_WATER_BOILER_SENSOR_OK,
  HOT_WATER_BOILER_SENSOR_ERROR,
  BREWING_MECH_OK,
  BREWING_MECH_ERROR,
  WATER_SUPPLY_OK,
  WATER_SUPPLY_ERROR,
  RIGHT_COF_GRINDER_OK,
  RIGHT_COF_GRINDER_ERROR,
  LEFT_COF_GRINDER_OK,
  LEFT_COF_GRINDER_ERROR,
};

class BoardFlagsDiff {
 public:
  [[nodiscard]] auto diff(const BoardFlags& fresh,
                          BoardPacketTypes current_status)
      -> std::vector<BoardFlagsEvent> {
    std::vector<BoardFlagsEvent> events;
    if (!m_has_previous_) {
      m_has_previous_ = true;
      m_previous_ = fresh;
      return events;
    }
 
    // байт 10 (cond.cpp:1484-1526)
    if (fresh.m_door != m_previous_.m_door) {
      events.push_back(fresh.m_door ? BoardFlagsEvent::DOOR_OPEN
                                    : BoardFlagsEvent::DOOR_CLOSE);
    }
    if (fresh.m_innerWaterBunker != m_previous_.m_innerWaterBunker) {
      events.push_back(fresh.m_innerWaterBunker
                           ? BoardFlagsEvent::INER_WATER_UNSET
                           : BoardFlagsEvent::INER_WATER_SET);
    }
    if (fresh.m_brewingUnit != m_previous_.m_brewingUnit) {
      events.push_back(fresh.m_brewingUnit ? BoardFlagsEvent::BREWING_UNIT_UNSET
                                           : BoardFlagsEvent::BREWING_UNIT_SET);
    }
 
    // байт 11 (cond.cpp:1531-1614)
    if (fresh.m_bunkerForBulkMissing != m_previous_.m_bunkerForBulkMissing) {
      events.push_back(fresh.m_bunkerForBulkMissing
                           ? BoardFlagsEvent::BUNK_BULK_UNSET
                           : BoardFlagsEvent::BUNK_BULK_SET);
    }
    // emptyLeft/RightCoffeBunker - ЕДИНСТВЕННЫЕ два сигнала во всём этом
    // классе, которые старый парсер не просто "не эмитит", пока
    // current_status == WORK, а буквально ЗАМОРАЖИВАЕТ (не даёт их
    // собственному "предыдущему" значению обновиться, пока идёт WORK -
    // cond.cpp:1549, 1580-1584) - иначе первое же сравнение СРАЗУ после
    // выхода из WORK сравнивало бы не с состоянием ДО WORK, а с
    // произвольным шумом, накопившимся во время него. Реализовано ниже:
    // m_previous_ для этих двух бит специально не трогается, пока
    // current_status == WORK (см. конец функции).
    if (current_status != BoardPacketTypes::WORK) {
      if (fresh.m_emptyLeftCoffeBunker != m_previous_.m_emptyLeftCoffeBunker) {
        events.push_back(fresh.m_emptyLeftCoffeBunker
                             ? BoardFlagsEvent::L_BUNK_EMPTY
                             : BoardFlagsEvent::L_BUNK_FULL);
      }
      if (fresh.m_emptyRightCoffeBunker !=
          m_previous_.m_emptyRightCoffeBunker) {
        events.push_back(fresh.m_emptyRightCoffeBunker
                             ? BoardFlagsEvent::R_BUNK_EMPTY
                             : BoardFlagsEvent::R_BUNK_FULL);
      }
    }
    if (fresh.m_leftBunkerCoffeeMissing !=
        m_previous_.m_leftBunkerCoffeeMissing) {
      events.push_back(fresh.m_leftBunkerCoffeeMissing
                           ? BoardFlagsEvent::L_BUNK_UNSET
                           : BoardFlagsEvent::L_BUNK_SET);
    }
    if (fresh.m_rightBunkerCoffeeOrBothMissing !=
        m_previous_.m_rightBunkerCoffeeOrBothMissing) {
      events.push_back(fresh.m_rightBunkerCoffeeOrBothMissing
                           ? BoardFlagsEvent::R_BUNK_UNSET
                           : BoardFlagsEvent::R_BUNK_SET);
    }
 
    // байт 12 (cond.cpp:1616-1646)
    if (fresh.m_emptyLeftBulkBunker != m_previous_.m_emptyLeftBulkBunker) {
      events.push_back(fresh.m_emptyLeftBulkBunker
                           ? BoardFlagsEvent::L_BUNK_BULK_EMPTY
                           : BoardFlagsEvent::L_BUNK_BULK_FULL);
    }
    if (fresh.m_emptyRightBulkBunker != m_previous_.m_emptyRightBulkBunker) {
      events.push_back(fresh.m_emptyRightBulkBunker
                           ? BoardFlagsEvent::R_BUNK_BULK_EMPTY
                           : BoardFlagsEvent::R_BUNK_BULK_FULL);
    }
 
    // байт 13 (cond.cpp:1648-1678)
    if (fresh.m_systemLackOfWater != m_previous_.m_systemLackOfWater) {
      events.push_back(fresh.m_systemLackOfWater
                           ? BoardFlagsEvent::WATER_LACK
                           : BoardFlagsEvent::WATER_FILLED);
    }
    if (fresh.m_systemOverPressure != m_previous_.m_systemOverPressure) {
      events.push_back(fresh.m_systemOverPressure
                           ? BoardFlagsEvent::OVER_PRESSURE
                           : BoardFlagsEvent::NORM_PRESSURE);
    }
 
    // байт 15 (cond.cpp:1680-1710)
    if (fresh.m_boilerTooLow != m_previous_.m_boilerTooLow) {
      events.push_back(fresh.m_boilerTooLow
                           ? BoardFlagsEvent::BOILER_TEMP_TOO_LOW
                           : BoardFlagsEvent::BOILER_TEMP_OK);
    }
    if (fresh.m_steamBoilTooLow != m_previous_.m_steamBoilTooLow) {
      events.push_back(fresh.m_steamBoilTooLow
                           ? BoardFlagsEvent::STEAM_BOILER_TEMP_TOO_LOW
                           : BoardFlagsEvent::STEAM_BOILER_TEMP_OK);
    }
 
    // байты 14+17 (cond.cpp:1712-1753) - milkMissing/selfDiagnosisBrewingUnit
    // читаются ДВАЖДЫ (одноимённая пара в каждом байте) и объединяются
    // через OR ПЕРЕД сравнением - независимо друг от друга их читать
    // нельзя, старый парсер тоже сравнивает только объединённое значение.
    const bool old_milk_missing =
        m_previous_.m_milkMissing || m_previous_.m_milkMissing2;
    const bool new_milk_missing = fresh.m_milkMissing || fresh.m_milkMissing2;
    if (old_milk_missing != new_milk_missing) {
      events.push_back(new_milk_missing ? BoardFlagsEvent::MILK_EMPTY
                                        : BoardFlagsEvent::MILK_PRESENT);
    }
    const bool old_needs_diagnosis = m_previous_.m_selfDiagnosisBrewingUnit ||
                                     m_previous_.m_selfDiagnosisBrewingUnit2;
    const bool new_needs_diagnosis =
        fresh.m_selfDiagnosisBrewingUnit || fresh.m_selfDiagnosisBrewingUnit2;
    if (old_needs_diagnosis != new_needs_diagnosis) {
      events.push_back(new_needs_diagnosis
                           ? BoardFlagsEvent::NEED_DIAGNOSIS_BREWING_UNIT
                           : BoardFlagsEvent::DONE_DIAGNOSIS_BREWING_UNIT);
    }
 
    // байт 18 (cond.cpp:1755-1815)
    if (fresh.m_heatingWaterBoilerTimeToLong !=
        m_previous_.m_heatingWaterBoilerTimeToLong) {
      events.push_back(fresh.m_heatingWaterBoilerTimeToLong
                           ? BoardFlagsEvent::BOILER_HEATING_TIME_TOO_LONG
                           : BoardFlagsEvent::BOILER_HEATING_TIME_OK);
    }
    if (fresh.m_heatingSteamBoilerTimeToLong !=
        m_previous_.m_heatingSteamBoilerTimeToLong) {
      events.push_back(fresh.m_heatingSteamBoilerTimeToLong
                           ? BoardFlagsEvent::BOILER_STEAM_HEATING_TIME_TOO_LONG
                           : BoardFlagsEvent::BOILER_STEAM_HEATING_TIME_OK);
    }
    if (fresh.m_hotSteamBoilSensError != m_previous_.m_hotSteamBoilSensError) {
      events.push_back(fresh.m_hotSteamBoilSensError
                           ? BoardFlagsEvent::HOT_STEAM_BOILER_SENSOR_ERROR
                           : BoardFlagsEvent::HOT_STEAM_BOILER_SENSOR_OK);
    }
    if (fresh.m_hotWaterBoilSensError != m_previous_.m_hotWaterBoilSensError) {
      events.push_back(fresh.m_hotWaterBoilSensError
                           ? BoardFlagsEvent::HOT_WATER_BOILER_SENSOR_ERROR
                           : BoardFlagsEvent::HOT_WATER_BOILER_SENSOR_OK);
    }
 
    // байт 19 (cond.cpp:1817-1877)
    if (fresh.m_brewingMechError != m_previous_.m_brewingMechError) {
      events.push_back(fresh.m_brewingMechError
                           ? BoardFlagsEvent::BREWING_MECH_ERROR
                           : BoardFlagsEvent::BREWING_MECH_OK);
    }
    if (fresh.m_waterSupplyError != m_previous_.m_waterSupplyError) {
      events.push_back(fresh.m_waterSupplyError
                           ? BoardFlagsEvent::WATER_SUPPLY_ERROR
                           : BoardFlagsEvent::WATER_SUPPLY_OK);
    }
    if (fresh.m_rightCoffeeGrindError != m_previous_.m_rightCoffeeGrindError) {
      events.push_back(fresh.m_rightCoffeeGrindError
                           ? BoardFlagsEvent::RIGHT_COF_GRINDER_ERROR
                           : BoardFlagsEvent::RIGHT_COF_GRINDER_OK);
    }
    if (fresh.m_leftCoffeeGrindError != m_previous_.m_leftCoffeeGrindError) {
      events.push_back(fresh.m_leftCoffeeGrindError
                           ? BoardFlagsEvent::LEFT_COF_GRINDER_ERROR
                           : BoardFlagsEvent::LEFT_COF_GRINDER_OK);
    }
 
    BoardFlags next_previous = fresh;
    if (current_status == BoardPacketTypes::WORK) {
      // См. doc-комментарий emptyLeft/RightCoffeBunker выше - заморозка,
      // а не просто пропуск события.
      next_previous.m_emptyLeftCoffeBunker = m_previous_.m_emptyLeftCoffeBunker;
      next_previous.m_emptyRightCoffeBunker =
          m_previous_.m_emptyRightCoffeBunker;
    }
    m_previous_ = next_previous;
    return events;
  }
 
 private:
  BoardFlags m_previous_{};
  bool m_has_previous_{false};
};
 
}  // namespace proto::back_board_proto