ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------------
+//
+//	ControllerReplication.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_CONTROLLER_REPLICATION
+//
+//	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 _ControllerReplication_H
+#define _ControllerReplication_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	/** \brief Implements COMMAND_CLASS_CONTROLLER_REPLICATION (0x21), a Z-Wave device command class.
+	 */
+	class ControllerReplication: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new ControllerReplication( _homeId, _nodeId ); }
+		virtual ~ControllerReplication(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x21; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_CONTROLLER_REPLICATION"; }
+
+		void StartReplication( uint8 const _targetNodeId, uint8 const _funcId );
+		void SendNextData( uint8 const _targetNodeId );
+
+		// 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:
+		ControllerReplication( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+
+		uint8	m_funcId;
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,163 @@
+//-----------------------------------------------------------------------------
+//
+//	EnergyProduction.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_ENERGY_PRODUCTION
+//
+//	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 "EnergyProduction.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+#include "ValueDecimal.h"
+
+using namespace OpenZWave;
+
+enum EnergyProductionCmd
+{
+	EnergyProductionCmd_Get		= 0x02,
+	EnergyProductionCmd_Report	= 0x03
+};
+
+enum 
+{
+	EnergyProductionIndex_Instant = 0,
+	EnergyProductionIndex_Total,
+	EnergyProductionIndex_Today,
+	EnergyProductionIndex_Time
+};
+
+static char const* c_energyParameterNames[] = 
+{
+	"Instant energy production",
+	"Total energy production",
+	"Energy production today",
+	"Total production time"
+};
+
+//-----------------------------------------------------------------------------
+// <EnergyProduction::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool EnergyProduction::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	bool request = false;
+	if( _requestFlags & RequestFlag_Dynamic )
+	{
+		// Request each of the production values
+		request |= RequestValue( _requestFlags, EnergyProductionIndex_Instant, _instance, _queue );
+		request |= RequestValue( _requestFlags, EnergyProductionIndex_Total, _instance, _queue );
+		request |= RequestValue( _requestFlags, EnergyProductionIndex_Today, _instance, _queue );
+		request |= RequestValue( _requestFlags, EnergyProductionIndex_Time, _instance, _queue );
+	}
+
+	return request;
+}
+
+//-----------------------------------------------------------------------------
+// <EnergyProduction::RequestValue>												   
+// Request current production from the device									   
+//-----------------------------------------------------------------------------
+bool EnergyProduction::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _valueEnum,		// one of EnergyProductionIndex enums
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Log::Write( LogLevel_Info, GetNodeId(), "Requesting the %s value", c_energyParameterNames[_valueEnum] );
+	Msg* msg = new Msg( "EnergyProductionCmd_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( 3 );
+	msg->Append( GetCommandClassId() );
+	msg->Append( EnergyProductionCmd_Get );
+	msg->Append( _valueEnum );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <EnergyProduction::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool EnergyProduction::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if (EnergyProductionCmd_Report == (EnergyProductionCmd)_data[0])
+	{
+		uint8 scale;
+		uint8 precision = 0;
+		string value = ExtractValue( &_data[2], &scale, &precision );
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received an Energy production report: %s = %s", c_energyParameterNames[_data[1]], value.c_str() );
+		if( ValueDecimal* decimalValue = static_cast<ValueDecimal*>( GetValue( _instance, _data[1] ) ) )
+		{
+			decimalValue->OnValueRefreshed( value );
+			if( decimalValue->GetPrecision() != precision )
+			{
+				decimalValue->SetPrecision( precision );
+			}
+			decimalValue->Release();
+		}
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <EnergyProduction::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void EnergyProduction::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+	  	node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, (uint8)EnergyProductionIndex_Instant, c_energyParameterNames[EnergyProductionIndex_Instant], "W", true, false, "0.0", 0 );
+		node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, (uint8)EnergyProductionIndex_Total, c_energyParameterNames[EnergyProductionIndex_Total], "kWh", true, false, "0.0", 0 );
+		node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, (uint8)EnergyProductionIndex_Today, c_energyParameterNames[EnergyProductionIndex_Today], "kWh", true, false, "0.0", 0 );
+		node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, (uint8)EnergyProductionIndex_Time, c_energyParameterNames[EnergyProductionIndex_Time], "", true, false, "0.0", 0 );
+	}
+}
+
+
+

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

@@ -0,0 +1,65 @@
+//-----------------------------------------------------------------------------
+//
+//	EnergyProduction.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_ENERGY_PRODUCTION
+//
+//	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 _EnergyProduction_H
+#define _EnergyProduction_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	class ValueDecimal;
+
+	/** \brief Implements COMMAND_CLASS_ENERGY_PRODUCTION (0x90), a Z-Wave device command class.
+	 */
+	class EnergyProduction: public CommandClass
+	{
+	public:
+ 		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new EnergyProduction( _homeId, _nodeId ); }
+		virtual ~EnergyProduction(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x90; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_ENERGY_PRODUCTION"; }
+
+		// From CommandClass
+		virtual bool RequestState( uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue );
+		virtual bool RequestValue( uint32 const _requestFlags, uint8 const _valueEnum, 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 );
+
+	protected:
+		virtual void CreateVars( uint8 const _instance );
+
+	private:
+		EnergyProduction( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------------
+//
+//	Hail.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_HAIL
+//
+//	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 "Hail.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+using namespace OpenZWave;
+
+enum HailCmdEnum
+{
+	HailCmd_Hail = 1
+};
+
+
+//-----------------------------------------------------------------------------
+// <Hail::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Hail::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if( HailCmd_Hail == _data[0] )
+	{
+		// We have received a hail from the Z-Wave device.
+		// Request an update of the dynamic values.
+		Log::Write( LogLevel_Info, GetNodeId(), "Received Hail command from node %d", GetNodeId() );
+		if( Node* node = GetNodeUnsafe() )
+		{
+			node->RequestDynamicValues();
+		}
+		return true;
+	}
+	return false;
+}
+

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

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

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

@@ -0,0 +1,159 @@
+//-----------------------------------------------------------------------------
+//
+//	Indicator.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_INDICATOR
+//
+//	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 "Indicator.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+#include "ValueByte.h"
+
+using namespace OpenZWave;
+
+enum IndicatorCmd
+{
+	IndicatorCmd_Set	= 0x01,
+	IndicatorCmd_Get	= 0x02,
+	IndicatorCmd_Report	= 0x03
+};
+
+//-----------------------------------------------------------------------------
+// <Indicator::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool Indicator::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Dynamic )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Indicator::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool Indicator::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Msg* msg = new Msg( "IndicatorCmd_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( IndicatorCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <Indicator::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Indicator::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if( IndicatorCmd_Report == (IndicatorCmd)_data[0] )
+	{
+		Log::Write( LogLevel_Info, GetNodeId(), "Received an Indicator report: Indicator=%d", _data[1] );
+
+		if( ValueByte* value = static_cast<ValueByte*>( GetValue( _instance, 0 ) ) )
+		{
+			value->OnValueRefreshed( _data[1] != 0 );
+			value->Release();
+		}
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Indicator::SetValue>
+// Set the device's indicator value 
+//-----------------------------------------------------------------------------
+bool Indicator::SetValue
+(
+	Value const& _value
+)
+{
+	if( ValueID::ValueType_Byte == _value.GetID().GetType() )
+	{
+		ValueByte const* value = static_cast<ValueByte const*>(&_value);
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Indicator::SetValue - Setting indicator to %d", 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( IndicatorCmd_Set );
+		msg->Append( value->GetValue() );
+		msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+		GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Indicator::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void Indicator::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+	  	node->CreateValueByte( ValueID::ValueGenre_User, GetCommandClassId(), _instance, 0, "Indicator", "", false, false, false, 0 );
+	}
+}
+
+