WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/can/Protocol.cpp

  */
 #include "Protocol.h"
 #include <stdexcept>
+#include <string.h>
 #include <boost/lexical_cast.hpp>
 namespace atom {
 namespace can {
+    {
         LOG.Error(e.what());
         return false;
+    }
-    LOG.Info("Protocol loaded successfully");
+    LOG.Info("Protocol loaded successfully.");
     return true;
+}
 std::string Protocol::LookupClassName(unsigned int class_id)
+{
+    }
+}
 std::string Protocol::LookupModuleName(unsigned int module_id)
+{
+    if (module_id == 0)
+    {
+        return "";
+    }
     try
+    {
         return this->root_node_.FindChild("modules").SelectChild("id", boost::lexical_cast<std::string>(module_id)).GetAttributeValue("name");
+    }
     catch (std::runtime_error& e)
     {
         LOG.Error(e.what());
         throw std::runtime_error("No such module id found, " + boost::lexical_cast<std::string>(module_id));
+    }
 }
 unsigned int Protocol::ResolveModuleId(std::string module_name)
+{
+    if (module_name == "")
+    {
+        return 0;
+    }
     try
     {
         return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("modules").SelectChild("name", module_name).GetAttributeValue("id"));
+    }
     catch (std::runtime_error& e)
     {
         LOG.Error(e.what());
         throw std::runtime_error("No such module name found, " + module_name);
+    }
 }
 xml::Node::NodeList Protocol::GetCommandVariables(std::string command_name, std::string module_name)
 {
     try
     {
         return this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name).FindChild("variables").GetChildren();
     }
     catch (std::runtime_error& e)
+    {
+    }
     try
     {
         return this->root_node_.FindChild("commands").SelectChild("name", command_name).FindChild("variables").GetChildren();
     }
     catch (std::runtime_error& e)
     {
         LOG.Error(e.what());
         throw std::runtime_error("No such command found, name = " + command_name + ", module = " + module_name);
+    }
+}
 xml::Node::NodeList Protocol::GetNMTCommandVariables(std::string command_name)
 {
     try
     {
         return this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).FindChild("variables").GetChildren();
+    }
     catch (std::runtime_error& e)
+    {
         LOG.Error(e.what());
         throw std::runtime_error("No such nmt command found, name = " + command_name);
     }
 }
+std::string Protocol::DecodeInt(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
+{
+    unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
+    int raw_value = 0;
+    memcpy(&raw_value, &raw_bit_value, sizeof(raw_value));
+    return boost::lexical_cast<std::string>(raw_value);
+}
+void Protocol::EncodeInt(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
-/*
+{
+    unsigned long raw_bit_value = 0;
+    int raw_value = boost::lexical_cast<int>(value);
+    memcpy(&raw_bit_value, &raw_value, sizeof(raw_value));
-void Protocol::makeNMTDataValid(std::string commandName, map<std::string, CanVariable> &data)
+    bitset.Write(start_bit, bit_length, raw_bit_value);
-{
+}
-    std::vector<Node> commandNodes = xmlNode.findChild("nmt_messages").getChildren();
+std::string Protocol::DecodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
-    for (int n = 0; n < commandNodes.size(); n++)
+{
-    {
+    unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
-        map<std::string, std::string> attributes = commandNodes[n].getAttributes();
+    return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);
-        if (attributes["name"] == commandName)
+}
-        {
-            Node varablesNode = commandNodes[n].findChild("variables");
+void Protocol::EncodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
+{
-            makeDataValid(varablesNode.getChildren(), data);
+    unsigned long raw_bit_value = boost::lexical_cast<unsigned int>(value);
-            return;
+    bitset.Write(start_bit, bit_length, raw_bit_value);
-        }
+}
-    }
-}
+std::string Protocol::DecodeFloat(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
+{
-void Protocol::makeDataValid(int commandId, std::string moduleName, map<std::string, CanVariable> &data)
+    float raw_value = 0;
-{
+    bool negative = false;;
-    std::vector<Node> commandNodes = xmlNode.findChild("commands").getChildren();
+    if (bitset.Get(start_bit))
-    for (int n = 0; n < commandNodes.size(); n++)
+    {
-    {
+        negative = true;
-        map<std::string, std::string> attributes = commandNodes[n].getAttributes();
-        bool correct = false;
-        if (commandId >= 128)
-        {
-            if (stoi(attributes["id"]) == commandId && attributes["module"] == moduleName)
-            {
-                correct = true;
-            }
-        }
-        else if (stoi(attributes["id"]) == commandId)
-        {
-            correct = true;
-        }
-        if (correct)
-        {
-            Node varablesNode = commandNodes[n].findChild("variables");
-            makeDataValid(varablesNode.getChildren(), data);
-            return;
-        }
-    }
-}
-void Protocol::makeDataValid(std::vector<Node> variableNodes, map<std::string, CanVariable> &data)
-{
-    ///FIXME: Remove variables that do not exist in the xmlfile
-    for (int c = 0; c < variableNodes.size(); c++)
-    {
-        map<std::string, std::string> attributes = variableNodes[c].getAttributes();
-        if (data.find(attributes["name"]) != data.end())
-        {
-            data[attributes["name"]].setType(attributes["type"]);
-            data[attributes["name"]].setUnit(attributes["unit"]);
-            data[attributes["name"]].setBitLength(stoi(attributes["bit_length"]));
-            data[attributes["name"]].setStartBit(stoi(attributes["start_bit"]));
-            if (attributes["type"] == "enum")
-            {
-                std::vector<Node> values = variableNodes[c].getChildren();
-                for (int k = 0; k < values.size(); k++)
-                {
-                    map<std::string, std::string> valueAttributes = values[k].getAttributes();
-                    data[attributes["name"]].addEnumValue(valueAttributes["id"], valueAttributes["name"]);
-                }
-            }
-        }
-    }
-}
-std::string Protocol::translateDataToHex(int commandId, std::string moduleName, map<std::string, CanVariable> &data)
-{
-    makeDataValid(commandId, moduleName, data);
-    return translateValidDataToHex(data);
-}
-map<std::string, CanVariable> Protocol::translateData(int commandId, std::string moduleName, std::string dataHex)
-{
-    std::vector<Node> commandNodes = xmlNode.findChild("commands").getChildren();
-    for (int n = 0; n < commandNodes.size(); n++)
-    {
-        map<std::string, std::string> attributes = commandNodes[n].getAttributes();
-        bool correct = false;
-        if (commandId >= 128)
-        {
-            if (stoi(attributes["id"]) == commandId && attributes["module"] == moduleName)
-            {
-                correct = true;
-            }
-        }
-        else if (stoi(attributes["id"]) == commandId)
-        {
-            correct = true;
-        }
-        if (correct)
-        {
-            Node varablesNode = commandNodes[n].findChild("variables");
-            return translateData(varablesNode.getChildren(), dataHex);
-        }
-    }
-    map<std::string, CanVariable> variables;
-    return variables;
-}
-map<std::string, CanVariable> Protocol::translateNMTData(int commandId, std::string dataHex)
-{
-    std::vector<Node> commandNodes = xmlNode.findChild("nmt_messages").getChildren();
-    for (int n = 0; n < commandNodes.size(); n++)
-    {
-        map<std::string, std::string> attributes = commandNodes[n].getAttributes();
-        if (stoi(attributes["id"]) == commandId)
-        {
-            Node varablesNode = commandNodes[n].findChild("variables");
-            return translateData(varablesNode.getChildren(), dataHex);
-        }
-    }
-    map<std::string, CanVariable> variables;
-    return variables;
-}
-std::string Protocol::translateNMTDataToHex(std::string commandName, map<std::string, CanVariable> &data)
-{
-    makeNMTDataValid(commandName, data);
-    return translateValidDataToHex(data);
-}
-template <class T>
-bool from_std::string(T& t,
-                const std::std::string& s,
-                std::ios_base& (*f)(std::ios_base&))
-{
-    std::istd::stringstream iss(s);
-    return !(iss >> f >> t).fail();
-}
-std::string Protocol::translateValidDataToHex(map<std::string, CanVariable> &data)
-{
-    std::string bin = "0000000000000000000000000000000000000000000000000000000000000000";
-    int highestBit = 0;
-    for (map<std::string, CanVariable>::iterator iter = data.begin(); iter != data.end(); iter++)
-    {
-        if (iter->second.getType() == "uint")
-        {
-            if (iter->second.getStartBit() + iter->second.getBitLength() > highestBit)
-                highestBit = iter->second.getStartBit() + iter->second.getBitLength();
-            unsigned int a = stou(iter->second.getValue());
-            bin.replace(iter->second.getStartBit(), iter->second.getBitLength(), uint2bin(a, iter->second.getBitLength()));
-        }
-        else if (iter->second.getType() == "int")
-        {
-            if (iter->second.getStartBit() + iter->second.getBitLength() > highestBit)
-                highestBit = iter->second.getStartBit() + iter->second.getBitLength();
-            unsigned int a = stou(iter->second.getValue());
-            bin.replace(iter->second.getStartBit(), iter->second.getBitLength(), uint2bin(a, iter->second.getBitLength()));
-        }
-        else if (iter->second.getType() == "float")
-        {
-            if (iter->second.getStartBit() + iter->second.getBitLength() > highestBit)
-                highestBit = iter->second.getStartBit() + iter->second.getBitLength();
-            bin.replace(iter->second.getStartBit(), iter->second.getBitLength(), float2bin(stof(iter->second.getValue()), iter->second.getBitLength()));
-        }
-        else if (iter->second.getType() == "enum")
-        {
-            if (iter->second.getStartBit() + iter->second.getBitLength() > highestBit)
-                highestBit = iter->second.getStartBit() + iter->second.getBitLength();
-            std::string value = iter->second.getEnumIdValue();
-            if (value == "")
-            {
-                throw new CanMessageException("Got enum that could not be converterd to a value. value = \"" + iter->second.getValue() + "\" enumString is \"" + iter->second.getEnumsString() + "\"\n");
-            }
-            else
-            {
-                bin.replace(iter->second.getStartBit(), iter->second.getBitLength(), uint2bin(stou(value), iter->second.getBitLength()));
-            }
-        }
-        else if (iter->second.getType() == "ascii")
-        {
-            for (int n = 0; n < iter->second.getValue().length(); n++)
-            {
-                if (iter->second.getStartBit()+n*8 + 8 > highestBit)
-                    highestBit = iter->second.getStartBit()+n*8 + 8;
-                //bin.replace(iter->second.getStartBit()+n*8, 8, uint2bin((unsigned int)iter->second.getValue()[n], 8));
-                    unsigned int temp = iter->second.getValue()[n];
-                    if (temp > 0xff)
-                    {
-                        temp &= 0xff;
-                    }
-                    bin.replace(iter->second.getStartBit()+n*8, 8, uint2bin(temp, 8));
-            }
-        }
-        else if (iter->second.getType() == "hexstd::string")
-        {
-            for (int n = 0; n < iter->second.getValue().length(); n++)
-            {
-                if (iter->second.getStartBit()+n*4 + 4 > highestBit)
-                    highestBit = iter->second.getStartBit()+n*4 + 4;
-                std::string character;
-                character += iter->second.getValue()[n];
-                bin.replace(iter->second.getStartBit()+n*4, 4, hex2bin(character));
-            }
-        }
-    }
-    try
-    {
-        while (highestBit%8 != 0)
-        {
-            highestBit++;
-        }
-        bin = bin.substr(0, highestBit);
-    }
-    catch (std::out_of_range& e)
-    {
-        cout << "DEBUG: translateValidDataToHex exception: " << e.what() << "\n";
-        cout << "DEBUG: A bin=" << bin << " :: highestBit=" << highestBit << endl;
-    }
-    return bin2hex(bin);
-}
-map<std::string, CanVariable> Protocol::translateData(std::vector<Node> variableNodes, std::string dataHex)
-{
-    map<std::string, CanVariable> variables;
-    std::string dataBin = hex2bin(dataHex);
-    //dataBin = rpad(dataBin, 64, '0');
-    for (int c = 0; c < variableNodes.size(); c++)
-    {
-        map<std::string, std::string> attributes = variableNodes[c].getAttributes();
-        int bitStart = stoi(attributes["start_bit"]);
-        int bitLength = stoi(attributes["bit_length"]);
-        std::string bits;
-        try
-        {
-            bits = dataBin.substr(bitStart, bitLength);
-        }
-        catch (std::out_of_range& e)
-        {
-            return variables;
-        }
-        CanVariable variable;
-        variable.setName(attributes["name"]);
-        variable.setType(attributes["type"]);
-        variable.setUnit(attributes["unit"]);
-        variable.setStartBit(bitStart);
-        variable.setBitLength(bitLength);
-        if (attributes["type"] == "uint")
-        {
-            variable.setValue(utos(bin2uint(bits)));
-        }
-        else if (attributes["type"] == "int")
-        {
-            variable.setValue(itos(bin2int(bits)));
-        }
-        else if (attributes["type"] == "float")
-        {
-            variable.setValue(ftos(bin2float(bits)));
-        }
-        else if (attributes["type"] == "enum")
-        {
-            std::vector<Node> values = variableNodes[c].getChildren();
-            std::string value = utos(bin2uint(bits));
-            for (int k = 0; k < values.size(); k++)
-            {
-                map<std::string, std::string> valueAttributes = values[k].getAttributes();
-                variable.addEnumValue(valueAttributes["id"], valueAttributes["name"]);
-                if (valueAttributes["id"] == value)
-                {
-                    variable.setValue(valueAttributes["name"]);
-                }
-            }
-        }
-        else if (attributes["type"] == "ascii")
-        {
-            std::string str;
-            for (int k = 0; k < bits.length(); k += 8)
-            {
-                try
-                {
-                    str += (char)bin2uint(bits.substr(k, 8));
-                }
-                catch (std::out_of_range& e)
-                {
-                    cout << "DEBUG: TranslateData exception: " << e.what() << "\n";
-                    cout << "DEBUG: B bits=" << bits << " :: k=" << k << endl;
-                    continue;
-                }
+    }
+    for (int c = bit_length-1; c > 0; c--)
+    {
+        if (bitset.Get(start_bit + c) != negative)
+        {
-            variable.setValue(str);
+            raw_value += pow(2.0f, (int)(bit_length-1-c));
+        }
-        else if (attributes["type"] == "hexstd::string")
-        {
+    }
-            std::string str;
+    raw_value /= 64.0f;
-            for (int k = 0; k < bits.length(); k += 4)
+    if (negative)
+    {
+        raw_value = -raw_value;
+    }
+    return boost::lexical_cast<std::string>(raw_value);
+}
+void Protocol::EncodeFloat(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
+{
+ // TODO:
+}
+std::string Protocol::DecodeAscii(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
+{
+    std::string value;
+    char c = 0;
+    for (unsigned int p = 0; p < bit_length; p += 8)
+    {
+        unsigned long raw_bit_value = bitset.Read(start_bit + p, 8);
+        memcpy(&c, &raw_bit_value, sizeof(c));
-                try
+        value += c;
+    }
+    return value;
+}
+void Protocol::EncodeAscii(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
+{
-                    str += bin2hex(bits.substr(k, 4));
-                }
+    // TODO
+}
-                catch (std::out_of_range& e)
+std::string Protocol::DecodeHexstring(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
+{
+    std::string value;
-                    cout << "DEBUG: TranslateData exception: " << e.what() << "\n";
+    char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+    for (unsigned int p = 0; p < bit_length; p += 4)
+    {
-                    cout << "DEBUG: C bits=" << bits << " :: k=" << k << endl;
+        unsigned long raw_bit_value = bitset.Read(start_bit + p, 4);
+        if (raw_bit_value >= sizeof(hex))
+        {
-                    continue;
+            value += '-';
+        }
+        else
+        {
+            value += hex[raw_bit_value];
+        }
+    }
-            variable.setValue(str);
-        }
-        variables[attributes["name"]] = variable;
-    }
-    return variables;
+    return value;
 }
+void Protocol::EncodeHexstring(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
+{
-   */
+    // TODO:
+}
 }; // namespace can
 }; // namespace atom

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/can/Protocol.cpp – Rev 1596 → 1598