ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,147 @@
+//-----------------------------------------------------------------------------
+//
+//	HidController.h
+//
+//	Cross-platform HID port handler
+//
+//	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 _HidController_H
+#define _HidController_H
+
+#include <string>
+#include "Defs.h"
+#include "Controller.h"
+#include "hidapi.h"
+
+namespace OpenZWave
+{
+	class Driver;
+	class Msg;
+	class Thread;
+	class Event;
+
+    class HidController: public Controller
+	{
+	public:
+		/**
+		 * Constructor.
+		 * Creates an object that represents a HID port.
+		 */
+		HidController();
+
+		/**
+		 * Destructor.
+		 * Destroys the HID port object.
+		 */
+		virtual ~HidController();
+
+		/**
+		 * Set the USB vendor ID search value.  The HID port must be closed for the setting to be accepted.
+		 * @param _baud Vendor ID value to match when enumerating USB HID devices.
+		 * @return True if the vendor ID value was accepted.
+		 * @see Open, Close
+		 */
+		bool SetVendorId( uint32 const _vendorId );
+
+		/**
+		 * Set the USB product ID search value.  The HID port must be closed for the setting to be accepted.
+		 * @param _parity Product ID value to match when enumerating USB HID devices.
+		 * @return True if the product ID value was accepted.
+		 * @see Open, Close
+		 */
+		bool SetProductId( uint32 const _productId );
+
+		/**
+		 * Set the USB serial number search value.  The HID port must be closed for the setting to be accepted.
+ 		 * @param _parity Serial number string to match when enumerating USB HID devices. If empty, any serial number will be accepted.
+		 * @return True if the serial number value was accepted.
+		 * @see Open, Close
+		 */
+		bool SetSerialNumber( string const& _serialNumber );
+
+		/**
+		 * Open a HID port.
+		 * Attempts to open a HID port and initialize it with the specified paramters.
+		 * @param _HidControllerName The name of the port to open.  For example, ttyS1 on Linux, or \\.\COM2 in Windows.
+		 * @return True if the port was opened and configured successfully.
+		 * @see Close, Read, Write
+		 */
+		bool Open( string const& _hidControllerName );
+
+		/**
+		 * Close a HID port.
+		 * Closes the HID port.
+		 * @return True if the port was closed successfully, or false if the port was already closed, or an error occurred.
+		 * @see Open
+		 */
+		bool Close();
+
+		/**
+		 * Write to a HID port.
+		 * Attempts to write data to an open HID port.
+		 * @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
+		 */
+		uint32 Write( uint8* _buffer, uint32 _length );
+
+	private:
+		bool Init( uint32 const _attempts );
+		void Read();
+
+	        // helpers for internal use only
+
+	        /**
+		* Read bytes from the specified HID feature report
+	        * @param _buffer Buffer array for receiving the feature report bytes.
+	        * @param _length Length of the buffer array.
+	        * @param _reportId ID of the report to read.
+		* @return Actual number of bytes retrieved, or -1 on error.
+		*/
+	        int GetFeatureReport( uint32 _length, uint8 _reportId, uint8* _buffer );
+
+	        /**
+		* Write bytes to the specified HID feature report
+		* @param _data Bytes to be written to the feature report.
+		* @param _length Length of bytes to be written.
+		* @return Actal number of bytes written, or -1 on error.
+		*/
+	        int SendFeatureReport( uint32 _length, const uint8* _data );
+
+		static void ThreadEntryPoint( Event* _exitEvent, void* _context );
+		void ThreadProc( Event* _exitEvent );
+
+		hid_device*		m_hHidController;
+		Thread*			m_thread;
+	        uint32          	m_vendorId;
+	        uint32          	m_productId;
+	        string          	m_serialNumber;
+		string			m_hidControllerName;
+		bool			m_bOpen;
+	};
+
+} // namespace OpenZWave
+
+#endif //_HidController_H
+

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

@@ -0,0 +1,310 @@
+//-----------------------------------------------------------------------------
+//
+//	Log.cpp
+//
+//	Cross-platform message and error logging
+//
+//	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 <stdarg.h>
+
+#include "Defs.h"
+#include "Mutex.h"
+#include "Log.h"
+
+#include "LogImpl.h"	// Platform-specific implementation of a log
+
+
+using namespace OpenZWave;
+
+Log* Log::s_instance = NULL;
+i_LogImpl* Log::m_pImpl = NULL;
+static bool s_dologging;
+
+//-----------------------------------------------------------------------------
+//	<Log::Create>
+//	Static creation of the singleton
+//-----------------------------------------------------------------------------
+Log* Log::Create
+(
+	string const& _filename,
+	bool const _bAppend,
+	bool const _bConsoleOutput,
+	LogLevel const _saveLevel,
+	LogLevel const _queueLevel,
+	LogLevel const _dumpTrigger
+)
+{
+	if( NULL == s_instance )
+	{
+		s_instance = new Log( _filename, _bAppend, _bConsoleOutput, _saveLevel, _queueLevel, _dumpTrigger );
+		s_dologging = true; // default logging to true so no change to what people experience now
+	}
+
+	return s_instance;
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::Create>
+//	Static creation of the singleton
+//-----------------------------------------------------------------------------
+/* 	It isn't clear this is ever called or used.  If no one complains, consider
+	deleting this code in April 2012.
+Log* Log::Create
+(
+	i_LogImpl *LogClass
+)
+{
+	if (NULL == s_instance )
+	{
+		s_instance = new Log( "" );
+		s_dologging = true;
+	}
+	SetLoggingClass( LogClass );
+	return s_instance;
+}
+*/
+
+//-----------------------------------------------------------------------------
+//	<Log::Destroy>
+//	Static method to destroy the logging singleton.
+//-----------------------------------------------------------------------------
+void Log::Destroy
+(
+)
+{
+	delete s_instance;
+	s_instance = NULL;
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::Create>
+//	Static creation of the singleton
+//-----------------------------------------------------------------------------
+bool Log::SetLoggingClass
+(
+	i_LogImpl *LogClass
+)
+{
+	delete m_pImpl;
+	m_pImpl = LogClass;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::SetLoggingState>
+//	Set flag to actually write to log or skip it (legacy version)
+//	If logging is enabled, the default log detail settings will be used
+//	Write to file/screen		LogLevel_Detail
+//	Save in queue for errors	LogLevel_Debug
+//	Trigger for dumping queue	LogLevel_Warning
+//	Console output?				Yes
+//	Append to an existing log?	No (overwrite)
+//-----------------------------------------------------------------------------
+void Log::SetLoggingState
+(
+	bool _dologging
+)
+{
+	bool prevLogging = s_dologging;
+	s_dologging = _dologging;
+	
+	if (!prevLogging && s_dologging) Log::Write(LogLevel_Always, "Logging started\n\n");
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::SetLoggingState>
+//	Set flag to actually write to log or skip it
+//-----------------------------------------------------------------------------
+void Log::SetLoggingState
+( 
+	LogLevel _saveLevel, 
+	LogLevel _queueLevel, 
+	LogLevel _dumpTrigger 
+)
+{
+	// parameter checking:
+	//  _queueLevel cannot be less than or equal to _saveLevel (where lower ordinals are more severe conditions)
+	//  _dumpTrigger cannot be greater than or equal to _queueLevel
+	if( _queueLevel <= _saveLevel )
+		Log::Write( LogLevel_Warning, "Only lower priority messages may be queued for error-driven display." );
+	if( _dumpTrigger >= _queueLevel )
+		Log::Write( LogLevel_Warning, "The trigger for dumping queued messages must be a higher-priority message than the level that is queued." );
+
+	bool prevLogging = s_dologging;
+	// s_dologging is true if any messages are to be saved in file or queue
+	if( (_saveLevel > LogLevel_Always) ||
+		(_queueLevel > LogLevel_Always) )
+	{
+		s_dologging = true;
+	}
+	else
+	{
+		s_dologging = false;
+	}
+
+	if( s_instance && s_dologging && s_instance->m_pImpl )
+	{
+	  	s_instance->m_logMutex->Lock();
+		s_instance->m_pImpl->SetLoggingState( _saveLevel, _queueLevel, _dumpTrigger );
+		s_instance->m_logMutex->Unlock();
+	}
+	
+	if (!prevLogging && s_dologging) Log::Write(LogLevel_Always, "Logging started\n\n");
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::GetLoggingState>
+//	Return a flag to indicate whether logging is enabled
+//-----------------------------------------------------------------------------
+bool Log::GetLoggingState
+(
+)
+{
+	return s_dologging;
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::Write>
+//	Write to the log
+//-----------------------------------------------------------------------------
+void Log::Write
+(
+	LogLevel _level,
+	char const* _format,
+	...
+)
+{
+	if( s_instance && s_dologging && s_instance->m_pImpl )
+	{
+		s_instance->m_logMutex->Lock(); // double locks if recursive
+		va_list args;
+		va_start( args, _format );
+		s_instance->m_pImpl->Write( _level, 0, _format, args );
+		va_end( args );
+		s_instance->m_logMutex->Unlock();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::Write>
+//	Write to the log
+//-----------------------------------------------------------------------------
+void Log::Write
+(
+	LogLevel _level,
+	uint8 const _nodeId,
+	char const* _format,
+	...
+)
+{
+	if( s_instance && s_dologging && s_instance->m_pImpl )
+	{
+		if( _level != LogLevel_Internal )
+		  	s_instance->m_logMutex->Lock();
+		va_list args;
+		va_start( args, _format );
+		s_instance->m_pImpl->Write( _level, _nodeId, _format, args );
+		va_end( args );
+		if( _level != LogLevel_Internal )
+			s_instance->m_logMutex->Unlock();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::QueueDump>
+//	Send queued messages to the log (and empty the queue)
+//-----------------------------------------------------------------------------
+void Log::QueueDump
+(
+)
+{
+	if( s_instance && s_dologging && s_instance->m_pImpl )
+	{
+	  	s_instance->m_logMutex->Lock();
+		s_instance->m_pImpl->QueueDump();
+		s_instance->m_logMutex->Unlock();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::QueueClear>
+//	Empty the queued message queue
+//-----------------------------------------------------------------------------
+void Log::QueueClear
+(
+)
+{
+	if( s_instance && s_dologging && s_instance->m_pImpl )
+	{
+	  	s_instance->m_logMutex->Lock();
+		s_instance->m_pImpl->QueueClear();
+		s_instance->m_logMutex->Unlock();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::SetLogFileName>
+//	Change the name of the log file (will start writing a new file)
+//-----------------------------------------------------------------------------
+void Log::SetLogFileName
+(
+	string _filename
+)
+{
+	if( s_instance && s_dologging && s_instance->m_pImpl )
+	{
+	  	s_instance->m_logMutex->Lock();
+		s_instance->m_pImpl->SetLogFileName( _filename );
+		s_instance->m_logMutex->Unlock();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::Log>
+//	Constructor
+//-----------------------------------------------------------------------------
+Log::Log
+(
+	string const& _filename,
+	bool const _bAppend,
+	bool const _bConsoleOutput,
+	LogLevel const _saveLevel,
+	LogLevel const _queueLevel,
+	LogLevel const _dumpTrigger
+):
+	m_logMutex( new Mutex() )
+{
+	m_pImpl = new LogImpl( _filename, _bAppend, _bConsoleOutput, _saveLevel, _queueLevel, _dumpTrigger );
+}
+
+//-----------------------------------------------------------------------------
+//	<Log::~Log>
+//	Destructor
+//-----------------------------------------------------------------------------
+Log::~Log
+(
+)
+{
+	m_logMutex->Release();
+	delete m_pImpl;
+}