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


/*
 *
 *  Copyright (C) 2010  Mattias Runge
 *
 *  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.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
 
#include "Protocol.h"
 
#include <stdexcept>
#include <string.h>
 
#include <boost/lexical_cast.hpp>
 
namespace atom {
namespace can {
 
Protocol::Pointer Protocol::instance_;
 
Protocol::Protocol() : LOG("can::Protocol")
{
}
 
Protocol::~Protocol()
{
}
 
void Protocol::Create()
{
    Protocol::instance_ = Protocol::Pointer(new Protocol());
}
 
Protocol::Pointer Protocol::Instance()
{
    return Protocol::instance_;
}
 
void Protocol::Delete()
{
    Protocol::instance_.reset();
}
   
bool Protocol::Load(std::string filename)
{
    try
    {
        this->root_node_.LoadFile(filename);
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        return false;
    }
   
    LOG.Info("Protocol loaded successfully.");
    return true;
}
 
std::string Protocol::LookupClassName(unsigned int class_id)
{
    try
    {
        return this->root_node_.FindChild("classes").SelectChild("id", boost::lexical_cast<std::string>(class_id)).GetAttributeValue("name");
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such class_id found, " + boost::lexical_cast<std::string>(class_id));
    }
}
 
unsigned int Protocol::ResolveClassId(std::string class_name)
{
    try
    {
        return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("classes").SelectChild("name", class_name).GetAttributeValue("id"));
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such class_name found, " + class_name);
    }
}
 
std::string Protocol::LookupCommandName(unsigned int command_id, std::string module_name)
{
    try
    {
        if (command_id >= 128)
        {
            return this->root_node_.FindChild("commands").SelectChild("id", boost::lexical_cast<std::string>(command_id), "module", module_name).GetAttributeValue("name");
        }
   
        return this->root_node_.FindChild("commands").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such command found, id = " + boost::lexical_cast<std::string>(command_id) + ", module = " + module_name);
    }
}
 
unsigned int Protocol::ResolveCommandId(std::string command_name, std::string module_name)
{
    try
    {
        return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name).GetAttributeValue("id"));
    }
    catch (std::runtime_error& e)
    {
    }
   
    try
    {
        return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("commands").SelectChild("name", command_name).GetAttributeValue("id"));
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such command found, name = " + command_name + ", module = " + module_name);
    }
}
 
std::string Protocol::LookupNMTCommandName(unsigned int command_id)
{
    try
    {
        return this->root_node_.FindChild("nmt_messages").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such nmt command found, id = " + boost::lexical_cast<std::string>(command_id));
    }
}
 
unsigned int Protocol::ResolveNMTCommandId(std::string command_name)
{
    try
    {
        return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).GetAttributeValue("id"));
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such nmt command found, name = " + command_name);
    }
}
 
std::string Protocol::GetDefineId(std::string name, std::string group)
{
    try
    {
        return this->root_node_.FindChild("defines").SelectChild("name", name, "group", group).GetAttributeValue("id");
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such define found, name = " + name + ", group = " + group);
    }
}
 
std::string Protocol::LookupDirectionFlag(unsigned int direction_flag)
{
    try
    {
        return this->root_node_.FindChild("defines").SelectChild("id", boost::lexical_cast<std::string>(direction_flag), "group", "DirectionFlag").GetAttributeValue("name");
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such direction flag found, direction_flag = " + boost::lexical_cast<std::string>(direction_flag));
    }
}
 
unsigned int Protocol::ResolveDirectionFlag(std::string direction_name)
{
    try
    {
        return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("defines").SelectChild("name", direction_name, "group", "DirectionFlag").GetAttributeValue("id"));
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("No such direction flag found, direction_name = " + direction_name);
    }
}
 
std::string Protocol::LookupModuleName(unsigned int module_id)
{
    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)
{
    xml::Node node;
   
    try
    {
        node = this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name);
       
        try
        {
            return node.FindChild("variables").GetChildren();
        }
        catch (std::runtime_error& e)
        {
            return xml::Node::NodeList();
        }
    }
    catch (std::runtime_error& e)
    {
    }
 
   
    try
    {
        node = this->root_node_.FindChild("commands").SelectChild("name", command_name);
       
        try
        {
            return node.FindChild("variables").GetChildren();
        }
        catch (std::runtime_error& e)
        {
            return xml::Node::NodeList();
        }
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("Could not find variables for command, name = " + command_name + ", module = " + module_name);
    }
   
    return xml::Node::NodeList();
}
 
xml::Node::NodeList Protocol::GetNMTCommandVariables(std::string command_name)
{
    xml::Node node;
   
    try
    {
        node = this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name);
       
        try
        {
            return node.FindChild("variables").GetChildren();
        }
        catch (std::runtime_error& e)
        {
            return xml::Node::NodeList();
        }
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
        throw std::runtime_error("Could not find variables for nmt command, name = " + command_name);
    }
   
    return xml::Node::NodeList();
}
 
std::string Protocol::DecodeInt(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
    bool sign = bitset.Get(start_bit) == 1;
   
    unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
 
 
 
 
    int raw_value = raw_bit_value;
   
    if (sign)
    {
        long mask = 0;
       
        for (unsigned int n = 0; n < bit_length; n++)
        {
            mask += (1 << n);
        }
       
        raw_value = -((~raw_bit_value) & mask);
    }
 
    return boost::lexical_cast<std::string>(raw_value);
}
 
void Protocol::EncodeInt(common::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);
   
    raw_bit_value = raw_bit_value;
   
    if (raw_value < 0)
    {
        long mask = 0;
       
        for (unsigned int n = 0; n < bit_length; n++)
        {
            mask += (1 << n);
        }
       
        raw_bit_value = (~(-raw_value)) & mask;
    }
   
    bitset.Write(start_bit, bit_length, raw_bit_value);
}
 
std::string Protocol::DecodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
    unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
   
    //LOG.Debug("DecodeUint: raw_bit_value=" + boost::lexical_cast<std::string>(raw_bit_value));
   
    return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);
}
 
void Protocol::EncodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
{
    unsigned long raw_bit_value = boost::lexical_cast<unsigned int>(value);
   
    bitset.Write(start_bit, bit_length, raw_bit_value);
}
 
std::string Protocol::DecodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
    float float_value = boost::lexical_cast<float>(this->DecodeInt(bitset, start_bit, bit_length));
    LOG.Debug("DecodeFloat::float_value1=" + boost::lexical_cast<std::string>(float_value));
   
   
    float_value = float_value / 64.0f;
   
    LOG.Debug("DecodeFloat::float_value2=" + boost::lexical_cast<std::string>(float_value));
   
    return boost::lexical_cast<std::string>(float_value);
}
 
void Protocol::EncodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
{
    int int_value = boost::lexical_cast<float>(value) * 64.0f;
   
    this->EncodeInt(bitset, start_bit, bit_length, boost::lexical_cast<std::string>(int_value));
}
 
std::string Protocol::DecodeAscii(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
    std::string value;
   
    for (unsigned int n = 0; n < bit_length; n += 8)
    {
        unsigned long raw_value = bitset.Read(start_bit + n, 8);
        value += (char)raw_value;
    }
   
    return value;
}
 
void Protocol::EncodeAscii(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
{
    //LOG.Debug("EncodeAscii: " + value + ", length=" + boost::lexical_cast<std::string>(value.length()) + ", bit_length=" + boost::lexical_cast<std::string>(bit_length));
   
    for (unsigned int n = 0; n < bit_length; n += 8)
    {
        if (n / 8 >= value.length())
        {
            break;
        }
       
        //LOG.Debug(boost::lexical_cast<std::string>((unsigned int)value[n / 8]));
       
        bitset.Write(start_bit + n, 8, value[n / 8]);
    }
}
 
std::string Protocol::DecodeHexstring(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
    std::string value;
    char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
   
    for (unsigned int n = 0; n < bit_length; n += 4)
    {
        unsigned long raw_bit_value = bitset.Read(start_bit + n, 4);
       
        if (raw_bit_value >= sizeof(hex))
        {
            value += '-';
        }
        else
        {
            value += hex[raw_bit_value];
        }
    }
   
    return value;
}
 
void Protocol::EncodeHexstring(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
{
    int ascii_value;
   
    for (unsigned int n = 0; n < bit_length; n += 4)
    {
        ascii_value = boost::lexical_cast<int>((int)std::toupper(value[n / 4]));
       
        if (48 <= ascii_value && ascii_value <= 57)
        {
            bitset.Write(start_bit + n, 4, ascii_value - 48);
        }
        else if (65 <= ascii_value && ascii_value <= 70)
        {
            bitset.Write(start_bit + n, 4, ascii_value - 65);
        }
        else
        {
            throw std::runtime_error("This is not an hex string, " + value);
        }
    }
}
 
}; // namespace can
}; // namespace atom
 

Rev 1646	Rev 1689
1	/*	1	/*
2	*	2	*
3	* Copyright (C) 2010 Mattias Runge	3	* Copyright (C) 2010 Mattias Runge
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or	7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License along	15	* You should have received a copy of the GNU General Public License along
16	* with this program; if not, write to the Free Software Foundation, Inc.,	16	* with this program; if not, write to the Free Software Foundation, Inc.,
17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	*	18	*
19	*/	19	*/
20		20
21	#include "Protocol.h"	21	#include "Protocol.h"
22		22
23	#include <stdexcept>	23	#include <stdexcept>
24	#include <string.h>	24	#include <string.h>
25		25
26	#include <boost/lexical_cast.hpp>	26	#include <boost/lexical_cast.hpp>
27		27
28	namespace atom {	28	namespace atom {
29	namespace can {	29	namespace can {
30		30
31	Protocol::Pointer Protocol::instance_;	31	Protocol::Pointer Protocol::instance_;
32		32
33	Protocol::Protocol() : LOG("can::Protocol")	33	Protocol::Protocol() : LOG("can::Protocol")
34	{	34	{
35	}	35	}
36		36
37	Protocol::~Protocol()	37	Protocol::~Protocol()
38	{	38	{
39	}	39	}
40		40
41	void Protocol::Create()	41	void Protocol::Create()
42	{	42	{
43	Protocol::instance_ = Protocol::Pointer(new Protocol());	43	Protocol::instance_ = Protocol::Pointer(new Protocol());
44	}	44	}
45		45
46	Protocol::Pointer Protocol::Instance()	46	Protocol::Pointer Protocol::Instance()
47	{	47	{
48	return Protocol::instance_;	48	return Protocol::instance_;
49	}	49	}
50		50
51	void Protocol::Delete()	51	void Protocol::Delete()
52	{	52	{
53	Protocol::instance_.reset();	53	Protocol::instance_.reset();
54	}	54	}
55		55
56	bool Protocol::Load(std::string filename)	56	bool Protocol::Load(std::string filename)
57	{	57	{
58	try	58	try
59	{	59	{
60	this->root_node_.LoadFile(filename);	60	this->root_node_.LoadFile(filename);
61	}	61	}
62	catch (std::runtime_error& e)	62	catch (std::runtime_error& e)
63	{	63	{
64	LOG.Error(e.what());	64	LOG.Error(e.what());
65	return false;	65	return false;
66	}	66	}
67		67
68	LOG.Info("Protocol loaded successfully.");	68	LOG.Info("Protocol loaded successfully.");
69	return true;	69	return true;
70	}	70	}
71		71
72	std::string Protocol::LookupClassName(unsigned int class_id)	72	std::string Protocol::LookupClassName(unsigned int class_id)
73	{	73	{
74	try	74	try
75	{	75	{
76	return this->root_node_.FindChild("classes").SelectChild("id", boost::lexical_cast<std::string>(class_id)).GetAttributeValue("name");	76	return this->root_node_.FindChild("classes").SelectChild("id", boost::lexical_cast<std::string>(class_id)).GetAttributeValue("name");
77	}	77	}
78	catch (std::runtime_error& e)	78	catch (std::runtime_error& e)
79	{	79	{
80	LOG.Error(e.what());	80	LOG.Error(e.what());
81	throw std::runtime_error("No such class_id found, " + boost::lexical_cast<std::string>(class_id));	81	throw std::runtime_error("No such class_id found, " + boost::lexical_cast<std::string>(class_id));
82	}	82	}
83	}	83	}
84		84
85	unsigned int Protocol::ResolveClassId(std::string class_name)	85	unsigned int Protocol::ResolveClassId(std::string class_name)
86	{	86	{
87	try	87	try
88	{	88	{
89	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("classes").SelectChild("name", class_name).GetAttributeValue("id"));	89	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("classes").SelectChild("name", class_name).GetAttributeValue("id"));
90	}	90	}
91	catch (std::runtime_error& e)	91	catch (std::runtime_error& e)
92	{	92	{
93	LOG.Error(e.what());	93	LOG.Error(e.what());
94	throw std::runtime_error("No such class_name found, " + class_name);	94	throw std::runtime_error("No such class_name found, " + class_name);
95	}	95	}
96	}	96	}
97		97
98	std::string Protocol::LookupCommandName(unsigned int command_id, std::string module_name)	98	std::string Protocol::LookupCommandName(unsigned int command_id, std::string module_name)
99	{	99	{
100	try	100	try
101	{	101	{
102	if (command_id >= 128)	102	if (command_id >= 128)
103	{	103	{
104	return this->root_node_.FindChild("commands").SelectChild("id", boost::lexical_cast<std::string>(command_id), "module", module_name).GetAttributeValue("name");	104	return this->root_node_.FindChild("commands").SelectChild("id", boost::lexical_cast<std::string>(command_id), "module", module_name).GetAttributeValue("name");
105	}	105	}
106		106
107	return this->root_node_.FindChild("commands").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");	107	return this->root_node_.FindChild("commands").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");
108	}	108	}
109	catch (std::runtime_error& e)	109	catch (std::runtime_error& e)
110	{	110	{
111	LOG.Error(e.what());	111	LOG.Error(e.what());
112	throw std::runtime_error("No such command found, id = " + boost::lexical_cast<std::string>(command_id) + ", module = " + module_name);	112	throw std::runtime_error("No such command found, id = " + boost::lexical_cast<std::string>(command_id) + ", module = " + module_name);
113	}	113	}
114	}	114	}
115		115
116	unsigned int Protocol::ResolveCommandId(std::string command_name, std::string module_name)	116	unsigned int Protocol::ResolveCommandId(std::string command_name, std::string module_name)
117	{	117	{
118	try	118	try
119	{	119	{
120	return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name).GetAttributeValue("id"));	120	return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name).GetAttributeValue("id"));
121	}	121	}
122	catch (std::runtime_error& e)	122	catch (std::runtime_error& e)
123	{	123	{
124	}	124	}
125		125
126	try	126	try
127	{	127	{
128	return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("commands").SelectChild("name", command_name).GetAttributeValue("id"));	128	return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("commands").SelectChild("name", command_name).GetAttributeValue("id"));
129	}	129	}
130	catch (std::runtime_error& e)	130	catch (std::runtime_error& e)
131	{	131	{
132	LOG.Error(e.what());	132	LOG.Error(e.what());
133	throw std::runtime_error("No such command found, name = " + command_name + ", module = " + module_name);	133	throw std::runtime_error("No such command found, name = " + command_name + ", module = " + module_name);
134	}	134	}
135	}	135	}
136		136
137	std::string Protocol::LookupNMTCommandName(unsigned int command_id)	137	std::string Protocol::LookupNMTCommandName(unsigned int command_id)
138	{	138	{
139	try	139	try
140	{	140	{
141	return this->root_node_.FindChild("nmt_messages").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");	141	return this->root_node_.FindChild("nmt_messages").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");
142	}	142	}
143	catch (std::runtime_error& e)	143	catch (std::runtime_error& e)
144	{	144	{
145	LOG.Error(e.what());	145	LOG.Error(e.what());
146	throw std::runtime_error("No such nmt command found, id = " + boost::lexical_cast<std::string>(command_id));	146	throw std::runtime_error("No such nmt command found, id = " + boost::lexical_cast<std::string>(command_id));
147	}	147	}
148	}	148	}
149		149
150	unsigned int Protocol::ResolveNMTCommandId(std::string command_name)	150	unsigned int Protocol::ResolveNMTCommandId(std::string command_name)
151	{	151	{
152	try	152	try
153	{	153	{
154	return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).GetAttributeValue("id"));	154	return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).GetAttributeValue("id"));
155	}	155	}
156	catch (std::runtime_error& e)	156	catch (std::runtime_error& e)
157	{	157	{
158	LOG.Error(e.what());	158	LOG.Error(e.what());
159	throw std::runtime_error("No such nmt command found, name = " + command_name);	159	throw std::runtime_error("No such nmt command found, name = " + command_name);
160	}	160	}
161	}	161	}
162		162
163	std::string Protocol::GetDefineId(std::string name, std::string group)	163	std::string Protocol::GetDefineId(std::string name, std::string group)
164	{	164	{
165	try	165	try
166	{	166	{
167	return this->root_node_.FindChild("defines").SelectChild("name", name, "group", group).GetAttributeValue("id");	167	return this->root_node_.FindChild("defines").SelectChild("name", name, "group", group).GetAttributeValue("id");
168	}	168	}
169	catch (std::runtime_error& e)	169	catch (std::runtime_error& e)
170	{	170	{
171	LOG.Error(e.what());	171	LOG.Error(e.what());
172	throw std::runtime_error("No such define found, name = " + name + ", group = " + group);	172	throw std::runtime_error("No such define found, name = " + name + ", group = " + group);
173	}	173	}
174	}	174	}
175		175
176	std::string Protocol::LookupDirectionFlag(unsigned int direction_flag)	176	std::string Protocol::LookupDirectionFlag(unsigned int direction_flag)
177	{	177	{
178	try	178	try
179	{	179	{
180	return this->root_node_.FindChild("defines").SelectChild("id", boost::lexical_cast<std::string>(direction_flag), "group", "DirectionFlag").GetAttributeValue("name");	180	return this->root_node_.FindChild("defines").SelectChild("id", boost::lexical_cast<std::string>(direction_flag), "group", "DirectionFlag").GetAttributeValue("name");
181	}	181	}
182	catch (std::runtime_error& e)	182	catch (std::runtime_error& e)
183	{	183	{
184	LOG.Error(e.what());	184	LOG.Error(e.what());
185	throw std::runtime_error("No such direction flag found, direction_flag = " + boost::lexical_cast<std::string>(direction_flag));	185	throw std::runtime_error("No such direction flag found, direction_flag = " + boost::lexical_cast<std::string>(direction_flag));
186	}	186	}
187	}	187	}
188		188
189	unsigned int Protocol::ResolveDirectionFlag(std::string direction_name)	189	unsigned int Protocol::ResolveDirectionFlag(std::string direction_name)
190	{	190	{
191	try	191	try
192	{	192	{
193	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("defines").SelectChild("name", direction_name, "group", "DirectionFlag").GetAttributeValue("id"));	193	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("defines").SelectChild("name", direction_name, "group", "DirectionFlag").GetAttributeValue("id"));
194	}	194	}
195	catch (std::runtime_error& e)	195	catch (std::runtime_error& e)
196	{	196	{
197	LOG.Error(e.what());	197	LOG.Error(e.what());
198	throw std::runtime_error("No such direction flag found, direction_name = " + direction_name);	198	throw std::runtime_error("No such direction flag found, direction_name = " + direction_name);
199	}	199	}
200	}	200	}
201		201
202	std::string Protocol::LookupModuleName(unsigned int module_id)	202	std::string Protocol::LookupModuleName(unsigned int module_id)
203	{	203	{
204	try	204	try
205	{	205	{
206	return this->root_node_.FindChild("modules").SelectChild("id", boost::lexical_cast<std::string>(module_id)).GetAttributeValue("name");	206	return this->root_node_.FindChild("modules").SelectChild("id", boost::lexical_cast<std::string>(module_id)).GetAttributeValue("name");
207	}	207	}
208	catch (std::runtime_error& e)	208	catch (std::runtime_error& e)
209	{	209	{
210	LOG.Error(e.what());	210	LOG.Error(e.what());
211	throw std::runtime_error("No such module id found, " + boost::lexical_cast<std::string>(module_id));	211	throw std::runtime_error("No such module id found, " + boost::lexical_cast<std::string>(module_id));
212	}	212	}
213	}	213	}
214		214
215	unsigned int Protocol::ResolveModuleId(std::string module_name)	215	unsigned int Protocol::ResolveModuleId(std::string module_name)
216	{	216	{
217	if (module_name == "")	217	if (module_name == "")
218	{	218	{
219	return 0;	219	return 0;
220	}	220	}
221		221
222	try	222	try
223	{	223	{
224	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("modules").SelectChild("name", module_name).GetAttributeValue("id"));	224	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("modules").SelectChild("name", module_name).GetAttributeValue("id"));
225	}	225	}
226	catch (std::runtime_error& e)	226	catch (std::runtime_error& e)
227	{	227	{
228	LOG.Error(e.what());	228	LOG.Error(e.what());
229	throw std::runtime_error("No such module name found, " + module_name);	229	throw std::runtime_error("No such module name found, " + module_name);
230	}	230	}
231	}	231	}
232		232
233	xml::Node::NodeList Protocol::GetCommandVariables(std::string command_name, std::string module_name)	233	xml::Node::NodeList Protocol::GetCommandVariables(std::string command_name, std::string module_name)
234	{	234	{
235	xml::Node node;	235	xml::Node node;
236		236
237	try	237	try
238	{	238	{
239	node = this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name);	239	node = this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name);
240		240
241	try	241	try
242	{	242	{
243	return node.FindChild("variables").GetChildren();	243	return node.FindChild("variables").GetChildren();
244	}	244	}
245	catch (std::runtime_error& e)	245	catch (std::runtime_error& e)
246	{	246	{
247	return xml::Node::NodeList();	247	return xml::Node::NodeList();
248	}	248	}
249	}	249	}
250	catch (std::runtime_error& e)	250	catch (std::runtime_error& e)
251	{	251	{
252	}	252	}
253		253
254		254
255	try	255	try
256	{	256	{
257	node = this->root_node_.FindChild("commands").SelectChild("name", command_name);	257	node = this->root_node_.FindChild("commands").SelectChild("name", command_name);
258		258
259	try	259	try
260	{	260	{
261	return node.FindChild("variables").GetChildren();	261	return node.FindChild("variables").GetChildren();
262	}	262	}
263	catch (std::runtime_error& e)	263	catch (std::runtime_error& e)
264	{	264	{
265	return xml::Node::NodeList();	265	return xml::Node::NodeList();
266	}	266	}
267	}	267	}
268	catch (std::runtime_error& e)	268	catch (std::runtime_error& e)
269	{	269	{
270	LOG.Error(e.what());	270	LOG.Error(e.what());
271	throw std::runtime_error("Could not find variables for command, name = " + command_name + ", module = " + module_name);	271	throw std::runtime_error("Could not find variables for command, name = " + command_name + ", module = " + module_name);
272	}	272	}
273		273
274	return xml::Node::NodeList();	274	return xml::Node::NodeList();
275	}	275	}
276		276
277	xml::Node::NodeList Protocol::GetNMTCommandVariables(std::string command_name)	277	xml::Node::NodeList Protocol::GetNMTCommandVariables(std::string command_name)
278	{	278	{
279	xml::Node node;	279	xml::Node node;
280		280
281	try	281	try
282	{	282	{
283	node = this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name);	283	node = this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name);
284		284
285	try	285	try
286	{	286	{
287	return node.FindChild("variables").GetChildren();	287	return node.FindChild("variables").GetChildren();
288	}	288	}
289	catch (std::runtime_error& e)	289	catch (std::runtime_error& e)
290	{	290	{
291	return xml::Node::NodeList();	291	return xml::Node::NodeList();
292	}	292	}
293	}	293	}
294	catch (std::runtime_error& e)	294	catch (std::runtime_error& e)
295	{	295	{
296	LOG.Error(e.what());	296	LOG.Error(e.what());
297	throw std::runtime_error("Could not find variables for nmt command, name = " + command_name);	297	throw std::runtime_error("Could not find variables for nmt command, name = " + command_name);
298	}	298	}
299		299
300	return xml::Node::NodeList();	300	return xml::Node::NodeList();
301	}	301	}
302		302
303	std::string Protocol::DecodeInt(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	303	std::string Protocol::DecodeInt(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
304	{	304	{
-		305	bool sign = bitset.Get(start_bit) == 1;
-		306
305	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);	307	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
306	int raw_value = 0;	-
307		-
308	memcpy(&raw_value, &raw_bit_value, sizeof(raw_value));	-
309		308
-		309	int raw_value = raw_bit_value;
-		310
-		311	if (sign)
-		312	{
-		313	long mask = 0;
-		314
-		315	for (unsigned int n = 0; n < bit_length; n++)
-		316	{
-		317	mask += (1 << n);
-		318	}
-		319
-		320	raw_value = -((~raw_bit_value) & mask);
-		321	}
-		322
310	return boost::lexical_cast<std::string>(raw_value);	323	return boost::lexical_cast<std::string>(raw_value);
311	}	324	}
312		325
313	void Protocol::EncodeInt(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	326	void Protocol::EncodeInt(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
314	{	327	{
315	unsigned long raw_bit_value = 0;	328	unsigned long raw_bit_value = 0;
316	int raw_value = boost::lexical_cast<int>(value);	329	int raw_value = boost::lexical_cast<int>(value);
317		330
318	~~memcpy(&raw_bit_value,~~ ~~&raw_value,~~ ~~sizeof(raw_value))~~;	331	raw_bit_value = raw_bit_value;
319		332
-		333	if (raw_value < 0)
-		334	{
-		335	long mask = 0;
-		336
-		337	for (unsigned int n = 0; n < bit_length; n++)
-		338	{
-		339	mask += (1 << n);
-		340	}
-		341
-		342	raw_bit_value = (~(-raw_value)) & mask;
-		343	}
-		344
320	bitset.Write(start_bit, bit_length, raw_bit_value);	345	bitset.Write(start_bit, bit_length, raw_bit_value);
321	}	346	}
322		347
323	std::string Protocol::DecodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	348	std::string Protocol::DecodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
324	{	349	{
325	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);	350	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
326		351
327	//LOG.Debug("DecodeUint: raw_bit_value=" + boost::lexical_cast<std::string>(raw_bit_value));	352	//LOG.Debug("DecodeUint: raw_bit_value=" + boost::lexical_cast<std::string>(raw_bit_value));
328		353
329	return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);	354	return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);
330	}	355	}
331		356
332	void Protocol::EncodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	357	void Protocol::EncodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
333	{	358	{
334	unsigned long raw_bit_value = boost::lexical_cast<unsigned int>(value);	359	unsigned long raw_bit_value = boost::lexical_cast<unsigned int>(value);
335		360
336	bitset.Write(start_bit, bit_length, raw_bit_value);	361	bitset.Write(start_bit, bit_length, raw_bit_value);
337	}	362	}
338		363
339	std::string Protocol::DecodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	364	std::string Protocol::DecodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
340	{	365	{
341	float float_value = boost::lexical_cast<float>(this->DecodeInt(bitset, start_bit, bit_length)) / 64.0f;	366	float float_value = boost::lexical_cast<float>(this->DecodeInt(bitset, start_bit, bit_length));
-		367	LOG.Debug("DecodeFloat::float_value1=" + boost::lexical_cast<std::string>(float_value));
-		368
-		369
-		370	float_value = float_value / 64.0f;
-		371
-		372	LOG.Debug("DecodeFloat::float_value2=" + boost::lexical_cast<std::string>(float_value));
342		373
343	return boost::lexical_cast<std::string>(float_value);	374	return boost::lexical_cast<std::string>(float_value);
344	}	375	}
345		376
346	void Protocol::EncodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	377	void Protocol::EncodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
347	{	378	{
348	int int_value = boost::lexical_cast<float>(value) * 64.0f;	379	int int_value = boost::lexical_cast<float>(value) * 64.0f;
349		380
350	this->EncodeInt(bitset, start_bit, bit_length, boost::lexical_cast<std::string>(int_value));	381	this->EncodeInt(bitset, start_bit, bit_length, boost::lexical_cast<std::string>(int_value));
351	}	382	}
352		383
353	std::string Protocol::DecodeAscii(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	384	std::string Protocol::DecodeAscii(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
354	{	385	{
355	std::string value;	386	std::string value;
356		387
357	for (unsigned int n = 0; n < bit_length; n += 8)	388	for (unsigned int n = 0; n < bit_length; n += 8)
358	{	389	{
359	unsigned long raw_value = bitset.Read(start_bit + n, 8);	390	unsigned long raw_value = bitset.Read(start_bit + n, 8);
360	value += (char)raw_value;	391	value += (char)raw_value;
361	}	392	}
362		393
363	return value;	394	return value;
364	}	395	}
365		396
366	void Protocol::EncodeAscii(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	397	void Protocol::EncodeAscii(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
367	{	398	{
368	//LOG.Debug("EncodeAscii: " + value + ", length=" + boost::lexical_cast<std::string>(value.length()) + ", bit_length=" + boost::lexical_cast<std::string>(bit_length));	399	//LOG.Debug("EncodeAscii: " + value + ", length=" + boost::lexical_cast<std::string>(value.length()) + ", bit_length=" + boost::lexical_cast<std::string>(bit_length));
369		400
370	for (unsigned int n = 0; n < bit_length; n += 8)	401	for (unsigned int n = 0; n < bit_length; n += 8)
371	{	402	{
372	if (n / 8 >= value.length())	403	if (n / 8 >= value.length())
373	{	404	{
374	break;	405	break;
375	}	406	}
376		407
377	//LOG.Debug(boost::lexical_cast<std::string>((unsigned int)value[n / 8]));	408	//LOG.Debug(boost::lexical_cast<std::string>((unsigned int)value[n / 8]));
378		409
379	bitset.Write(start_bit + n, 8, value[n / 8]);	410	bitset.Write(start_bit + n, 8, value[n / 8]);
380	}	411	}
381	}	412	}
382		413
383	std::string Protocol::DecodeHexstring(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	414	std::string Protocol::DecodeHexstring(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
384	{	415	{
385	std::string value;	416	std::string value;
386	char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };	417	char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
387		418
388	for (unsigned int n = 0; n < bit_length; n += 4)	419	for (unsigned int n = 0; n < bit_length; n += 4)
389	{	420	{
390	unsigned long raw_bit_value = bitset.Read(start_bit + n, 4);	421	unsigned long raw_bit_value = bitset.Read(start_bit + n, 4);
391		422
392	if (raw_bit_value >= sizeof(hex))	423	if (raw_bit_value >= sizeof(hex))
393	{	424	{
394	value += '-';	425	value += '-';
395	}	426	}
396	else	427	else
397	{	428	{
398	value += hex[raw_bit_value];	429	value += hex[raw_bit_value];
399	}	430	}
400	}	431	}
401		432
402	return value;	433	return value;
403	}	434	}
404		435
405	void Protocol::EncodeHexstring(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	436	void Protocol::EncodeHexstring(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
406	{	437	{
407	int ascii_value;	438	int ascii_value;
408		439
409	for (unsigned int n = 0; n < bit_length; n += 4)	440	for (unsigned int n = 0; n < bit_length; n += 4)
410	{	441	{
411	ascii_value = boost::lexical_cast<int>((int)std::toupper(value[n / 4]));	442	ascii_value = boost::lexical_cast<int>((int)std::toupper(value[n / 4]));
412		443
413	if (48 <= ascii_value && ascii_value <= 57)	444	if (48 <= ascii_value && ascii_value <= 57)
414	{	445	{
415	bitset.Write(start_bit + n, 4, ascii_value - 48);	446	bitset.Write(start_bit + n, 4, ascii_value - 48);
416	}	447	}
417	else if (65 <= ascii_value && ascii_value <= 70)	448	else if (65 <= ascii_value && ascii_value <= 70)
418	{	449	{
419	bitset.Write(start_bit + n, 4, ascii_value - 65);	450	bitset.Write(start_bit + n, 4, ascii_value - 65);
420	}	451	}
421	else	452	else
422	{	453	{
423	throw std::runtime_error("This is not an hex string, " + value);	454	throw std::runtime_error("This is not an hex string, " + value);
424	}	455	}
425	}	456	}
426	}	457	}
427		458
428	}; // namespace can	459	}; // namespace can
429	}; // namespace atom	460	}; // namespace atom
430		461

Subversion Repositories HomeAutomation

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