ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------------
+//
+//	ThermostatSetpoint.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_THERMOSTAT_SETPOINT
+//
+//	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 _ThermostatSetpoint_H
+#define _ThermostatSetpoint_H
+
+#include <vector>
+#include <string>
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	class ValueDecimal;
+
+	/** \brief Implements COMMAND_CLASS_THERMOSTAT_SETPOINT (0x43), a Z-Wave device command class.
+	 */
+	class ThermostatSetpoint: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new ThermostatSetpoint( _homeId, _nodeId ); }
+		virtual ~ThermostatSetpoint(){} 
+
+		static uint8 const StaticGetCommandClassId(){ return 0x43; }		
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_THERMOSTAT_SETPOINT"; }
+
+		// From CommandClass
+		virtual void ReadXML( TiXmlElement const* _ccElement );
+		virtual void WriteXML( TiXmlElement* _ccElement );
+		virtual bool RequestState( uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue );
+		virtual bool RequestValue( uint32 const _requestFlags, uint8 const _setPointIndex, uint8 const _dummy, 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 );
+
+	public:
+		virtual void CreateVars( uint8 const _instance, uint8 const _index );
+
+	private:
+		ThermostatSetpoint( uint32 const _homeId, uint8 const _nodeId );
+		uint8 m_setPointBase;
+	};
+
+} // namespace OpenZWave
+
+#endif
+
+
+

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

@@ -0,0 +1,255 @@
+//-----------------------------------------------------------------------------
+//
+//	Version.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_VERSION
+//
+//	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 "Version.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Driver.h"
+#include "Node.h"
+#include "Log.h"
+
+#include "ValueString.h"
+
+using namespace OpenZWave;
+
+enum VersionCmd
+{
+	VersionCmd_Get					= 0x11,
+	VersionCmd_Report				= 0x12,
+	VersionCmd_CommandClassGet		= 0x13,
+	VersionCmd_CommandClassReport	= 0x14
+};
+
+enum
+{
+	VersionIndex_Library = 0,
+	VersionIndex_Protocol,
+	VersionIndex_Application
+};
+
+//-----------------------------------------------------------------------------
+// <Version::Version>
+// Constructor
+//-----------------------------------------------------------------------------
+Version::Version
+(
+	uint32 const _homeId,
+	uint8 const _nodeId
+):
+	CommandClass( _homeId, _nodeId ), m_classGetSupported( true )
+{
+	SetStaticRequest( StaticRequest_Values );
+}
+
+//-----------------------------------------------------------------------------
+// <Version::ReadXML>
+// Read configuration.
+//-----------------------------------------------------------------------------
+void Version::ReadXML
+( 
+	TiXmlElement const* _ccElement
+)
+{
+	CommandClass::ReadXML( _ccElement );
+
+	char const* str = _ccElement->Attribute("classgetsupported");
+	if( str )
+	{
+		m_classGetSupported = !strcmp( str, "true");
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <Version::WriteXML>
+// Save changed configuration
+//-----------------------------------------------------------------------------
+void Version::WriteXML
+( 
+	TiXmlElement* _ccElement
+)
+{
+	CommandClass::WriteXML( _ccElement );
+
+	if( !m_classGetSupported )
+	{
+		_ccElement->SetAttribute( "classgetsupported", "false" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <Version::RequestState>
+// Request current state from the device
+//-----------------------------------------------------------------------------
+bool Version::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( ( _requestFlags & RequestFlag_Static ) && HasStaticRequest( StaticRequest_Values ) )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Version::RequestValue>
+// Request current value from the device
+//-----------------------------------------------------------------------------
+bool Version::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,		// = 0
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _instance != 1 )
+	{
+		// This command class doesn't work with multiple instances
+		return false;
+	}
+
+	Msg* msg = new Msg( "VersionCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+	msg->Append( GetNodeId() );
+	msg->Append( 2 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( VersionCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <Version::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Version::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+		if( VersionCmd_Report == (VersionCmd)_data[0] )
+		{
+			char library[8];
+			char protocol[16];
+			char application[16];
+
+			snprintf( library, sizeof(library), "%d", _data[1] );
+			snprintf( protocol, sizeof(protocol), "%d.%.2d", _data[2], _data[3] );
+			snprintf( application, sizeof(application), "%d.%.2d", _data[4], _data[5] );
+
+			Log::Write( LogLevel_Info, GetNodeId(), "Received Version report from node %d: Library=%s, Protocol=%s, Application=%s", GetNodeId(), library, protocol, application );
+			ClearStaticRequest( StaticRequest_Values );
+
+			if( ValueString* libraryValue = static_cast<ValueString*>( GetValue( _instance, VersionIndex_Library ) ) )
+			{
+				libraryValue->OnValueRefreshed( library );
+				libraryValue->Release();
+			}
+			if( ValueString* protocolValue = static_cast<ValueString*>( GetValue( _instance, VersionIndex_Protocol ) ) )
+			{
+				protocolValue->OnValueRefreshed( protocol );
+				protocolValue->Release();
+			}
+			if( ValueString* applicationValue = static_cast<ValueString*>( GetValue( _instance, VersionIndex_Application ) ) )
+			{
+				applicationValue->OnValueRefreshed( application );
+				applicationValue->Release();
+			}
+
+			return true;
+		}
+	
+		if (VersionCmd_CommandClassReport == (VersionCmd)_data[0])
+		{
+			if( CommandClass* pCommandClass = node->GetCommandClass( _data[1] ) )
+			{
+				Log::Write( LogLevel_Info, GetNodeId(), "Received Command Class Version report from node %d: CommandClass=%s, Version=%d", GetNodeId(), pCommandClass->GetCommandClassName().c_str(), _data[2] );
+				pCommandClass->ClearStaticRequest( StaticRequest_Version );
+				pCommandClass->SetVersion( _data[2] );
+			}
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Version::RequestCommandClassVersion>
+// Request the version of a command class used by the device 
+//-----------------------------------------------------------------------------
+bool Version::RequestCommandClassVersion
+(
+	CommandClass const* _commandClass
+)
+{
+	if( m_classGetSupported )
+	{
+		if( _commandClass->HasStaticRequest( StaticRequest_Version ) )
+		{
+			Msg* msg = new Msg( "VersionCmd_CommandClassGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+			msg->Append( GetNodeId() );
+			msg->Append( 3 );
+			msg->Append( GetCommandClassId() );
+			msg->Append( VersionCmd_CommandClassGet );
+			msg->Append( _commandClass->GetCommandClassId() );
+			msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+			GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Version::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void Version::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+	  	node->CreateValueString( ValueID::ValueGenre_System, GetCommandClassId(), _instance, VersionIndex_Library, "Library Version", "", true, false, "Unknown", 0 );
+		node->CreateValueString( ValueID::ValueGenre_System, GetCommandClassId(), _instance, VersionIndex_Protocol, "Protocol Version", "", true, false, "Unknown", 0 );
+		node->CreateValueString( ValueID::ValueGenre_System, GetCommandClassId(), _instance, VersionIndex_Application, "Application Version", "", true, false, "Unknown", 0 );
+	}
+}

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

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------------
+//
+//	Version.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_VERSION
+//
+//	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 _Version_H
+#define _Version_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	class ValueString;
+
+	/** \brief Implements COMMAND_CLASS_VERSION (0x86), a Z-Wave device command class.
+	 */
+	class Version: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new Version( _homeId, _nodeId ); }
+		virtual ~Version(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x86; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_VERSION"; }
+
+		bool RequestCommandClassVersion( CommandClass const* _commandClass );
+
+		// From CommandClass
+		virtual void ReadXML( TiXmlElement const* _ccElement );
+		virtual void WriteXML( TiXmlElement* _ccElement );
+		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 );
+
+	protected:
+		virtual void CreateVars( uint8 const _instance );
+
+	private:
+		Version( uint32 const _homeId, uint8 const _nodeId );
+
+		bool m_classGetSupported;
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,391 @@
+//-----------------------------------------------------------------------------
+//
+//	WakeUp.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_WAKE_UP
+//
+//	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 "WakeUp.h"
+#include "MultiCmd.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Driver.h"
+#include "Node.h"
+#include "Log.h"
+#include "Mutex.h"
+#include "ValueInt.h"
+
+using namespace OpenZWave;
+
+enum WakeUpCmd
+{
+	WakeUpCmd_IntervalSet		= 0x04,
+	WakeUpCmd_IntervalGet		= 0x05,
+	WakeUpCmd_IntervalReport	= 0x06,
+	WakeUpCmd_Notification		= 0x07,
+	WakeUpCmd_NoMoreInformation	= 0x08
+};
+
+
+//-----------------------------------------------------------------------------
+// <WakeUp::WakeUp>
+// Constructor
+//-----------------------------------------------------------------------------
+WakeUp::WakeUp
+( 
+	uint32 const _homeId,
+	uint8 const _nodeId 
+):
+	CommandClass( _homeId, _nodeId ), 
+	m_mutex( new Mutex() ),
+	m_awake( true ),
+	m_pollRequired( false ),
+	m_notification( false )
+{
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::~WakeUp>
+// Destructor
+//-----------------------------------------------------------------------------
+WakeUp::~WakeUp
+( 
+)
+{
+	m_mutex->Release();
+	while( !m_pendingQueue.empty() )
+	{
+		Driver::MsgQueueItem const& item = m_pendingQueue.front();
+		if( Driver::MsgQueueCmd_SendMsg == item.m_command )
+		{
+			delete item.m_msg;
+		}
+		m_pendingQueue.pop_front();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::Init>
+// Starts the process of requesting node state from a sleeping device
+//-----------------------------------------------------------------------------
+void WakeUp::Init
+( 
+)
+{
+	// Request the wake up interval.  When we receive the response, we
+	// can send a set interval message with the same interval, but with
+	// the target node id set to that of the controller.  This will ensure
+	// that the controller will receive the wake-up notifications from
+	// the device.  Once this is done, we can request the rest of the node
+	// state.
+	RequestState( CommandClass::RequestFlag_Session, 1, Driver::MsgQueue_Send );
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::RequestState>
+// Nothing to do for wakeup
+//-----------------------------------------------------------------------------
+bool WakeUp::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Session )
+	{
+		Node* node = GetNodeUnsafe();
+		if( node != NULL && !node->IsController() )
+		{
+			return RequestValue( _requestFlags, 0, _instance, _queue );
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::RequestValue>
+// Nothing to do for wakeup
+//-----------------------------------------------------------------------------
+bool WakeUp::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _instance != 1 )
+	{
+		// This command class doesn't work with multiple instances
+		return false;
+	}
+
+	// We won't get a response until the device next wakes up
+	Msg* msg = new Msg( "WakeUpCmd_IntervalGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+	msg->Append( GetNodeId() );
+	msg->Append( 2 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( WakeUpCmd_IntervalGet );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool WakeUp::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if( WakeUpCmd_IntervalReport == (WakeUpCmd)_data[0] )
+	{	
+		if( ValueInt* value = static_cast<ValueInt*>( GetValue( _instance, 0 ) ) )
+		{
+			// some interval reports received are validly formatted (proper checksum, etc.) but only have length
+			// of 3 (0x84 (classid), 0x06 (IntervalReport), 0x00).  Not sure what this means
+			if( _length < 6 )
+			{
+				Log::Write( LogLevel_Warning, "" );
+				Log::Write( LogLevel_Warning, GetNodeId(), "Unusual response: WakeUpCmd_IntervalReport with len = %d.  Ignored.", _length );
+				value->Release();
+				return false;
+			}
+
+			uint32 interval = ((uint32)_data[1]) << 16;
+			interval |= (((uint32)_data[2]) << 8);
+			interval |= (uint32)_data[3];
+
+			uint8 targetNodeId = _data[4];
+
+			Log::Write( LogLevel_Info, GetNodeId(), "Received Wakeup Interval report from node %d: Interval=%d, Target Node=%d", GetNodeId(), interval, targetNodeId );
+
+			value->OnValueRefreshed( (int32)interval );
+		
+			// Ensure that the target node for wake-up notifications is the controller
+			if( GetDriver()->GetNodeId() != targetNodeId )
+			{
+				SetValue( *value );	
+			}
+			value->Release();
+ 		}
+		return true;
+	}
+	else if( WakeUpCmd_Notification == (WakeUpCmd)_data[0] )
+	{	
+		// The device is awake.
+		Log::Write( LogLevel_Info, GetNodeId(), "Received Wakeup Notification from node %d", GetNodeId() );
+		m_notification = true;
+		SetAwake( true );				
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::SetValue>
+// Set the device's wakeup interval
+//-----------------------------------------------------------------------------
+bool WakeUp::SetValue
+(
+	Value const& _value
+)
+{
+	if( ValueID::ValueType_Int == _value.GetID().GetType() )
+	{
+		ValueInt const* value = static_cast<ValueInt const*>(&_value);
+	
+		Msg* msg = new Msg( "Wakeup Interval Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
+		msg->Append( GetNodeId() );
+		
+		if( GetNodeUnsafe()->GetCommandClass( MultiCmd::StaticGetCommandClassId() ) )
+		{
+			msg->Append( 10 );
+			msg->Append( MultiCmd::StaticGetCommandClassId() );
+			msg->Append( MultiCmd::MultiCmdCmd_Encap );
+			msg->Append( 1 );
+		}
+
+		int32 interval = value->GetValue();
+
+		msg->Append( 6 );	// length of command bytes following
+		msg->Append( GetCommandClassId() );
+		msg->Append( WakeUpCmd_IntervalSet );
+		msg->Append( (uint8)(( interval >> 16 ) & 0xff) ); 
+		msg->Append( (uint8)(( interval >> 8 ) & 0xff) );	 
+		msg->Append( (uint8)( interval & 0xff ) );		
+		msg->Append( GetDriver()->GetNodeId() );
+		msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+		GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::SetAwake>
+// Set whether the device is likely to be awake
+//-----------------------------------------------------------------------------
+void WakeUp::SetAwake
+(
+	bool _state
+)
+{
+	if( m_awake != _state )
+	{
+		m_awake = _state;
+		Log::Write( LogLevel_Info, GetNodeId(), "  Node %d has been marked as %s", GetNodeId(), m_awake ? "awake" : "asleep" );
+	}
+
+	if( m_awake )
+	{
+		// If the device is marked for polling, request the current state
+		if( m_pollRequired )
+		{
+			if( Node* node = GetNodeUnsafe() )
+			{
+				node->SetQueryStage( Node::QueryStage_Dynamic );
+			}
+			m_pollRequired = false;
+		}
+			
+		// Send all pending messages
+		SendPending();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::QueueMsg>
+// Add a Z-Wave message to the queue
+//-----------------------------------------------------------------------------
+void WakeUp::QueueMsg
+(
+	Driver::MsgQueueItem const& _item
+)
+{
+	m_mutex->Lock();
+
+	// See if there is already a copy of this message in the queue.  If so, 
+	// we delete it.  This is to prevent duplicates building up if the 
+	// device does not wake up very often.  Deleting the original and
+	// adding the copy to the end avoids problems with the order of
+	// commands such as on and off.
+	list<Driver::MsgQueueItem>::iterator it = m_pendingQueue.begin();
+	while( it != m_pendingQueue.end() )
+	{
+		Driver::MsgQueueItem const& item = *it;
+		if( item == _item )
+		{
+			// Duplicate found
+			if( Driver::MsgQueueCmd_SendMsg == item.m_command )
+			{
+				delete item.m_msg;
+			}
+			m_pendingQueue.erase( it++ );
+		}
+		else
+		{
+			++it;
+		}
+	}
+	m_pendingQueue.push_back( _item );
+	m_mutex->Unlock();
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::SendPending>
+// The device is awake, so send all the pending messages
+//-----------------------------------------------------------------------------
+void WakeUp::SendPending
+(
+)
+{
+	m_awake = true;
+
+	m_mutex->Lock();
+	list<Driver::MsgQueueItem>::iterator it = m_pendingQueue.begin();
+	while( it != m_pendingQueue.end() )
+	{	
+		Driver::MsgQueueItem const& item = *it;
+		if( Driver::MsgQueueCmd_SendMsg == item.m_command )
+		{
+			GetDriver()->SendMsg( item.m_msg, Driver::MsgQueue_WakeUp );
+		}
+		else if( Driver::MsgQueueCmd_QueryStageComplete == item.m_command )
+		{
+			GetDriver()->SendQueryStageComplete( item.m_nodeId, item.m_queryStage, Driver::MsgQueue_WakeUp );
+		}
+		it = m_pendingQueue.erase( it );
+	}
+	m_mutex->Unlock();
+
+	// Send the device back to sleep, unless we have outstanding queries.
+	bool sendToSleep = m_notification;
+	if( Node* node = GetNodeUnsafe() )
+	{
+		if( !node->AllQueriesCompleted() )
+		{
+			sendToSleep = false;
+		}
+	}
+
+	if( sendToSleep )
+	{
+		m_notification = false;
+		Msg* msg = new Msg( "Wakeup - No More Information  (send to sleep)", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
+		msg->Append( GetNodeId() );
+		msg->Append( 2 );
+		msg->Append( GetCommandClassId() );
+		msg->Append( WakeUpCmd_NoMoreInformation );
+		msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+		GetDriver()->SendMsg( msg, Driver::MsgQueue_WakeUp );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <WakeUp::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void WakeUp::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+		if( !node->IsController() )	// We don't add the interval value for controllers, because they don't appear to ever wake up on their own.
+		{
+		  	node->CreateValueInt( ValueID::ValueGenre_System, GetCommandClassId(), _instance, 0, "Wake-up Interval", "Seconds", false, false, 3600, 0 );
+		}
+	}
+}
+