Galaxis Codebase: ECUHandler Class Reference

#include <ECUHandler.hpp>

Public Member Functions
	ECUHandler ()

	~ECUHandler ()

uint32_t	calculateChecksum (ComputerPacket const &packet)

uint32_t	calculateChecksum (SettingsPacket const &packet)

void	init (PublishMeasurementsCallback cb)
	Provides the handler with a connection to the ECUNode to communicate via ROS. More...

void	TransmitPacket (SettingsPacket &packet)
	This function transmits a packet to the ECU. More...

void	TransmitPacket (ComputerPacket &packet)
	This function transmits a packet to the ECU. More...

Private Types
enum	ButtonType { BTN_SC1 = 1, BTN_SC2 = 1 << 1, BTN_SC3 = 1 << 2 }

enum	DrivingModeType { UNDEFINED, WITH_OBSTACLES, WITHOUT_OBSTACLES }

Private Member Functions
void	InitializeCommunication ()

void	ReceiveHandler ()

void	onNewPacketReceived (const EcuPacket *const)

void	Stop ()

Private Attributes
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

ComputerPacket	m_lastEcuPacket

PublishMeasurementsCallback	cb_

std::thread *	receiverThread = nullptr

bool	receiverThreadRunning = true

std::mutex	mutex_on_packet

EcuPacket	currentPacket

ComputerPacket	m_computerPacket

bool	firstPacketReceived

std::shared_ptr< ICommunication >	m_pCommunication = nullptr

Detailed Description

Definition at line 36 of file ECUHandler.hpp.

Member Enumeration Documentation

◆ ButtonType

enum ECUHandler::ButtonType

private

Enumerator
BTN_SC1
BTN_SC2
BTN_SC3

Definition at line 76 of file ECUHandler.hpp.

                {
     BTN_SC1 = 1,
     BTN_SC2 = 1 << 1,
     BTN_SC3 = 1 << 2,
   } ButtonType;

◆ DrivingModeType

enum ECUHandler::DrivingModeType

private

Enumerator
UNDEFINED
WITH_OBSTACLES
WITHOUT_OBSTACLES

Definition at line 82 of file ECUHandler.hpp.

                {
     UNDEFINED,
     WITH_OBSTACLES,
     WITHOUT_OBSTACLES,
   } DrivingModeType;

Constructor & Destructor Documentation

◆ ECUHandler()

ECUHandler::ECUHandler ( )

inline

Definition at line 38 of file ECUHandler.hpp.

38 :

39 difference_index(0), firstPacketReceived(false) {}

◆ ~ECUHandler()

ECUHandler::~ECUHandler ( )

inline

Definition at line 41 of file ECUHandler.hpp.

                 {
     Stop();
  
     if(m_pCommunication != nullptr) {
       m_pCommunication->VDisconnect();
     }
   }

References m_pCommunication, and Stop().

Here is the call graph for this function:

Member Function Documentation

◆ calculateChecksum() [1/2]

uint32_t ECUHandler::calculateChecksum ( ComputerPacket const & packet )

Definition at line 13 of file ECUHandler.cpp.

                                                                    {
   CRCType crc;
   crc.reset();
   /* compute crc without crc of packet */
   crc.process_bytes(&packet, sizeof(ComputerPacket) - sizeof(packet.crc));
  
   return crc.checksum();
 }

References ComputerPacket.

Referenced by TransmitPacket().

Here is the caller graph for this function:

◆ calculateChecksum() [2/2]

uint32_t ECUHandler::calculateChecksum ( SettingsPacket const & packet )

Definition at line 22 of file ECUHandler.cpp.

                                                                    {
   CRCType crc;
   crc.reset();
   /* compute crc without crc of packet */
   crc.process_bytes(&packet, sizeof(SettingsPacket) - sizeof(packet.crc));
  
   return crc.checksum();
 }

References SettingsPacket.

◆ init()

void ECUHandler::init ( PublishMeasurementsCallback cb )

Provides the handler with a connection to the ECUNode to communicate via ROS.

Parameters

cb	Function pointer to callback function

Definition at line 31 of file ECUHandler.cpp.

                                                     {
   cb_ = cb;
   InitializeCommunication();
   xlog("ECUHandler", "Successfully Initialised...");
 }

References cb_, InitializeCommunication(), and xlog.

Here is the call graph for this function:

◆ InitializeCommunication()

void ECUHandler::InitializeCommunication ( )

private

Definition at line 81 of file ECUHandler.cpp.

                                          {
   xlog("ECUHandler", "INIT UART");
   m_pCommunication = std::shared_ptr<ICommunication>(new UART());
  
   if(m_pCommunication != nullptr) {
     m_pCommunication->VConnect();
     if(!m_pCommunication->IsConnected()) {
       xlog("ECUHandler", "Failed to open serial port to breakout");
       return;
     }
  
     receiverThreadRunning = true;
     receiverThread        = new std::thread(&ECUHandler::ReceiveHandler, this);
  
     while(!firstPacketReceived) {
       /* TODO: why do we sleep here for 1 ms? */
       std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
   }
 }

References firstPacketReceived, m_pCommunication, ReceiveHandler(), receiverThread, receiverThreadRunning, and xlog.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ onNewPacketReceived()

void ECUHandler::onNewPacketReceived ( const EcuPacket * const packet )

private

Definition at line 65 of file ECUHandler.cpp.

                                                                   {
   if(this->cb_ == nullptr || packet == nullptr) {
     xlog("ECUHandler Error", "callback is a nullptr");
     /* TODO: go in failsafe mode */
     throw galaxis::Errors::POINTER_ERROR();
   }
  
   this->cb_(packet, packet_differences);
 }

References cb_, packet_differences, and xlog.

Referenced by ReceiveHandler().

Here is the caller graph for this function:

◆ ReceiveHandler()

void ECUHandler::ReceiveHandler ( )

private

Definition at line 102 of file ECUHandler.cpp.

                                 {
   CRCType crc;
   uint8_t buf[4096];
   uint8_t packet[sizeof(EcuPacket)];
  
   int packetIndex = 0;
  
   enum {
     RECEIVING_PREAMBLE,
     RECEIVING_DATA,
     CRC_UPDATE,
   } state = RECEIVING_PREAMBLE;
  
   while(receiverThreadRunning) {
     uint8_t byte;
     size_t bytesRead = m_pCommunication->VReceiveData(buf, sizeof(buf));
  
     for(size_t i = 0; i < bytesRead; i++) {
  
       byte = buf[i];
  
       switch(state) {
         case RECEIVING_PREAMBLE:
  
           packet[packetIndex] = byte;
           if(gcu8_header[packetIndex++] != byte) {
             packetIndex = 0;
           }
           if(packetIndex == 8)
             state = RECEIVING_DATA;
  
           break;
  
         case RECEIVING_DATA:
  
           packet[packetIndex++] = byte;
  
           if(packetIndex == sizeof(packet))
             state = CRC_UPDATE;
           break;
  
         default:
           /* TODO: errorhandler */
           return;
           break;
       }
  
       if(state == CRC_UPDATE) {
         const size_t begin_of_crc_sum = sizeof(packet) - 4;
         crc.reset();
         crc.process_bytes(packet, begin_of_crc_sum);
         const uint32_t computed_crc = crc.checksum();
  
         uint32_t packetCrc = packet[begin_of_crc_sum];
         packetCrc |= packet[begin_of_crc_sum + 1] << 8;
         packetCrc |= packet[begin_of_crc_sum + 2] << 16;
         packetCrc |= packet[begin_of_crc_sum + 3] << 24;
  
         if(packetCrc == computed_crc) {
           std::stringstream ss;
           //xlog("ECUHandler","Received new Packet");
  
           current_timestamp = std::chrono::steady_clock::now();
           if(firstPacketReceived) {
             std::chrono::duration<double, std::milli> diff_ms =
                 (current_timestamp - last_timestamp);
             if(diff_ms.count() < 9.5 || diff_ms.count() > 10.5 /*ms*/) {
               //ss << "=====>Current difference is " << diff_ms.count() << "ms";
  
               //std::cout << ss.str() << std::endl;
             }
             packet_differences.at(difference_index) = diff_ms;
           }
           last_timestamp = current_timestamp;
  
           difference_index++;
           if(difference_index == packet_differences.size()) {
             difference_index = 0;
           }
  
           firstPacketReceived = true;
           memcpy(&currentPacket, packet, sizeof(currentPacket));
           onNewPacketReceived(&currentPacket);
           //std::thread(&ECUHandler::onNewPacketReceived, this, &currentPacket);
         } else {
           xlog("ECUHandler", "Wrong CRC checksum");
         }
  
         packetIndex = 0;
         state       = RECEIVING_PREAMBLE;
       }
     }
   }
 }

References current_timestamp, currentPacket, difference_index, EcuPacket, firstPacketReceived, gcu8_header, last_timestamp, m_pCommunication, onNewPacketReceived(), packet_differences, receiverThreadRunning, and xlog.

Referenced by InitializeCommunication().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Stop()

void ECUHandler::Stop ( )

private

Definition at line 75 of file ECUHandler.cpp.

                       {
   receiverThreadRunning = false;
   if(receiverThread != nullptr)
     delete receiverThread;
 }

References receiverThread, and receiverThreadRunning.

Referenced by ~ECUHandler().

Here is the caller graph for this function:

◆ TransmitPacket() [1/2]

void ECUHandler::TransmitPacket ( ComputerPacket & packet )

This function transmits a packet to the ECU.

TODO

Definition at line 37 of file ECUHandler.cpp.

                                                       {
   memcpy(&(packet.preamble), gcu8_header, sizeof(packet.preamble));
   packet.packet_id = PACKET_ID_COMPUTER;
  
   packet.crc = calculateChecksum(packet);
  
   m_lastEcuPacket = packet;
  
   size_t written = m_pCommunication->VSendData(&packet, sizeof(ComputerPacket));
   if(written != sizeof(ComputerPacket)) {
     xlog("ECUHandler", "Could not write the whole computer packet");
   }
 }

References calculateChecksum(), ComputerPacket, gcu8_header, m_lastEcuPacket, m_pCommunication, PACKET_ID_COMPUTER, and xlog.

Here is the call graph for this function:

◆ TransmitPacket() [2/2]

void ECUHandler::TransmitPacket ( SettingsPacket & packet )

This function transmits a packet to the ECU.

TODO

Definition at line 51 of file ECUHandler.cpp.

                                                       {
   memcpy(&(packet.preamble), gcu8_header, sizeof(packet.preamble));
   packet.packet_id = PACKET_ID_SETTINGS;
  
   packet.crc = calculateChecksum(packet);
  
   size_t written = m_pCommunication->VSendData(&packet, sizeof(SettingsPacket));
   if(written != sizeof(SettingsPacket)) {
     xlog("ECUHandler", "Could not write the whole settings packet");
     /* TODO: ... */
     throw galaxis::Errors::UNDEFINED_ERROR();
   }
 }

References calculateChecksum(), gcu8_header, m_pCommunication, PACKET_ID_SETTINGS, SettingsPacket, and xlog.

Here is the call graph for this function:

Member Data Documentation

◆ cb_

PublishMeasurementsCallback ECUHandler::cb_

private

Definition at line 94 of file ECUHandler.hpp.

Referenced by init(), and onNewPacketReceived().

◆ current_timestamp

std::chrono::steady_clock::time_point ECUHandler::current_timestamp

private

Definition at line 71 of file ECUHandler.hpp.

Referenced by ReceiveHandler().

◆ currentPacket

EcuPacket ECUHandler::currentPacket

private

Definition at line 109 of file ECUHandler.hpp.

Referenced by ReceiveHandler().

◆ difference_index

size_t ECUHandler::difference_index

private

Definition at line 73 of file ECUHandler.hpp.

Referenced by ReceiveHandler().

◆ firstPacketReceived

bool ECUHandler::firstPacketReceived

private

Definition at line 111 of file ECUHandler.hpp.

Referenced by InitializeCommunication(), and ReceiveHandler().

◆ last_timestamp

std::chrono::steady_clock::time_point ECUHandler::last_timestamp

private

Definition at line 72 of file ECUHandler.hpp.

Referenced by ReceiveHandler().

◆ m_computerPacket

ComputerPacket ECUHandler::m_computerPacket

private

Definition at line 110 of file ECUHandler.hpp.

◆ m_lastEcuPacket

ComputerPacket ECUHandler::m_lastEcuPacket

private

Definition at line 88 of file ECUHandler.hpp.

Referenced by TransmitPacket().

◆ m_pCommunication

std::shared_ptr<ICommunication> ECUHandler::m_pCommunication = nullptr

private

Definition at line 117 of file ECUHandler.hpp.

Referenced by InitializeCommunication(), ReceiveHandler(), TransmitPacket(), and ~ECUHandler().

◆ mutex_on_packet

std::mutex ECUHandler::mutex_on_packet

private

Definition at line 102 of file ECUHandler.hpp.

◆ packet_differences

std::array<std::chrono::duration<double, std::milli>, 10> ECUHandler::packet_differences

private

Definition at line 74 of file ECUHandler.hpp.

Referenced by onNewPacketReceived(), and ReceiveHandler().

◆ receiverThread

std::thread* ECUHandler::receiverThread = nullptr

private

Definition at line 100 of file ECUHandler.hpp.

Referenced by InitializeCommunication(), and Stop().

◆ receiverThreadRunning

bool ECUHandler::receiverThreadRunning = true

private

Definition at line 101 of file ECUHandler.hpp.

Referenced by InitializeCommunication(), ReceiveHandler(), and Stop().

The documentation for this class was generated from the following files:

nodes/ECUNode/include/ECUHandler.hpp
nodes/ECUNode/src/ECUHandler.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ButtonType

◆ DrivingModeType

Constructor & Destructor Documentation

◆ ECUHandler()

◆ ~ECUHandler()

Member Function Documentation

◆ calculateChecksum() [1/2]

◆ calculateChecksum() [2/2]

◆ init()

◆ InitializeCommunication()

◆ onNewPacketReceived()

◆ ReceiveHandler()

◆ Stop()

◆ TransmitPacket() [1/2]

◆ TransmitPacket() [2/2]

Member Data Documentation

◆ cb_

◆ current_timestamp

◆ currentPacket

◆ difference_index

◆ firstPacketReceived

◆ last_timestamp

◆ m_computerPacket

◆ m_lastEcuPacket

◆ m_pCommunication

◆ mutex_on_packet

◆ packet_differences

◆ receiverThread

◆ receiverThreadRunning