ansible4ozw 0.0.2 → 0.0.3

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

@@ -0,0 +1,180 @@
+//-----------------------------------------------------------------------------
+//
+//	SerialController.h
+//
+//	Cross-platform serial 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/>.
+//
+//-----------------------------------------------------------------------------
+
+#include "Event.h"
+#include "Thread.h" 
+#include "Msg.h"
+#include "SerialController.h"
+#include "SerialControllerImpl.h"	// Platform-specific implementation of a serial port
+#include "Log.h"
+
+using namespace OpenZWave;
+
+
+//-----------------------------------------------------------------------------
+//	<SerialController::SerialController>
+//	Constructor
+//-----------------------------------------------------------------------------
+SerialController::SerialController
+(
+):
+	m_baud ( 115200 ),
+	m_parity ( SerialController::Parity_None ),
+	m_stopBits ( SerialController::StopBits_One ),
+	m_bOpen( false )
+{
+	m_pImpl = new SerialControllerImpl( this );
+}
+
+//-----------------------------------------------------------------------------
+//	<SerialController::~SerialController>
+//	Destructor
+//-----------------------------------------------------------------------------
+SerialController::~SerialController
+(
+)
+{
+	delete m_pImpl;
+}
+
+//-----------------------------------------------------------------------------
+//  <SerialController::SetBaud>
+//  Set the serial port baud rate.  
+//  The serial port must be closed for the setting to be accepted.
+//-----------------------------------------------------------------------------
+bool SerialController::SetBaud
+(
+    uint32 const _baud
+)
+{
+	if( m_bOpen )
+	{
+		return false;
+	}
+
+    m_baud = _baud;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+//  <SerialController::SetParity>
+//  Set the serial port parity.
+//  The serial port must be closed for the setting to be accepted.
+//-----------------------------------------------------------------------------
+bool SerialController::SetParity
+(
+    Parity const _parity
+)
+{
+	if( m_bOpen )
+	{
+		return false;
+	}
+
+    m_parity = _parity;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+//  <SerialController::SetStopBits>
+//  Set the serial port stop bits.
+//  The serial port must be closed for the setting to be accepted.
+//-----------------------------------------------------------------------------
+bool SerialController::SetStopBits
+(
+    StopBits const _stopBits
+)
+{
+	if( m_bOpen )
+	{
+		return false;
+	}
+
+    m_stopBits = _stopBits;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<SerialController::Open>
+//	Open and configure a serial port
+//-----------------------------------------------------------------------------
+bool SerialController::Open
+(
+	string const& _serialControllerName
+)
+{
+	if( m_bOpen )
+	{
+		return false;
+	}
+
+	m_serialControllerName = _serialControllerName; 
+	m_bOpen = m_pImpl->Open();
+	return m_bOpen;
+}
+
+//-----------------------------------------------------------------------------
+//	<SerialController::Close>
+//	Close a serial port
+//-----------------------------------------------------------------------------
+bool SerialController::Close
+(
+)
+{
+	if( !m_bOpen )
+	{
+		return false;
+	}
+
+	m_pImpl->Close();
+	m_bOpen = false;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<SerialController::Write>
+//	Write data to an open serial port
+//-----------------------------------------------------------------------------
+uint32 SerialController::Write
+(
+	uint8* _buffer,
+	uint32 _length
+)
+{
+	if( !m_bOpen )
+	{
+		return 0;
+	}
+
+	Log::Write( LogLevel_Debug, "      SerialController::Write (sent to controller)" );
+	LogData(_buffer, _length, "      Write: ");
+
+	return( m_pImpl->Write( _buffer, _length ) );
+}
+
+
+

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

@@ -0,0 +1,138 @@
+//-----------------------------------------------------------------------------
+//
+//	SerialController.h
+//
+//	Cross-platform serial 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 _SerialController_H
+#define _SerialController_H
+
+#include <string>
+#include "Defs.h"
+#include "Controller.h"
+
+namespace OpenZWave
+{
+	class Driver;
+    class Msg;
+	class SerialControllerImpl;
+
+    class SerialController: public Controller
+	{
+		friend class SerialControllerImpl;
+
+	public:
+		enum Parity
+		{
+			Parity_None = 0,
+			Parity_Odd,
+			Parity_Even,
+			Parity_Mark,
+			Parity_Space
+		};
+
+		enum StopBits
+		{
+			StopBits_One = 0,
+			StopBits_OneAndAHalf = 1,
+			StopBits_Two = 2
+		};
+
+		/**
+		 * Constructor.
+		 * Creates an object that represents a serial port.
+		 */
+		SerialController();
+
+		/**
+		 * Destructor.
+		 * Destroys the serial port object.
+		 */
+		virtual ~SerialController();
+
+		/**
+		 * Set the serial port baud rate.  The serial port must be closed for the setting to be accepted.
+		 * @param _baud Integer containing the expected baud-rate of the serial connection.  Most Z-Wave interfaces run at 115200 baud.
+		 * @return True if the baud value was accepted.
+		 * @see Open, Close
+		 */
+		bool SetBaud( uint32 const _baud );
+
+		/**
+		 * Set the serial port parity.  The serial port must be closed for the setting to be accepted.
+		 * @param _parity Parity enum value indicating the serial data's expected type of parity bits, if any.
+		 * @return True if the parity value was accepted.
+		 * @see Open, Close
+		 */
+		bool SetParity( Parity const _parity );
+
+		/**
+		 * Set the serial port stop bits.  The serial port must be closed for the setting to be accepted.
+ 		 * @param _stopBits StopBits enum value indicating the serial data's expected number of stop-bits.
+		 * @return True if the stop bits value was accepted.
+		 * @see Open, Close
+		 */
+		bool SetStopBits( StopBits const _stopBits );
+
+		/**
+		 * Open a serial port.
+		 * Attempts to open a serial port and initialize it with the specified paramters.
+		 * @param _SerialControllerName 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& _SerialControllerName );
+
+		/**
+		 * Close a serial port.
+		 * Closes the serial 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 serial port.
+		 * Attempts to write data to an open serial 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:
+        uint32                      m_baud;
+        SerialController::Parity    m_parity;
+        SerialController::StopBits  m_stopBits;
+		string						m_serialControllerName;
+
+		SerialControllerImpl*	    m_pImpl;	// Pointer to an object that encapsulates the platform-specific implementation of the serial port.
+		bool			            m_bOpen;
+	};
+
+} // namespace OpenZWave
+
+#endif //_SerialController_H
+

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

@@ -0,0 +1,229 @@
+//-----------------------------------------------------------------------------
+//
+//	Stream.h
+//
+//	Cross-platform circular buffer with signalling
+//
+//	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 "Stream.h"
+#include "Mutex.h"
+#include "Log.h"
+
+#include <string.h>
+
+#include <cstdio>
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<Stream::Stream>
+//	Constructor
+//-----------------------------------------------------------------------------
+Stream::Stream
+(
+	uint32 _bufferSize
+):
+	m_bufferSize( _bufferSize ),
+	m_signalSize(1),
+	m_dataSize(0),
+	m_head(0),
+	m_tail(0),
+	m_mutex( new Mutex() )
+{
+	m_buffer = new uint8[m_bufferSize];
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::~Stream>
+//	Destructor
+//-----------------------------------------------------------------------------
+Stream::~Stream
+(
+)
+{
+	m_mutex->Release();
+	delete [] m_buffer;
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::SetSignalThreshold>
+//	Set the amount of data that must be in the buffer for to to be signalled
+//-----------------------------------------------------------------------------
+void Stream::SetSignalThreshold
+(
+	uint32 _size 
+)
+{
+	m_signalSize = _size;
+	if( IsSignalled() )
+	{
+		// We have more data than we are waiting for, so notify the watchers
+		Notify();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::Get>
+//	Remove data from the buffer
+//-----------------------------------------------------------------------------
+bool Stream::Get
+(
+	uint8* _buffer,
+	uint32 _size
+)
+{
+	if( m_dataSize < _size )
+	{
+		// There is not enough data in the buffer to fulfill the request
+		Log::Write( LogLevel_Error, "ERROR: Not enough data in stream buffer");
+		return false;
+	}
+
+	m_mutex->Lock();
+	if( (m_tail + _size) > m_bufferSize )
+	{
+		// We will have to wrap around
+		uint32 block1 = m_bufferSize - m_tail;
+		uint32 block2 = _size - block1;
+
+		memcpy( _buffer, &m_buffer[m_tail], block1 );
+		memcpy( &_buffer[block1], m_buffer, block2 );
+		m_tail = block2;
+	}
+	else
+	{
+		// Requested data is in a contiguous block
+		memcpy( _buffer, &m_buffer[m_tail], _size );
+		m_tail += _size;
+	}
+
+	Log::Write( LogLevel_Debug, "      Stream::Get (provided to application)" );
+	LogData( _buffer, _size, "      Get: ");
+
+	m_dataSize -= _size;
+	m_mutex->Unlock();
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::Put>
+//	Add data to the buffer
+//-----------------------------------------------------------------------------
+bool Stream::Put
+(
+	uint8* _buffer,
+	uint32 _size
+)
+{
+	if( (m_bufferSize-m_dataSize) < _size )
+	{
+		// There is not enough space left in the buffer for the data
+		Log::Write( LogLevel_Error, "ERROR: Not enough space in stream buffer");
+		return false;
+	}
+
+	m_mutex->Lock();
+	Log::Write( LogLevel_Debug, "      Stream::Put (received from controller)" );
+	if( (m_head + _size) > m_bufferSize )
+	{
+		// We will have to wrap around
+		uint32 block1 = m_bufferSize - m_head;
+		uint32 block2 = _size - block1;
+
+		memcpy( &m_buffer[m_head], _buffer, block1 );
+		memcpy( m_buffer, &_buffer[block1], block2 );
+		m_head = block2;
+		LogData( m_buffer + m_head - block1, block1, "      Put: ");
+		LogData( m_buffer, block2, "      Put: ");
+	}
+	else
+	{
+		// There is enough space before we reach the end of the buffer
+		memcpy( &m_buffer[m_head], _buffer, _size );
+		m_head += _size;
+		LogData(m_buffer+m_head-_size, _size, "      Put: ");
+	}
+
+	m_dataSize += _size;
+
+	if( IsSignalled() )
+	{
+		// We now have more data than we are waiting for, so notify the watchers
+		Notify();
+	}
+
+	m_mutex->Unlock();
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::Purge>
+//	Empty the data buffer
+//-----------------------------------------------------------------------------
+void Stream::Purge
+(
+)
+{
+	m_tail = 0;
+	m_head = 0;
+	m_dataSize = 0;
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::IsSignalled>
+//	Test whether there is enough data to be signalled
+//-----------------------------------------------------------------------------
+bool Stream::IsSignalled
+(
+)
+{
+	return( m_dataSize >= m_signalSize );
+}
+
+//-----------------------------------------------------------------------------
+//	<Stream::LogData>
+//	Format the stream buffer data for log output
+//-----------------------------------------------------------------------------
+void Stream::LogData
+(
+	uint8* _buffer,
+	uint32 _length,
+	string _function
+)
+{
+	if( !_length ) return;
+
+	string str = "";
+	for( uint32 i=0; i<_length; ++i ) 
+	{
+		if( i )
+		{
+			str += ", ";
+		}
+			
+		char byteStr[8];
+		snprintf( byteStr, sizeof(byteStr), "0x%.2x", _buffer[i] );
+		str += byteStr;
+	}
+	Log::Write( LogLevel_Debug, "%s%s", _function.c_str(), str.c_str() );
+}