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