BoardModel.h

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <array>
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <tuple>
 
#include "AppRuntime.hpp"
#include "ILogger.hpp"
#include "protocols/lacte/LacteProtocol.hpp"
 
using namespace std::chrono_literals;
 
namespace detail {
// Превращает RuntimeFields (std::tuple<Field...> из простых типов полей)
// в std::tuple<std::optional<Field>...> - форму, в которой хранятся данные
// платы за один цикл опроса. Написано вручную намеренно, вместо того чтобы
// напрямую называть insitech::runtime::Runtime<RuntimeFields>::Snapshot:
// такой алиас заставил бы BoardModel.h зависеть от самого существования
// runtime.hpp/Runtime - именно от той связанности, которую, согласно
// собственному doc-комментарию этого файла, BoardModel не должен иметь.
// Оба типа фактически являются буквально одной и той же инстанциацией
// (та же форма tuple-из-optional, построенная из того же пакета
// RuntimeFields), поэтому значение BoardData всё равно передаётся прямо в
// LacteRuntime::Set() без какого-либо преобразования - см. собственный
// callback OnUpdate() в LacteApp.cpp.
template <typename Tuple>
struct BoardReadingOf;
template <typename... Fields>
struct BoardReadingOf<std::tuple<Fields...>> {
  using type = std::tuple<std::optional<Fields>...>;
};
}  // namespace detail
 
// Значения полей платы за один цикл опроса - непустые optional'ы это
// ровно те поля, что этот цикл действительно прочитал; всё остальное -
// std::nullopt. О том, как вызывающий код должен потреблять эти данные,
// см. собственный doc-комментарий BoardModel::OnUpdate().
using BoardData = typename detail::BoardReadingOf<RuntimeFields>::type;
 
// Собственная частота опроса Worker() - раньше была 20мс (50Гц),
// подтверждено вживую через `sample`, что именно она доминирующая причина
// холостого потолка CPU у lacteApp (каждый тик вызывает get_info() через
// host-протокол, который в режиме --virtual идёт круговым обходом через
// EchoInterface). Прошли путь 200мс (5Гц) -> 1000мс (1Гц) -> остановились
// на ~333мс (3Гц): при 1Гц измеренное CPU было ~0.2-0.4% (накопленная
// дельта CPU-времени за живое окно в 60с), но это давало запас всего в 3
// пропущенных цикла, прежде чем собственное значение по умолчанию
// m_online_timeout_ (3000мс, см. doc-комментарий SetOnlineTimeout())
// объявит плату оффлайн; 3Гц отдаёт часть этого запаса по CPU обратно в
// обмен на запас уже в ~9 пропущенных циклов, что всё ещё значительно
// дешевле базовых 50Гц.
inline constexpr auto K_WORKER_POLL_INTERVAL = 333ms;
 
// Небольшая пауза перед обращением к общим буферам протокола платы
// (m_host_proto) - даёт уже начавшемуся обмену данными потока worker'а
// устояться, прежде чем уйдёт запрос этого вызова, вместо гонки с ним.
inline constexpr auto K_MODEL_BOARD_PROTO_THROTTLE_DELAY =
    std::chrono::milliseconds(100);
// Таймаут "плата считается оффлайн" по умолчанию, используемый до того,
// как собственное значение AppConfig K_BOARD_ONLINE_TIMEOUT_MS
// переопределит его при старте (см. LacteApp::run_impl()).
inline constexpr std::chrono::milliseconds K_MODEL_DEFAULT_ONLINE_TIMEOUT{3000};
// Цикл повторных попыток для чтения/записи параметра, которое столкнулось
// с занятостью самой платы - короткая задержка, немного попыток:
// действительно оффлайн/сломанная плата должна отказать быстро, а не
// задерживать вызывающий код.
inline constexpr auto K_MODEL_PARAM_RETRY_DELAY = std::chrono::milliseconds(10);
inline constexpr int K_MODEL_PARAM_RETRY_COUNT = 5;
 
// Не шаблон: на процесс всегда есть только ОДИН BoardModel (LacteApp
// владеет ровно одним), поэтому его обращённые к хосту временные буферы
// (см. m_host_proto ниже) живут здесь как собственные статические члены
// класса, вместо того чтобы передаваться как аргументы шаблона uint8_t*
// тем, кто строит BoardModel - то же упрощение, что и у собственных
// rx_buffer_/tx_buffer_ у AppContext (см.
// Libraries/app_control/AppContext.h). Обращённые к плате буферы
// (собственные у VirtualBoard, собственные у LacteApp/tests) - это
// совершенно отдельная забота - BoardModel никогда их не трогает - так
// что они остаются у того, кто владеет VirtualBoard, а не переезжают
// тоже сюда.
class BoardModel {
 public:
  static constexpr std::size_t K_HOST_BUFFER_SIZE = 300;
  // NOLINTBEGIN(modernize-avoid-c-arrays): должны оставаться C-массивами,
  // не std::array - `LacteHostProtocol<RX,TX>` ниже принимает их как
  // нетиповые параметры шаблона, для чего нужен объект со связыванием
  // (linkage); обёртывание в std::array изменило бы идентичность шаблона,
  // а не только способ доступа к ним.
  inline static uint8_t host_rx_buffer[K_HOST_BUFFER_SIZE]{};
  inline static uint8_t host_tx_buffer[K_HOST_BUFFER_SIZE]{};
  // NOLINTEND(modernize-avoid-c-arrays)
 
  proto::lacte::LacteHostProtocol<host_rx_buffer, host_tx_buffer> m_host_proto;
 
  // ОДИН конструктор для обоих вызывающих: и `LoggerBusClient` (строится
  // через `ctx.logger_bus.MakeClient(name)` - см. LacteApp.cpp), и
  // обычный, не связанный с шиной `insitech::Logger` (например,
  // LacteApp/tests/BoardModelTest.cpp, у которого вообще нет AppContext/
  // шины) оба ЯВЛЯЮТСЯ `ILogger` (см.
  // `Libraries/logger/include/ILogger.hpp`/`Logger.hpp`) - log()/
  // LogStream() ниже просто идут через интерфейс, без ветвления по тому,
  // какой конкретно вид получил этот BoardModel. Вызывающий код,
  // передающий `Logger&`, владением которым он не хочет делиться с
  // BoardModel, сам оборачивает его в невладеющий `shared_ptr` (см.
  // BoardModelTest.cpp) - BoardModel в любом случае всегда хранит
  // `shared_ptr<ILogger>`.
  explicit BoardModel(std::shared_ptr<ILogger> log_sink)
      : m_log_sink_(std::move(log_sink)) {}
 
  auto get_aeration() -> int {
    std::unique_lock lock(m_worker_mtx_);
    std::this_thread::sleep_for(K_MODEL_BOARD_PROTO_THROTTLE_DELAY);
    if (const auto aeration_packet =
            m_host_proto.get_param<proto::lacte::Params::AERATION>()) {
      return aeration_packet.value().m_data;
    }
    return 0;
  }
 
  auto set_aeration(const uint8_t aeration) {
    proto::lacte::AerationParam packet;
    packet.m_data = aeration;
    std::unique_lock lock(m_worker_mtx_);
    std::this_thread::sleep_for(K_MODEL_BOARD_PROTO_THROTTLE_DELAY);
    return m_host_proto.set_param<proto::lacte::Params::AERATION>(packet);
  }
 
  auto flash(const std::string& path) -> bool {
    std::unique_lock lock(m_worker_mtx_);
    std::this_thread::sleep_for(K_MODEL_BOARD_PROTO_THROTTLE_DELAY);
    if (auto info = m_host_proto.get_info()) {
      if (info.value().m_status == proto::lacte::BoardStatus::WORK ||
          info.value().m_status == proto::lacte::BoardStatus::CALIBRATION) {
        log(LogLevel::INFO,
            "Device has status WORK or CALIBRATION. It's denied to update");
        return false;
      }
      log(LogLevel::INFO, "Device status is ", info.value().m_status);
      std::this_thread::sleep_for(K_MODEL_BOARD_PROTO_THROTTLE_DELAY);
      log(LogLevel::INFO, "Trying to reset board");
      if (const auto answer = m_host_proto.restart(); not answer) {
        log(LogLevel::WARNING,
            "Failed to execute RESTART command; the device may already "
            "be in bootloader mode.");
      } else if (answer.value().m_data == proto::lacte::BootAnswer::NO) {
        log(LogLevel::INFO,
            "Device returned denied on RESTART command; aborting "
            "firmware update.");
        return false;
      }
    }
    log(LogLevel::INFO, "Starting firmware update: ", path);
    return proto::lacte::LacteHostProtocol<
        host_rx_buffer, host_tx_buffer>::flash(m_log_sink_->get_stream(),
                                               path.c_str(),
                                               *m_flash_interface_);
  }
 
  ~BoardModel() { stop(); }  // NOLINT(bugprone-exception-escape)
 
  auto set_interfaces(proto::interface::IInterface& rx_interface,
                      proto::interface::IInterface& tx_interface) -> bool {
    m_host_proto.set_interfaces(rx_interface, tx_interface);
    m_flash_interface_ = &tx_interface;
    return true;
  }
 
  // Задаёт интерфейс, в который пишет прошивка firmware. SetInterfaces уже
  // делает это для обычно подключённой платы; этот метод нужен для случая,
  // когда интерфейсы были подключены другим способом и требуется задать
  // только цель для прошивки (например, виртуальная плата, подключённая
  // через собственный set_host — см. LacteApp).
  void set_flash_interface(proto::interface::IInterface& tx_interface) {
    m_flash_interface_ = &tx_interface;
  }
 
  void start() {
    std::unique_lock lock(m_worker_mtx_);
    if (m_running_) {
      log(LogLevel::WARNING, "model lacte is running. Please call stop firs!");
      return;
    }
 
    m_running_ = true;
    m_thread_worker_ = std::thread(&BoardModel::worker, this);
  }
 
  void stop() {
    if (bool expected = true;
        !m_running_.compare_exchange_strong(expected, false)) {
      return;  // уже остановлен, избегаем повторного выполнения
    }
 
    if (m_thread_worker_.joinable()) {
      log(LogLevel::INFO, "Waiting for lacte model thread to finish...");
      m_thread_worker_.join();
    }
  }
 
  // По умолчанию — тот же порог, на который уже полагается каждый
  // существующий вызывающий код (включая тестовый набор) — BoardModel
  // ничего не знает об AppConfig, вызывающий код, которому нужна
  // настраиваемость (см. LacteApp::RunImpl()), вызывает этот метод.
  void set_online_timeout(const std::chrono::milliseconds timeout) {
    m_online_timeout_ = timeout;
  }
 
  auto is_online() const -> bool {
    return std::chrono::system_clock::now() - m_last_update_time_ <
           m_online_timeout_;
  }
 
  // Был ли вызван Start() и ещё не выполнялся Stop() - используется,
  // например, для собственного health() у LacteApp (см. реализацию
  // ModelBusHandler в LacteApp.hpp), который раньше был собственным
  // health() у BoardModel, прежде чем ModelBusHandler переехал на уровень
  // выше.
  [[nodiscard]] auto is_running() const -> bool { return m_running_.load(); }
 
  // Регистрирует единственный callback, который Worker() вызывает один
  // раз за цикл опроса со свежим показанием BoardData: непустые optional'ы
  // это ровно те поля, что этот цикл действительно прочитал (либо, при
  // переходе в оффлайн, просто BoardOnlineStatus{false}); все остальные
  // поля оставлены пустыми. Это и есть целиком половина потока "плата
  // обновила своё состояние, вернула новое состояние" - что происходит
  // дальше (запись в Runtime, генерация diff/события) целиком дело
  // вызывающего кода, а не BoardModel (см. собственный файловый
  // doc-комментарий этого файла). Единственный слот callback'а, как и у
  // самого insitech::runtime::Runtime::OnDiff() - регистрация нового
  // заменяет предыдущий.
  void on_update(std::function<void(const BoardData&)> callback) {
    m_on_update_ = std::move(callback);
  }
 
 private:
  std::thread m_thread_worker_;
  std::atomic<bool> m_running_{false};
  std::mutex m_worker_mtx_;
  proto::interface::IInterface* m_flash_interface_{};
  std::chrono::time_point<std::chrono::system_clock> m_last_update_time_;
  std::chrono::milliseconds m_online_timeout_{K_MODEL_DEFAULT_ONLINE_TIMEOUT};
  // Заменяет старую защитную проверку "спросить у Runtime его последний
  // известный BoardOnlineStatus" (раньше для этого Worker() вызывал
  // m_runtime_.get<BoardOnlineStatus>()) - BoardModel не может прочитать
  // Runtime, которым он больше не владеет, поэтому отслеживает локально,
  // сообщал ли он в последний раз, что плата онлайн. Семантика та же, что
  // и раньше: сообщать о переходе в оффлайн только если хоть раз до этого
  // действительно произошло успешное чтение.
  bool m_reported_online_{false};
  std::function<void(const BoardData&)> m_on_update_;
 
  // СОБСТВЕННЫЙ приёмник логов этого BoardModel (см. собственный
  // doc-комментарий конструктора) - `LoggerBusClient`, помечающий каждую
  // строку тегом "[<name>]" на шине, либо обычный, не связанный с шиной
  // `insitech::Logger` в тестах. log()/LogStream() ниже просто идут через
  // него - какой конкретно вид это - здесь не важно.
  std::shared_ptr<ILogger> m_log_sink_;
 
  template <typename... Args>
  void log(LogLevel level, Args&&... args) const {
    m_log_sink_->log(level, std::forward<Args>(args)...);
  }
 
  // Считывает с платы свежие значения полей за один тик и возвращает их
  // как единое показание BoardData - непустые optional'ы это ровно те
  // поля, что этот цикл действительно прочитал. Объединение чтения
  // нескольких полей (например, весь блок RFID ниже) в одну атомарную
  // единицу изменения теперь дело вызывающего кода (см. собственный
  // callback OnUpdate() в LacteApp.cpp, который оборачивает свои вызовы
  // Runtime::Set() в один ReadCycle) - у самого BoardModel больше вообще
  // нет понятия "цикл чтения"/diff/Runtime.
  auto update_params(const proto::lacte::InfoPacketType& info) -> BoardData {
    using namespace proto::lacte;
 
    BoardData reading{};
    auto set_field = [&reading](auto value) -> void {
      std::get<std::optional<decltype(value)>>(reading) = std::move(value);
    };
 
    auto try_to_get = [&](auto&& func) -> decltype(func()) {
      std::this_thread::sleep_for(K_MODEL_PARAM_RETRY_DELAY);
      auto result = func();
      int cnt = 0;
      while (not result && cnt++ < K_MODEL_PARAM_RETRY_COUNT) {
        std::this_thread::sleep_for(K_MODEL_PARAM_RETRY_DELAY);
        result = func();
      }
      return result;
    };
 
    // Каждый вызов m_host_proto.get_*() ниже - это ограниченный по времени,
    // но медленный круговой обход к плате (собственный RECEIVE_TIMEOUT у
    // ProtocolEndpoint равен 1с; try_to_get повторяет попытку до 6 раз, так
    // что одно поле может занять ~6с, если плата вообще не отвечает).
    // Здесь ничего не держит никакой блокировки, кроме самого
    // m_worker_mtx_ (уже удерживаемого Worker() вокруг всего этого
    // вызова) - вызывающий код, проталкивающий это показание в Runtime
    // (см. собственный callback OnUpdate() в LacteApp.cpp), видит его
    // только один раз, уже полностью собранным ниже, никогда не в
    // процессе чтения.
    const auto hard_version =
        try_to_get([&]() -> auto { return m_host_proto.get_version(); });
    const auto uid =
        try_to_get([&]() -> auto { return m_host_proto.get_uid(); });
    const auto aeration = try_to_get(
        [&]() -> auto { return m_host_proto.get_param<Params::AERATION>(); });
 
    /*******   заполнение rfid data start *******/
    std::optional<RFIDDataPacketType> rfid_data;
    std::optional<RFIDNumberType> rfid_num_new;
    if (not(info.m_errors.has(BoardError::RFID_NO_CARD) and
            info.m_errors.has(BoardError::RFID_BAD_CARD)) and
        info.m_status != BoardStatus::CALIBRATION) {
      rfid_data =
          try_to_get([&]() -> auto { return m_host_proto.get_rfid_data(); });
      rfid_num_new =
          try_to_get([&]() -> auto { return m_host_proto.get_rfid(); });
    }
 
    set_field(info);
    set_field(BoardErrorDiff{info.m_errors});
 
    set_field(BoardOnlineStatus{"online"});
    set_field(SoftVersion{SOFTWARE_VERSION});
 
    if (hard_version) {
      set_field(*hard_version);
    }
    if (uid) {
      set_field(*uid);
    }
    if (aeration) {
      set_field(*aeration);
    }
 
    if (rfid_num_new and rfid_num_new.value().to_string() != "0" and
        rfid_data and rfid_data->m_magicWord.m_data == MagicWord::DEFAULT_VAL) {
      set_field(*rfid_num_new);
      set_field(rfid_data->m_magicWord);
      set_field(rfid_data->m_lacteId);
      set_field(rfid_data->m_lacteSn);
      set_field(rfid_data->m_productVolume);
      set_field(rfid_data->m_prodDate);
      set_field(rfid_data->m_shelfLife);
      set_field(rfid_data->m_usageTime);
      set_field(rfid_data->m_mcuUid);
      set_field(rfid_data->m_machineSn);
      set_field(rfid_data->m_activationTime);
      set_field(rfid_data->m_milkCounter);
      set_field(rfid_data->m_timeCounter);
    } else if (rfid_num_new and rfid_num_new.value().to_string() == "0") {
      // LACTE-BUG-001 (исправлено): метка реально отсутствует - сообщить
      // об этом ЯВНО (RFIDNumberType{0}), а не просто пропустить это
      // поле. Раньше, когда метку убирали, ЭТА ветка отсутствовала
      // целиком - set_field(*rfid_num_new) не вызывался вообще ни для
      // какого значения RFIDNumberType, значит Runtime::Set() (пишет
      // только непустые optional'ы из BoardData) никогда не видел
      // переход "метка была -> метки нет", и LacteId/ProductVolume/
      // MilkCounter/... (объявленные в LacteApp::GetRfidData()/
      // BuildSnapshot() как признак присутствия метки) оставались
      // зависшими на данных предыдущей метки сколь угодно долго после
      // её физического извлечения. LacteId/ProductVolume/... сами по
      // себе всё ещё не сбрасываются здесь (RFIDDataPacketType не
      // читается вовсе, когда метки нет) - именно поэтому
      // GetRfidData()/BuildSnapshot() должны сами проверять ИМЕННО
      // текущее значение RFIDNumberType (см. их собственные
      // doc-комментарии), а не наличие/отсутствие какого-либо другого
      // производного от RFID поля.
      set_field(*rfid_num_new);
    }
    /*******   заполнение rfid data end *******/
 
    // Старая проверка "вернуть rfid_num к прежнему значению, если
    // проскользнул свежепрочитанный 0" намеренно не воспроизведена:
    // теперь свежий "0" явно доходит до BoardData через ветку выше -
    // именно это и является исправлением LACTE-BUG-001, а не воссозданием
    // старой защитной проверки.
    return reading;
  }
 
  void worker() {
    log(LogLevel::INFO, "lacte model started ");
    while (m_running_) {
      std::this_thread::sleep_for(K_WORKER_POLL_INTERVAL);
      std::unique_lock lock(m_worker_mtx_);
      if (auto info = m_host_proto.get_info()) {
        m_last_update_time_ = std::chrono::system_clock::now();
        m_reported_online_ = true;
        if (const auto reading = update_params(*info); m_on_update_) {
          m_on_update_(reading);
        }
      } else if (not is_online() and m_reported_online_) {
        // Точно повторяет старую защитную проверку: действовать, только
        // если плата *ранее была известна как онлайн* — плата, которая ни
        // разу не была успешно прочитана, не должна вызывать ложное
        // сообщение "отключена".
        m_reported_online_ = false;
        log(LogLevel::WARNING,
            "lacte board was disconnected or there is some "
            "communication issue!");
        if (m_on_update_) {
          BoardData reading{};
          std::get<std::optional<BoardOnlineStatus>>(reading) =
              BoardOnlineStatus{"false"};
          m_on_update_(reading);
        }
      }
    }
    log(LogLevel::INFO, "lacte model stopped ");
  }
};