ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,66 @@
+//-----------------------------------------------------------------------------
+//
+//	NodeNaming.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_NODE_NAMING
+//
+//	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 _NodeNaming_H
+#define _NodeNaming_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	/** \brief Implements COMMAND_CLASS_NODE_NAMING (0x77), a Z-Wave device command class.
+	 */
+	class NodeNaming: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new NodeNaming( _homeId, _nodeId ); }
+		virtual ~NodeNaming(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x77; }		
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_NODE_NAMING"; }
+
+		// 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 );
+
+		void SetName( string const& _name );
+		void SetLocation( string const& _location );
+
+	private:
+		NodeNaming( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+
+		string ExtractString( uint8 const* _data, uint32 const _length );
+		uint32 ConvertUFT16ToUTF8( uint16 _utf16, char* _buffer, uint32 pos );
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,157 @@
+//-----------------------------------------------------------------------------
+//
+//	Powerlevel.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_POWERLEVEL
+//
+//	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 "Powerlevel.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Driver.h"
+#include "Log.h"
+
+using namespace OpenZWave;
+
+enum PowerlevelCmd
+{
+	PowerlevelCmd_Set				= 0x01,
+	PowerlevelCmd_Get				= 0x02,
+	PowerlevelCmd_Report			= 0x03,
+	PowerlevelCmd_TestNodeSet		= 0x04,
+	PowerlevelCmd_TestNodeGet		= 0x05,
+	PowerlevelCmd_TestNodeReport	= 0x06
+};
+
+static char const* c_powerLevelNames[] = 
+{
+	"Normal",
+	"-1dB",
+	"-2dB",
+	"-3dB",
+	"-4dB",
+	"-5dB",
+	"-6dB",
+	"-7dB",
+	"-8dB",
+	"-9dB"
+};
+
+static char const* c_powerLevelStatusNames[] = 
+{
+	"Failed",
+	"Success",
+	"In Progress"
+};
+
+
+//-----------------------------------------------------------------------------
+// <Powerlevel::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Powerlevel::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if( PowerlevelCmd_Report == (PowerlevelCmd)_data[0] )
+	{
+		PowerLevelEnum powerLevel = (PowerLevelEnum)_data[1];
+		uint8 timeout = _data[2];
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received a PowerLevel report: PowerLevel=%s, Timeout=%d", c_powerLevelNames[powerLevel], timeout );
+		return true;
+	}
+
+	if( PowerlevelCmd_TestNodeReport == (PowerlevelCmd)_data[0] )
+	{
+		uint8 testNode = _data[1];
+		PowerLevelStatusEnum status = (PowerLevelStatusEnum)_data[2];
+		uint16 ackCount = (((uint16)_data[3])<<8) | (uint16)_data[4];
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received a PowerLevel Test Node report: Test Node=%d, Status=%s, Test Frame ACK Count=%d", testNode, c_powerLevelStatusNames[status], ackCount );
+		return true;
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Powerlevel::Set>
+// Set the transmit power of a node for a specified time
+//-----------------------------------------------------------------------------
+void Powerlevel::Set
+(
+	PowerLevelEnum _powerLevel,
+	uint8 _timeout
+)
+{
+	if( _powerLevel > PowerLevel_Minus9dB )
+	{
+		return;
+	}
+
+	Log::Write( LogLevel_Info, GetNodeId(), "Setting the power level to %s for %d seconds", c_powerLevelNames[_powerLevel], _timeout );
+	Msg* msg = new Msg( "PowerlevelCmd_Set", 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( PowerlevelCmd_Set );
+	msg->Append( (uint8)_powerLevel );
+	msg->Append( _timeout );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+}
+
+//-----------------------------------------------------------------------------
+// <Powerlevel::Test>
+// Test node to node communications
+//-----------------------------------------------------------------------------
+void Powerlevel::Test
+(
+	uint8 _testNodeId,
+	PowerLevelEnum _powerLevel,
+	uint16 _numFrames
+)
+{
+	if( _powerLevel > PowerLevel_Minus9dB )
+	{
+		return;
+	}
+
+	Log::Write( LogLevel_Info, GetNodeId(), "Running a Power Level Test: Target Node = %d, Power Level = %s, Number of Frames = %d", _testNodeId, c_powerLevelNames[_powerLevel], _numFrames );
+	Msg* msg = new Msg( "PowerlevelCmd_TestNodeSet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
+	msg->Append( GetNodeId() );
+	msg->Append( 6 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( PowerlevelCmd_TestNodeSet );
+	msg->Append( _testNodeId );
+	msg->Append( (uint8)_powerLevel );
+	msg->Append( (uint8)(_numFrames >> 8) );
+	msg->Append( (uint8)(_numFrames & 0x00ff) );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+}
+

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

@@ -0,0 +1,82 @@
+//-----------------------------------------------------------------------------
+//
+//	Powerlevel.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_POWERLEVEL
+//
+//	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 _Powerlevel_H
+#define _Powerlevel_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	/** \brief Implements COMMAND_CLASS_POWERLEVEL (0x73), a Z-Wave device command class.
+	 */
+	class Powerlevel: public CommandClass
+	{
+	public:
+		enum PowerLevelEnum
+		{
+			PowerLevel_Normal = 0,
+			PowerLevel_Minus1dB,
+			PowerLevel_Minus2dB,
+			PowerLevel_Minus3dB,
+			PowerLevel_Minus4dB,
+			PowerLevel_Minus5dB,
+			PowerLevel_Minus6dB,
+			PowerLevel_Minus7dB,
+			PowerLevel_Minus8dB,
+			PowerLevel_Minus9dB
+		};
+
+		enum PowerLevelStatusEnum
+		{
+			PowerLevelStatus_Failed = 0,
+			PowerLevelStatus_Success,
+			PowerLevelStatus_InProgress
+		};
+
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new Powerlevel( _homeId, _nodeId ); }
+		virtual ~Powerlevel(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x73; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_POWERLEVEL"; }
+
+		void Set( PowerLevelEnum _powerLevel, uint8 _timeout );
+		void Test( uint8 _testNodeId, PowerLevelEnum _powerLevel, uint16 _numFrames );
+
+		// From CommandClass
+		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 );
+
+	private:	
+		Powerlevel( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,62 @@
+//-----------------------------------------------------------------------------
+//
+//	Proprietary.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_PROPRIETARY
+//
+//	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 "Proprietary.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Driver.h"
+#include "Log.h"
+
+using namespace OpenZWave;
+
+enum ProprietaryCmd
+{
+	ProprietaryCmd_Set		= 0x01,
+	ProprietaryCmd_Get		= 0x02,
+	ProprietaryCmd_Report	= 0x03
+};
+
+
+//-----------------------------------------------------------------------------
+// <Proprietary::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Proprietary::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if (ProprietaryCmd_Report == (ProprietaryCmd)_data[0])
+	{
+		return true;
+	}
+	return false;
+}
+

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

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+//
+//	Proprietary.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_PROPRIETARY
+//
+//	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 _Proprietary_H
+#define _Proprietary_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	/** \brief Implements COMMAND_CLASS_PROPRIETARY (0x88), a Z-Wave device command class.
+	 */
+	class Proprietary: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new Proprietary( _homeId, _nodeId ); }
+		virtual ~Proprietary(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x88; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_PROPRIETARY"; }
+
+		// From CommandClass
+		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 );
+
+	private:
+		Proprietary( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,177 @@
+//-----------------------------------------------------------------------------
+//
+//	Protection.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_PROTECTION
+//
+//	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 <vector>
+
+#include "CommandClasses.h"
+#include "Protection.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+#include "ValueList.h"
+
+using namespace OpenZWave;
+
+enum ProtectionCmd
+{
+	ProtectionCmd_Set		= 0x01,
+	ProtectionCmd_Get		= 0x02,
+	ProtectionCmd_Report	= 0x03
+};
+
+static char const* c_protectionStateNames[] = 
+{
+	"Unprotected",
+	"Protection by Sequence",
+	"No Operation Possible"
+};
+
+//-----------------------------------------------------------------------------
+// <Protection::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool Protection::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Session )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Protection::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool Protection::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Msg* msg = new Msg( "ProtectionCmd_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( ProtectionCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <Protection::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Protection::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if (ProtectionCmd_Report == (ProtectionCmd)_data[0])
+	{
+		Log::Write( LogLevel_Info, GetNodeId(), "Received a Protection report: %s", c_protectionStateNames[_data[1]] );
+		if( ValueList* value = static_cast<ValueList*>( GetValue( _instance, 0 ) ) )
+		{
+			value->OnValueRefreshed( (int)_data[1] );
+			value->Release();
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Protection::SetValue>
+// Set the device's protection state
+//-----------------------------------------------------------------------------
+bool Protection::SetValue
+(
+	Value const& _value
+)
+{
+	if( ValueID::ValueType_List == _value.GetID().GetType() )
+	{
+		ValueList const* value = static_cast<ValueList const*>(&_value);
+		ValueList::Item const& item = value->GetItem();
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Protection::Set - Setting protection state to '%s'", item.m_label.c_str() );
+		Msg* msg = new Msg( "Protection 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( ProtectionCmd_Set );
+		msg->Append( (uint8)item.m_value );
+		msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+		GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Protection::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void Protection::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+		vector<ValueList::Item> items;
+
+		ValueList::Item item;
+		for( uint8 i=0; i<3; ++i )
+		{
+			item.m_label = c_protectionStateNames[i];
+			item.m_value = i;
+			items.push_back( item ); 
+		}
+
+		node->CreateValueList(  ValueID::ValueGenre_System, GetCommandClassId(), _instance, 0, "Protection", "", false, false, 1, items, 0, 0 );
+	}
+}