OpenZWave Library  1.2
 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  };
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
uint32 GetHomeId() const
Definition: CommandClass.h:81
virtual void SetValueBasic(uint8 const _instance, uint8 const _level)
Definition: CommandClass.h:69
bool IsAfterMark() const
Definition: CommandClass.h:108
bool IsCreateVars() const
Definition: CommandClass.h:109
Message object to be passed to and from devices on the Z-Wave network.
Definition: Msg.h:42
Definition: Bitfield.h:34
MsgQueue
Definition: Driver.h:583
#define OPENZWAVE_EXPORT
Definition: Defs.h:51
uint8 GetVersion() const
Definition: CommandClass.h:79
void SentCntIncr()
Definition: CommandClass.h:188
#define OPENZWAVE_EXPORT_WARNINGS_ON
Definition: Defs.h:53
uint8 cc
Definition: CommandClass.h:134
void ClearSecureSupport()
Definition: CommandClass.h:114
std::vector< RefreshValue * > RefreshClasses
Definition: CommandClass.h:138
bool IsSecureSupported() const
Definition: CommandClass.h:113
virtual void CreateVars(uint8 const _instance, uint8 const _index)
Definition: CommandClass.h:146
uint8 index
Definition: CommandClass.h:137
uint8 genre
Definition: CommandClass.h:135
uint8 GetEndPoint(uint8 const _instance)
Definition: CommandClass.h:87
Definition: CommandClass.h:133
StaticRequest
Definition: CommandClass.h:168
virtual bool RequestValue(uint32 const _requestFlags, uint8 const _index, uint8 const _instance, Driver::MsgQueue const _queue)
Definition: CommandClass.h:63
#define OPENZWAVE_EXPORT_WARNINGS_OFF
Definition: Defs.h:52
uint32 GetReceivedCnt() const
Definition: CommandClass.h:187
Definition: Bitfield.h:36
The Node class describes a Z-Wave node object...typically a device on the Z-Wave network.
Definition: Node.h:63
virtual void CreateVars(uint8 const _instance)
Definition: CommandClass.h:142
Base class for all Z-Wave command classes.
Definition: CommandClass.h:46
void SetEndPoint(uint8 const _instance, uint8 const _endpoint)
Definition: CommandClass.h:107
void SetSecured()
Definition: CommandClass.h:112
bool IsSecured() const
Definition: CommandClass.h:111
signed char int8
Definition: Defs.h:62
The Driver class handles communication between OpenZWave and a device attached via a serial port (typ...
Definition: Driver.h:56
signed int int32
Definition: Defs.h:68
unsigned int uint32
Definition: Defs.h:69
virtual uint8 GetMaxVersion()
Definition: CommandClass.h:77
void SetSecureSupport()
Definition: CommandClass.h:115
void SetStaticRequest(uint8 _request)
Definition: CommandClass.h:176
uint32 GetSentCnt() const
Definition: CommandClass.h:186
virtual void SetVersion(uint8 const _version)
Definition: CommandClass.h:70
uint8 GetNodeId() const
Definition: CommandClass.h:82
virtual bool RequestState(uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue)
Definition: CommandClass.h:62
bool IsGetSupported() const
Definition: CommandClass.h:110
Base class for values associated with a node.
Definition: Value.h:44
uint8 GetInstance(uint8 const _endPoint)
Definition: CommandClass.h:92
uint8 instance
Definition: CommandClass.h:136
Bitfield const * GetInstances() const
Definition: CommandClass.h:80
void SetAfterMark()
Definition: CommandClass.h:106
void ReceivedCntIncr()
Definition: CommandClass.h:189
virtual bool SetValue(Value const &_value)
Definition: CommandClass.h:68
bool HasStaticRequest(uint8 _request) const
Definition: CommandClass.h:175
unsigned char uint8
Definition: Defs.h:63