WIP2 all mod data

Author: JimsterCoder

can/messages/Tesla/TSModCellVoltages.cpp

@@ -15,36 +15,34 @@ namespace {
 
 TSModCellVoltages::TSModCellVoltages():
    Message(ID_TS_MOD_CELLS_VOLTS, GROUP_NONE),
-   m_cell_voltage(),
-   m_module_num()
+   m_cell_data()
 {
 }
 
 TSModCellVoltages::TSModCellVoltages(const DataFrame& frame):
    Message(ID_TS_MOD_CELLS_VOLTS, GROUP_NONE),
-   m_cell_voltage(),
-   m_module_num()
+   m_cell_data()
 {
    if (frame.id() != id()) return;
    if (frame.size() != 8) return;
 
-   m_module_num = frame.getByte(1);
+   m_cell_data.module_num = frame.getByte(1);
 
    for (int i=0; i < 6; i++)
    {
-      m_cell_voltage[i] = 2.0 + (frame.getByte(i+2) / 100.0f);
+      m_cell_data.voltages[i] = 2.0 + (frame.getByte(i+2) / 100.0f);
    }
    setValid();
 }
 
 float TSModCellVoltages::getCellVoltage(uint cell) const
 {
-   return m_cell_voltage[cell];
+   return m_cell_data.voltages[cell];
 }
 
 uint16_t TSModCellVoltages::getModuleNum() const
 {
-   return m_module_num;
+   return m_cell_data.module_num;
 }
 
 

can/messages/Tesla/TSModCellVoltages.hpp

@@ -16,16 +16,21 @@ namespace Tesla {
 class TSModCellVoltages: public Message
 {
 public:
+   struct CellVoltageData {
+      uint16_t module_num;
+      float voltages[6];
+   };
+
    TSModCellVoltages();
    TSModCellVoltages(const DataFrame& f);
 
    uint16_t getModuleNum() const;
    float getCellVoltage(uint cell) const;
+   const CellVoltageData& getCellVoltages() const { return m_cell_data; }
    virtual void toStream(logging::ostream&) const;
 
 private:
-   float m_cell_voltage[6];
-   uint16_t m_module_num;
+   CellVoltageData m_cell_data;
 };
 
 }

logging/logging.cpp

@@ -30,6 +30,8 @@
 
 using namespace std;
 using namespace logging;
+using namespace can::messages::Tesla;
+
 
 // Log file name. File name should be change from here only
 const string logFileName = "BatteryController.log";
@@ -42,7 +44,8 @@ Logger::Logger(LOG_LEVEL loglevel, core::Timer& timer, std::vector<monitor::Moni
    m_vmonitor(vmonitor),
    m_datalog_callback(*this, &Logger::updateDataLog),
    resetCallback(true),
-   m_prev_minute(0)
+   m_prev_minute(0),
+   m_mod_cell_data(m_mod_cell_data) // just to initialize the reference, it will be set to the actual data in the process function when the first message is received
 {
    m_File.open(logFileName.c_str(), ios::out|ios::app);
    m_LogLevel  = loglevel;
@@ -106,6 +109,41 @@ void Logger::setMonitor(std::vector<monitor::Monitor*> vmonitor)
    }
 }
 
+void Logger::sink(const can::messages::Tesla::Message& message)
+{
+   info("CAN message received in Logger", __FILENAME__, __LINE__);
+   if (not message.valid()) return;
+
+   switch(message.id())
+   {
+   case can::messages::Tesla::ID_TS_MOD_CELLS_VOLTS:
+      process(static_cast<const can::messages::Tesla::TSModCellVoltages&>(message));
+      break;
+
+   default:
+      // unknown id
+      return;
+   }
+}
+
+// void TeslaSlaveMonitor::process(const TSBatteryStatus& battery_status)
+// {
+
+void Logger::process(const can::messages::Tesla::TSModCellVoltages& mod_cell_volts)
+{
+   m_mod_cell_data = mod_cell_volts.getCellVoltages();
+
+   std::string message = "TSModCellVoltages module=" + std::to_string(m_mod_cell_data.module_num);
+   for (unsigned i = 0; i < 6; ++i)
+   {
+      message += " v" + std::to_string(m_mod_cell_data.voltages[i]);
+   }
+
+   std::string debugMessage = message;
+   info(debugMessage);
+}
+
+
 void Logger::updateDataLog()
 {
    // called once per DATALOG_CALLBACK_PERIOD

logging/logging.hpp

@@ -1,6 +1,13 @@
 #ifndef LOGGING_LOGGING_HPP_
 #define LOGGING_LOGGING_HPP_
 
+#include "can/FrameSink.hpp"
+#include "can/messages/Tesla/TSModCellVoltages.hpp"
+#include "can/messages/Tesla/Message.hpp"
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // @File Name:     Logger.h                                                  //
 // @Author:        Pankaj Choudhary                                          //
@@ -52,6 +59,19 @@
 
 #define __FILENAME__ (strrchr(__FILE__,47)+1)
 
+namespace can {
+namespace messages {
+namespace Tesla {
+class Message;
+class TSTemperatures;
+// class CellVoltageRange;
+// class BatteryState;
+// class BatteryStatus;
+// class BatteryPowerLimits;
+}
+}
+}
+
 namespace logging
 {
    // Default value for maximum number of log files 
@@ -79,14 +99,16 @@ namespace logging
       FILE_LOG          = 3,
    }LogType;
 
-   class Logger
+   class Logger : public can::messages::Tesla::MessageSink
    {
       public:
          Logger(LOG_LEVEL loglevel, core::Timer& timer, std::vector<monitor::Monitor*> vmonitor);
          ~Logger();
 
          void setMonitor(std::vector<monitor::Monitor*> vmonitor);
 
+         virtual void sink(const can::messages::Tesla::Message&);
+
          // Interface for Error Log
          void error(const char* text) throw();
          void error(std::string& text) throw();
@@ -161,6 +183,7 @@ namespace logging
          void logIntoFile(std::string& data);
          void logOnConsole(std::string& data);
          // void rollLogFiles();
+         void process(const can::messages::Tesla::TSModCellVoltages& mod_cell_volts);
 
       private:
          std::thread httpPostThread;
@@ -187,6 +210,9 @@ namespace logging
          #define DATA_COUNT 9
          AvgMinMax m_bat_data[DATA_COUNT][MAX_BATTERIES];
 
+         can::messages::Tesla::TSModCellVoltages::CellVoltageData &m_mod_cell_data;
+
+
          // unsigned int		 logSize; // Size of a log file in bytes
          // unsigned int		 maxLogFiles; // Maximum number of log files
          // unsigned int		 logFilesCount; // Count of existing log files 

monitor/Tesla/TeslaSlaveMonitor.cpp

@@ -102,7 +102,7 @@ void TeslaSlaveMonitor::sink(const can::messages::Tesla::Message& message)
       process(static_cast<const TSBatteryStatus&>(message));
       break;
 
-      case ID_TS_TEMPS:
+   case ID_TS_TEMPS:
       process(static_cast<const TSTemperatures&>(message));
       break;
 
@@ -153,6 +153,8 @@ void TeslaSlaveMonitor::process(const TSBatteryStatus& battery_status)
    if (status != m_prev_battery_status && !m_battery_status_ok) m_log->alarm(ss,__FILENAME__,__LINE__);
    m_prev_battery_status = status;
    updateOperationalSafety();
+
+   m_log->info("TeslaSlaveMonitor: Battery Status processed", __FILENAME__, __LINE__);
 }
 
 void TeslaSlaveMonitor::process(const TSVoltages& voltages)