ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,277 @@
+//-----------------------------------------------------------------------------
+//
+//	AssociationCommandConfiguration.cpp
+//
+//	Implementation of the COMMAND_CLASS_ASSOCIATION_COMMAND_CONFIGURATION
+//
+//	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 "AssociationCommandConfiguration.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Group.h"
+#include "Driver.h"
+#include "Log.h"
+#include "ValueBool.h"
+#include "ValueByte.h"
+#include "ValueShort.h"
+
+using namespace OpenZWave;
+
+enum AssociationCommandConfigurationCmd
+{
+	AssociationCommandConfigurationCmd_SupportedRecordsGet		= 0x01,
+	AssociationCommandConfigurationCmd_SupportedRecordsReport	= 0x02,
+	AssociationCommandConfigurationCmd_Set						= 0x03,
+	AssociationCommandConfigurationCmd_Get						= 0x04,
+	AssociationCommandConfigurationCmd_Report					= 0x05
+};
+
+enum
+{
+	AssociationCommandConfigurationIndex_MaxCommandLength = 0,
+	AssociationCommandConfigurationIndex_CommandsAreValues,
+	AssociationCommandConfigurationIndex_CommandsAreConfigurable,
+	AssociationCommandConfigurationIndex_NumFreeCommands,
+	AssociationCommandConfigurationIndex_MaxCommands
+};
+
+
+//-----------------------------------------------------------------------------
+// <AssociationCommandConfiguration::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool AssociationCommandConfiguration::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Session )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <AssociationCommandConfiguration::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool AssociationCommandConfiguration::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	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( "AssociationCommandConfigurationCmd_SupportedRecordsGet", 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( AssociationCommandConfigurationCmd_SupportedRecordsGet );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <AssociationCommandConfiguration::RequestCommands>												   
+// Request the command data									   
+//-----------------------------------------------------------------------------
+void AssociationCommandConfiguration::RequestCommands
+(
+	uint8 const _groupIdx,
+	uint8 const _nodeId
+)
+{
+	Msg* msg = new Msg( "AssociationCommandConfigurationCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+	msg->Append( GetNodeId() );
+	msg->Append( 4 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( AssociationCommandConfigurationCmd_Get );
+	msg->Append( _groupIdx );
+	msg->Append( _nodeId );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+}
+
+//-----------------------------------------------------------------------------
+// <AssociationCommandConfiguration::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool AssociationCommandConfiguration::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if (AssociationCommandConfigurationCmd_SupportedRecordsReport == (AssociationCommandConfigurationCmd)_data[0])
+	{
+		uint8 maxCommandLength			=	 _data[1] >> 2;
+		bool commandsAreValues			= ( (_data[1] & 0x02) != 0 );
+		bool commandsAreConfigurable	= ( (_data[1] & 0x01) != 0 );
+		int16 numFreeCommands			= (((int16)_data[2])<<16) | (int16)_data[3];
+		int16 maxCommands				= (((int16)_data[4])<<16) | (int16)_data[5];
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received AssociationCommandConfiguration Supported Records Report:" );
+		Log::Write( LogLevel_Info, GetNodeId(), "    Maximum command length = %d bytes", maxCommandLength );
+		Log::Write( LogLevel_Info, GetNodeId(), "    Maximum number of commands = %d", maxCommands );
+		Log::Write( LogLevel_Info, GetNodeId(), "    Number of free commands = %d", numFreeCommands );
+		Log::Write( LogLevel_Info, GetNodeId(), "    Commands are %s and are %s", commandsAreValues ? "values" : "not values", commandsAreConfigurable ? "configurable" : "not configurable" );
+
+		ValueBool* valueBool;
+		ValueByte* valueByte;
+		ValueShort* valueShort;
+
+		if( (valueByte = static_cast<ValueByte*>( GetValue( _instance, AssociationCommandConfigurationIndex_MaxCommandLength ) )) )
+		{
+			valueByte->OnValueRefreshed( maxCommandLength );
+			valueByte->Release();
+		}
+
+		if( (valueBool = static_cast<ValueBool*>( GetValue( _instance, AssociationCommandConfigurationIndex_CommandsAreValues ) )) )
+		{
+			valueBool->OnValueRefreshed( commandsAreValues );
+			valueBool->Release();
+		}
+
+		if( (valueBool = static_cast<ValueBool*>( GetValue( _instance, AssociationCommandConfigurationIndex_CommandsAreConfigurable ) )) )
+		{
+			valueBool->OnValueRefreshed( commandsAreConfigurable );
+			valueBool->Release();
+		}
+
+		if( (valueShort = static_cast<ValueShort*>( GetValue( _instance, AssociationCommandConfigurationIndex_NumFreeCommands ) )) )
+		{
+			valueShort->OnValueRefreshed( numFreeCommands );
+			valueShort->Release();
+		}
+
+		if( (valueShort = static_cast<ValueShort*>( GetValue( _instance, AssociationCommandConfigurationIndex_MaxCommands ) )) )
+		{
+			valueShort->OnValueRefreshed( maxCommands );
+			valueShort->Release();
+		}
+		return true;
+	}
+	
+	if (AssociationCommandConfigurationCmd_Report == (AssociationCommandConfigurationCmd)_data[0])
+	{
+		uint8 groupIdx		= _data[1];
+		uint8 nodeIdx		= _data[2];
+		bool  firstReports	= ( ( _data[3] & 0x80 ) != 0 );		// True if this is the first message containing commands for this group and node.
+		uint8 numReports	= _data[3] & 0x0f;
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received AssociationCommandConfiguration Report from:" );
+		Log::Write( LogLevel_Info, GetNodeId(), "    Commands for node %d in group %d,", nodeIdx, groupIdx );
+
+		if( Node* node = GetNodeUnsafe() )
+		{
+			Group* group = node->GetGroup( groupIdx );
+			if( NULL == group )
+			{
+				if( firstReports )
+				{
+					// This is the first report message, so we should clear any existing command data
+					group->ClearCommands( nodeIdx );
+				}
+
+				uint8 const* start = &_data[4];
+
+				for( uint8 i=0; i<numReports; ++i )
+				{
+					uint8 length = start[0];
+					group->AddCommand( nodeIdx, length, start+1 );
+					start += length;
+				}
+			}
+		}
+
+		return true;
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <AssociationCommandConfiguration::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void AssociationCommandConfiguration::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+	  	node->CreateValueByte (	ValueID::ValueGenre_System, GetCommandClassId(), _instance, AssociationCommandConfigurationIndex_MaxCommandLength,			"Max Command Length",			"", true, false, 0, 0 );
+		node->CreateValueBool ( ValueID::ValueGenre_System, GetCommandClassId(), _instance, AssociationCommandConfigurationIndex_CommandsAreValues,			"Commands are Values",			"", true, false, false, 0 );
+		node->CreateValueBool ( ValueID::ValueGenre_System, GetCommandClassId(), _instance, AssociationCommandConfigurationIndex_CommandsAreConfigurable,	"Commands are Configurable",	"", true, false, false, 0 );
+		node->CreateValueShort( ValueID::ValueGenre_System, GetCommandClassId(), _instance, AssociationCommandConfigurationIndex_NumFreeCommands,			"Free Commands",				"", true, false, 0, 0 );
+		node->CreateValueShort( ValueID::ValueGenre_System, GetCommandClassId(), _instance, AssociationCommandConfigurationIndex_MaxCommands,				"Max Commands",					"", true, false, 0, 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <AssociationCommandConfiguration::SetCommand>
+// Set a command for the association									   
+//-----------------------------------------------------------------------------
+void AssociationCommandConfiguration::SetCommand
+(
+	uint8 const _groupIdx,
+	uint8 const _nodeId,
+	uint8 const _length,
+	uint8 const* _data
+)
+{
+	Msg* msg = new Msg( "AssociationCommandConfigurationCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+	msg->Append( GetNodeId() );
+	msg->Append( _length + 5 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( AssociationCommandConfigurationCmd_Set );
+	msg->Append( _groupIdx );
+	msg->Append( _nodeId );
+	msg->Append( _length );
+
+	for( uint8 i=0; i<_length; ++i )
+	{
+		msg->Append( _data[i] );
+	}
+
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+}
+
+
+

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

@@ -0,0 +1,70 @@
+//-----------------------------------------------------------------------------
+//
+//	AssociationCommandConfiguration.h
+//
+//	Implementation of the COMMAND_CLASS_ASSOCIATION_COMMAND_CONFIGURATION
+//
+//	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 _AssociationCommandConfiguration_H
+#define _AssociationCommandConfiguration_H
+
+#include "CommandClass.h"
+#include "ValueBool.h"
+#include "ValueByte.h"
+#include "ValueShort.h"
+
+
+namespace OpenZWave
+{
+	/** \brief Implements COMMAND_CLASS_ASSOCIATION_COMMAND_CONFIGURATION (0x9b), a Z-Wave device command class.
+	 */
+
+	class AssociationCommandConfiguration: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new AssociationCommandConfiguration( _homeId, _nodeId ); }
+		virtual ~AssociationCommandConfiguration(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x9b; }		
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_ASSOCIATION_COMMAND_CONFIGURATION"; }
+	
+		void RequestCommands( uint8 const _groupIdx, uint8 const _nodeId );
+		void SetCommand( uint8 const _groupIdx, uint8 const _nodeId, uint8 const _length, uint8 const* _data );
+
+		// 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 );
+
+	protected:
+		virtual void CreateVars( uint8 const _instance );
+
+	private:
+		AssociationCommandConfiguration( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+	};
+
+} // namespace OpenZWave
+
+#endif

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

@@ -0,0 +1,212 @@
+//-----------------------------------------------------------------------------
+//
+//	Basic.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_BASIC
+//
+//	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 "Basic.h"
+#include "Association.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Notification.h"
+#include "Log.h"
+
+#include "ValueByte.h"
+
+using namespace OpenZWave;
+
+enum BasicCmd
+{
+	BasicCmd_Set	= 0x01,
+	BasicCmd_Get	= 0x02,
+	BasicCmd_Report	= 0x03
+};
+
+//-----------------------------------------------------------------------------
+// <Basic::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool Basic::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Dynamic )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Basic::RequestValue>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool Basic::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Msg* msg = new Msg( "BasicCmd_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( BasicCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <Basic::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Basic::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if( BasicCmd_Report == (BasicCmd)_data[0] )
+	{
+		// Level
+		Log::Write( LogLevel_Info, GetNodeId(), "Received Basic report from node %d: level=%d", GetNodeId(), _data[1] );
+		if( ValueByte* value = static_cast<ValueByte*>( GetValue( _instance, 0 ) ) )
+		{
+			value->OnValueRefreshed( _data[1] );
+			value->Release();
+		}
+		return true;
+	}
+
+	if( BasicCmd_Set == (BasicCmd)_data[0] )
+	{
+		// Commmand received from the node.  Handle as a notifcation event
+		Log::Write( LogLevel_Info, GetNodeId(), "Received Basic set from node %d: level=%d.  Sending event notification.", GetNodeId(), _data[1] );
+
+		Notification* notification = new Notification( Notification::Type_NodeEvent );
+		notification->SetHomeAndNodeIds( GetHomeId(), GetNodeId() );
+		notification->SetEvent( _data[1] );
+		GetDriver()->QueueNotification( notification );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Basic::SetValue>
+// Set a value on the Z-Wave device
+//-----------------------------------------------------------------------------
+bool Basic::SetValue
+(
+	Value const& _value
+)
+{
+	if( ValueID::ValueType_Byte == _value.GetID().GetType() )
+	{
+		ValueByte const* value = static_cast<ValueByte const*>(&_value);
+	
+		Log::Write( LogLevel_Info, GetNodeId(), "Basic::Set - Setting node %d to level %d", GetNodeId(), value->GetValue() );
+		Msg* msg = new Msg( "Basic Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );		
+		msg->SetInstance( this, _value.GetID().GetInstance() );
+		msg->Append( GetNodeId() );
+		msg->Append( 3 );
+		msg->Append( GetCommandClassId() );
+		msg->Append( BasicCmd_Set );
+		msg->Append( value->GetValue() );
+		msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+		GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Basic::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void Basic::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+	  	node->CreateValueByte( ValueID::ValueGenre_Basic, GetCommandClassId(), _instance, 0, "Basic", "", false, false, 0, 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <Basic::Set>
+// Helper method to set the level
+//-----------------------------------------------------------------------------
+void Basic::Set
+(
+	uint8 const _level
+)
+{
+	// This may look like a long winded way to do this, but
+	// it ensures that all the proper notifications get sent.
+	if( ValueByte* value = static_cast<ValueByte*>( GetValue( 1, 0 ) ) )
+	{
+		value->Set( _level );
+		value->Release();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// <Basic::SetMapping>
+// Map COMMAND_CLASS_BASIC messages to another command class
+//-----------------------------------------------------------------------------
+bool Basic::SetMapping
+(
+	uint8 const _commandClassId
+)
+{
+	bool res = false;
+
+	if( Node const* node = GetNodeUnsafe() )
+	{
+		if( CommandClass* cc = node->GetCommandClass( _commandClassId ) )
+		{
+			Log::Write( LogLevel_Info, GetNodeId(), "    COMMAND_CLASS_BASIC will be mapped to %s", cc->GetCommandClassName().c_str() );
+			m_mapping = _commandClassId;
+			res = true;
+		}
+	}
+
+	return res;
+}