SerialPortClass.cpp

Go to the documentation of this file.

/**
\file    SerialPortClass.cpp
\brief   A class for handling serial port communications. \n
         The intention is for this class to handle WIN32 serial port
         communications and eventually also linux serial port 
         communications. A preprocessor directive will be used
         to distinguish the build.

\author  Glenn D. MacGougan (GDM)
\date    2008-11-26
\since   2008-11-26

\b "LICENSE INFORMATION" \n
Copyright (c) 2008, refer to 'author' doxygen tags \n
All rights reserved. \n

Redistribution and use in source and binary forms, with or without
modification, are permitted provided the following conditions are met: \n

- Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer. \n
- Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution. \n
- The name(s) of the contributor(s) may not be used to endorse or promote 
  products derived from this software without specific prior written 
  permission. \n

THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS 
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
SUCH DAMAGE.
*/

#include <stdio.h>
#include "SerialPortClass.h"


SerialPort::~SerialPort()
{
  if( m_serialport.isPortOpen )
  {
    if( !SERIALPORT_Close( &m_serialport ) )
    {
      SERIALPORT_ERROR_MSG( "SERIALPORT_Close returned FALSE." );
    }
  }
}


SerialPort::SerialPort() 
{     
  if( !SERIALPORT_Initialize( &m_serialport) )
  {
    SERIALPORT_ERROR_MSG( "SERIALPORT_Init returned FALSE." );    
  }
}

bool SerialPort::Close()
{
  if( m_serialport.isPortOpen )
  {
    if( !SERIALPORT_Close( &m_serialport ) )
    {
      SERIALPORT_ERROR_MSG( "SERIALPORT_Close returned FALSE." );
      return false;
    }
  }
  return true;
}

bool SerialPort::Open(
  const unsigned short              portnumber,   //!< The COM port number [1-N].
  const SERIALPORT_enumBaudRate     baudrate,     //!< The port baud rate [bps].
  const SERIALPORT_enumParity       parity,       //!< The port parity setting.
  const SERIALPORT_enumDataBits     databits,     //!< The port data bits setting.
  const SERIALPORT_enumStopBits     stopbits,     //!< The port stop bits setting.
  const SERIALPORT_enumFlowControl  flowcontrol,  //!< The port flow control setting.
  const SERIALPORT_enumBehaviour    behaviour,    //!< The port's read behaviour (settings for waiting on the read timeout).
  const unsigned                    timeout_in_ms //!< The read function's timeout [ms]. Not used if behaviour == SERIALPORT_BEHAVIOUR_RETURN_IMMEDIATELY.
  )
{
  m_serialport.port = portnumber;
  m_serialport.baudrate = baudrate;
  m_serialport.parity = parity;
  m_serialport.databits = databits;
  m_serialport.stopbits = stopbits;
  m_serialport.flowcontrol = flowcontrol;
  m_serialport.behaviour = behaviour;
  m_serialport.timeout = timeout_in_ms;

  if( !SERIALPORT_Open( &m_serialport ) )
  {
    SERIALPORT_ERROR_MSG( "SERIALPORT_Open returned FALSE." );    
    return false;
  } 
  return true;
}

bool SerialPort::Read(
  unsigned char* buffer,     //!< A valid buffer (!NULL) in which to place data. 
  const unsigned bufferSize, //!< The size of the buffer [bytes].
  unsigned& nrBytesRead      //!< The number of bytes read [bytes].
  )
{
  if( !SERIALPORT_Read( &m_serialport, buffer, bufferSize, &nrBytesRead ) )
  {
    SERIALPORT_ERROR_MSG( "SERIALPORT_Read returned FALSE." );
    return false;
  } 
  return true;
}

bool SerialPort::Write(
  unsigned char* buffer,        //!< A valid buffer (!NULL) with data to be written to the port. 
  const unsigned nrBytesToWrite //!< The number of bytes in the buffer to write [bytes].    
  )
{
  if( !SERIALPORT_Write( &m_serialport, buffer, nrBytesToWrite ) )
  {
    SERIALPORT_ERROR_MSG( "SERIALPORT_Write returned FALSE." );
    return false;
  } 
  return true;
}

bool SerialPort::WaitOnRingIndicator( unsigned short timeout_ms, bool& ring_detected )
{
  BOOL rd = FALSE;
  if( !SERIALPORT_WaitOnRingIndicatorEvent( &m_serialport, timeout_ms, &rd ) )
  {
    SERIALPORT_ERROR_MSG( "SERIALPORT_WaitOnRingIndicatorEvent returned FALSE." );
    return false;
  } 
  if( rd )
    ring_detected = true;
  else
    ring_detected = false;

  return true;
}