ansible4ozw 0.0.2 → 0.0.3

data/lib/ansible/zwave/openzwave/src/command_classes/Clock.cpp

@@ -0,0 +1,227 @@
+//-----------------------------------------------------------------------------
+//
+//	Clock.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_CLOCK
+//
+//	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/>.
+//
+//-----------------------------------------------------------------------------
+
+#include "CommandClasses.h"
+#include "Clock.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+#include "ValueByte.h"
+#include "ValueList.h"
+
+using namespace OpenZWave;
+
+enum ClockCmd
+{
+	ClockCmd_Set	= 0x04,
+	ClockCmd_Get	= 0x05,
+	ClockCmd_Report	= 0x06
+};
+
+enum
+{
+	ClockIndex_Day = 0,
+	ClockIndex_Hour,
+	ClockIndex_Minute
+};
+
+static char const* c_dayNames[] = 
+{
+	"Invalid",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday",
+	"Sunday"
+};
+
+//-----------------------------------------------------------------------------
+// <Clock::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool Clock::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Dynamic )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Clock::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool Clock::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Msg* msg = new Msg( "ClockCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+	msg->SetInstance( this, _instance );
+	msg->Append( GetNodeId() );
+	msg->Append( 2 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( ClockCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <Clock::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Clock::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1   
+)
+{
+	if (ClockCmd_Report == (ClockCmd)_data[0])
+	{
+		uint8 day = _data[1] >> 5;
+		uint8 hour = _data[1] & 0x1f;
+		uint8 minute = _data[2];
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received Clock report: %s %.2d:%.2d", c_dayNames[day], hour, minute );
+
+
+		if( ValueList* dayValue = static_cast<ValueList*>( GetValue( _instance, ClockIndex_Day ) ) )
+		{
+			dayValue->OnValueRefreshed( day );
+			dayValue->Release();
+		}
+		if( ValueByte* hourValue = static_cast<ValueByte*>( GetValue( _instance, ClockIndex_Hour ) ) )
+		{
+			hourValue->OnValueRefreshed( hour );
+			hourValue->Release();
+		}
+		if( ValueByte* minuteValue = static_cast<ValueByte*>( GetValue( _instance, ClockIndex_Minute ) ) )
+		{
+			minuteValue->OnValueRefreshed( minute );
+			minuteValue->Release();
+		}
+		return true;
+	}
+	
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Clock::SetValue>
+// Set a value in the Z-Wave device
+//-----------------------------------------------------------------------------
+bool Clock::SetValue
+(
+	Value const& _value
+)
+{
+	bool ret = false;
+
+	uint8 instance = _value.GetID().GetInstance();
+
+	ValueList* dayValue = static_cast<ValueList*>( GetValue( instance, ClockIndex_Day ) );
+	ValueByte* hourValue = static_cast<ValueByte*>( GetValue( instance, ClockIndex_Hour ) );
+	ValueByte* minuteValue = static_cast<ValueByte*>( GetValue( instance, ClockIndex_Minute ) );
+
+	if( dayValue && hourValue && minuteValue )
+	{
+		uint8 day = dayValue->GetItem().m_value;
+		uint8 hour = hourValue->GetValue();
+		uint8 minute = minuteValue->GetValue();
+
+		Msg* msg = new Msg( "ClockCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
+		msg->SetInstance( this, instance );
+		msg->Append( GetNodeId() );
+		msg->Append( 4 );
+		msg->Append( GetCommandClassId() );
+		msg->Append( ClockCmd_Set );
+		msg->Append( ( day << 5 ) | hour );
+		msg->Append( minute );
+		msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+		GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+		ret = true;
+	}
+
+	if( dayValue != NULL )
+	{
+		dayValue->Release();
+	}
+	if( hourValue != NULL )
+	{
+		hourValue->Release();
+	}
+	if( minuteValue != NULL )
+	{
+		minuteValue->Release();
+	}
+	return ret;
+}
+
+//-----------------------------------------------------------------------------
+// <Clock::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void Clock::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+		vector<ValueList::Item> items;
+		for( int i=1; i<=7; ++i )
+		{	
+			ValueList::Item item;
+			item.m_label = c_dayNames[i];
+			item.m_value = i;
+			items.push_back( item ); 
+		}
+
+		node->CreateValueList( ValueID::ValueGenre_User, GetCommandClassId(), _instance, ClockIndex_Day, "Day", "", false, false, 1, items, 0, 0 );
+		node->CreateValueByte( ValueID::ValueGenre_User, GetCommandClassId(), _instance, ClockIndex_Hour, "Hour", "", false, false, 12, 0 );
+		node->CreateValueByte( ValueID::ValueGenre_User, GetCommandClassId(), _instance, ClockIndex_Minute, "Minute", "", false, false, 0, 0 );
+	}
+}
+
+

data/lib/ansible/zwave/openzwave/src/command_classes/Clock.h

@@ -0,0 +1,67 @@
+//-----------------------------------------------------------------------------
+//
+//	Clock.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_CLOCK
+//
+//	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 _Clock_H
+#define _Clock_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	class ValueByte;
+	class ValueList;
+
+	/** \brief Implements COMMAND_CLASS_CLOCK (0x81), a Z-Wave device command class.
+	 */
+	class Clock: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new Clock( _homeId, _nodeId ); }
+		virtual ~Clock(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x81; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_CLOCK"; }
+
+		// From CommandClass
+		virtual bool RequestState( uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue );
+		virtual bool RequestValue( uint32 const _requestFlags, uint8 const _index, uint8 const _instance, Driver::MsgQueue const _queue );
+		virtual uint8 const GetCommandClassId()const{ return StaticGetCommandClassId(); }
+		virtual string const GetCommandClassName()const{ return StaticGetCommandClassName(); }
+		virtual bool HandleMsg( uint8 const* _data, uint32 const _length, uint32 const _instance = 1 );
+		virtual bool SetValue( Value const& _value );
+
+	protected:
+		virtual void CreateVars( uint8 const _instance );
+
+	private:
+		Clock( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+	};
+
+} // namespace OpenZWave
+
+#endif
+

data/lib/ansible/zwave/openzwave/src/command_classes/CommandClass.cpp

@@ -0,0 +1,546 @@
+//-----------------------------------------------------------------------------
+//
+//	CommandClass.cpp
+//
+//	Base class for all Z-Wave Command Classes
+//
+//	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/>.
+//
+//-----------------------------------------------------------------------------
+
+#include <math.h>
+#include <locale.h>
+#include "tinyxml.h"
+#include "CommandClass.h"
+#include "MultiInstance.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Manager.h"
+#include "Log.h"
+#include "ValueStore.h"
+
+using namespace OpenZWave;
+
+static uint8 const	c_sizeMask		= 0x07;
+static uint8 const	c_scaleMask		= 0x18;
+static uint8 const	c_scaleShift		= 0x03;
+static uint8 const	c_precisionMask		= 0xe0;
+static uint8 const	c_precisionShift	= 0x05;
+
+
+//-----------------------------------------------------------------------------
+// <CommandClass::CommandClass>
+// Constructor
+//-----------------------------------------------------------------------------
+CommandClass::CommandClass
+(
+	uint32 const _homeId,
+	uint8 const _nodeId
+):
+	m_homeId( _homeId ),
+	m_nodeId( _nodeId ),
+	m_version( 1 ),
+	m_afterMark( false ),
+	m_createVars( true ),
+	m_overridePrecision( -1 ),
+	m_staticRequests( 0 )
+{
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::GetDriver>
+// Get a pointer to our driver
+//-----------------------------------------------------------------------------
+Driver* CommandClass::GetDriver
+(
+)const
+{
+	return( Manager::Get()->GetDriver( m_homeId ) );
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::GetNode>
+// Get a pointer to our node without locking the mutex
+//-----------------------------------------------------------------------------
+Node* CommandClass::GetNodeUnsafe
+(
+)const
+{
+	return( GetDriver()->GetNodeUnsafe( m_nodeId ) );
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::GetValue>
+// Get a pointer to a value by its instance and index
+//-----------------------------------------------------------------------------
+Value* CommandClass::GetValue
+(
+	uint8 const _instance,
+	uint8 const _index
+)
+{
+	Value* value = NULL;
+	if( Node* node = GetNodeUnsafe() )
+	{
+		value = node->GetValue( GetCommandClassId(), _instance, _index );
+	}
+	return value;
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::SetInstances>
+// Instances as set by the MultiInstance V1 command class
+//-----------------------------------------------------------------------------
+void CommandClass::SetInstances
+( 
+	uint8 const _instances
+)
+{
+	// Ensure we have a set of reported variables for each new instance
+	if( !m_afterMark )
+	{	
+		for( uint8 i=0; i<_instances; ++i )
+		{
+			SetInstance( i+1 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::SetInstance>
+// Instances as set by the MultiChannel (i.e. MultiInstance V2) command class
+//-----------------------------------------------------------------------------
+void CommandClass::SetInstance
+( 
+	uint8 const _endPoint
+)
+{
+	if( !m_instances.IsSet( _endPoint ) )
+	{
+		m_instances.Set( _endPoint );
+		if( IsCreateVars() )
+		{
+			CreateVars( _endPoint );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::ReadXML>
+// Read the saved command class data
+//-----------------------------------------------------------------------------
+void CommandClass::ReadXML
+( 
+	TiXmlElement const* _ccElement
+)
+{
+	int32 intVal;
+	char const* str;
+
+	if( TIXML_SUCCESS == _ccElement->QueryIntAttribute( "version", &intVal ) )
+	{
+		m_version = (uint8)intVal;
+	}
+
+	uint8 instances = 1;
+	if( TIXML_SUCCESS == _ccElement->QueryIntAttribute( "instances", &intVal ) )
+	{
+		instances = (uint8)intVal;
+	}
+
+	if( TIXML_SUCCESS == _ccElement->QueryIntAttribute( "request_flags", &intVal ) )
+	{
+		m_staticRequests = (uint8)intVal;
+	}
+
+	if( TIXML_SUCCESS == _ccElement->QueryIntAttribute( "override_precision", &intVal ) )
+	{
+		m_overridePrecision = (int8)intVal;
+	}
+
+	str = _ccElement->Attribute( "after_mark" );
+	if( str )
+	{
+		m_afterMark = !strcmp( str, "true" );
+	}
+
+	str = _ccElement->Attribute( "create_vars" );
+	if( str )
+	{
+		m_createVars = !strcmp( str, "true" );
+	}
+
+	// Setting the instance count will create all the values.
+	SetInstances( instances );
+
+	// Apply any differences from the saved XML to the values
+	TiXmlElement const* child = _ccElement->FirstChildElement();
+	while( child )
+	{
+		str = child->Value();
+		if( str )
+		{
+			if( !strcmp( str, "Instance" ) )
+			{
+				// Add an instance to the command class
+				if( TIXML_SUCCESS == child->QueryIntAttribute( "index", &intVal ) )
+				{
+					uint8 instance = (uint8)intVal;
+					SetInstance( instance );
+				}
+			}
+			else if( !strcmp( str, "Value" ) )
+			{
+				// Apply any differences from the saved XML to the value
+				GetNodeUnsafe()->ReadValueFromXML( GetCommandClassId(), child );
+			}
+		}
+
+		child = child->NextSiblingElement();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::WriteXML>
+// Save the static node configuration data
+//-----------------------------------------------------------------------------
+void CommandClass::WriteXML
+( 
+	TiXmlElement* _ccElement
+)
+{
+	char str[32];
+
+	snprintf( str, 32, "%d", GetCommandClassId() );
+	_ccElement->SetAttribute( "id", str );
+	_ccElement->SetAttribute( "name", GetCommandClassName().c_str() );
+
+	snprintf( str, 32, "%d", GetVersion() );
+	_ccElement->SetAttribute( "version", str );
+
+	if( m_staticRequests )
+	{
+		snprintf( str, 32, "%d", m_staticRequests );
+		_ccElement->SetAttribute( "request_flags", str );
+	}
+
+	if( m_overridePrecision >= 0 )
+	{
+		snprintf( str, 32, "%d", m_overridePrecision );
+		_ccElement->SetAttribute( "override_precision", str );
+	}
+
+	if( m_afterMark )
+	{
+		_ccElement->SetAttribute( "after_mark", "true" );
+	}
+
+	if( m_createVars )
+	{
+		_ccElement->SetAttribute( "create_vars", "true" );
+	}
+
+	// Write out the instances
+	for( Bitfield::Iterator it = m_instances.Begin(); it != m_instances.End(); ++ it )
+	{
+		TiXmlElement* instanceElement = new TiXmlElement( "Instance" );
+		_ccElement->LinkEndChild( instanceElement );
+
+		snprintf( str, 32, "%d", *it );
+		instanceElement->SetAttribute( "index", str );
+	}
+
+	// Write out the values for this command class
+	ValueStore* store = GetNodeUnsafe()->GetValueStore();
+	for( ValueStore::Iterator it = store->Begin(); it != store->End(); ++it )
+	{
+		Value* value = it->second;
+		if( value->GetID().GetCommandClassId() == GetCommandClassId() )
+		{
+			TiXmlElement* valueElement = new TiXmlElement( "Value" );
+			_ccElement->LinkEndChild( valueElement );
+			value->WriteXML( valueElement );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::ExtractValue>
+// Read a value from a variable length sequence of bytes
+//-----------------------------------------------------------------------------
+string CommandClass::ExtractValue
+(
+	uint8 const* _data,
+	uint8* _scale,
+	uint8* _precision,
+	uint8 _valueOffset // = 1
+)const
+{
+	uint8 const size = _data[0] & c_sizeMask;
+	uint8 const precision = (_data[0] & c_precisionMask) >> c_precisionShift;
+
+	if( _scale )
+	{
+		*_scale = (_data[0] & c_scaleMask) >> c_scaleShift;
+	}
+
+	if( _precision )
+	{
+		*_precision = precision;
+	}
+
+	uint32 value = 0;
+	uint8 i;
+	for( i=0; i<size; ++i )
+	{
+		value <<= 8;
+		value |= (uint32)_data[i+(uint32)_valueOffset];
+	}
+
+	// Deal with sign extension.  All values are signed
+	string res;
+	if( _data[_valueOffset] & 0x80 )
+	{
+		res = "-";
+
+		// MSB is signed
+		if( size == 1 )
+		{
+			value |= 0xffffff00;
+		}
+		else if( size == 2 )
+		{
+			value |= 0xffff0000;
+		}
+	}
+
+	// Convert the integer to a decimal string.  We avoid
+	// using floats to prevent accuracy issues.
+	char numBuf[12];
+
+	if( precision == 0 )
+	{
+		// The precision is zero, so we can just print the number directly into the string.
+		snprintf( numBuf, 12, "%d", (signed long)value );
+		res = numBuf;
+	}
+	else
+	{
+		// We'll need to insert a decimal point and include any necessary leading zeros.
+
+		// Fill the buffer with the value padded with leading zeros.
+		snprintf( numBuf, 12, "%011d", (signed long)value );
+
+		// Calculate the position of the decimal point in the buffer
+		int32 decimal = 10-precision;
+
+		// Shift the characters to make space for the decimal point.
+		// We don't worry about overwriting any minus sign since that is
+		// already written into the res string. While we're shifting, we 
+		// also look for the real starting position of the number so we 
+		// can copy it into the res string later.
+		int32 start = -1;
+		for( int32 i=0; i<decimal; ++i )
+		{
+			numBuf[i] = numBuf[i+1];
+			if( ( start<0 ) && ( numBuf[i] != '0' ) )
+			{
+				start = i;
+			}
+		}
+		if( start<0 )
+		{
+			start = decimal-1;
+		}
+
+		// Insert the decimal point
+		struct lconv const* locale = localeconv();
+		numBuf[decimal] = *(locale->decimal_point);
+
+		// Copy the buffer into res
+		res += &numBuf[start];
+	}
+
+	return res;
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::AppendValue>
+// Add a value to a message as a sequence of bytes
+//-----------------------------------------------------------------------------
+void CommandClass::AppendValue
+(
+	Msg* _msg,
+	string const& _value,
+	uint8 const _scale
+)const
+{
+	uint8 precision;
+	uint8 size;
+	int32 val = ValueToInteger( _value, &precision, &size );
+
+	_msg->Append( (precision<<c_precisionShift) | (_scale<<c_scaleShift) | size );
+
+	int32 shift = (size-1)<<3;
+	for( int32 i=size; i>0; --i, shift-=8 )
+	{
+		_msg->Append( (uint8)(val >> shift) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::GetAppendValueSize>
+// Get the number of bytes that would be added by a call to AppendValue
+//-----------------------------------------------------------------------------
+uint8 const CommandClass::GetAppendValueSize
+(
+	string const& _value
+)const
+{
+	uint8 size;
+	ValueToInteger( _value, NULL, &size );
+	return size;
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::ValueToInteger>
+// Convert a decimal string to an integer and report the precision and
+// number of bytes required to store the value.
+//-----------------------------------------------------------------------------
+int32 CommandClass::ValueToInteger
+(
+	string const& _value,
+	uint8* o_precision,
+	uint8* o_size
+)const
+{
+	int32 val;
+	uint8 precision;
+	
+	// Find the decimal point
+	size_t pos = _value.find_first_of( "." );
+	if( pos == string::npos )
+		pos = _value.find_first_of( "," );
+
+	if( pos == string::npos )
+	{
+		// No decimal point
+		precision = 0;
+
+		// Convert the string to an integer
+		val = atol( _value.c_str() );
+	}
+	else
+	{
+		// Remove the decimal point and convert to an integer
+		precision = (_value.size()-pos)-1;
+
+		string str = _value.substr( 0, pos ) + _value.substr( pos+1 );
+		val = atol( str.c_str() );
+	}
+
+	if ( m_overridePrecision > 0 )
+	{
+		while ( precision < m_overridePrecision ) {
+			precision++;
+			val *= 10;
+		}
+	}
+
+	if ( o_precision ) *o_precision = precision;
+
+	if( o_size )
+	{
+		// Work out the size as either 1, 2 or 4 bytes
+		*o_size = 4;
+		if( val < 0 )
+		{
+			if( ( val & 0xffffff80 ) == 0xffffff80 )
+			{
+				*o_size = 1;
+			}
+			else if( ( val & 0xffff8000 ) == 0xffff8000 )
+			{
+				*o_size = 2;
+			}
+		}
+		else
+		{
+			if( ( val & 0xffffff00 ) == 0 )
+			{
+				*o_size = 1;
+			}
+			else if( ( val & 0xffff0000 ) == 0 )
+			{
+				*o_size = 2;
+			}
+		}
+	}
+
+	return val;
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::ClearStaticRequest>
+// The static data for this command class has been read from the device
+//-----------------------------------------------------------------------------
+void CommandClass::ClearStaticRequest
+( 
+	uint8 _request
+)
+{ 
+	m_staticRequests &= ~_request;
+}
+
+//-----------------------------------------------------------------------------
+// <CommandClass::RequestStateForAllInstances>
+// Request current state from the device
+//-----------------------------------------------------------------------------
+bool CommandClass::RequestStateForAllInstances
+(
+	uint32 const _requestFlags,
+	Driver::MsgQueue const _queue
+)
+{
+	bool res = false;
+	if( m_createVars )
+	{
+		if( Node* node = GetNodeUnsafe() )
+		{
+			MultiInstance* multiInstance = static_cast<MultiInstance*>( node->GetCommandClass( MultiInstance::StaticGetCommandClassId() ) );
+			if( multiInstance != NULL )
+			{
+				for( Bitfield::Iterator it = m_instances.Begin(); it != m_instances.End(); ++it )
+				{
+					res |= RequestState( _requestFlags, (uint8)*it, _queue );
+				}
+			}
+			else
+			{
+				res = RequestState( _requestFlags, 1, _queue );
+			}
+		}
+	}
+
+	return res;
+}
+
+