OpenZWave Library 1.2
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
38namespace OpenZWave
39{
40 class Msg;
41 class Node;
42 class Value;
43
47 {
48
49 public:
50 enum
51 {
52 RequestFlag_Static = 0x00000001,
53 RequestFlag_Session = 0x00000002,
54 RequestFlag_Dynamic = 0x00000004,
55 };
56
57 CommandClass( uint32 const _homeId, uint8 const _nodeId );
58 virtual ~CommandClass();
59
60 virtual void ReadXML( TiXmlElement const* _ccElement );
61 virtual void WriteXML( TiXmlElement* _ccElement );
62 virtual bool RequestState( uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue ){ return false; }
63 virtual bool RequestValue( uint32 const _requestFlags, uint8 const _index, uint8 const _instance, Driver::MsgQueue const _queue ) { return false; }
64
65 virtual uint8 const GetCommandClassId()const = 0;
66 virtual string const GetCommandClassName()const = 0;
67 virtual bool HandleMsg( uint8 const* _data, uint32 const _length, uint32 const _instance = 1 ) = 0;
68 virtual bool SetValue( Value const& _value ){ return false; }
69 virtual void SetValueBasic( uint8 const _instance, uint8 const _level ){} // Class specific handling of BASIC value mapping
70 virtual void SetVersion( uint8 const _version ){ m_version = _version; }
71
72 bool RequestStateForAllInstances( uint32 const _requestFlags, Driver::MsgQueue const _queue );
73 bool CheckForRefreshValues(Value const* _value );
74
75 // The highest version number of the command class implemented by OpenZWave. We only need
76 // to do version gets on command classes that override this with a number greater than one.
77 virtual uint8 GetMaxVersion(){ return 1; }
78
79 uint8 GetVersion()const{ return m_version; }
80 Bitfield const* GetInstances()const{ return &m_instances; }
81 uint32 GetHomeId()const{ return m_homeId; }
82 uint8 GetNodeId()const{ return m_nodeId; }
83 Driver* GetDriver()const;
84 Node* GetNodeUnsafe()const;
85 Value* GetValue( uint8 const _instance, uint8 const _index );
86 bool RemoveValue( uint8 const _instance, uint8 const _index );
87 uint8 GetEndPoint( uint8 const _instance )
88 {
89 map<uint8,uint8>::iterator it = m_endPointMap.find( _instance );
90 return( it == m_endPointMap.end() ? 0 : it->second );
91 }
92 uint8 GetInstance( uint8 const _endPoint )
93 {
94 for( map<uint8,uint8>::iterator it = m_endPointMap.begin(); it != m_endPointMap.end(); ++it )
95 {
96 if( _endPoint == it->second )
97 {
98 return it->first;
99 }
100 }
101 return 0;
102 }
103
104 void SetInstances( uint8 const _instances );
105 void SetInstance( uint8 const _endPoint );
106 void SetAfterMark(){ m_afterMark = true; }
107 void SetEndPoint( uint8 const _instance, uint8 const _endpoint){ m_endPointMap[_instance] = _endpoint; }
108 bool IsAfterMark()const{ return m_afterMark; }
109 bool IsCreateVars()const{ return m_createVars; }
110 bool IsGetSupported()const{ return m_getSupported; }
111 bool IsSecured()const{ return m_isSecured; }
112 void SetSecured(){ m_isSecured = true; }
113 bool IsSecureSupported()const { return m_SecureSupport; }
114 void ClearSecureSupport() { m_SecureSupport = false; }
115 void SetSecureSupport() { m_SecureSupport = true; }
116
117 // Helper methods
118 string ExtractValue( uint8 const* _data, uint8* _scale, uint8* _precision, uint8 _valueOffset = 1 )const;
119
127 void AppendValue( Msg* _msg, string const& _value, uint8 const _scale )const;
128 uint8 const GetAppendValueSize( string const& _value )const;
129 int32 ValueToInteger( string const& _value, uint8* o_precision, uint8* o_size )const;
130
131 void UpdateMappedClass( uint8 const _instance, uint8 const _classId, uint8 const _value ); // Update mapped class's value from BASIC class
132
133 typedef struct RefreshValue {
138 std::vector<RefreshValue *> RefreshClasses;
139 } RefreshValue;
140
141 protected:
142 virtual void CreateVars( uint8 const _instance ){}
143 void ReadValueRefreshXML ( TiXmlElement const* _ccElement );
144
145 public:
146 virtual void CreateVars( uint8 const _instance, uint8 const _index ){}
147
148 private:
149 uint32 m_homeId;
150 uint8 m_nodeId;
151 uint8 m_version;
152 Bitfield m_instances;
154 map<uint8,uint8> m_endPointMap;
156 bool m_afterMark; // Set to true if the command class is listed after COMMAND_CLASS_MARK, and should not create any values.
157 bool m_createVars; // Do we want to create variables
158 int8 m_overridePrecision; // Override precision when writing values if >=0
159 bool m_getSupported; // Get operation supported
160 bool m_isSecured; // is this command class secured with the Security Command Class
161 bool m_SecureSupport; // Does this commandclass support secure encryption (eg, the Security CC doesn't encrypt itself, so it doesn't support encryption)
162 std::vector<RefreshValue *> m_RefreshClassValues; // what Command Class Values should we refresh ?
163
164 //-----------------------------------------------------------------------------
165 // Record which items of static data have been read from the device
166 //-----------------------------------------------------------------------------
167 public:
169 {
170 StaticRequest_Instances = 0x01,
171 StaticRequest_Values = 0x02,
172 StaticRequest_Version = 0x04
173 };
174
175 bool HasStaticRequest( uint8 _request )const{ return( (m_staticRequests & _request) != 0 ); }
176 void SetStaticRequest( uint8 _request ){ m_staticRequests |= _request; }
177 void ClearStaticRequest( uint8 _request );
178
179 private:
180 uint8 m_staticRequests;
181
182 //-----------------------------------------------------------------------------
183 // Statistics
184 //-----------------------------------------------------------------------------
185 public:
186 uint32 GetSentCnt()const{ return m_sentCnt; }
187 uint32 GetReceivedCnt()const{ return m_receivedCnt; }
188 void SentCntIncr(){ m_sentCnt++; }
189 void ReceivedCntIncr(){ m_receivedCnt++; }
190
191 private:
192 uint32 m_sentCnt; // Number of messages sent from this command class.
193 uint32 m_receivedCnt; // Number of messages received from this commandclass.
194 };
195
196} // namespace OpenZWave
197
198#endif
unsigned int uint32
Definition: Defs.h:69
signed char int8
Definition: Defs.h:62
signed int int32
Definition: Defs.h:68
#define OPENZWAVE_EXPORT_WARNINGS_ON
Definition: Defs.h:53
#define OPENZWAVE_EXPORT
Definition: Defs.h:51
#define OPENZWAVE_EXPORT_WARNINGS_OFF
Definition: Defs.h:52
unsigned char uint8
Definition: Defs.h:63
Definition: Bitfield.h:37
Base class for all Z-Wave command classes.
Definition: CommandClass.h:47
void SetEndPoint(uint8 const _instance, uint8 const _endpoint)
Definition: CommandClass.h:107
void SetStaticRequest(uint8 _request)
Definition: CommandClass.h:176
void ReceivedCntIncr()
Definition: CommandClass.h:189
virtual bool RequestValue(uint32 const _requestFlags, uint8 const _index, uint8 const _instance, Driver::MsgQueue const _queue)
Definition: CommandClass.h:63
uint32 GetSentCnt() const
Definition: CommandClass.h:186
virtual void CreateVars(uint8 const _instance, uint8 const _index)
Definition: CommandClass.h:146
virtual void SetVersion(uint8 const _version)
Definition: CommandClass.h:70
uint8 GetNodeId() const
Definition: CommandClass.h:82
void SetSecureSupport()
Definition: CommandClass.h:115
virtual bool RequestState(uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue)
Definition: CommandClass.h:62
bool IsSecureSupported() const
Definition: CommandClass.h:113
virtual uint8 const GetCommandClassId() const =0
virtual uint8 GetMaxVersion()
Definition: CommandClass.h:77
uint8 GetVersion() const
Definition: CommandClass.h:79
bool IsCreateVars() const
Definition: CommandClass.h:109
void SentCntIncr()
Definition: CommandClass.h:188
bool IsAfterMark() const
Definition: CommandClass.h:108
bool HasStaticRequest(uint8 _request) const
Definition: CommandClass.h:175
uint32 GetHomeId() const
Definition: CommandClass.h:81
Bitfield const * GetInstances() const
Definition: CommandClass.h:80
uint32 GetReceivedCnt() const
Definition: CommandClass.h:187
virtual bool SetValue(Value const &_value)
Definition: CommandClass.h:68
bool IsSecured() const
Definition: CommandClass.h:111
StaticRequest
Definition: CommandClass.h:169
virtual bool HandleMsg(uint8 const *_data, uint32 const _length, uint32 const _instance=1)=0
void SetSecured()
Definition: CommandClass.h:112
bool IsGetSupported() const
Definition: CommandClass.h:110
virtual void CreateVars(uint8 const _instance)
Definition: CommandClass.h:142
virtual void SetValueBasic(uint8 const _instance, uint8 const _level)
Definition: CommandClass.h:69
virtual string const GetCommandClassName() const =0
void ClearSecureSupport()
Definition: CommandClass.h:114
void SetAfterMark()
Definition: CommandClass.h:106
uint8 GetEndPoint(uint8 const _instance)
Definition: CommandClass.h:87
uint8 GetInstance(uint8 const _endPoint)
Definition: CommandClass.h:92
The Driver class handles communication between OpenZWave and a device attached via a serial port (typ...
Definition: Driver.h:57
MsgQueue
Definition: Driver.h:584
Message object to be passed to and from devices on the Z-Wave network.
Definition: Msg.h:43
The Node class describes a Z-Wave node object...typically a device on the Z-Wave network.
Definition: Node.h:64
Base class for values associated with a node.
Definition: Value.h:45
Definition: Bitfield.h:35
Definition: CommandClass.h:133
uint8 index
Definition: CommandClass.h:137
uint8 instance
Definition: CommandClass.h:136
std::vector< RefreshValue * > RefreshClasses
Definition: CommandClass.h:138
uint8 genre
Definition: CommandClass.h:135
uint8 cc
Definition: CommandClass.h:134