/***************************************************************************
* Copyright (C) November 28, 2008 by Mattias Runge *
* mattias@runge.se *
* canmessage.cpp *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <string>
#include <iostream>
#include "canidtranslator.h"
#include "canmessage.h"
void CanMessage::setRaw(string rawHex)
{
CanIdTranslator &translator = CanIdTranslator::getInstance();
//SyslogStream &slog = SyslogStream::getInstance();
//PKT 00060102 1 0 00 00 c4
rawHex = trim(rawHex, '\n');
rawHex = trim(rawHex);
vector<string> parts = explode(" ", rawHex);
if (parts.size() < 2 || parts[0].compare("PKT") != 0)
{
//slog << "Malformed can message received from canDaemon: \"" << rawHex << "\"\n";
throw new CanMessageException("Malformed can message received from canDaemon");
}
myRawHeaderBin = hex2bin(parts[1]);
myIsHeartbeat = (parts[1] == translator.getDefineId("HeartbeatHeader", "None"));
// This is not a module id header, but heartbeats are sent this way so we want to check it anyway
if (myIsHeartbeat)
{
string rawHexData = "";
for (int n = 4; n < parts.size(); n++)
{
rawHexData += parts[n];
}
myData = translator.translateHeartbeatData(rawHexData);
}
else
{
myClassName = translator.lookupClassName(bin2uint(myRawHeaderBin.substr(3, 4)));
if (myClassName == "")
{
myIsUnknown = true;
return;
}
myDirectionFlag = translator.lookupDirectionFlag(bin2uint(myRawHeaderBin.substr(7, 1)));
myModuleName = translator.lookupModuleName(bin2uint(myRawHeaderBin.substr(8, 8)));
myModuleId = bin2uint(myRawHeaderBin.substr(16, 8));
int commandId = bin2uint(myRawHeaderBin.substr(24, 8));
myCommandName = translator.lookupCommandName(commandId, myModuleName);
string rawHexData = "";
for (int n = 4; n < parts.size(); n++)
{
rawHexData += parts[n];
}
myData = translator.translateData(commandId, myModuleName, rawHexData);
}
}
string CanMessage::getRaw()
{
CanIdTranslator &translator = CanIdTranslator::getInstance();
string rawHex = "PKT ";
string bin = "000";
int classId = translator.resolveClassId(myClassName);
if (classId == -1)
bin += "0000";
else
bin += uint2bin(classId, 4);
bin += uint2bin(translator.resolveDirectionFlag(myDirectionFlag), 1);
int moduleTypeId = translator.resolveModuleId(myModuleName);
if (moduleTypeId == -1)
bin += "00000000";
else
bin += uint2bin(moduleTypeId, 8);
int moduleId = myModuleId;
bin += uint2bin(moduleId, 8);
int commandNameId = translator.resolveCommandId(myCommandName, myModuleName);
if (commandNameId == -1)
bin += "00000000";
else
bin += uint2bin(commandNameId, 8);
rawHex += bin2hex(bin);
rawHex += " 1 0";
string dataHex = translator.translateDataToHex(commandNameId, myModuleName, myData);
while (dataHex.size() > 0)
{
string hex = dataHex.substr(0, 2);
dataHex.erase(0, 2);
rawHex += " " + hex;
}
rawHex += "\n";
return rawHex;
}
void CanMessage::setJSON(string json)
{
cout << json << "\n";
string data = trim(json, '(');
data = trim(data, ')');
data = trim(data, '{');
data = trim(data, '{');
data = trim(data, ' ');
vector<string> parts = explode(",", data);
for (int n = 0; n < parts.size(); n++)
{
string part = trim(parts[n], ' ');
vector<string> innerParts = explode(":", part);
int c = 0;
if (innerParts[0] == "data")
c++;
string name = trim(innerParts[c], ' ');
name = trim(name, '{');
name = trim(name, '}');
string value = trim(innerParts[c+1], ' ');
value = trim(value, '{');
value = trim(value, '}');
value = trim(value, '"');
cout << "\n" << name << "=" << value << "\n";
if (name == "className")
myClassName = value;
else if (name == "directionFlag")
myDirectionFlag = value;
else if (name == "moduleName")
myModuleName = value;
else if (name == "moduleId")
myModuleId = stoi(value);
else if (name == "commandName")
myCommandName = value;
else
{
CanVariable canVariable(name, value, "", "");
myData[name] = canVariable;
}
}
}
string CanMessage::getJSON()
{
string json = "{ ";
json += "className : '" + myClassName + "', ";
json += "directionFlag : '" + myDirectionFlag + "', ";
json += "moduleName : '" + myModuleName + "', ";
json += "moduleId : " + itos(myModuleId) + ", ";
json += "commandName : '" + myCommandName + "', ";
json += "data : {";
map<string, CanVariable>::iterator iter;
for (iter = myData.begin(); iter != myData.end(); iter++)
{
json += " " + iter->first + " : { ";
json += "unit : '" + iter->second.getUnit() + "', ";
json += "type : '" + iter->second.getType() + "', ";
json += "value : ";
if (iter->second.getType() == "uint")
{
json += iter->second.getValue();
}
else if (iter->second.getType() == "float")
{
json += iter->second.getValue();
}
else if (iter->second.getType() == "ascii" || iter->second.getType() == "hexstring")
{
json += "'" + iter->second.getValue() + "'";
}
json += " },";
}
json = trim(json, ',');
json += " }";
return json + " }";
}
string CanMessage::getJSONData()
{
string json = "{";
map<string, CanVariable>::iterator iter;
for (iter = myData.begin(); iter != myData.end(); iter++)
{
json += " " + iter->first + " : ";
if (iter->second.getType() == "uint")
{
json += iter->second.getValue();
}
else if (iter->second.getType() == "float")
{
json += iter->second.getValue();
}
else if (iter->second.getType() == "ascii" || iter->second.getType() == "hexstring")
{
json += "'" + escape(iter->second.getValue()) + "'";
}
json += ",";
}
json = trim(json, ',');
return json + " }";
}