ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,85 @@
+//-----------------------------------------------------------------------------
+//
+//	WakeUp.h
+//
+//	Implementation of the Z-Wave COMMAND_CLASS_WAKE_UP
+//
+//	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 _WakeUp_H
+#define _WakeUp_H
+
+#include <list>
+#include "CommandClass.h"
+#include "Driver.h"
+
+namespace OpenZWave
+{
+	class Msg;
+	class ValueInt;
+	class Mutex;
+
+	/** \brief Implements COMMAND_CLASS_WAKE_UP (0x84), a Z-Wave device command class.
+	 */
+	class WakeUp: public CommandClass
+	{
+	public:
+		static CommandClass* Create( uint32 const _homeId, uint8 const _nodeId ){ return new WakeUp( _homeId, _nodeId ); }
+		virtual ~WakeUp();
+
+		static uint8 const StaticGetCommandClassId(){ return 0x84; }		
+		static string const StaticGetCommandClassName(){ return "COMMAND_CLASS_WAKE_UP"; }
+
+		void Init();	// Starts the process of requesting node state from a sleeping device.
+		void QueueMsg( Driver::MsgQueueItem const& _item );
+		void SendPending();
+		bool IsAwake()const{ return m_awake; }
+		void SetAwake( bool _state );
+		void SetPollRequired(){ m_pollRequired = true; }
+
+		// 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 );
+		virtual bool SetValue( Value const& _value );
+		virtual uint8 GetMaxVersion(){ return 2; }
+
+	protected:
+		virtual void CreateVars( uint8 const _instance );
+
+	private:
+		WakeUp( uint32 const _homeId, uint8 const _nodeId );
+
+		Mutex*						m_mutex;			// Serialize access to the pending queue
+		list<Driver::MsgQueueItem>	m_pendingQueue;		// Messages waiting to be sent when the device wakes up
+		bool						m_awake;
+		bool						m_pollRequired;
+		bool						m_notification;
+	};
+
+} // namespace OpenZWave
+
+#endif
+
+

data/lib/ansible/zwave/openzwave/src/platform/Controller.cpp

@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------------
+//
+//	Controller.cpp
+//
+//	Cross-platform, hardware-abstracted controller data interface
+//
+//	Copyright (c) 2010 Jason Frazier <frazierjason@gmail.com>
+//
+//	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 "Defs.h"
+#include "Driver.h"
+#include "Controller.h"
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+// <Controller::PlayInitSequence>
+//  Queues up the controller's initialization commands.
+//-----------------------------------------------------------------------------
+void Controller::PlayInitSequence
+(
+	Driver* _driver
+)
+{
+	_driver->SendMsg( new Msg( "FUNC_ID_ZW_GET_VERSION", 0xff, REQUEST, FUNC_ID_ZW_GET_VERSION, false ), Driver::MsgQueue_Command );
+	_driver->SendMsg( new Msg( "FUNC_ID_ZW_MEMORY_GET_ID", 0xff, REQUEST, FUNC_ID_ZW_MEMORY_GET_ID, false ), Driver::MsgQueue_Command);
+	_driver->SendMsg( new Msg( "FUNC_ID_ZW_GET_CONTROLLER_CAPABILITIES", 0xff, REQUEST, FUNC_ID_ZW_GET_CONTROLLER_CAPABILITIES, false ), Driver::MsgQueue_Command);
+	_driver->SendMsg( new Msg( "FUNC_ID_SERIAL_API_GET_CAPABILITIES", 0xff, REQUEST, FUNC_ID_SERIAL_API_GET_CAPABILITIES, false ), Driver::MsgQueue_Command);
+	_driver->SendMsg( new Msg( "FUNC_ID_ZW_GET_SUC_NODE_ID", 0xff, REQUEST, FUNC_ID_ZW_GET_SUC_NODE_ID, false ), Driver::MsgQueue_Command);
+	// FUNC_ID_ZW_GET_VIRTUAL_NODES & FUNC_ID_SERIAL_API_GET_INIT_DATA has moved into the handler for FUNC_ID_SERIAL_API_GET_CAPABILITIES
+}
+
+//-----------------------------------------------------------------------------
+//	<Controller::Read>
+//	Read from a controller
+//-----------------------------------------------------------------------------
+uint32 Controller::Read
+(
+	uint8* _buffer,
+	uint32 _length
+)
+{
+	// Fetch the data from the ring buffer (which is an all or nothing read)
+	if( Get( _buffer, _length ) )
+	{
+		return _length;
+	}
+
+	return 0;
+}
+

data/lib/ansible/zwave/openzwave/src/platform/Controller.h

@@ -0,0 +1,106 @@
+//-----------------------------------------------------------------------------
+//
+//	Controller.h
+//
+//	Cross-platform, hardware-abstracted controller data interface
+//
+//	Copyright (c) 2010 Jason Frazier <frazierjason@gmail.com>
+//
+//	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 _Controller_H
+#define _Controller_H
+
+#include <string>
+#include <list>
+#include "Defs.h"
+#include "Stream.h"
+
+namespace OpenZWave
+{
+	class Driver;
+
+	class Controller: public Stream
+	{
+		// Controller is derived from Stream rather than containing one, so that
+		// we can use its Wait abilities without having to duplicate them here.
+		// The stream is used for input.  Buffering of output is handled by the OS. 
+
+	public:
+		/**
+		 * Consructor.
+		 * Creates the controller object.
+		 */
+		Controller():Stream( 2048 ){}
+
+		/**
+		 * Destructor.
+		 * Destroys the controller object.
+		 */
+		virtual ~Controller(){}
+
+		/**
+		 * Queues a set of Z-Wave messages in the correct order needed to initialize the Controller implementation.
+		 * @param Pointer to the driver object that will handle the messages.
+		 * @see Driver::Init
+		 */
+		void PlayInitSequence( Driver* _driver );
+
+		/**
+		 * Open a controller.
+		 * Attempts to open a controller and initialize it with the specified paramters.
+		 * @param _controllerName The name of the port to open.  For example, ttyS1 on Linux, or \\.\COM2 in Windows.
+		 * @see Close, Read, Write
+		 */
+		virtual bool Open( string const& _controllerName ) = 0;
+
+		/**
+		 * Close a controller.
+		 * Closes the controller.
+		 * @return True if the controller was closed successfully, or false if the controller was already closed, or an error occurred.
+		 * @see Open
+		 */
+		virtual bool Close() = 0;
+
+		/**
+		 * Write to a controller.
+		 * Attempts to write data to an open controller.
+		 * @param _buffer Pointer to a block of memory containing the data to be written.
+		 * @param _length Length in bytes of the data.
+		 * @return The number of bytes written.
+		 * @see Read, Open, Close
+		 */
+		virtual uint32 Write( uint8* _buffer, uint32 _length ) = 0;
+
+		/**
+		 * Read from a controller.
+		 * Attempts to read data from an open controller.
+		 * @param _buffer Pointer to a block of memory large enough to hold the requested data.
+		 * @param _length Length in bytes of the data to be read.
+		 * @return The number of bytes read.
+		 * @see Write, Open, Close
+		 */
+		uint32 Read( uint8* _buffer, uint32 _length );
+	};
+
+} // namespace OpenZWave
+
+#endif //_Controller_H
+

data/lib/ansible/zwave/openzwave/src/platform/Event.cpp

@@ -0,0 +1,102 @@
+//-----------------------------------------------------------------------------
+//
+//	Event.cpp
+//
+//	Cross-platform event
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	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 "Defs.h"
+#include "Event.h"
+#include "EventImpl.h"	// Platform-specific implementation of an event
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<Event::Event>
+//	Constructor
+//-----------------------------------------------------------------------------
+Event::Event
+(
+):
+	m_pImpl( new EventImpl() )
+{
+}
+
+//-----------------------------------------------------------------------------
+//	<Event::~Event>
+//	Destructor
+//-----------------------------------------------------------------------------
+Event::~Event
+(
+)
+{
+	delete m_pImpl;
+}
+
+//-----------------------------------------------------------------------------
+//	<Event::Set>
+//	Set the event to signalled
+//-----------------------------------------------------------------------------
+void Event::Set
+(
+)
+{
+	m_pImpl->Set();
+	Notify();			// Notify any watchers that the event is now set
+}
+
+//-----------------------------------------------------------------------------
+//	<Event::Reset>
+//	Set the event to not signalled
+//-----------------------------------------------------------------------------
+void Event::Reset
+(
+)
+{
+	m_pImpl->Reset();
+}
+
+//-----------------------------------------------------------------------------
+//	<Event::IsSignalled>
+//	Test whether the event is set
+//-----------------------------------------------------------------------------
+bool Event::IsSignalled
+(
+)
+{
+	return m_pImpl->IsSignalled();
+}
+
+//-----------------------------------------------------------------------------
+//	<Event::Wait>
+//	Wait for the event to become signalled
+//-----------------------------------------------------------------------------
+bool Event::Wait
+(
+	int32 const _timeout
+)
+{
+	return m_pImpl->Wait( _timeout );
+}
+
+

data/lib/ansible/zwave/openzwave/src/platform/Event.h

@@ -0,0 +1,91 @@
+//-----------------------------------------------------------------------------
+//
+//	Event.h
+//
+//	Cross-platform manual-reset event
+//
+//	Copyright (c) 2010 Mal Lansell <mal@lansell.org>
+//	All rights reserved.
+//
+//	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 _Event_H
+#define _Event_H
+
+#include "Wait.h"
+
+namespace OpenZWave
+{
+	class EventImpl;
+
+	/** \brief Platform-independent definition of event objects.
+	 */
+	class Event: public Wait
+	{
+		friend class SerialControllerImpl;
+		friend class Wait;
+
+	public:
+		/**
+		 * Constructor.
+		 * Creates a cross-platform event object equivalent to the Windows manual-reset event
+		 */
+		Event();
+
+		/**
+		 * Set the event to signalled.
+		 * \see Reset, Wait
+		 */
+		void Set();
+
+		/**
+		 * Set the event to not signalled.
+		 * \see Set, Wait
+		 */
+		void Reset();
+
+	protected:
+		/**
+		 * Used by the Wait class to test whether the event is set.
+		 */
+		virtual bool IsSignalled();
+
+		/**
+		 * Used by the Wait::Multiple method.
+		 * returns true if the event signalled, false if it timed out
+		 */
+		bool Wait( int32 _timeout );
+
+		/**
+		 * Destructor.
+		 * Destroys the event object.
+		 */
+		~Event();
+
+	private:
+		Event( Event const&	);					// prevent copy
+		Event& operator = ( Event const& );		// prevent assignment
+
+		EventImpl*	m_pImpl;	// Pointer to an object that encapsulates the platform-specific implementation of a event.
+	};
+
+} // namespace OpenZWave
+
+#endif //_Event_H
+