OpenZWave Library 1.6.1914
Loading...
Searching...
No Matches
CommandClass.h
Go to the documentation of this file.
1//-----------------------------------------------------------------------------
2//
3// CommandClass.h
4//
5// Base class for all Z-Wave Command Classes
6//
7// Copyright (c) 2010 Mal Lansell <openzwave@lansell.org>
8//
9// SOFTWARE NOTICE AND LICENSE
10//
11// This file is part of OpenZWave.
12//
13// OpenZWave is free software: you can redistribute it and/or modify
14// it under the terms of the GNU Lesser General Public License as published
15// by the Free Software Foundation, either version 3 of the License,
16// or (at your option) any later version.
17//
18// OpenZWave is distributed in the hope that it will be useful,
19// but WITHOUT ANY WARRANTY; without even the implied warranty of
20// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21// GNU Lesser General Public License for more details.
22//
23// You should have received a copy of the GNU Lesser General Public License
24// along with OpenZWave. If not, see <http://www.gnu.org/licenses/>.
25//
26//-----------------------------------------------------------------------------
27
28#ifndef _CommandClass_H
29#define _CommandClass_H
30
31#include <string>
32#include <vector>
33#include <map>
34#include "Defs.h"
35#include "Bitfield.h"
36#include "Driver.h"
37#include "CompatOptionManager.h"
38
39namespace OpenZWave
40{
41
42 class Msg;
43 class Node;
44 class Value;
45
46 namespace Internal
47 {
48 namespace CC
49 {
61 {
63 public:
64 enum
65 {
66 RequestFlag_Static = 0x00000001,
67 RequestFlag_Session = 0x00000002,
68 RequestFlag_Dynamic = 0x00000004,
69 RequestFlag_AfterMark = 0x00000008
70 };
71
72 CommandClass(uint32 const _homeId, uint8 const _nodeId);
73 virtual ~CommandClass();
74
75 virtual void ReadXML(TiXmlElement const* _ccElement);
76 virtual void WriteXML(TiXmlElement* _ccElement);
77 virtual bool RequestState(uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue)
78 {
79 return false;
80 }
81 virtual bool RequestValue(uint32 const _requestFlags, uint16 const _index, uint8 const _instance, Driver::MsgQueue const _queue)
82 {
83 return false;
84 }
85 virtual void refreshValuesOnWakeup();
86
87 virtual uint8 const GetCommandClassId() const = 0;
88 virtual string const GetCommandClassName() const = 0;
89 string const GetCommandClassLabel();
90 void SetCommandClassLabel(string label);
91 virtual bool HandleMsg(uint8 const* _data, uint32 const _length, uint32 const _instance = 1) = 0;
92 virtual bool HandleIncomingMsg(uint8 const* _data, uint32 const _length, uint32 const _instance = 1);
93 virtual bool SetValue(Internal::VC::Value const& _value)
94 {
95 return false;
96 }
97 virtual void SetValueBasic(uint8 const _instance, uint8 const _level)
98 {
99 } // Class specific handling of BASIC value mapping
100 virtual void SetVersion(uint8 const _version); // Made out-of-line to allow checks against downgrade
101
102 bool RequestStateForAllInstances(uint32 const _requestFlags, Driver::MsgQueue const _queue);
103 bool CheckForRefreshValues(Internal::VC::Value const* _value);
104
105 // The highest version number of the command class implemented by OpenZWave. We only need
106 // to do version gets on command classes that override this with a number greater than one.
108 {
109 return 1;
110 }
111
113 {
114 return m_dom.GetFlagByte(STATE_FLAG_CCVERSION);
115 }
116 Bitfield const* GetInstances() const
117 {
118 return &m_instances;
119 }
121 {
122 return m_homeId;
123 }
125 {
126 return m_nodeId;
127 }
128 Driver* GetDriver() const;
129 Node* GetNodeUnsafe() const;
130 Internal::VC::Value* GetValue(uint8 const _instance, uint16 const _index);
131 bool RemoveValue(uint8 const _instance, uint16 const _index);
132 uint8 GetEndPoint(uint8 const _instance)
133 {
134 map<uint8, uint8>::iterator it = m_endPointMap.find(_instance);
135 return (it == m_endPointMap.end() ? 0 : it->second);
136 }
137 uint8 GetInstance(uint8 const _endPoint)
138 {
139 for (map<uint8, uint8>::iterator it = m_endPointMap.begin(); it != m_endPointMap.end(); ++it)
140 {
141 if (_endPoint == it->second)
142 {
143 return it->first;
144 }
145 }
146 return 0;
147 }
148
149 virtual bool supportsMultiInstance() {
150 return true;
151 }
152
153 void SetInstances(uint8 const _instances);
154 void SetInstance(uint8 const _endPoint);
155 /* overridden in the MultiInstance CC to set the Global Label for each Instance */
156 virtual void SetInstanceLabel(uint8 const _instance, char *label);
157 string GetInstanceLabel(uint8 const _instance);
159 {
160 return (uint8) m_endPointMap.size();
161 }
162 ;
164 {
165 m_dom.SetFlagBool(STATE_FLAG_AFTERMARK, true);
166 }
167 void SetEndPoint(uint8 const _instance, uint8 const _endpoint)
168 {
169 m_endPointMap[_instance] = _endpoint;
170 }
171 bool IsAfterMark() const
172 {
173 return m_dom.GetFlagBool(STATE_FLAG_AFTERMARK);
174 }
175 bool IsSecured() const
176 {
177 return m_dom.GetFlagBool(STATE_FLAG_ENCRYPTED);
178 }
180 {
181 m_dom.SetFlagBool(STATE_FLAG_ENCRYPTED, true);
182 }
183 bool IsSecureSupported() const
184 {
185 return m_SecureSupport;
186 }
188 {
189 m_SecureSupport = false;
190 }
192 {
193 m_SecureSupport = true;
194 }
195 void SetInNIF()
196 {
197 m_dom.SetFlagBool(STATE_FLAG_INNIF, true);
198 }
199 bool IsInNIF()
200 {
201 return m_dom.GetFlagBool(STATE_FLAG_INNIF);
202 }
203
204 // Helper methods
205 string ExtractValue(uint8 const* _data, uint8* _scale, uint8* _precision, uint8 _valueOffset = 1) const;
206 uint32 decodeDuration(uint8 data) const;
207 uint8 encodeDuration(uint32 seconds) const;
215 void AppendValue(Msg* _msg, string const& _value, uint8 const _scale) const;
216 uint8 const GetAppendValueSize(string const& _value) const;
217 int32 ValueToInteger(string const& _value, uint8* o_precision, uint8* o_size) const;
218
219 void UpdateMappedClass(uint8 const _instance, uint8 const _classId, uint8 const _value); // Update mapped class's value from BASIC class
220
221 typedef struct RefreshValue
222 {
226 } RefreshValue;
227
228 protected:
229 virtual void CreateVars(uint8 const _instance);
230 void ReadValueRefreshXML(TiXmlElement const* _ccElement);
233
234 public:
235 void CreateVars();
236
237 private:
238 uint32 m_homeId;
239 uint8 m_nodeId;
240 Bitfield m_instances;
241 map<uint8, uint8> m_endPointMap;
242 map<uint8, string> m_instanceLabel;
243 bool m_SecureSupport; // Does this commandclass support secure encryption (eg, the Security CC doesn't encrypt itself, so it doesn't support encryption)
244 multimap<uint16, RefreshValue *> m_RefreshClassValues; // what Command Class Values should we refresh ?
245 string m_commandClassLabel;
246 //-----------------------------------------------------------------------------
247 // Record which items of static data have been read from the device
248 //-----------------------------------------------------------------------------
249 public:
251 {
252 StaticRequest_Instances = 0x01,
253 StaticRequest_Values = 0x02,
254 StaticRequest_Version = 0x04
255 };
256
257 bool HasStaticRequest(uint8_t _request) const
258 {
259 return ((m_dom.GetFlagByte(STATE_FLAG_STATIC_REQUESTS) & _request) != 0);
260 }
261 void SetStaticRequest(uint8_t _request);
262 void ClearStaticRequest(uint8_t _request);
263
264 //-----------------------------------------------------------------------------
265 // Statistics
266 //-----------------------------------------------------------------------------
267 public:
269 {
270 return m_sentCnt;
271 }
273 {
274 return m_receivedCnt;
275 }
277 {
278 m_sentCnt++;
279 }
281 {
282 m_receivedCnt++;
283 }
284
285 private:
286 uint32 m_sentCnt; // Number of messages sent from this command class.
287 uint32 m_receivedCnt; // Number of messages received from this commandclass.
288
289 };
291 }// namespace CC
292 } // namespace Internal
293} // namespace OpenZWave
294
295#endif
unsigned short uint16
Definition Defs.h:88
unsigned int uint32
Definition Defs.h:91
signed int int32
Definition Defs.h:90
#define OPENZWAVE_EXPORT
Definition Defs.h:52
unsigned char uint8
Definition Defs.h:85
The Driver class handles communication between OpenZWave and a device attached via a serial port (typ...
Definition Driver.h:85
MsgQueue
Definition Driver.h:660
Definition Bitfield.h:40
Base class for all Z-Wave command classes.
Definition CommandClass.h:61
uint32 GetHomeId() const
Definition CommandClass.h:120
uint8 GetEndPoint(uint8 const _instance)
Definition CommandClass.h:132
virtual uint8 GetMaxVersion()
Definition CommandClass.h:107
uint8 GetInstance(uint8 const _endPoint)
Definition CommandClass.h:137
void SetEndPoint(uint8 const _instance, uint8 const _endpoint)
Definition CommandClass.h:167
CompatOptionManager m_dom
Definition CommandClass.h:232
virtual bool HandleMsg(uint8 const *_data, uint32 const _length, uint32 const _instance=1)=0
virtual bool supportsMultiInstance()
Definition CommandClass.h:149
void ReceivedCntIncr()
Definition CommandClass.h:280
virtual uint8 const GetCommandClassId() const =0
virtual bool RequestValue(uint32 const _requestFlags, uint16 const _index, uint8 const _instance, Driver::MsgQueue const _queue)
Definition CommandClass.h:81
void ClearSecureSupport()
Definition CommandClass.h:187
void SetInNIF()
Definition CommandClass.h:195
uint8 GetVersion() const
Definition CommandClass.h:112
bool IsSecureSupported() const
Definition CommandClass.h:183
virtual bool RequestState(uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue)
Definition CommandClass.h:77
virtual void SetValueBasic(uint8 const _instance, uint8 const _level)
Definition CommandClass.h:97
Bitfield const * GetInstances() const
Definition CommandClass.h:116
virtual bool SetValue(Internal::VC::Value const &_value)
Definition CommandClass.h:93
void SetSecured()
Definition CommandClass.h:179
bool IsSecured() const
Definition CommandClass.h:175
uint32 GetReceivedCnt() const
Definition CommandClass.h:272
bool IsInNIF()
Definition CommandClass.h:199
uint8 GetNumInstances()
Definition CommandClass.h:158
StaticRequest
Definition CommandClass.h:251
void SentCntIncr()
Definition CommandClass.h:276
uint32 GetSentCnt() const
Definition CommandClass.h:268
void SetAfterMark()
Definition CommandClass.h:163
uint8 GetNodeId() const
Definition CommandClass.h:124
CompatOptionManager m_com
Definition CommandClass.h:231
void SetSecureSupport()
Definition CommandClass.h:191
bool HasStaticRequest(uint8_t _request) const
Definition CommandClass.h:257
virtual string const GetCommandClassName() const =0
bool IsAfterMark() const
Definition CommandClass.h:171
Definition CompatOptionManager.h:142
uint8_t GetFlagByte(CompatOptionFlags flag, uint32_t index=-1) const
Definition CompatOptionManager.cpp:467
Message object to be passed to and from devices on the Z-Wave network.
Definition Msg.h:51
Container that holds all of the values associated with a given node.
Definition ValueStore.h:50
Base class for values associated with a node.
Definition Value.h:55
The Node class describes a Z-Wave node object...typically a device on the Z-Wave network.
Definition Node.h:82
@ STATE_FLAG_STATIC_REQUESTS
Definition CompatOptionManager.h:73
@ STATE_FLAG_INNIF
Definition CompatOptionManager.h:76
@ STATE_FLAG_CCVERSION
Definition CompatOptionManager.h:72
@ STATE_FLAG_ENCRYPTED
Definition CompatOptionManager.h:75
@ STATE_FLAG_AFTERMARK
Definition CompatOptionManager.h:74
Definition Bitfield.cpp:31
uint16 index
Definition CommandClass.h:225
uint8 cc
Definition CommandClass.h:223
uint8 requestflags
Definition CommandClass.h:224