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