ansible4ozw 0.0.2 → 0.0.3

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

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

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

@@ -0,0 +1,237 @@
+//-----------------------------------------------------------------------------
+//
+//	SensorMultilevel.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_SENSOR_MULTILEVEL
+//
+//	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 "SensorMultilevel.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"
+
+using namespace OpenZWave;
+
+enum SensorMultilevelCmd
+{
+	SensorMultilevelCmd_Get		= 0x04,
+	SensorMultilevelCmd_Report	= 0x05
+};
+
+enum SensorType
+{
+	SensorType_Temperature = 1,
+	SensorType_General,
+	SensorType_Luminance,
+	SensorType_Power,
+	SensorType_RelativeHumidity,
+	SensorType_Velocity,
+	SensorType_Direction,
+	SensorType_AtmosphericPressure,
+	SensorType_BarometricPressure,
+	SensorType_SolarRadiation,
+	SensorType_DewPoint,
+	SensorType_RainRate,
+	SensorType_TideLevel,
+	SensorType_Weight,
+	SensorType_Voltage,
+	SensorType_Current,
+	SensorType_CO2,
+	SensorType_AirFlow,
+	SensorType_TankCapacity,
+	SensorType_Distance
+};
+
+static char const* c_sensorTypeNames[] = 
+{
+	"Undefined",
+	"Temperature",
+	"General",
+	"Luminance",
+	"Power",
+	"Relative Humidity",
+	"Velocity",
+	"Direction",
+	"Atmospheric Pressure",
+	"Barometric Pressure",
+	"Solar Radiation",
+	"Dew Point",
+	"Rain Rate",
+	"Tide Level",
+	"Weight",
+	"Voltage",
+	"Current",
+	"CO2 Level",
+	"Air Flow",
+	"Tank Capacity",
+	"Distance"
+};
+
+static char const* c_tankCapcityUnits[] = 
+{
+	"l",
+	"cbm",
+	"gal"
+};
+
+static char const* c_distanceUnits[] = 
+{
+	"m",
+	"cm",
+	"ft"
+};
+
+//-----------------------------------------------------------------------------
+// <SensorMultilevel::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool SensorMultilevel::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Dynamic )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <SensorMultilevel::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool SensorMultilevel::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy,		// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Msg* msg = new Msg( "SensorMultilevelCmd_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( SensorMultilevelCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <SensorMultilevel::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool SensorMultilevel::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if (SensorMultilevelCmd_Report == (SensorMultilevelCmd)_data[0])
+	{
+		uint8 scale;
+		uint8 precision = 0;
+		uint8 sensorType = _data[1];
+		string valueStr = ExtractValue( &_data[2], &scale, &precision );
+
+		Node* node = GetNodeUnsafe();
+		if( node != NULL )
+		{
+			char const* units = "";
+			switch( sensorType )
+			{
+				case SensorType_Temperature:			units = scale ? "F" : "C";				break;
+				case SensorType_General:				units = scale ? "" : "%";				break;
+				case SensorType_Luminance:				units = scale ? "lux" : "%";			break;
+				case SensorType_Power:					units = scale ? "BTU/h" : "W";			break;
+				case SensorType_RelativeHumidity:		units = "%";							break;
+				case SensorType_Velocity:				units = scale ? "mph" : "m/s";			break;
+				case SensorType_Direction:				units = "";								break;
+				case SensorType_AtmosphericPressure:	units = scale ? "inHg" : "kPa";			break;
+				case SensorType_BarometricPressure:		units = scale ? "inHg" : "kPa";			break;
+				case SensorType_SolarRadiation:			units = "W/m2";							break;
+				case SensorType_DewPoint:				units = scale ? "in/h" : "mm/h";		break;
+				case SensorType_RainRate:				units = scale ? "F" : "C";				break;
+				case SensorType_TideLevel:				units = scale ? "ft" : "m";				break;
+				case SensorType_Weight:					units = scale ? "lb" : "kg";			break;
+				case SensorType_Voltage:				units = scale ? "mV" : "V";				break;
+				case SensorType_Current:				units = scale ? "mA" : "A";				break;
+				case SensorType_CO2:					units = "ppm";							break;
+				case SensorType_AirFlow:				units = scale ? "cfm" : "m3/h";			break;
+				case SensorType_TankCapacity:			units = c_tankCapcityUnits[scale];		break;
+				case SensorType_Distance:				units = c_distanceUnits[scale];			break;
+				default:																		break;
+			}
+
+			ValueDecimal* value = static_cast<ValueDecimal*>( GetValue( _instance, sensorType ) );
+			if( value == NULL)
+			{
+				node->CreateValueDecimal(  ValueID::ValueGenre_User, GetCommandClassId(), _instance, sensorType, c_sensorTypeNames[sensorType], units, true, false, "0.0", 0  );
+				value = static_cast<ValueDecimal*>( GetValue( _instance, sensorType ) );
+			}
+			else 
+			{
+				value->SetUnits(units);
+			}
+
+			Log::Write( LogLevel_Info, GetNodeId(), "Received SensorMultiLevel report from node %d, instance %d: value=%s%s", GetNodeId(), _instance, valueStr.c_str(), value->GetUnits().c_str() );
+			if( value->GetPrecision() != precision )
+			{
+				value->SetPrecision( precision );
+			}
+			value->OnValueRefreshed( valueStr );
+			value->Release();
+			return true;
+		}
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <SensorMultilevel::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void SensorMultilevel::CreateVars
+(
+	uint8 const _instance
+)
+{
+	// Don't create anything here. We do it in the report.
+}
+
+
+

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

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------------
+//
+//	SensorMultilevel.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_SENSOR_MULTILEVEL
+//
+//	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 _SensorMultilevel_H
+#define _SensorMultilevel_H
+
+#include "CommandClass.h"
+
+namespace OpenZWave
+{
+	class ValueDecimal;
+
+	/** \brief Implements COMMAND_CLASS_SENSOR_MULTILEVEL (0x31), a Z-Wave device command class.
+	 */
+	class SensorMultilevel: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new SensorMultilevel( _homeId, _nodeId ); }
+		virtual ~SensorMultilevel(){}
+
+		static uint8 const StaticGetCommandClassId(){ return 0x31; }
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_SENSOR_MULTILEVEL"; }
+
+		// From CommandClass
+		virtual bool RequestState( uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue );
+		virtual bool RequestValue( uint32 const _requestFlags, uint8 const _dummy, 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 );
+		
+		// We return 1 instead of 3 because the latter versions only introduce new
+		// sensor types, with no new message format changes.  Setting this to 1 prevents
+		// OpenZWave from making an unecessary version requests. 
+		virtual uint8 GetMaxVersion(){ return 1; }
+
+	protected:
+		virtual void CreateVars( uint8 const _instance );
+
+	private:
+		SensorMultilevel( uint32 const _homeId, uint8 const _nodeId ): CommandClass( _homeId, _nodeId ){}
+	};
+
+} // namespace OpenZWave
+
+
+#endif
+

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

@@ -0,0 +1,219 @@
+//-----------------------------------------------------------------------------
+//
+//	SwitchAll.cpp
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_SWITCH_ALL
+//
+//	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 "SwitchAll.h"
+#include "Defs.h"
+#include "Msg.h"
+#include "Node.h"
+#include "Driver.h"
+#include "Log.h"
+
+#include "ValueList.h"
+
+using namespace OpenZWave;
+
+enum SwitchAllCmd
+{
+	SwitchAllCmd_Set	= 0x01,
+	SwitchAllCmd_Get	= 0x02,
+	SwitchAllCmd_Report	= 0x03,
+	SwitchAllCmd_On		= 0x04,
+	SwitchAllCmd_Off	= 0x05
+};
+
+static char const* c_switchAllStateName[] = 
+{
+	"Disabled",
+	"Off Enabled",
+	"On Enabled",
+	"On and Off Enabled"
+};
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::RequestState>												   
+// Request current state from the device									   
+//-----------------------------------------------------------------------------
+bool SwitchAll::RequestState
+(
+	uint32 const _requestFlags,
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	if( _requestFlags & RequestFlag_Session )
+	{
+		return RequestValue( _requestFlags, 0, _instance, _queue );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::RequestValue>												   
+// Request current value from the device									   
+//-----------------------------------------------------------------------------
+bool SwitchAll::RequestValue
+(
+	uint32 const _requestFlags,
+	uint8 const _dummy1,	// = 0 (not used)
+	uint8 const _instance,
+	Driver::MsgQueue const _queue
+)
+{
+	Msg* msg = new Msg( "SwitchAllCmd_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( SwitchAllCmd_Get );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	GetDriver()->SendMsg( msg, _queue );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::HandleMsg>
+// Handle a message from the Z-Wave network
+//-----------------------------------------------------------------------------
+bool SwitchAll::HandleMsg
+(
+	uint8 const* _data,
+	uint32 const _length,
+	uint32 const _instance	// = 1
+)
+{
+	if (SwitchAllCmd_Report == (SwitchAllCmd)_data[0])
+	{
+		if( ValueList* value = static_cast<ValueList*>( GetValue( _instance, 0 ) ) )
+		{
+			value->OnValueRefreshed( (int32)_data[1] );
+			value->Release();
+			Log::Write( LogLevel_Info, GetNodeId(), "Received SwitchAll report from node %d: %s", GetNodeId(), value->GetItem().m_label.c_str() );
+		}
+ 		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::SetValue>
+// Set the device's response to SWITCH_ALL commands 
+//-----------------------------------------------------------------------------
+bool SwitchAll::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(), "SwitchAll::Set - %s on node %d", item.m_label.c_str(), GetNodeId() );
+		Msg* msg = new Msg( "SwitchAllCmd_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( SwitchAllCmd_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;
+}
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::Off>
+// Send a command to switch all devices off 
+//-----------------------------------------------------------------------------
+void SwitchAll::Off
+(
+	Driver* _driver,
+	uint8 const _nodeId 
+)
+{
+	Log::Write( LogLevel_Info, _nodeId, "SwitchAll::Off (Node=%d)", _nodeId );
+	Msg* msg = new Msg( "SwitchAllCmd_Off", _nodeId, REQUEST, FUNC_ID_ZW_SEND_DATA, true );		
+	msg->Append( _nodeId );
+	msg->Append( 2 );
+	msg->Append( StaticGetCommandClassId() );
+	msg->Append( SwitchAllCmd_Off );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	_driver->SendMsg( msg, Driver::MsgQueue_Send );
+}
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::On>
+// Send a command to switch all devices on 
+//-----------------------------------------------------------------------------
+void SwitchAll::On
+(
+	Driver* _driver,
+	uint8 const _nodeId 
+)
+{
+	Log::Write( LogLevel_Info, _nodeId, "SwitchAll::On (Node=%d)", _nodeId );
+	Msg* msg = new Msg( "SwitchAllCmd_On", _nodeId, REQUEST, FUNC_ID_ZW_SEND_DATA, true );		
+	msg->Append( _nodeId );
+	msg->Append( 2 );
+	msg->Append( StaticGetCommandClassId() );
+	msg->Append( SwitchAllCmd_On );
+	msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
+	_driver->SendMsg( msg, Driver::MsgQueue_Send );
+}
+
+//-----------------------------------------------------------------------------
+// <SwitchAll::CreateVars>
+// Create the values managed by this command class
+//-----------------------------------------------------------------------------
+void SwitchAll::CreateVars
+(
+	uint8 const _instance
+)
+{
+	if( Node* node = GetNodeUnsafe() )
+	{
+		vector<ValueList::Item> items;
+		for( int i=0; i<4; ++i )
+		{	
+			ValueList::Item item;
+			item.m_label = c_switchAllStateName[i];
+			item.m_value = (i==3) ? 0x000000ff : i;
+			items.push_back( item ); 
+		}
+
+		node->CreateValueList(  ValueID::ValueGenre_System, GetCommandClassId(), _instance, 0, "Switch All", "", false, false, 1, items, 0, 0 );
+	}
+}
+
+
+