578 lines
25 KiB
C++
578 lines
25 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// Node.h
|
|
//
|
|
// A node in the Z-Wave network
|
|
//
|
|
// Copyright (c) 2010 Mal Lansell <openzwave@lansell.org>
|
|
//
|
|
// SOFTWARE NOTICE AND LICENSE
|
|
//
|
|
// This file is part of OpenZWave.
|
|
//
|
|
// OpenZWave is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published
|
|
// by the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// OpenZWave is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with OpenZWave. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _Node_H
|
|
#define _Node_H
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <list>
|
|
#include <map>
|
|
#include "Defs.h"
|
|
#include "value_classes/ValueID.h"
|
|
#include "value_classes/ValueList.h"
|
|
#include "Msg.h"
|
|
#include "platform/TimeStamp.h"
|
|
|
|
class TiXmlElement;
|
|
|
|
namespace OpenZWave
|
|
{
|
|
class CommandClass;
|
|
class Driver;
|
|
class Group;
|
|
class ValueStore;
|
|
class Value;
|
|
class ValueBool;
|
|
class ValueButton;
|
|
class ValueByte;
|
|
class ValueDecimal;
|
|
class ValueInt;
|
|
class ValueSchedule;
|
|
class ValueShort;
|
|
class ValueString;
|
|
class Mutex;
|
|
|
|
/** \brief The Node class describes a Z-Wave node object...typically a device on the
|
|
* Z-Wave network.
|
|
*/
|
|
class Node
|
|
{
|
|
friend class Manager;
|
|
friend class Driver;
|
|
friend class Group;
|
|
friend class Value;
|
|
friend class ValueButton;
|
|
friend class Alarm;
|
|
friend class Association;
|
|
friend class AssociationCommandConfiguration;
|
|
friend class Basic;
|
|
friend class Battery;
|
|
friend class ClimateControlSchedule;
|
|
friend class Clock;
|
|
friend class CommandClass;
|
|
friend class ControllerReplication;
|
|
friend class EnergyProduction;
|
|
friend class Hail;
|
|
friend class Indicator;
|
|
friend class Language;
|
|
friend class Lock;
|
|
friend class ManufacturerSpecific;
|
|
friend class Meter;
|
|
friend class MeterPulse;
|
|
friend class MultiInstance;
|
|
friend class NodeNaming;
|
|
friend class Protection;
|
|
friend class Security;
|
|
friend class SensorAlarm;
|
|
friend class SensorBinary;
|
|
friend class SensorMultilevel;
|
|
friend class SwitchAll;
|
|
friend class SwitchBinary;
|
|
friend class SwitchMultilevel;
|
|
friend class SwitchToggleBinary;
|
|
friend class SwitchToggleMultilevel;
|
|
friend class ThermostatFanMode;
|
|
friend class ThermostatFanState;
|
|
friend class ThermostatMode;
|
|
friend class ThermostatOperatingState;
|
|
friend class ThermostatSetpoint;
|
|
friend class Version;
|
|
friend class WakeUp;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Construction
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
/** Constructor initializes the node object, associating it with a specific
|
|
* network (_homeId) and network node (_nodeId).
|
|
* \param _homeId The homeId of the network to which this node is connected.
|
|
* \param _nodeId The nodeId of this node.
|
|
*/
|
|
Node( uint32 const _homeId, uint8 const _nodeId );
|
|
/** Destructor cleans up memory allocated to node and its child objects.
|
|
*/
|
|
virtual ~Node();
|
|
|
|
private:
|
|
/** Returns a pointer to the driver (interface with a Z-Wave controller)
|
|
* associated with this node.
|
|
*/
|
|
Driver* GetDriver()const;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Initialization
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
enum QueryStage
|
|
{
|
|
QueryStage_ProtocolInfo, /**< Retrieve protocol information */
|
|
QueryStage_Probe, /**< Ping device to see if alive */
|
|
QueryStage_WakeUp, /**< Start wake up process if a sleeping node */
|
|
QueryStage_ManufacturerSpecific1, /**< Retrieve manufacturer name and product ids if ProtocolInfo lets us */
|
|
QueryStage_NodeInfo, /**< Retrieve info about supported, controlled command classes */
|
|
QueryStage_SecurityReport, /**< Retrive a list of Command Classes that require Security */
|
|
QueryStage_ManufacturerSpecific2, /**< Retrieve manufacturer name and product ids */
|
|
QueryStage_Versions, /**< Retrieve version information */
|
|
QueryStage_Instances, /**< Retrieve information about multiple command class instances */
|
|
QueryStage_Static, /**< Retrieve static information (doesn't change) */
|
|
QueryStage_Probe1, /**< Ping a device upon starting with configuration */
|
|
QueryStage_Associations, /**< Retrieve information about associations */
|
|
QueryStage_Neighbors, /**< Retrieve node neighbor list */
|
|
QueryStage_Session, /**< Retrieve session information (changes infrequently) */
|
|
QueryStage_Dynamic, /**< Retrieve dynamic information (changes frequently) */
|
|
QueryStage_Configuration, /**< Retrieve configurable parameter information (only done on request) */
|
|
QueryStage_Complete, /**< Query process is completed for this node */
|
|
QueryStage_None /**< Query process hasn't started for this node */
|
|
};
|
|
|
|
|
|
/**
|
|
* This function advances the query process (see Remarks below for more detail on the
|
|
* process). It iterates through the various query stages enumerated in Node::QueryStage.
|
|
*
|
|
* \remark
|
|
* For OpenZWave to discover everything about a node, we have to follow a certain
|
|
* order of queries, because the results of one stage may affect what is requested
|
|
* in the next stage. The stage is saved with the node data, so that any incomplete
|
|
* queries can be restarted the next time the application runs.
|
|
* <p>
|
|
* The individual command classes also store some state information as to whether
|
|
* they have had a response to certain queries. This state information is
|
|
* initilized by the SetStaticRequests call in QueryStage_None. It is also saved,
|
|
* so we do not need to request state from every command class if some have previously
|
|
* responded.
|
|
*/
|
|
void AdvanceQueries();
|
|
|
|
/**
|
|
* Signal that a specific query stage has been completed for this node. This will
|
|
* only work if the query process for this node is indeed at the specified stage.
|
|
* Otherwise, the function returns with no action.
|
|
* \param _stage The current stage of the query process.
|
|
*/
|
|
void QueryStageComplete( QueryStage const _stage );
|
|
|
|
/**
|
|
* Retry the specified query stage (up to _maxAttempts retries). This will
|
|
* only work if the query process for this node is indeed at the specified stage.
|
|
* Otherwise, the function returns with no action.
|
|
* \param _stage The query stage to retry.
|
|
* \param _maxAttempts
|
|
*/
|
|
void QueryStageRetry( QueryStage const _stage, uint8 const _maxAttempts = 0 ); // maxAttempts of zero means no limit
|
|
|
|
/**
|
|
* This function sets the query stage for the node (but only to an earlier stage).
|
|
* If a later stage is specified than the current one, it is ignored.
|
|
* \param _stage The desired query stage.
|
|
* \see m_queryStage, m_queryPending
|
|
*/
|
|
void SetQueryStage( QueryStage const _stage, bool const _advance = true );
|
|
|
|
/**
|
|
* Returns the current query stage enum.
|
|
* \return Enum value with the current query stage.
|
|
* \see m_queryStage
|
|
*/
|
|
Node::QueryStage GetCurrentQueryStage() { return m_queryStage; }
|
|
|
|
/**
|
|
* Returns the specified query stage string.
|
|
* \param _stage The query stage.
|
|
* \return Specified query stage string.
|
|
* \see m_queryStage, m_queryPending
|
|
*/
|
|
string GetQueryStageName( QueryStage const _stage );
|
|
|
|
/**
|
|
* Returns whether the library thinks a node is functioning properly
|
|
* \return boolean status of node.
|
|
*/
|
|
bool IsNodeAlive()const{ return m_nodeAlive; }
|
|
|
|
/**
|
|
* This function handles a response to the FUNC_ID_ZW_GET_NODE_PROTOCOL_INFO
|
|
* command for this node. If protocol information has already been retrieved
|
|
* for the node, the function simply returns. Otherwise, it populates several
|
|
* member variables about the device at this node:
|
|
* - m_routing (whether it is a routing node (capable of passing commands along to other nodes in the network) or not
|
|
* - m_maxBaudRate (the maximum baud rate at which this device can communicate)
|
|
* - m_version (TODO)
|
|
* - m_security (whether device supports security features)
|
|
* - m_listening (device is powered and listening constantly)
|
|
* - m_frequentListening (device can be woken up with a beam)
|
|
* - m_beaming (device is beam capable)
|
|
*/
|
|
void UpdateProtocolInfo( uint8 const* _data );
|
|
void UpdateNodeInfo( uint8 const* _data, uint8 const _length );
|
|
|
|
bool ProtocolInfoReceived()const{ return m_protocolInfoReceived; }
|
|
bool NodeInfoReceived()const{ return m_nodeInfoReceived; }
|
|
|
|
bool AllQueriesCompleted()const{ return( QueryStage_Complete == m_queryStage ); }
|
|
|
|
/**
|
|
* Handle dead node detection tracking.
|
|
* Use this routine to set state of nodes.
|
|
* Tracks state as well as send notifications.
|
|
*/
|
|
void SetNodeAlive( bool const _isAlive );
|
|
|
|
private:
|
|
void SetStaticRequests();
|
|
|
|
QueryStage m_queryStage;
|
|
bool m_queryPending;
|
|
bool m_queryConfiguration;
|
|
uint8 m_queryRetries;
|
|
bool m_protocolInfoReceived;
|
|
bool m_nodeInfoReceived;
|
|
bool m_manufacturerSpecificClassReceived;
|
|
bool m_nodeInfoSupported;
|
|
bool m_nodeAlive;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Capabilities
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
// Security flags
|
|
enum
|
|
{
|
|
SecurityFlag_Security = 0x01,
|
|
SecurityFlag_Controller = 0x02,
|
|
SecurityFlag_SpecificDevice = 0x04,
|
|
SecurityFlag_RoutingSlave = 0x08,
|
|
SecurityFlag_BeamCapability = 0x10,
|
|
SecurityFlag_Sensor250ms = 0x20,
|
|
SecurityFlag_Sensor1000ms = 0x40,
|
|
SecurityFlag_OptionalFunctionality = 0x80
|
|
};
|
|
|
|
// Node Ids
|
|
enum
|
|
{
|
|
NodeBroadcast = 0xff
|
|
};
|
|
|
|
bool IsListeningDevice()const{ return m_listening; }
|
|
bool IsFrequentListeningDevice()const{ return m_frequentListening; }
|
|
bool IsBeamingDevice()const{ return m_beaming; }
|
|
bool IsRoutingDevice()const{ return m_routing; }
|
|
bool IsSecurityDevice()const{ return m_security; }
|
|
uint32 GetMaxBaudRate()const{ return m_maxBaudRate; }
|
|
uint8 GetVersion()const{ return m_version; }
|
|
uint8 GetSecurity()const{ return m_security; }
|
|
|
|
uint8 GetNodeId()const{ return m_nodeId; }
|
|
|
|
uint8 GetBasic()const{ return m_basic; }
|
|
uint8 GetGeneric()const{ return m_generic; }
|
|
uint8 GetSpecific()const{ return m_specific; }
|
|
string const& GetType()const{ return m_type; }
|
|
uint32 GetNeighbors( uint8** o_associations );
|
|
bool IsController()const{ return ( m_basic == 0x01 || m_basic == 0x02 ) && ( m_generic == 0x01 || m_generic == 0x02 ); }
|
|
bool IsAddingNode() const { return m_addingNode; } /* These three *AddingNode functions are used to tell if we this node is just being discovered. Currently used by the Security CC to initiate the Network Key Exchange */
|
|
void SetAddingNode() { m_addingNode = true; }
|
|
void ClearAddingNode() { m_addingNode = false; }
|
|
|
|
private:
|
|
bool m_listening;
|
|
bool m_frequentListening;
|
|
bool m_beaming;
|
|
bool m_routing;
|
|
uint32 m_maxBaudRate;
|
|
uint8 m_version;
|
|
bool m_security;
|
|
uint32 m_homeId;
|
|
uint8 m_nodeId;
|
|
uint8 m_basic; //*< Basic device class (0x01-Controller, 0x02-Static Controller, 0x03-Slave, 0x04-Routing Slave
|
|
uint8 m_generic;
|
|
uint8 m_specific;
|
|
string m_type; // Label representing the specific/generic/basic value
|
|
uint8 m_neighbors[29]; // Bitmask containing the neighbouring nodes
|
|
uint8 m_numRouteNodes; // number of node routes
|
|
uint8 m_routeNodes[5]; // nodes to route to
|
|
map<uint8,uint8> m_buttonMap; // Map button IDs into virtual node numbers
|
|
bool m_addingNode;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Device Naming
|
|
//-----------------------------------------------------------------------------
|
|
private:
|
|
// Manufacturer, Product and Name are stored here so they can be set by the
|
|
// user even if the device does not support the relevant command classes.
|
|
string GetManufacturerName()const{ return m_manufacturerName; }
|
|
string GetProductName()const{ return m_productName; }
|
|
string GetNodeName()const{ return m_nodeName; }
|
|
string GetLocation()const{ return m_location; }
|
|
|
|
string GetManufacturerId()const{ return m_manufacturerId; }
|
|
string GetProductType()const{ return m_productType; }
|
|
string GetProductId()const{ return m_productId; }
|
|
|
|
void SetManufacturerName( string const& _manufacturerName ){ m_manufacturerName = _manufacturerName; }
|
|
void SetProductName( string const& _productName ){ m_productName = _productName; }
|
|
void SetNodeName( string const& _nodeName );
|
|
void SetLocation( string const& _location );
|
|
|
|
void SetManufacturerId( string const& _manufacturerId ){ m_manufacturerId = _manufacturerId; }
|
|
void SetProductType( string const& _productType ){ m_productType = _productType; }
|
|
void SetProductId( string const& _productId ){ m_productId = _productId; }
|
|
|
|
string m_manufacturerName;
|
|
string m_productName;
|
|
string m_nodeName;
|
|
string m_location;
|
|
|
|
string m_manufacturerId;
|
|
string m_productType;
|
|
string m_productId;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Command Classes
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
/**
|
|
* This function retrieves a pointer to the requested command class object (if supported by this node).
|
|
* \param _commandClassId Class ID (a single byte value) identifying the command class requested.
|
|
* \return Pointer to the requested CommandClass object if supported, otherwise NULL.
|
|
* \see CommandClass, m_commandClassMap
|
|
*/
|
|
CommandClass* GetCommandClass( uint8 const _commandClassId )const;
|
|
void ApplicationCommandHandler( uint8 const* _data );
|
|
|
|
/**
|
|
* This function sets up Secured Command Classes. It iterates over the existing command classes marking them
|
|
* as Secured if they exist, and if they don't, it creates new Command Classes and sets them up as Secured
|
|
* @param _data a list of Command Classes that are Secured by the Device
|
|
* @param _length the length of the _data string
|
|
*/
|
|
void SetSecuredClasses( uint8 const* _data, uint8 const _length );
|
|
|
|
private:
|
|
/**
|
|
* Creates the specified command class object and adds it to the node (via the
|
|
* m_commandClassMap) if it doesn't exist.
|
|
* No new object is created if it already exists for this node.
|
|
* \param _commandClassId Class ID (a single byte value) identifying the command class requested.
|
|
* \return Pointer to the CommandClass object just added to the map (NULL if the object
|
|
* was already there or if the CommandClass object creation failed).
|
|
* \see CommandClass, CommandClasses::CreateCommandClass, m_commandClassMap
|
|
*/
|
|
CommandClass* AddCommandClass( uint8 const _commandClassId );
|
|
/**
|
|
* Removes a command class object from the node (via the m_commandClassMap). Before removing the
|
|
* object, this function also removes any values stored in the object's ValueStore.
|
|
* \param _commandClassId Class ID (a single byte value) identifying the command class to be removed.
|
|
* \see m_commandClassMap, ValueStore, GetValueStore, ValueStore::RemoveCommandClassValues
|
|
*/
|
|
void RemoveCommandClass( uint8 const _commandClassId );
|
|
void ReadXML( TiXmlElement const* _nodeElement );
|
|
void ReadDeviceProtocolXML( TiXmlElement const* _ccsElement );
|
|
void ReadCommandClassesXML( TiXmlElement const* _ccsElement );
|
|
void WriteXML( TiXmlElement* _nodeElement );
|
|
|
|
map<uint8,CommandClass*> m_commandClassMap; /**< Map of command class ids and pointers to associated command class objects */
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Basic commands (helpers that go through the basic command class)
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
void SetLevel( uint8 const _level );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// On/Off commands (helpers that go through the basic or switchall command class)
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
void SetNodeOn();
|
|
void SetNodeOff();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Values (handled by the command classes)
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
ValueID CreateValueID( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, ValueID::ValueType const _type );
|
|
|
|
Value* GetValue( ValueID const& _id );
|
|
Value* GetValue( uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex );
|
|
bool RemoveValue( uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex );
|
|
|
|
// Helpers for creating values
|
|
bool CreateValueBool( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, bool const _default, uint8 const _pollIntensity );
|
|
bool CreateValueButton( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, uint8 const _pollIntensity );
|
|
bool CreateValueByte( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, uint8 const _default, uint8 const _pollIntensity );
|
|
bool CreateValueDecimal( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, string const& _default, uint8 const _pollIntensity );
|
|
bool CreateValueInt( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, int32 const _default, uint8 const _pollIntensity );
|
|
bool CreateValueList( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, uint8 const _size, vector<ValueList::Item> const& _items, int32 const _default, uint8 const _pollIntensity );
|
|
bool CreateValueRaw( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, uint8 const* _default, uint8 const _length, uint8 const _pollIntensity );
|
|
bool CreateValueSchedule( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, uint8 const _pollIntensity );
|
|
bool CreateValueShort( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, int16 const _default, uint8 const _pollIntensity );
|
|
bool CreateValueString( ValueID::ValueGenre const _genre, uint8 const _commandClassId, uint8 const _instance, uint8 const _valueIndex, string const& _label, string const& _units, bool const _readOnly, bool const _writeOnly, string const& _default, uint8 const _pollIntensity );
|
|
|
|
// helpers for removing values
|
|
void RemoveValueList( ValueList* _value );
|
|
|
|
void ReadValueFromXML( uint8 const _commandClassId, TiXmlElement const* _valueElement );
|
|
bool CreateValueFromXML( uint8 const _commandClassId, TiXmlElement const* _valueElement );
|
|
|
|
private:
|
|
ValueStore* GetValueStore()const{ return m_values; }
|
|
|
|
ValueStore* m_values; // Values reported via command classes
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Configuration Parameters (handled by the Configuration command class)
|
|
//-----------------------------------------------------------------------------
|
|
private:
|
|
bool SetConfigParam( uint8 const _param, int32 _value, uint8 const _size );
|
|
void RequestConfigParam( uint8 const _param );
|
|
bool RequestAllConfigParams( uint32 const _requestFlags );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Dynamic Values (used by query and other command classes for updating)
|
|
//-----------------------------------------------------------------------------
|
|
private:
|
|
bool RequestDynamicValues();
|
|
//-----------------------------------------------------------------------------
|
|
// Groups
|
|
//-----------------------------------------------------------------------------
|
|
private:
|
|
// The public interface is provided via the wrappers in the Manager class
|
|
uint8 GetNumGroups();
|
|
uint32 GetAssociations( uint8 const _groupIdx, uint8** o_associations );
|
|
uint8 GetMaxAssociations( uint8 const _groupIdx );
|
|
string GetGroupLabel( uint8 const _groupIdx );
|
|
void AddAssociation( uint8 const _groupIdx, uint8 const _targetNodeId );
|
|
void RemoveAssociation( uint8 const _groupIdx, uint8 const _targetNodeId );
|
|
void AutoAssociate();
|
|
|
|
// The following methods are not exposed
|
|
Group* GetGroup( uint8 const _groupIdx ); // Get a pointer to a Group object. This must only be called while holding the node Lock.
|
|
void AddGroup( Group* _group ); // The groups are fixed properties of a device, so there is no need for a matching RemoveGroup.
|
|
void WriteGroups( TiXmlElement* _associationsElement ); // Write the group data out to XNL
|
|
|
|
map<uint8,Group*> m_groups; // Maps group indices to Group objects.
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Device Classes (static data read from the device_classes.xml file)
|
|
//-----------------------------------------------------------------------------
|
|
private:
|
|
// Container for device class info
|
|
class DeviceClass
|
|
{
|
|
public:
|
|
DeviceClass( TiXmlElement const* _el );
|
|
~DeviceClass(){ delete [] m_mandatoryCommandClasses; }
|
|
|
|
uint8 const* GetMandatoryCommandClasses(){ return m_mandatoryCommandClasses; }
|
|
uint8 GetBasicMapping(){ return m_basicMapping; }
|
|
string const& GetLabel(){ return m_label; }
|
|
|
|
private:
|
|
uint8* m_mandatoryCommandClasses; // Zero terminated array of mandatory command classes for this device type.
|
|
uint8 m_basicMapping; // Command class that COMMAND_CLASS_BASIC maps on to, or zero if there is no mapping.
|
|
string m_label; // Descriptive label for the device.
|
|
};
|
|
|
|
// Container for generic device class info
|
|
class GenericDeviceClass : public DeviceClass
|
|
{
|
|
public:
|
|
GenericDeviceClass( TiXmlElement const* _el );
|
|
~GenericDeviceClass();
|
|
|
|
DeviceClass* GetSpecificDeviceClass( uint8 const& _specific );
|
|
|
|
private:
|
|
map<uint8,DeviceClass*> m_specificDeviceClasses;
|
|
};
|
|
|
|
|
|
bool SetDeviceClasses( uint8 const _basic, uint8 const _generic, uint8 const _specific ); // Set the device class data for the node
|
|
bool AddMandatoryCommandClasses( uint8 const* _commandClasses ); // Add mandatory command classes as specified in the device_classes.xml to the node.
|
|
void ReadDeviceClasses(); // Read the static device class data from the device_classes.xml file
|
|
string GetEndPointDeviceClassLabel( uint8 const _generic, uint8 const _specific );
|
|
|
|
static bool s_deviceClassesLoaded; // True if the xml file has alreayd been loaded
|
|
static map<uint8,string> s_basicDeviceClasses; // Map of basic device classes.
|
|
static map<uint8,GenericDeviceClass*> s_genericDeviceClasses; // Map of generic device classes.
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Statistics
|
|
//-----------------------------------------------------------------------------
|
|
public:
|
|
struct CommandClassData
|
|
{
|
|
uint8 m_commandClassId;
|
|
uint32 m_sentCnt;
|
|
uint32 m_receivedCnt;
|
|
};
|
|
|
|
struct NodeData
|
|
{
|
|
uint32 m_sentCnt;
|
|
uint32 m_sentFailed;
|
|
uint32 m_retries;
|
|
uint32 m_receivedCnt;
|
|
uint32 m_receivedDups;
|
|
uint32 m_receivedUnsolicited;
|
|
string m_sentTS;
|
|
string m_receivedTS;
|
|
uint32 m_lastRequestRTT;
|
|
uint32 m_averageRequestRTT; // ms
|
|
uint32 m_lastResponseRTT;
|
|
uint32 m_averageResponseRTT;
|
|
uint8 m_quality; // Node quality measure
|
|
uint8 m_lastReceivedMessage[254];
|
|
list<CommandClassData> m_ccData;
|
|
};
|
|
|
|
private:
|
|
void GetNodeStatistics( NodeData* _data );
|
|
|
|
uint32 m_sentCnt; // Number of messages sent from this node.
|
|
uint32 m_sentFailed; // Number of sent messages failed
|
|
uint32 m_retries; // Number of message retries
|
|
uint32 m_receivedCnt; // Number of messages received from this node.
|
|
uint32 m_receivedDups; // Number of duplicated messages received;
|
|
uint32 m_receivedUnsolicited; // Number of messages received unsolicited
|
|
uint32 m_lastRequestRTT; // Last message request RTT
|
|
uint32 m_lastResponseRTT; // Last message response RTT
|
|
TimeStamp m_sentTS; // Last message sent time
|
|
TimeStamp m_receivedTS; // Last message received time
|
|
uint32 m_averageRequestRTT; // Average Request round trip time.
|
|
uint32 m_averageResponseRTT; // Average Reponse round trip time.
|
|
uint8 m_quality; // Node quality measure
|
|
uint8 m_lastReceivedMessage[254]; // Place to hold last received message
|
|
uint8 m_errors; // Count errors for dead node detection
|
|
};
|
|
|
|
} //namespace OpenZWave
|
|
|
|
#endif //_Node_H
|