cm_protocol.hpp

Go to the documentation of this file.

#pragma once

 
#include <libraries/interfaces/UartLinux.hpp>
 
#include "ProtocolEndpoint.hpp"
#include "back_proto_prototype.hpp"
#include "hmi_proto_prototype.hpp"
 
namespace proto::back_board_proto {
 
// Простая контрольная сумма побайтовым сложением - не CRC в строгом смысле,
// реализована именно так, потому что таким образом её считает плата
// (см. "сделай как в коде" ниже - это воспроизведение поведения из образца
// вендорского кода, а не собственный выбор алгоритма).
class CustomCrc final : ICrc {
 public:
  explicit CustomCrc() : ICrc("custom crc") {}
  void reset() override {}
  auto calc(const CustomSpan<uint8_t> buffer) -> uint32_t override {
    uint8_t crc = 0;
    for (const auto value : buffer) {
      crc += value;
    }
    return crc;  // сделай как в коде
  }
 
  auto append(const uint32_t last_crc, const CustomSpan<uint8_t> data)
      -> uint32_t override {
    const uint8_t crc = calc(data) + last_crc;
    return crc;  // сделай как в коде
  }
};
 
template <typename T>
void log_change(const char* name, T& old_val, T new_val) {
  if (old_val != new_val) {
    std::cout << name << ": " << +old_val << " -> " << +new_val << '\n';
    old_val = new_val;
  }
}
 
template <typename T>
void log_flag(const char* name, T& old_val, T new_val) {
  const bool old_b = old_val != 0;
  if (const bool new_b = new_val != 0; old_b != new_b) {
    std::cout << name << ": " << old_b << " -> " << new_b << '\n';
    old_val = new_val;
  }
}
 
// Конечная точка протокола обмена с задней платой: принимает кадры
// HeadBoardPrototype и отправляет кадры BackBoardPrototype, используя
// CustomCrc в качестве контрольной суммы.
template <uint8_t* RX_BASE, uint8_t* TX_BASE>
class BackBoardProtocol
    : public ProtocolEndpoint<
          typename HeadBoardPrototype<RX_BASE>::packet_fields,
          typename BackBoardPrototype<TX_BASE>::packet_fields, CustomCrc> {
 public:
  using ReceiveType = typename ProtocolEndpoint<
      typename HeadBoardPrototype<RX_BASE>::packet_fields,
      typename BackBoardPrototype<TX_BASE>::packet_fields,
      CustomCrc>::RxFieldsSnapshot;
  explicit BackBoardProtocol(bool debug = false) {
    this->m_rx.set_print_flags(PRINT_PARSING_ERRORS);
 
    this->set_debug(debug);
  }
 
  void test_diagnostics(interface::UartLinuxInterface m_uart_interface) {
    using namespace std::string_literals;
    this->set_interfaces(m_uart_interface, m_uart_interface);
    auto get_diff = [&](ReceiveType&& snapshot) -> void {
      static HeadFlags flags;
      static HeadPacketTypes packet_types;
      auto new_flags = meta::get_named<FieldName::HEADER_FIELD>(snapshot);
      auto new_packet = meta::get_named<FieldName::TYPE_FIELD>(snapshot);
      auto new_data = meta::get_named<FieldName::DATA_FIELD>(snapshot);
      for (int i = 0; i < static_cast<int>(flags.m_dummy1.size()); i++) {
        using namespace std::string_literals;
        log_change<uint8_t>(("m_dummy1["s + std::to_string(i) + "] ").c_str(),
                            flags.m_dummy1[i], new_flags.m_dummy1[i]);
      }
      log_change<uint8_t>("door_flags_and_other"s.c_str(), flags.door_and_other,
                          new_flags.door_and_other);
      for (int i = 0; i < static_cast<int>(flags.m_dummy2.size()); i++) {
        using namespace std::string_literals;
        log_change<uint8_t>(("m_dummy1["s + std::to_string(i) + "] ").c_str(),
                            flags.m_dummy1[i], new_flags.m_dummy1[i]);
      }
      log_change("packet type", packet_types, new_packet);
    };
    set_receive_callback(get_diff);
  }

  void reset() { this->m_rx.reset(); }
};
}  // namespace proto::back_board_proto