ECUHandler.hpp

Go to the documentation of this file.

#pragma once
 
#define xlog(X, Y)                                        \
  do {                                                    \
    std::cout << "[" << (X) << "]: " << (Y) << std::endl; \
  } while(0)
 
/* c includes */
#include <cstdlib>
#include <cstddef>
#include <cstring>
 
/* cpp includes */
#include <chrono>
#include <thread>
#include <sstream>
#include <functional>
#include <mutex>
#include <boost/crc.hpp>
#include <atomic>
#include <array>
 
/* project includes */
#include "util/Conversions.hpp"
#include "util/Packets.hpp"
#include "com/ICommunication.h"
#include "com/UART.hpp"
 
using CRCType = boost::crc_32_type;
 
typedef std::function<void(const EcuPacket* const, const std::array<std::chrono::duration<double, std::milli>, 10>&)> PublishMeasurementsCallback;
 
class ECUHandler {
public:
  ECUHandler() :
      difference_index(0), firstPacketReceived(false) {}
 
  ~ECUHandler() {
    Stop();
 
    if(m_pCommunication != nullptr) {
      m_pCommunication->VDisconnect();
    }
  }
 
  uint32_t calculateChecksum(ComputerPacket const& packet);
  uint32_t calculateChecksum(SettingsPacket const& packet);
 
  void init(PublishMeasurementsCallback cb);
 
  void TransmitPacket(SettingsPacket& packet);
 
  void TransmitPacket(ComputerPacket& packet);
 
private:
  std::chrono::steady_clock::time_point current_timestamp;
  std::chrono::steady_clock::time_point last_timestamp;
  size_t difference_index;
  std::array<std::chrono::duration<double, std::milli>, 10> packet_differences;
 
  typedef enum {
    BTN_SC1 = 1,
    BTN_SC2 = 1 << 1,
    BTN_SC3 = 1 << 2,
  } ButtonType;
 
  typedef enum {
    UNDEFINED,
    WITH_OBSTACLES,
    WITHOUT_OBSTACLES,
  } DrivingModeType;
 
  ComputerPacket m_lastEcuPacket;
 
  /* 
     * Stores the Callback function to the ecu
     * node to publish data from the ecu.
     */
  PublishMeasurementsCallback cb_;
 
  /*
     * The thread that is used for the handling
     * of the communication with the ECU
     */
  std::thread* receiverThread = nullptr;
  bool receiverThreadRunning  = true;
  std::mutex mutex_on_packet;
 
  /*
     * The packets that will be used for 
     * the communication between the Jetson and
     * the microcontroller
     */
  EcuPacket currentPacket;
  ComputerPacket m_computerPacket;
  bool firstPacketReceived;
 
  /*
     * A pointer to the implementation of the selected
     * communication protocol
     */
  std::shared_ptr<ICommunication> m_pCommunication = nullptr;
 
  /*
     * Initializes the communication channel that has
     * been selected in the launch file and passed
     * as an enum value to this method
     */
  void InitializeCommunication();
 
  /*
     * Runner function for the thread
     * that handles the communication.
     */
  void ReceiveHandler();
 
  /*
     * Callback Function when a new
     * message is received from the ECU and
     * needs to be send to the ECUNode to 
     * be send out. 
     */
  void onNewPacketReceived(const EcuPacket* const);
 
  /*
     * Stops the ECU handler by disconnecting the communicatino
     * and joining the thread back into the main thread
     */
  void Stop();
};
/* vim:set et sw=2 ts=2 tw=80: */