ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------------
+//
+//	ManufacturerSpecific.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_MANUFACTURER_SPECIFIC
+//
+//	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 _ManufacturerSpecific_H
+#define _ManufacturerSpecific_H
+
+#include <map>
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	/** \brief Implements COMMAND_CLASS_MANUFACTURER_SPECIFIC (0x72), a Z-Wave device command class.
+	 */
+	class ManufacturerSpecific: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new ManufacturerSpecific( _homeId, _nodeId ); }
+		virtual ~ManufacturerSpecific(){ UnloadProductXML(); }
+
+		static uint8 const StaticGetCommandClassId(){ return 0x72; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_MANUFACTURER_SPECIFIC"; }
+
+		// 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 );
+
+		static string SetProductDetails( Node *_node, uint16 _manufacturerId, uint16 _productType, uint16 _productId );
+		static bool LoadConfigXML( Node* _node, string const& _configXML );
+		
+		void ReLoadConfigXML();
+
+	private:
+		ManufacturerSpecific( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){ SetStaticRequest( StaticRequest_Values ); }
+		static bool LoadProductXML();
+		static void UnloadProductXML();
+
+		class Product
+		{
+		public:
+			Product
+			( 
+				uint16 _manufacturerId,
+				uint16 _productType,
+				uint16 _productId,
+				string const& _productName,
+				string const& _configPath
+			):	
+				m_manufacturerId( _manufacturerId ),
+				m_productType( _productType ),
+				m_productId( _productId ),
+				m_productName( _productName ),
+				m_configPath( _configPath )
+			{
+			}
+
+			int64 GetKey()const
+			{
+				return( GetKey( m_manufacturerId, m_productType, m_productId ) );
+			}
+
+			static int64 GetKey( uint16 _manufacturerId, uint16 _productType, uint16 _productId )
+			{
+				int64 key = (((int64)_manufacturerId)<<32) | (((int64)_productType)<<16) | (int64)_productId;
+				return key;
+			}
+
+			uint16 GetManufacturerId()const{ return m_manufacturerId; }
+			uint16 GetProductType()const{ return m_productType; }
+			uint16 GetProductId()const{ return m_productId; }
+			string GetProductName()const{ return m_productName; }
+			string GetConfigPath()const{ return m_configPath; }
+
+		private:
+			uint16	m_manufacturerId;
+			uint16	m_productType;
+			uint16	m_productId;
+			string	m_productName;
+			string	m_configPath;
+		};
+
+		static map<uint16,string>	s_manufacturerMap;
+		static map<int64,Product*>	s_productMap;
+		static bool					s_bXmlLoaded;
+	};
+
+} // namespace OpenZWave
+
+#endif
+

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

@@ -0,0 +1,541 @@
+//-----------------------------------------------------------------------------
+//
+//	Meter.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_METER
+//
+//	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 "Meter.h"
+#include "MultiInstance.h"
+#include "Defs.h"
+#include "Bitfield.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+#include "ValueDecimal.h"
+#include "ValueList.h"
+#include "ValueButton.h"
+#include "ValueInt.h"
+#include "ValueBool.h"
+
+using namespace OpenZWave;
+
+enum MeterCmd
+{
+	MeterCmd_Get				= 0x01,
+	MeterCmd_Report				= 0x02,
+	// Version 2
+	MeterCmd_SupportedGet		= 0x03,
+	MeterCmd_SupportedReport	= 0x04,
+	MeterCmd_Reset				= 0x05
+};
+
+enum MeterType
+{
+	MeterType_Electric = 1,
+	MeterType_Gas,
+	MeterType_Water
+};
+
+enum
+{
+	MeterIndex_Exporting = 32,
+	MeterIndex_Reset
+};
+
+
+static char const* c_meterTypes[] = 
+{
+	"Unknown",
+	"Electric",
+	"Gas",
+	"Water"
+};
+
+static char const* c_electricityUnits[] = 
+{
+	"kWh",
+	"kVAh",
+	"W",
+	"pulses",
+	"V",
+	"A",
+	"Power Factor",
+	""
+};
+
+static char const* c_gasUnits[] = 
+{
+	"cubic meters",
+	"cubic feet",
+	"",
+	"pulses"
+	"",
+	"",
+	"",
+	""
+};
+
+static char const* c_waterUnits[] = 
+{
+	"cubic meters",
+	"cubic feet",
+	"US gallons",
+	"pulses"
+	"",
+	"",
+	"",
+	""
+};
+
+static char const* c_electricityLabels[] = 
+{
+	"Energy",
+	"Energy",
+	"Power",
+	"Count",
+	"Voltage",
+	"Current",
+	"Power Factor",
+	"Unknown"
+};
+
+//-----------------------------------------------------------------------------
+// <Meter::Meter>												   
+// Constructor
+//-----------------------------------------------------------------------------
+Meter::Meter
+(
+	uint32 const _homeId,
+	uint8 const _nodeId
+):
+	CommandClass( _homeId, _nodeId ),
+	m_scale( 0 )
+{
+	SetStaticRequest( StaticRequest_Values );
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool Meter::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	bool res = false;
+	if( GetVersion() > 1 )
+	{
+		if( _requestFlags & RequestFlag_Static )
+		{
+ 			Msg* msg = new Msg( "MeterCmd_SupportedGet", 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( MeterCmd_SupportedGet );
+			msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+			GetDriver()->SendMsg( msg, _queue );
+			res = true;
+		}
+	}
+
+	if( _requestFlags & RequestFlag_Dynamic )
+	{
+		res |= RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return res;
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool Meter::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	bool res = false;
+	for( uint8 i=0; i<8; ++i )
+	{
+		uint8 baseIndex = i<<2;
+
+		Value* value = GetValue( _instance, baseIndex );
+		if( value != NULL )
+		{
+			value->Release();
+			Msg* msg = new Msg( "MeterCmd_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( MeterCmd_Get );
+			msg->Append( (uint8)( i << 3 ) );
+			msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+			GetDriver()->SendMsg( msg, _queue );
+			res |= true;
+		}
+	}
+	return res;
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool Meter::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	bool handled = false;
+	if (MeterCmd_SupportedReport == (MeterCmd)_data[0])
+	{
+		handled = HandleSupportedReport( _data, _length, _instance );
+	}
+	else if (MeterCmd_Report == (MeterCmd)_data[0])
+	{
+		handled = HandleReport( _data, _length, _instance );
+	}
+
+	return handled;
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::HandleSupportedReport>
+// Create the values for this command class based on the reported parameters
+//-----------------------------------------------------------------------------
+bool Meter::HandleSupportedReport
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance
+)
+{
+	bool canReset = ((_data[1] & 0x80) != 0);
+	MeterType meterType = (MeterType)(_data[1] & 0x1f);
+
+	ClearStaticRequest( StaticRequest_Version );
+	if( Node* node = GetNodeUnsafe() )
+	{
+		string msg;
+		string valueLabel;
+
+		msg = c_meterTypes[meterType];
+		msg += ": ";
+		// Create the list of supported scales
+		uint8 scaleSupported = _data[2];
+		if( GetVersion() == 2 )
+		{
+			// Only four scales are allowed in version 2
+			scaleSupported &= 0x0f;
+		}
+
+		for( uint8 i=0; i<8; ++i )
+		{
+			if( scaleSupported & (1<<i) )
+			{
+				uint8 baseIndex = i<<2;		// We leave space between the value indices to insert previous and time delta values if we need to later on.
+				switch( meterType )
+				{
+					case MeterType_Electric:
+					{
+						if( ValueDecimal* value = static_cast<ValueDecimal*>( GetValue( _instance, baseIndex ) ) )
+						{
+							value->SetLabel( c_electricityLabels[i] );
+							value->SetUnits( c_electricityUnits[i] );
+							value->Release();
+						}
+						else
+						{
+							node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, baseIndex, c_electricityLabels[i], c_electricityUnits[i], true, false, "0.0", 0 );
+						}
+						if( i != 0 )
+							msg += ", ";
+						msg += c_electricityUnits[i];
+						break;
+					}
+					case MeterType_Gas:
+					{
+						if( ValueDecimal* value = static_cast<ValueDecimal*>( GetValue( _instance, baseIndex ) ) )
+						{
+							value->SetLabel( "Gas" );
+							value->SetUnits( c_gasUnits[i] );
+							value->Release();
+						}
+						else
+						{
+							node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, baseIndex, "Gas", c_gasUnits[i], true, false, "0.0", 0 );
+						}
+						if( i != 0 )
+							msg += ", ";
+						msg += c_gasUnits[i];
+						break;
+					}
+					case MeterType_Water:
+					{
+						if( ValueDecimal* value = static_cast<ValueDecimal*>( GetValue( _instance, baseIndex ) ) )
+						{
+							value->SetLabel( "Water" );
+							value->SetUnits( c_waterUnits[i] );
+							value->Release();
+						}
+						else
+						{
+							node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, baseIndex, "Water", c_waterUnits[i], true, false, "0.0", 0 );
+						}
+						if( i != 0 )
+							msg += ", ";
+						msg += c_waterUnits[i];
+						break;
+					}
+					default:
+					{
+						break;
+					}
+				}
+			}
+		}
+
+		// Create the export flag
+		node->CreateValueBool( ValueID::ValueGenre_User, GetCommandClassId(), _instance, MeterIndex_Exporting, "Exporting", "", true, false, false, 0 );
+
+		// Create the reset button
+		if( canReset )
+		{
+			node->CreateValueButton( ValueID::ValueGenre_System, GetCommandClassId(), _instance, MeterIndex_Reset, "Reset", 0 );
+		}
+
+		Log::Write( LogLevel_Info, GetNodeId(), "Received Meter supported report from node %d, %s", GetNodeId(), msg.c_str() );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::HandleReport>
+// Read the reported meter value
+//-----------------------------------------------------------------------------
+bool Meter::HandleReport
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance
+)
+{
+	// Import or Export (only valid in version > 1)
+	bool exporting = false;
+	if( GetVersion() > 1 )
+	{
+		exporting = ((_data[1] & 0x60) == 0x40 );
+		if( ValueBool* value = static_cast<ValueBool*>( GetValue( _instance, MeterIndex_Exporting ) ) )
+		{
+			value->OnValueRefreshed( exporting );
+			value->Release();
+		}
+	}
+
+	// Get the value and scale
+	uint8 scale;
+	uint8 precision = 0;
+	string valueStr = ExtractValue( &_data[2], &scale, &precision );
+
+	if( GetVersion() == 1 )
+	{
+		// In version 1, we don't know the scale until we get the first value report
+		string label;
+		string units;
+
+		switch( (MeterType)(_data[1] & 0x1f) )
+		{ 
+			case MeterType_Electric:
+			{
+				// Electricity Meter
+				label = c_electricityLabels[scale];
+				units = c_electricityUnits[scale];
+				break;
+			}
+			case MeterType_Gas:
+			{
+				// Gas Meter
+				label = "Gas";
+				units = c_gasUnits[scale];
+				break;
+			}
+			case MeterType_Water:
+			{
+				// Water Meter
+				label = "Water";
+				units = c_waterUnits[scale];
+				break;
+			}
+			default:
+			{
+				break;
+			}
+		}
+
+		if( ValueDecimal* value = static_cast<ValueDecimal*>( GetValue( _instance, 0 ) ) )
+		{
+			Log::Write( LogLevel_Info, GetNodeId(), "Received Meter report from node %d: %s=%s%s", GetNodeId(), label.c_str(), valueStr.c_str(), units.c_str() );
+			value->SetLabel( label );
+			value->SetUnits( units );
+			value->OnValueRefreshed( valueStr );
+			if( value->GetPrecision() != precision )
+			{
+				value->SetPrecision( precision );
+			}
+			value->Release();
+		}
+	}
+	else
+	{
+		// Version 2 and above
+		uint8 baseIndex = scale << 2;
+		if( GetVersion() > 2 )
+		{
+			// In version 3, an extra scale bit is stored in the meter type byte.
+			scale |= ((_data[1]&0x80)>>5);
+			baseIndex = scale << 2;
+		}
+
+		if( ValueDecimal* value = static_cast<ValueDecimal*>( GetValue( _instance, baseIndex ) ) )
+		{
+			Log::Write( LogLevel_Info, GetNodeId(), "Received Meter report from node %d: %s%s=%s%s", GetNodeId(), exporting ? "Exporting ": "", value->GetLabel().c_str(), valueStr.c_str(), value->GetUnits().c_str() );
+			value->OnValueRefreshed( valueStr );
+			if( value->GetPrecision() != precision )
+			{
+				value->SetPrecision( precision );
+			}
+			value->Release();
+
+			// Read any previous value and time delta
+			uint8 size = _data[2] & 0x07;
+			uint16 delta = (uint16)( (_data[3+size]<<8) | _data[4+size]);
+
+			if( delta )
+			{
+				// There is only a previous value if the time delta is non-zero
+				ValueDecimal* previous = static_cast<ValueDecimal*>( GetValue( _instance, baseIndex+1 ) );
+				if( NULL == previous )
+				{
+					// We need to create a value to hold the previous
+					if( Node* node = GetNodeUnsafe() )
+					{
+						node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, baseIndex+1, "Previous Reading", value->GetUnits().c_str(), true, false, "0.0", 0 );
+						previous = static_cast<ValueDecimal*>( GetValue( _instance, baseIndex+1 ) );
+					}
+				}
+				if( previous )
+				{
+					precision = 0;
+					valueStr = ExtractValue( &_data[2], &scale, &precision, 3+size );
+					Log::Write( LogLevel_Info, GetNodeId(), "    Previous value was %s%s, received %d seconds ago.", valueStr.c_str(), previous->GetUnits().c_str(), delta );
+					previous->OnValueRefreshed( valueStr );
+					if( previous->GetPrecision() != precision )
+					{
+						previous->SetPrecision( precision );
+					}
+					previous->Release();
+				}
+
+				// Time delta
+				ValueInt* interval = static_cast<ValueInt*>( GetValue( _instance, baseIndex+2 ) );
+				if( NULL == interval )
+				{
+					// We need to create a value to hold the time delta
+					if( Node* node = GetNodeUnsafe() )
+					{
+						node->CreateValueInt( ValueID::ValueGenre_User, GetCommandClassId(), _instance, baseIndex+2, "Interval", "seconds", true, false, 0, 0 );
+						interval = static_cast<ValueInt*>( GetValue( _instance, baseIndex+2 ) );
+					}
+				}
+				if( interval )
+				{
+		 			interval->OnValueRefreshed( (int32)delta );
+					interval->Release();
+				}
+			}
+		}
+	}
+ 
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::SetValue>
+// Set the device's scale, or reset its accumulated values.
+//-----------------------------------------------------------------------------
+bool Meter::SetValue
+(
+	Value const& _value
+)
+{
+	if( MeterIndex_Reset == _value.GetID().GetIndex() )
+	{
+		ValueButton const* button = static_cast<ValueButton const*>(&_value);
+		if( button->IsPressed() )
+		{
+			Msg* msg = new Msg( "MeterCmd_Reset", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
+			msg->SetInstance( this, _value.GetID().GetInstance() ); 
+			msg->Append( GetNodeId() );
+			msg->Append( 2 );
+			msg->Append( GetCommandClassId() );
+			msg->Append( MeterCmd_Reset );
+			msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+			GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <Meter::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void Meter::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+		node->CreateValueDecimal( ValueID::ValueGenre_User, GetCommandClassId(), _instance, 0, "Unknown", "", true, false, "0.0", 0 );
+	}
+}