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)
{
    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));
   
    bitset.Write(start_bit, bit_length, raw_bit_value);
}
 
std::string Protocol::DecodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
    unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
   
    return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);
}
 
void Protocol::EncodeUint(type::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(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
{
 
 
 
 
 
 
 
 
 
 
 
 
    float float_value = boost::lexical_cast<float>(this->DecodeInt(bitset, start_bit, bit_length)) / 64.0f;
 
 
 
 
 
 
 
 
 
   
    return boost::lexical_cast<std::string>(float_value);
}
 
void Protocol::EncodeFloat(type::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(type::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(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
{
    for (unsigned int n = 0; n < bit_length; n += 8)
    {
        bitset.Write(start_bit + n, 8, value[n / 8]);
    }
}
 
std::string Protocol::DecodeHexstring(type::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(type::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 1599	Rev 1600
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	if (module_id == 0)	204	if (module_id == 0)
205	{	205	{
206	return "";	206	return "";
207	}	207	}
208		208
209	try	209	try
210	{	210	{
211	return this->root_node_.FindChild("modules").SelectChild("id", boost::lexical_cast<std::string>(module_id)).GetAttributeValue("name");	211	return this->root_node_.FindChild("modules").SelectChild("id", boost::lexical_cast<std::string>(module_id)).GetAttributeValue("name");
212	}	212	}
213	catch (std::runtime_error& e)	213	catch (std::runtime_error& e)
214	{	214	{
215	LOG.Error(e.what());	215	LOG.Error(e.what());
216	throw std::runtime_error("No such module id found, " + boost::lexical_cast<std::string>(module_id));	216	throw std::runtime_error("No such module id found, " + boost::lexical_cast<std::string>(module_id));
217	}	217	}
218	}	218	}
219		219
220	unsigned int Protocol::ResolveModuleId(std::string module_name)	220	unsigned int Protocol::ResolveModuleId(std::string module_name)
221	{	221	{
222	if (module_name == "")	222	if (module_name == "")
223	{	223	{
224	return 0;	224	return 0;
225	}	225	}
226		226
227	try	227	try
228	{	228	{
229	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("modules").SelectChild("name", module_name).GetAttributeValue("id"));	229	return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("modules").SelectChild("name", module_name).GetAttributeValue("id"));
230	}	230	}
231	catch (std::runtime_error& e)	231	catch (std::runtime_error& e)
232	{	232	{
233	LOG.Error(e.what());	233	LOG.Error(e.what());
234	throw std::runtime_error("No such module name found, " + module_name);	234	throw std::runtime_error("No such module name found, " + module_name);
235	}	235	}
236	}	236	}
237		237
238	xml::Node::NodeList Protocol::GetCommandVariables(std::string command_name, std::string module_name)	238	xml::Node::NodeList Protocol::GetCommandVariables(std::string command_name, std::string module_name)
239	{	239	{
240	try	240	try
241	{	241	{
242	return this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name).FindChild("variables").GetChildren();	242	return this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name).FindChild("variables").GetChildren();
243	}	243	}
244	catch (std::runtime_error& e)	244	catch (std::runtime_error& e)
245	{	245	{
246	}	246	}
247		247
248	try	248	try
249	{	249	{
250	return this->root_node_.FindChild("commands").SelectChild("name", command_name).FindChild("variables").GetChildren();	250	return this->root_node_.FindChild("commands").SelectChild("name", command_name).FindChild("variables").GetChildren();
251	}	251	}
252	catch (std::runtime_error& e)	252	catch (std::runtime_error& e)
253	{	253	{
254	LOG.Error(e.what());	254	LOG.Error(e.what());
255	throw std::runtime_error("No such command found, name = " + command_name + ", module = " + module_name);	255	throw std::runtime_error("No such command found, name = " + command_name + ", module = " + module_name);
256	}	256	}
257	}	257	}
258		258
259	xml::Node::NodeList Protocol::GetNMTCommandVariables(std::string command_name)	259	xml::Node::NodeList Protocol::GetNMTCommandVariables(std::string command_name)
260	{	260	{
261	try	261	try
262	{	262	{
263	return this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).FindChild("variables").GetChildren();	263	return this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).FindChild("variables").GetChildren();
264	}	264	}
265	catch (std::runtime_error& e)	265	catch (std::runtime_error& e)
266	{	266	{
267	LOG.Error(e.what());	267	LOG.Error(e.what());
268	throw std::runtime_error("No such nmt command found, name = " + command_name);	268	throw std::runtime_error("No such nmt command found, name = " + command_name);
269	}	269	}
270	}	270	}
271		271
272	std::string Protocol::DecodeInt(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	272	std::string Protocol::DecodeInt(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
273	{	273	{
274	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);	274	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
275	int raw_value = 0;	275	int raw_value = 0;
276		276
277	memcpy(&raw_value, &raw_bit_value, sizeof(raw_value));	277	memcpy(&raw_value, &raw_bit_value, sizeof(raw_value));
278		278
279	return boost::lexical_cast<std::string>(raw_value);	279	return boost::lexical_cast<std::string>(raw_value);
280	}	280	}
281		281
282	void Protocol::EncodeInt(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	282	void Protocol::EncodeInt(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
283	{	283	{
284	unsigned long raw_bit_value = 0;	284	unsigned long raw_bit_value = 0;
285	int raw_value = boost::lexical_cast<int>(value);	285	int raw_value = boost::lexical_cast<int>(value);
286		286
287	memcpy(&raw_bit_value, &raw_value, sizeof(raw_value));	287	memcpy(&raw_bit_value, &raw_value, sizeof(raw_value));
288		288
289	bitset.Write(start_bit, bit_length, raw_bit_value);	289	bitset.Write(start_bit, bit_length, raw_bit_value);
290	}	290	}
291		291
292	std::string Protocol::DecodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	292	std::string Protocol::DecodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
293	{	293	{
294	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);	294	unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
295		295
296	return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);	296	return boost::lexical_cast<std::string>((unsigned int)raw_bit_value);
297	}	297	}
298		298
299	void Protocol::EncodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	299	void Protocol::EncodeUint(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
300	{	300	{
301	unsigned long raw_bit_value = boost::lexical_cast<unsigned int>(value);	301	unsigned long raw_bit_value = boost::lexical_cast<unsigned int>(value);
302		302
303	bitset.Write(start_bit, bit_length, raw_bit_value);	303	bitset.Write(start_bit, bit_length, raw_bit_value);
304	}	304	}
305		305
306	std::string Protocol::DecodeFloat(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	306	std::string Protocol::DecodeFloat(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
307	{	307	{
308	float raw_value = 0;	-
309	bool negative = false;;	-
310		-
311	if (bitset.Get(start_bit))	-
312	{	-
313	negative = true;	-
314	}	-
315		-
316	for (int c = bit_length - 1; c > 0; c--)	-
317	{	-
318	if (bitset.Get(start_bit + c) != negative)	-
319	{	-
320	~~raw_value +~~= ~~pow(2.0f, (int)~~(~~bit_length - 1~~ - c));	308	float float_value = boost::lexical_cast<float>(this->DecodeInt(bitset, start_bit, bit_length)) / 64.0f;
321	}	-
322	}	-
323		-
324	raw_value /= 64.0f;	-
325		-
326	if (negative)	-
327	{	-
328	raw_value = -raw_value;	-
329	}	-
330		309
331	return boost::lexical_cast<std::string>(~~raw_value~~);	310	return boost::lexical_cast<std::string>(float_value);
332	}	311	}
333		312
334	void Protocol::EncodeFloat(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	313	void Protocol::EncodeFloat(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
335	{	314	{
-		315	int int_value = boost::lexical_cast<float>(value) * 64.0f;
336	~~// TODO:~~	316
337	~~LOG.Error~~(~~"EncodeFloat() is not implemented yet!"~~);	317	this->EncodeInt(bitset, start_bit, bit_length, boost::lexical_cast<std::string>(int_value));
338	}	318	}
339		319
340	std::string Protocol::DecodeAscii(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)	320	std::string Protocol::DecodeAscii(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
341	{	321	{
342	std::string value;	322	std::string value;
343	char c = 0;	-
344		323
345	for (unsigned int p = 0; p < bit_length; p += 8)	324	for (unsigned int n = 0; n < bit_length; n += 8)
346	{	325	{
347	unsigned long ~~raw_bit_value~~ = bitset.Read(start_bit + p, 8);	326	unsigned long raw_value = bitset.Read(start_bit + n, 8);
348	memcpy(&c, &raw_bit_value, sizeof(c));	-
349	value += c;	327	value += (char)raw_value;
350	}	328	}
351		329
352	return value;	330	return value;
353	}	-
354		-
355	void Protocol::EncodeAscii(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	-
356	{	-
357	// TODO	-
358	LOG.Error("EncodeAscii() is not implemented yet!");	-
359	}	331	}
360		332
361	~~std::string~~ Protocol::~~DecodeHexstring~~(type~~::Bitset~~& bitset, unsigned int ~~start_bit,~~ ~~unsigned~~ ~~int~~ ~~bit_length~~)	333	void Protocol::EncodeAscii(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
362	{	334	{
363	~~std~~::string ~~value;~~	335	for (unsigned int n = 0; n < bit_length; n += 8)
-		336	{
364	~~char~~ ~~hex[] =~~ { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', ~~'F'~~ };	337	bitset.Write(start_bit + n, 8, value[n / 8]);
-		338	}
-		339	}
365		340
-		341	std::string Protocol::DecodeHexstring(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
-		342	{
-		343	std::string value;
-		344	char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-		345
366	for (unsigned int p = 0; p < bit_length; p += 4)	346	for (unsigned int n = 0; n < bit_length; n += 4)
367	{	347	{
368	unsigned long raw_bit_value = bitset.Read(start_bit + p, 4);	348	unsigned long raw_bit_value = bitset.Read(start_bit + n, 4);
369		349
370	if (raw_bit_value >= sizeof(hex))	350	if (raw_bit_value >= sizeof(hex))
371	{	351	{
372	value += '-';	352	value += '-';
373	}	353	}
374	else	354	else
375	{	355	{
376	value += hex[raw_bit_value];	356	value += hex[raw_bit_value];
377	}	357	}
378	}	358	}
379		359
380	return value;	360	return value;
381	}	361	}
382		362
383	void Protocol::EncodeHexstring(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)	363	void Protocol::EncodeHexstring(type::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
384	{	364	{
-		365	int ascii_value;
-		366
-		367	for (unsigned int n = 0; n < bit_length; n += 4)
-		368	{
-		369	ascii_value = boost::lexical_cast<int>((int)std::toupper(value[n / 4]));
-		370
-		371	if (48 <= ascii_value && ascii_value <= 57)
-		372	{
-		373	bitset.Write(start_bit + n, 4, ascii_value - 48);
-		374	}
-		375	else if (65 <= ascii_value && ascii_value <= 70)
-		376	{
-		377	bitset.Write(start_bit + n, 4, ascii_value - 65);
-		378	}
385	// ~~TODO:~~	379	else
-		380	{
386	~~LOG.Error~~(~~"EncodeHexstring() is not~~ ~~implemented~~ ~~yet!~~");	381	throw std::runtime_error("This is not an hex string, " + value);
-		382	}
-		383	}
387	}	384	}
388		385
389	}; // namespace can	386	}; // namespace can
390	}; // namespace atom	387	}; // namespace atom
391		388

Subversion Repositories HomeAutomation

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