serdev.c File Reference

RS-232 serial device communication definitions. More...

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <limits.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/new.h"
#include "rnr/serdev.h"

Go to the source code of this file.

Classes
struct	SerDevAttrKvp_T
	Serial Device Attribute Key - Value Pair structure. More...

Macros
#define	NOTBITS(bits)   ~((uint_t)(bits))
	Bitwise complement. More...
#define	SERDEVLOG(buffer, size, bNewLine)   {if(LOGABLE(LOG_LEVEL_DIAG4)) {SerDevLogBytes(buffer, size, bNewLine);}}
	Log read/written bytes to log stream. More...
#define	SERDEVLOGNL()   {if(LOGABLE(LOG_LEVEL_DIAG4)) {fprintf(LOG_GET_LOGFP(), "\n");}}
	Write newline character to log stream.
#define	SERDEV_FIONREAD   0x541b
	number in input queue
#define	SERDEV_NO_ATTR   0xffffffff
	Special "No Attribute" value.
#define	SERDEV_ATTR_ENTRY(attr)   { (void *)#attr , attr }
	Serial device attribute macros. More...
#define	SERDEV_GET_ATTR(attr)
	Get I/O defined attribute value. More...
#define	SERDEV_BAUDRATE_ENTRY(baudrate)   { (void *)((unsigned long)baudrate), B##baudrate }
	Serial device supported baudrate macros. More...
#define	SERDEV_GET_BAUDRATE(baudrate)
	Get baudrate defined value. More...

Functions
static void	fdset_nowarn (int fd, fd_set *pset)
	FD_SET() wrapper with no annoying warnings. More...
static void	SerDevLogBytes (byte_t buffer[], size_t size, bool_t bNewLine)
	Log read/written bytes to log stream. More...
static void	timer_mark (struct timeval *pTvMark)
	Mark the current time. Resolution is microseconds. More...
static uint_t	timer_elapsed (struct timeval *pTvMark)
	Calculate the elapsed time between the given time mark and this call. More...
static int	SerDevOptAttrCmp (const void *pKey1, const void *pKey2)
	Serial option attribute comparator. More...
static int	SerDevBaudRateCmp (const void *pKey1, const void *pKey2)
	BaudRate attribute comparator. More...
static unsigned int	SerDevAttrLookup (SerDevAttrKvp_T tbl[], size_t nTblEntries, const void *pKey, int(*cmp)(const void *, const void *))
	Lookup the attribute value associated with the key. More...
static int	SerDevConfigure (int fd, int nBaudRate, int nByteSize, int cParity, int nStopBits, bool_t bRtsCts, bool_t bXonXoff)
	(Re)configure a serial device attibutes. More...
int	SerDevOpen (const char *sSerDevName, int nBaudRate, int nByteSize, int cParity, int nStopBits, bool_t bRtsCts, bool_t bXonXoff)
	Open and configure serial device for communication. More...
int	SerDevClose (int fd)
	Close serial device port. More...
ssize_t	SerDevReadLine (int fd, char buffer[], size_t count, char *eol, uint_t usec)
	Read a ASCII character line from the serial device. More...
ssize_t	SerDevWriteLine (int fd, char *buffer, char *eol, uint_t usec)
	Write null-terminated ASCII character line to serial device. More...
int	SerDevGetc (int fd, uint_t usec)
	Get 1 character from the serial device. More...
int	SerDevPutc (int fd, byte_t byte, uint_t usec)
	Put one character to serial device. More...
ssize_t	SerDevRead (int fd, byte_t *buffer, size_t count, uint_t usec)
	Read from the serial device. More...
ssize_t	SerDevWrite (int fd, byte_t *buffer, size_t count, uint_t usec)
	Write to serial device. More...
ssize_t	SerDevFIFOInputCount (int fd)
	Determine the number of bytes in the input FIFO of the serial device. More...
ssize_t	SerDevFIFOInputFlush (int fd)
	Flush the input FIFO buffer, discarding all data in buffer. More...
void	SerDevFIFOOutputFlush (int fd)
	Flush output FIFO buffer, discarding all data in buffer. More...
void	SerDevFIFOOutputDrain (int fd)
	Transmit (drain) all data written to the output FIFO buffer. More...
int	SerDevSetBaudRate (int fd, int nBaudRate)
	Set the baudrate. More...
int	SerDevSetByteSize (int fd, int nByteSize)
	Set the byte size. More...
int	SerDevSetParity (int fd, int cParity)
	Set the parity. More...
int	SerDevSetStopBits (int fd, int nStopBits)
	Set the number of stop bits. More...
int	SerDevSetHwFlowControl (int fd, bool_t bRtsCts)
	Set hardware flow control state. More...
int	SerDevSetSwFlowControl (int fd, bool_t bXonXoff)
	Set software flow control state. More...
int	SerDevAssertRTS (int fd)
	Assert RTS (request to send). More...
int	SerDevDeassertRTS (int fd)
	De-assert RTS (request to send). More...
int	SerDevAssertCTS (int fd)
	Assert RTS (clear to send). More...
int	SerDevDeassertCTS (int fd)
	De-assert RTS (clear to send). More...

Variables
static SerDevAttrKvp_T	SerDevOptAttrTbl []
	SerDevOptAttr table. Dynamic method to determine serial device optional defined attributes for each plaform architecture. More...
static SerDevAttrKvp_T	SerDevBaudRateTbl []
	SerDevBaudRate table. Dynamic method to determine Serial device supported baud rates for each plaform architecture.

Detailed Description

RS-232 serial device communication definitions.

LastChangedDate

2015-02-24 12:58:53 -0700 (Tue, 24 Feb 2015)

Rev

3870

Ported from ipserddev.c (RoadNarrows)

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2006-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file serdev.c.

Macro Definition Documentation

#define NOTBITS

(

bits

)

~((uint_t)(bits))

Bitwise complement.

Parameters

bits

Bits.

Definition at line 86 of file serdev.c.

Referenced by SerDevConfigure(), SerDevSetByteSize(), SerDevSetHwFlowControl(), SerDevSetParity(), SerDevSetStopBits(), and SerDevSetSwFlowControl().

#define SERDEV_ATTR_ENTRY

(

attr

)

{ (void *)#attr , attr }

Serial device attribute macros.

Parameters

attr	Attribute define.

Definition at line 243 of file serdev.c.

#define SERDEV_BAUDRATE_ENTRY

(

baudrate

)

{ (void *)((unsigned long)baudrate), B##baudrate }

Serial device supported baudrate macros.

Parameters

baudrate

Integer baudrate.

Definition at line 298 of file serdev.c.

#define SERDEV_GET_ATTR

(

attr

)

Value:

SerDevAttrLookup(SerDevOptAttrTbl, \
    arraysize(SerDevOptAttrTbl), (void *)#attr, SerDevOptAttrCmp)

Get I/O defined attribute value.

Parameters

attr	Attribute define.

Definition at line 249 of file serdev.c.

Referenced by SerDevConfigure(), SerDevSetHwFlowControl(), and SerDevSetSwFlowControl().

#define SERDEV_GET_BAUDRATE

(

baudrate

)

Value:

SerDevAttrLookup(SerDevBaudRateTbl, arraysize(SerDevBaudRateTbl), \
    (void *)((unsigned long)baudrate), SerDevBaudRateCmp)

Get baudrate defined value.

Parameters

baudrate

Integer baudrate.

Definition at line 305 of file serdev.c.

Referenced by SerDevConfigure(), and SerDevSetBaudRate().

#define SERDEVLOG	(		buffer,
			size,
			bNewLine
	)		{if(LOGABLE(LOG_LEVEL_DIAG4)) {SerDevLogBytes(buffer, size, bNewLine);}}

Log read/written bytes to log stream.

Parameters

buffer	Buffer of bytes.
size	Number of bytes in buffer to log.
bNewLine	Do [not] output trailing newline.

Definition at line 113 of file serdev.c.

Referenced by SerDevFIFOInputCount(), SerDevRead(), and SerDevWrite().

Function Documentation

static void fdset_nowarn ( int  fd, fd_set *  pset  )

inlinestatic

FD_SET() wrapper with no annoying warnings.

Parameters

fd	File descriptor to add to set.
pset	Pointer to fd set.

Definition at line 94 of file serdev.c.

Referenced by SerDevGetc(), SerDevPutc(), SerDevRead(), and SerDevWrite().

{
  FD_SET(fd, pset);
}

int SerDevAssertCTS

(

int

fd

)

Assert RTS (clear to send).

Parameters

fd	File descriptor to the opened serial device.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1500 of file serdev.c.

Referenced by SerDevDeassertCTS(), and SerDevIsInputDataPresent().

{
  int status;

  if( ioctl(fd, TIOCMGET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMGET,...)", fd);
    return RC_ERROR;
  }

  status |= TIOCM_CTS;

  if( ioctl(fd, TIOCMSET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMSET,0x%x)", fd, status);
    return RC_ERROR;
  }

  return OK;
}

int SerDevAssertRTS

(

int

fd

)

Assert RTS (request to send).

Parameters

fd	File descriptor to the opened serial device.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1458 of file serdev.c.

Referenced by SerDevDeassertCTS(), and SerDevIsInputDataPresent().

{
  int status;

  if( ioctl(fd, TIOCMGET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMGET,...)", fd);
    return RC_ERROR;
  }

  status |= TIOCM_RTS;

  if( ioctl(fd, TIOCMSET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMSET,0x%x)", fd, status);
    return RC_ERROR;
  }

  return OK;
}

static unsigned int SerDevAttrLookup ( SerDevAttrKvp_T  tbl[], size_t  nTblEntries, const void *  pKey, int(*)(const void *, const void *)  cmp  )

static

Lookup the attribute value associated with the key.

Parameters

tbl[]	Attribute Key-Value Pair table.
nTblEntries	Number of Key-Value Pair table entries.
pKey	Key to lookup.
cmp	Attribute key comparator function.

Returns

The associated attribute value on success, or SERDEV_NO_ATTR if the search failed.

Definition at line 433 of file serdev.c.

References SerDevAttrKvp_T::m_uVal, and SERDEV_NO_ATTR.

{
  int i;

  for(i=0; i<nTblEntries; ++i)
  {
    if( !cmp(tbl[i].m_pKey, pKey) )
    {
      return tbl[i].m_uVal;
    }
  }
  return SERDEV_NO_ATTR;
}

static int SerDevBaudRateCmp ( const void *  pKey1, const void *  pKey2  )

inlinestatic

BaudRate attribute comparator.

Parameters

pKey1	Attribute key 1
pKey2	Attribute key 2

Definition at line 314 of file serdev.c.

{
  return (unsigned long)pKey1 == (unsigned long)pKey2? 0: 1;
}

int SerDevClose

(

int

fd

)

Close serial device port.

Parameters

fd	File descriptor to the opened serial device.

Returns

On success, OK(0) is returned.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 704 of file serdev.c.

{
  LOGDIAG4CALL(_TINT(fd));

  if( fd < 0 )
  {
    LOGERROR("Invalid serial device file descriptor: %d", fd);
    errno = EBADF;
    return RC_ERROR;
  }
  else
  {
    return close(fd);
  }
}

static int SerDevConfigure ( int  fd, int  nBaudRate, int  nByteSize, int  cParity, int  nStopBits, bool_t  bRtsCts, bool_t  bXonXoff  )

static

(Re)configure a serial device attibutes.

Parameters

fd	File descriptor to the opened serial device.
nBaudRate	Baud rate.
nByteSize	Bytes size in bits 5...8.
cParity	Parity. One of: 'N', 'E', 'O'
nStopBits	Number of stop bits 1, 2
bRtsCts	Do [not] use hardware flow control.
bXonXoff	Do [not] use software flow control.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 463 of file serdev.c.

References NOTBITS, SERDEV_GET_ATTR, SERDEV_GET_BAUDRATE, and SERDEV_NO_ATTR.

Referenced by SerDevOpen().

{
  struct termios  tios;
  speed_t         ospeed, ispeed;
  uint_t          attr;

  if( fd < 0 )
  {
    LOGERROR("Invalid serial device file descriptor: %d", fd);
    errno = EBADF;
    return RC_ERROR;
  }

  // get the current device attributes
  if( tcgetattr(fd, &tios) == -1 )
  {
    LOGSYSERROR("tcgetattr(%d,...) failed", fd);
    return RC_ERROR;
  }

  // set up raw mode / no echo / binary
  tios.c_cflag |=  (CLOCAL|CREAD);
  tios.c_lflag &= NOTBITS(ICANON|ECHO|ECHOE|ECHOK|ECHONL|ISIG|IEXTEN);
                                    // |ECHOPRT
  if( (attr = SERDEV_GET_ATTR(ECHOCTL)) != SERDEV_NO_ATTR )
  {
    tios.c_lflag &= NOTBITS(attr);
  }
  if( (attr = SERDEV_GET_ATTR(ECHOKE)) != SERDEV_NO_ATTR )
  {
    tios.c_lflag &= NOTBITS(attr);
  }
        
  tios.c_oflag &= NOTBITS(OPOST);

  tios.c_iflag &= NOTBITS(INLCR|IGNCR|ICRNL|IGNBRK);
  if( (attr = SERDEV_GET_ATTR(IOCLC)) != SERDEV_NO_ATTR )
  {
    tios.c_iflag &= NOTBITS(attr);
  }
  if( (attr = SERDEV_GET_ATTR(PARMRK)) != SERDEV_NO_ATTR )
  {
    tios.c_iflag &= NOTBITS(attr);
  }
        
  // set up baudrate
  if((ospeed = SERDEV_GET_BAUDRATE(nBaudRate)) == SERDEV_NO_ATTR)
  {
    LOGERROR("Invalid/unsupported baud rate: %u", nBaudRate);
    errno = EINVAL;
    return RC_ERROR;
  }
  ispeed = ospeed;
  if( cfsetospeed(&tios, ospeed) == -1 )   // set output baudrate in structure
  {
    LOGSYSERROR("tcsetospeed(tios,%u)", ospeed);
    return RC_ERROR;
  }
  if( cfsetispeed(&tios, ispeed) == -1 )   // set input baudrate in structure
  {
    LOGSYSERROR("tcsetispeed(tios,%u)", ispeed);
    return RC_ERROR;
  }

  // set up data character size (bits)
  tios.c_cflag &= NOTBITS(CSIZE);
  switch( nByteSize )
  {
    case 8:
      tios.c_cflag |= CS8;
      break;
    case 7:
      tios.c_cflag |= CS7;
      break;
    case 6:
      tios.c_cflag |= CS6;
      break;
    case 5:
      tios.c_cflag |= CS5;
      break;
    default:
      LOGERROR("Invalid data byte size: %u", nByteSize);
      errno = EINVAL;
      return RC_ERROR;
  }

  // set up stopbits
  switch( nStopBits )
  {
    case 1:
      tios.c_cflag &= NOTBITS(CSTOPB);
      break;
    case 2:
      tios.c_cflag |=  (CSTOPB);
      break;
    default:
      LOGERROR("Invalid number of stop bits: %u", nStopBits);
      errno = EINVAL;
      return RC_ERROR;
  }

  // set up parity
  tios.c_iflag &= NOTBITS(INPCK|ISTRIP);
  switch( cParity )
  {
    case 'N':
      tios.c_cflag &= NOTBITS(PARENB|PARODD);
      break;
    case 'E':
      tios.c_cflag &= NOTBITS(PARODD);
      tios.c_cflag |=  (PARENB);
      break;
    case 'O':
      tios.c_cflag |=  (PARENB|PARODD);
      break;
    default:
      LOGERROR("Invalid parity: %c", cParity);
      errno = EINVAL;
      return RC_ERROR;
  }

  // set up xon/xoff software flow control
  if( (attr = SERDEV_GET_ATTR(IXANY)) != SERDEV_NO_ATTR )
  {
    if( bXonXoff )
    {
      tios.c_iflag |=  (IXON|IXOFF); // |IXANY)
    }
    else
    {
      tios.c_iflag &= NOTBITS(IXON|IXOFF|IXANY);
    }
  }
  else
  {
    if( bXonXoff )
    {
      tios.c_iflag |=  (IXON|IXOFF);
    }
    else
    {
      tios.c_iflag &= NOTBITS(IXON|IXOFF);
    }
  }

  // set up rts/cts hardware flow control
  if( (attr = SERDEV_GET_ATTR(CRTSCTS)) != SERDEV_NO_ATTR )
  {
    if( bRtsCts )
    {
      tios.c_cflag |=  (CRTSCTS);
    }
    else
    {
      tios.c_cflag &= NOTBITS(CRTSCTS);
    }
  }
  // try it with alternate constant name
  else if( (attr = SERDEV_GET_ATTR(CNEW_RTSCTS)) != SERDEV_NO_ATTR )
  {
    if( bRtsCts )
    {
      tios.c_cflag |=  (attr);
    }
    else
    {
      tios.c_cflag &= NOTBITS(attr);
    }
  }
  else
  {
    LOGDIAG4("Do not know how to set/clear RTS/CTS hardware flow control.");
  }
        
  // set up read buffering for non-blocking (vmin, vtime are byte values)
  // select() will handle timeouts.
  tios.c_cc[VMIN]  = 0;   // vmin is minimum number of characters to be read.
  tios.c_cc[VTIME] = 0;   // vtime is read timout in deciseconds 

  // activate the serial device settings
  if( tcsetattr(fd, TCSANOW, &tios) == -1 )
  {
    LOGSYSERROR("tcseattr(%d,TCSANOW,...)", fd);
    return RC_ERROR;
  }

  return OK;
}

int SerDevDeassertCTS

(

int

fd

)

De-assert RTS (clear to send).

Parameters

fd	File descriptor to the opened serial device.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1521 of file serdev.c.

References SerDevAssertCTS(), SerDevAssertRTS(), and SerDevDeassertRTS().

Referenced by SerDevIsInputDataPresent().

{
  int status;

  if( ioctl(fd, TIOCMGET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMGET,...)", fd);
    return RC_ERROR;
  }

  status &= ~TIOCM_CTS;

  if( ioctl(fd, TIOCMSET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMSET,0x%x)", fd, status);
    return RC_ERROR;
  }

  return OK;
}

int SerDevDeassertRTS

(

int

fd

)

De-assert RTS (request to send).

Parameters

fd	File descriptor to the opened serial device.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1479 of file serdev.c.

Referenced by SerDevDeassertCTS(), and SerDevIsInputDataPresent().

{
  int status;

  if( ioctl(fd, TIOCMGET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMGET,...)", fd);
    return RC_ERROR;
  }

  status &= ~TIOCM_RTS;

  if( ioctl(fd, TIOCMSET, &status) == -1 )
  {
    LOGSYSERROR("ioctl(%d,TIOCMSET,0x%x)", fd, status);
    return RC_ERROR;
  }

  return OK;
}

ssize_t SerDevFIFOInputCount

(

int

fd

)

Determine the number of bytes in the input FIFO of the serial device.

The input FIFO holds data received but not read.

Parameters

fd	File descriptor to the opened serial device.

Returns

On success, the number of bytes in the input FIFO.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1146 of file serdev.c.

References SERDEV_FIONREAD, SerDevFIFOInputFlush(), SERDEVLOG, SERDEVLOGNL, and SerDevRead().

Referenced by SerDevFIFOInputFlush(), and SerDevIsInputDataPresent().

{
  unsigned int  nBytes = 0;
  int           rc;

  rc = ioctl(fd, (unsigned long)SERDEV_FIONREAD, &nBytes);
  if( rc == -1 )
  {
    // not a tty, something is hosed 
    if( errno != ENOTTY )
    {
      LOGSYSERROR("ioctl(%d,0x%x,...)", fd, SERDEV_FIONREAD);
      return (ssize_t)(RC_ERROR);
    }
    else
    {
      return (ssize_t)0;
    }
  }
  else
  {
    return (ssize_t)nBytes;
  }
}

ssize_t SerDevFIFOInputFlush

(

int

fd

)

Flush the input FIFO buffer, discarding all data in buffer.

The input FIFO holds data received but not read.

This function does not block.

Parameters

fd	File descriptor to the opened serial device.

Returns

The number of bytes flushed.

Definition at line 1202 of file serdev.c.

References SerDevFIFOInputCount().

Referenced by SerDevFIFOInputCount().

{
  ssize_t n;

  LOGDIAG4CALL(_TINT(fd));

  n = SerDevFIFOInputCount(fd);

  tcflush(fd, TCIFLUSH);

  return n;
}

void SerDevFIFOOutputDrain

(

int

fd

)

Transmit (drain) all data written to the output FIFO buffer.

The output FIFO holds data written to the device but not transmitted.

This function blocks until all of the FIFO data has been transmitted.

Parameters

fd	File descriptor to the opened serial device.

Definition at line 1223 of file serdev.c.

{
  LOGDIAG4CALL(_TINT(fd));

  tcdrain(fd);
}

void SerDevFIFOOutputFlush

(

int

fd

)

Flush output FIFO buffer, discarding all data in buffer.

The output FIFO holds data written to the device but not transmitted.

This function does not block.

Parameters

fd	File descriptor to the opened serial device.

Definition at line 1216 of file serdev.c.

{
  LOGDIAG4CALL(_TINT(fd));

  tcflush(fd, TCOFLUSH);
}

int SerDevGetc	(	int	fd,
		uint_t	usec
	)

Get 1 character from the serial device.

Read 1 character from the serial device input. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the read can block indefinitely.

Parameters

fd	File descriptor to the opened serial device.
usec	Timeout in microseconds. If usec > 0, an upper timeout limit is placed on the read. If usec == 0, then the read will block indefinitely until count bytes are read or an I/O error occurred.

Returns

On success, returns the character read as unsigned char cast to an int.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 843 of file serdev.c.

References fdset_nowarn().

Referenced by SerDevReadLine().

{
  byte_t          byte;
  fd_set          rset;
  struct timeval  timeout;
  int             nFd;
  ssize_t         n;

  LOGDIAG4CALL(_TINT(fd), _TUINT(usec));

  FD_ZERO(&rset);
  fdset_nowarn(fd, &rset);

  // wait for character with timeout
  if( usec > 0 )
  {
    // load timeout
    timeout.tv_sec  = (time_t)(usec / 1000000);
    timeout.tv_usec = (time_t)(usec % 1000000);

    nFd = select(fd+1, &rset, NULL, NULL, &timeout);
  }

  // block indefinitely for character
  else 
  {
    nFd = select(fd+1, &rset, NULL, NULL, NULL);
  }

  // system error occurred
  if( nFd < 0 )
  {
    LOGSYSERROR("select(%d,...)", fd);
    return RC_ERROR;
  }

  // select() timeout occurred
  else if( nFd == 0 )
  {
    LOGDIAG4("select() on read timed out");
    errno = ETIMEDOUT;
    return RC_ERROR;
  }

  // data available from serial device, but error on read
  else if( (n = read(fd, &byte, (size_t)1)) < 0 )
  {
    LOGSYSERROR("read(%d,...)", fd);
    return RC_ERROR;
  }

  // nothing read
  else if( n == 0 )
  {
    LOGERROR("0=read(%d,...)", fd);
    errno = EIO;
    return RC_ERROR;
  }

  // read character
  else
  {
    LOGDIAG4("%s() byte=0x%02x read", LOGFUNCNAME, byte);
    return (int)(((uint_t)(byte)) & 0x00ff);
  }
}

static void SerDevLogBytes ( byte_t  buffer[], size_t  size, bool_t  bNewLine  )

static

Log read/written bytes to log stream.

Parameters

buffer	Buffer of bytes.
size	Number of bytes in buffer to log.
bNewLine	Do [not] output trailing newline.

Definition at line 138 of file serdev.c.

{
  size_t   n;
  FILE    *fp;
  char    *sep = " ";

  if( size == 0 )
  {
    return;
  }

  fp = LOG_GET_LOGFP();

  for(n=0; n<size; ++n)
  {
    fprintf(fp, "%s0x%02x", sep, buffer[n]);
  }

  if( bNewLine )
  {
    fprintf(fp, "\n");
  }
}

int SerDevOpen	(	const char *	sSerDevName,
		int	nBaudRate,
		int	nByteSize,
		int	cParity,
		int	nStopBits,
		bool_t	bRtsCts,
		bool_t	bXonXoff
	)

Open and configure serial device for communication.

Parameters

sSerDevName	Serial device port name (e.g. /dev/ttyS0).
nBaudRate	Baud rate.
nByteSize	Bytes size in bits 5...8.
cParity	Parity. One of: 'N', 'E', 'O'
nStopBits	Number of stop bits 1, 2
bRtsCts	Do [not] use hardware flow control.
bXonXoff	Do [not] use software flow control.

Returns

On success, a file descriptor(>=0) to the opened serial device.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 663 of file serdev.c.

References SerDevConfigure().

{
  int fd;

  LOGDIAG4CALL( _TSTR(sSerDevName),
                _TINT(nBaudRate),
                _TINT(nByteSize),
                _TCHAR(cParity),
                _TINT(nStopBits),
                _TBOOL(bRtsCts),
                _TBOOL(bXonXoff) );

  fd = open(sSerDevName, O_RDWR|O_NONBLOCK|O_NOCTTY);

  if( fd == -1 )
  {
    LOGSYSERROR("open(%s,...)", sSerDevName);
    return RC_ERROR;
  }

  else if( SerDevConfigure(fd, nBaudRate, nByteSize, cParity,
                            nStopBits, bRtsCts, bXonXoff) != OK )
  {
    LOGERROR("SerDevConfigure(): failed");
    close(fd);
    return RC_ERROR;
  }

  else
  {
    LOGDIAG4("Serial device %s opened", sSerDevName);
    return fd;
  }
}

static int SerDevOptAttrCmp ( const void *  pKey1, const void *  pKey2  )

inlinestatic

Serial option attribute comparator.

Parameters

pKey1	Attribute key 1
pKey2	Attribute key 2

Definition at line 258 of file serdev.c.

{
  return strcmp((const char *)pKey1, (const char *)pKey2);
}

int SerDevPutc	(	int	fd,
		byte_t	byte,
		uint_t	usec
	)

Put one character to serial device.

Write 1 character to the serial device output. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the write can block indefinitely.

Parameters

fd	File descriptor to the opened serial device.
byte	Character to write.
usec	Timeout in microseconds. If usec > 0, an upper timeout limit is placed on the write. If usec == 0, then the write will block indefinitely until count bytes are written or an I/O error occurred.

Returns

On success, returns the character written as unsigned char cast to an int.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 910 of file serdev.c.

References fdset_nowarn().

{
  fd_set          wset;
  struct timeval  timeout;
  int             nFd;
  ssize_t         n;

  LOGDIAG4CALL(_TINT(fd), _THEX(byte), _TUINT(usec));

  FD_ZERO(&wset);
  fdset_nowarn(fd, &wset);

  // wait for output with timeout
  if( usec > 0 )
  {
    // load timeout (gets munged after each select())
    timeout.tv_sec  = (time_t)(usec / 1000000);
    timeout.tv_usec = (time_t)(usec % 1000000);

    nFd = select(fd+1, NULL, &wset, NULL, &timeout);
  }

  // block indefinitely for output
  else 
  {
    nFd = select(fd+1, NULL, &wset, NULL, NULL);
  }

  // system error occurred
  if( nFd < 0 )
  {
    LOGSYSERROR("select(%d,...)", fd);
    return RC_ERROR;
  }

  // select() timeout occurred
  else if( nFd == 0 )
  {
    LOGDIAG4("select() on write timed out");
    errno = ETIMEDOUT;
    return RC_ERROR;
  }

  // data available from serial device (but error on write)
  else if( (n = write(fd, &byte, (size_t)1)) < 0 )
  {
    LOGSYSERROR("write(%d,...)", fd);
    return RC_ERROR;
  }

  // nothing written
  else if( n == 0 )
  {
    LOGERROR("0=write(%d,...)", fd);
    errno = EIO;
    return RC_ERROR;
  }

  // character written
  else
  {
    LOGDIAG4("%s() byte=0x%02x written", LOGFUNCNAME, byte);
    return (int)(((uint_t)(byte)) & 0x00ff);
  }
}

ssize_t SerDevRead	(	int	fd,
		byte_t *	buffer,
		size_t	count,
		uint_t	usec
	)

Read from the serial device.

Read up to count bytes into buffer from the serial device input. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the read can block indefinitely.

Note the the bytes read can be less than the count.

Parameters

fd	File descriptor to the opened serial device.
buffer	Output read buffer.
count	Number of bytes to read.
usec	Timeout in microseconds. If usec > 0, an upper timeout limit is placed on the read. If usec == 0, then the read will block indefinitely until count bytes are read or an I/O error occurred.

Returns

On success, the number of bytes read into buffer.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 976 of file serdev.c.

References fdset_nowarn(), SERDEVLOG, timer_elapsed(), and timer_mark().

Referenced by SerDevFIFOInputCount().

{
  bool_t          bNonBlocking;
  ssize_t         nBytes = 0;
  struct timeval  tstart;
  uint_t          tdelta;
  fd_set          rset;
  struct timeval  timeout;
  int             nFd;
  ssize_t         n;

  LOGDIAG4CALL(_TINT(fd), _TPTR(buffer), _TUINT(count), _TUINT(usec));

  bNonBlocking = usec > 0? true: false;

  while( nBytes < count )
  {
    FD_ZERO(&rset);
    fdset_nowarn(fd, &rset);

    // wait for input with timeout
    if( bNonBlocking )
    {
      timer_mark(&tstart);

      // (re)load timeout (gets munged after each select())
      timeout.tv_sec  = (time_t)(usec / 1000000);
      timeout.tv_usec = (time_t)(usec % 1000000);

      nFd = select(fd+1, &rset, NULL, NULL, &timeout);
    }
    // block indefinitely for input
    else 
    {
      nFd = select(fd+1, &rset, NULL, NULL, NULL);
    }

    // system error occurred
    if( nFd < 0 )
    {
      LOGSYSERROR("select(%d,...)", fd);
      return (ssize_t)(RC_ERROR);
    }

    // select() timeout occurred
    else if( nFd == 0 )
    {
      LOGDIAG4("select() on read timed out");
    }

    // data available from serial device (but error on read)
    else if( (n = read(fd, buffer+nBytes, count-(size_t)nBytes)) < 0 )
    {
      LOGSYSERROR("read(%d,...)", fd);
      return (ssize_t)(RC_ERROR);
    }

    // read some data
    else
    {
      nBytes += n;
    }

    // determine time left for non-blocking read timeout
    if( (nBytes < count) && bNonBlocking )
    {
      tdelta = timer_elapsed(&tstart);
      if( tdelta >= usec )
      {
        LOGDIAG4("%s() timed out", LOGFUNCNAME);
        break;
      }
      else
      {
        usec -= tdelta;
      }
    }
  }

  LOGDIAG4("%s() %lu bytes read", LOGFUNCNAME, nBytes);
  SERDEVLOG(buffer, (size_t)nBytes, true);

  return nBytes;
}

ssize_t SerDevReadLine	(	int	fd,
		char	buffer[],
		size_t	count,
		char *	eol,
		uint_t	usec
	)

Read a ASCII character line from the serial device.

Read up to count bytes into buffer from the serial device input. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the read can block indefinitely.

The end-of-line sequence defines the end of the line. It is stripped from the return buffer.

Parameters

	fd	File descriptor to the opened serial device.
[out]	buffer	Output read buffer.
	count	Number of bytes to read.
	eol	End-of-line character sequence > 0.
	usec	Timeout in microseconds. If usec > 0, an upper timeout limit is placed on the read. If usec == 0, then the read will block indefinitely until count bytes are read or an I/O error occurred.

Returns

On success, the number of bytes read into buffer.
On failure, errno is set and RC_ERROR(-1) is returned.
In either case, the buffer is guaranteed to be NULL terminated.

Definition at line 720 of file serdev.c.

References SerDevGetc(), timer_elapsed(), and timer_mark().

{
  struct timeval  tstart;         // start of read line
  uint_t          tdelta;         // read delta time
  int             c;              // received character
  ssize_t         len = 0;        // length of line sans eol sequence
  bool_t          bInEol = false; // [not] in end-of-line state
  char           *sSave = eol;    // save eol pointer

  buffer[0] = 0;

  // must have an end-of-line termination sequence
  if( (eol == NULL) || (*eol == 0) )
  {
    LOGERROR("No end-of-line sequence specified.");
    return RC_ERROR;
  }

  // start 
  timer_mark(&tstart);

  //
  // Read until the end of the end-of-line sequence or an error has occurred.
  //
  while( len < count-1 )
  {
    // read character
    c = SerDevGetc(fd, usec);

    // read error occurred
    if( c < 0 )
    {
      buffer[len] = 0;
      return RC_ERROR;
    }

    // end-of-line sequence
    else if( c == *eol )
    {
      // start of eol
      if( !bInEol )
      {
        buffer[len] = 0;
        bInEol = true;
      }

      ++eol;

      // got a full line
      if( *eol == 0 )
      {
        return len;
      }
    }

    // unexpected character in end-of-line sequence
    else if( bInEol )
    {
      LOGWARN("Unexpected character '%c' found in end-of-line sequence \"%s\".",
          c, sSave);
      return len;
    }

    // normal character
    else
    {
      buffer[len++] = (char)c;
    }

    // delta time
    tdelta = timer_elapsed(&tstart);

    // timed out
    if( (usec > 0) && (tdelta >= usec) )
    {
      LOGDIAG4("%s() timed out", LOGFUNCNAME);
      buffer[len] = 0;
      return RC_ERROR;
    }
  }

  buffer[len] = 0;

  LOGERROR("Line > %zu characters long.", count);

  return RC_ERROR;
}

int SerDevSetBaudRate	(	int	fd,
		int	nBaudRate
	)

Set the baudrate.

Parameters

fd	File descriptor to the opened serial device.
nBaudRate	Baud rate.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1230 of file serdev.c.

References SERDEV_GET_BAUDRATE, and SERDEV_NO_ATTR.

Referenced by SerDevIsInputDataPresent().

{
  struct termios  tios;
  speed_t         ospeed, ispeed;

  LOGDIAG4CALL(_TINT(fd), _TINT(nBaudRate));

  // get the current device attributes
  if( tcgetattr(fd, &tios) == -1 )
  {
    LOGSYSERROR("tcgetattr(%d,...) failed", fd);
    return RC_ERROR;
  }

  // set up baudrate
  if((ospeed = SERDEV_GET_BAUDRATE(nBaudRate)) == SERDEV_NO_ATTR)
  {
    LOGERROR("Invalid/unsupported baud rate: %u", nBaudRate);
    errno = EINVAL;
    return RC_ERROR;
  }
  ispeed = ospeed;
  if( cfsetospeed(&tios, ospeed) == -1 )   // set output baudrate in structure
  {
    LOGSYSERROR("tcsetospeed(tios,%u)", ospeed);
    return RC_ERROR;
  }
  if( cfsetispeed(&tios, ispeed) == -1 )   // set input baudrate in structure
  {
    LOGSYSERROR("tcsetispeed(tios,%u)", ispeed);
    return RC_ERROR;
  }

  return OK;
}

int SerDevSetByteSize	(	int	fd,
		int	nByteSize
	)

Set the byte size.

Parameters

fd	File descriptor to the opened serial device.
nByteSize	Bytes size in bits 5...8.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1266 of file serdev.c.

References NOTBITS.

Referenced by SerDevIsInputDataPresent().

{
  struct termios  tios;

  LOGDIAG4CALL(_TINT(fd), _TINT(nByteSize));

  // set up data character size (bits)
  tios.c_cflag &= NOTBITS(CSIZE);
  switch( nByteSize )
  {
    case 8:
      tios.c_cflag |= CS8;
      break;
    case 7:
      tios.c_cflag |= CS7;
      break;
    case 6:
      tios.c_cflag |= CS6;
      break;
    case 5:
      tios.c_cflag |= CS5;
      break;
    default:
      LOGERROR("Invalid data byte size: %u", nByteSize);
      errno = EINVAL;
      return RC_ERROR;
  }

  return OK;
}

int SerDevSetHwFlowControl	(	int	fd,
		bool_t	bRtsCts
	)

Set hardware flow control state.

Parameters

fd	File descriptor to the opened serial device.
bRtsCts	Do [not] use hardware flow control.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1350 of file serdev.c.

References NOTBITS, SERDEV_GET_ATTR, and SERDEV_NO_ATTR.

Referenced by SerDevIsInputDataPresent().

{
  struct termios  tios;
  unsigned int    attr;

  LOGDIAG4CALL(_TINT(fd), _TBOOL(bRtsCts));

  // get the current device attributes
  if( tcgetattr(fd, &tios) == -1 )
  {
    LOGSYSERROR("tcgetattr(%d,...) failed", fd);
    return RC_ERROR;
  }

  // set up rts/cts hardware flow control
  if( (attr = SERDEV_GET_ATTR(CRTSCTS)) != SERDEV_NO_ATTR )
  {
    if( bRtsCts )
    {
      tios.c_cflag |=  (CRTSCTS);
    }
    else
    {
      tios.c_cflag &= NOTBITS(CRTSCTS);
    }
  }
  // try it with alternate constant name
  else if( (attr = SERDEV_GET_ATTR(CNEW_RTSCTS)) != SERDEV_NO_ATTR )
  {
    if( bRtsCts )
    {
      tios.c_cflag |=  (attr);
    }
    else
    {
      tios.c_cflag &= NOTBITS(attr);
    }
  }
  else
  {
    LOGDIAG4("Do not know how to set/clear RTS/CTS hardware flow control.");
    return RC_ERROR;
  }

  // flush data
  if( tcflush(fd, TCIOFLUSH) == -1 )
  {
    LOGSYSERROR("tcflush(%d,TCIOFLUSH)", fd);
  }

  // set hw flow control
  if( tcsetattr(fd, TCSANOW, &tios) == -1 )
  {
    LOGSYSERROR("tcseattr(%d,TCSANOW,...)", fd);
    return RC_ERROR;
  }

  return OK;
}

int SerDevSetParity	(	int	fd,
		int	cParity
	)

Set the parity.

Parameters

fd	File descriptor to the opened serial device.
cParity	Parity. One of: 'N', 'E', 'O'

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1297 of file serdev.c.

References NOTBITS.

Referenced by SerDevIsInputDataPresent().

{
  struct termios  tios;

  LOGDIAG4CALL(_TINT(fd), _TCHAR(cParity));

  // set up parity
  tios.c_iflag &= NOTBITS(INPCK|ISTRIP);
  switch( cParity )
  {
    case 'N':
      tios.c_cflag &= NOTBITS(PARENB|PARODD);
      break;
    case 'E':
      tios.c_cflag &= NOTBITS(PARODD);
      tios.c_cflag |=  (PARENB);
      break;
    case 'O':
      tios.c_cflag |=  (PARENB|PARODD);
      break;
    default:
      LOGERROR("Invalid parity: %c", cParity);
      errno = EINVAL;
      return RC_ERROR;
  }

  return OK;
}

int SerDevSetStopBits	(	int	fd,
		int	nStopBitgs
	)

Set the number of stop bits.

Parameters

fd	File descriptor to the opened serial device.
nStopBits	Number of stop bits 1, 2

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1326 of file serdev.c.

References NOTBITS.

Referenced by SerDevIsInputDataPresent().

{
  struct termios  tios;

  LOGDIAG4CALL(_TINT(fd), _TINT(nStopBits));

  // set up stopbits
  switch( nStopBits )
  {
    case 1:
      tios.c_cflag &= NOTBITS(CSTOPB);
      break;
    case 2:
      tios.c_cflag |=  (CSTOPB);
      break;
    default:
      LOGERROR("Invalid number of stop bits: %u", nStopBits);
      errno = EINVAL;
      return RC_ERROR;
  }

  return OK;
}

int SerDevSetSwFlowControl	(	int	fd,
		bool_t	bXonXoff
	)

Set software flow control state.

Parameters

fd	File descriptor to the opened serial device.
bXonXoff	Do [not] use software flow control.

Returns

Returns OK(0) on success.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1410 of file serdev.c.

References NOTBITS, SERDEV_GET_ATTR, and SERDEV_NO_ATTR.

Referenced by SerDevIsInputDataPresent().

{
  struct termios  tios;
  unsigned int    attr;

  LOGDIAG4CALL(_TINT(fd), _TBOOL(bXonXoff));

  // get the current device attributes
  if( tcgetattr(fd, &tios) == -1 )
  {
    LOGSYSERROR("tcgetattr(%d,...) failed", fd);
    return RC_ERROR;
  }

  // set up xon/xoff software flow control
  if( (attr = SERDEV_GET_ATTR(IXANY)) != SERDEV_NO_ATTR )
  {
    if( bXonXoff )
    {
      tios.c_iflag |=  (IXON|IXOFF); // |IXANY)
    }
    else
    {
      tios.c_iflag &= NOTBITS(IXON|IXOFF|IXANY);
    }
  }
  else
  {
    if( bXonXoff )
    {
      tios.c_iflag |=  (IXON|IXOFF);
    }
    else
    {
      tios.c_iflag &= NOTBITS(IXON|IXOFF);
    }
  }

  // set sw flow control
  if( tcsetattr(fd, TCSANOW, &tios) == -1 )
  {
    LOGSYSERROR("tcseattr(%d,TCSANOW,...)", fd);
    return RC_ERROR;
  }

  return OK;
}

ssize_t SerDevWrite	(	int	fd,
		byte_t *	buffer,
		size_t	count,
		uint_t	usec
	)

Write to serial device.

Write up to count bytes from the buffer to the serial device output. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the write can block indefinitely.

Note that the number of bytes written can be less than the count.

Parameters

fd	File descriptor to the opened serial device.
buffer	Input write buffer.
count	Number of of bytes to write.
usec	Timeout in microseconds. If usec > 0, an upper timeout limit is placed on the write. If usec == 0, then the write will block indefinitely until count bytes are written or an I/O error occurred.

Returns

On success, the number of bytes written is returned.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 1061 of file serdev.c.

References fdset_nowarn(), SERDEVLOG, timer_elapsed(), and timer_mark().

Referenced by SerDevWriteLine().

{
  bool_t          bNonBlocking;
  ssize_t         nBytes = 0;
  struct timeval  tstart;
  uint_t          tdelta;
  fd_set          wset;
  struct timeval  timeout;
  int             nFd;
  ssize_t         n;

  LOGDIAG4CALL(_TINT(fd), _TPTR(buffer), _TUINT(count), _TUINT(usec));

  bNonBlocking = usec > 0? true: false;

  while( nBytes < count )
  {
    FD_ZERO(&wset);
    fdset_nowarn(fd, &wset);

    // wait for output with timeout
    if( bNonBlocking )
    {
      timer_mark(&tstart);

      // (re)load timeout (gets munged after each select())
      timeout.tv_sec  = (time_t)(usec / 1000000);
      timeout.tv_usec = (time_t)(usec % 1000000);

      nFd = select(fd+1, NULL, &wset, NULL, &timeout);
    }
    // block indefinitely for output
    else 
    {
      nFd = select(fd+1, NULL, &wset, NULL, NULL);
    }

    // system error occurred
    if( nFd < 0 )
    {
      LOGSYSERROR("select(%d,...)", fd);
      return (ssize_t)(RC_ERROR);
    }

    // select() timeout occurred
    else if( nFd == 0 )
    {
      LOGDIAG4("select() on write timed out");
    }

    // data available from serial device (but error on read)
    else if( (n = write(fd, buffer+nBytes, count-(size_t)nBytes)) < 0 )
    {
      LOGSYSERROR("write(%d,...)", fd);
      return (ssize_t)(RC_ERROR);
    }

    // written some data
    else
    {
      nBytes += n;
    }

    // determine time left for non-blocking read timeout
    if( (nBytes < count) && bNonBlocking )
    {
      tdelta = timer_elapsed(&tstart);
      if( tdelta >= usec )
      {
        LOGDIAG4("%s() timed out", LOGFUNCNAME);
        break;
      }
      else
      {
        usec -= tdelta;
      }
    }
  }

  LOGDIAG4("%s() %lu bytes written", LOGFUNCNAME, nBytes);
  SERDEVLOG(buffer, (size_t)nBytes, true);

  return nBytes;
}

ssize_t SerDevWriteLine	(	int	fd,
		char *	buffer,
		char *	eol,
		uint_t	usec
	)

Write null-terminated ASCII character line to serial device.

Write line plus end-of-line sequence. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the write can block indefinitely.

Parameters

	fd	File descriptor to the opened serial device.
[in]	buffer	Buffer to write.
	eol	End-of-line character sequence to append to buffer output.
	usec	Timeout in microseconds. If usec > 0, an upper timeout limit is placed on the write. If usec == 0, then the write will block indefinitely until count bytes are written or an I/O error occurred.

Returns

On success, the number of bytes written is returned.
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 812 of file serdev.c.

References SerDevWrite().

{
  size_t  lenBuf, lenEol;
  ssize_t m, n;

  // must have an end-of-line termination sequence
  if( (eol == NULL) || (*eol == 0) )
  {
    LOGERROR("No end-of-line sequence specified.");
    return RC_ERROR;
  }

  lenBuf = strlen(buffer);
  lenEol = strlen(eol);

  m = SerDevWrite(fd, (byte_t *)buffer, lenBuf, usec);
  n = SerDevWrite(fd, (byte_t *)eol, lenEol, usec);

  if( (m == lenBuf) && (n == lenEol) )
  {
    return m;
  }
  else
  {
    return RC_ERROR;
  }
}

static uint_t timer_elapsed ( struct timeval *  pTvMark )

static

Calculate the elapsed time between the given time mark and this call.

Parameters

pTvMark

Pointer to timeval holding time mark.

Returns

Number of microseconds elasped. If the marked time is invalid or the current time cannot be ascertained, UINT_MAX is returned.

Definition at line 192 of file serdev.c.

References timer_mark().

Referenced by SerDevRead(), SerDevReadLine(), and SerDevWrite().

{
  struct timeval  tvEnd, tvDelta;

  timer_mark(&tvEnd);

  if( !timerisset(pTvMark) || !timerisset(&tvEnd) )
  {
    return UINT_MAX;
  }

  tvDelta.tv_sec = tvEnd.tv_sec - pTvMark->tv_sec;
  if( tvEnd.tv_usec < pTvMark->tv_usec )
  {
    tvDelta.tv_sec--;
    tvEnd.tv_usec += 1000000;
  }
  tvDelta.tv_usec = tvEnd.tv_usec - pTvMark->tv_usec;

  return (uint_t)(tvDelta.tv_sec * 1000000 + tvDelta.tv_usec);
}

static void timer_mark ( struct timeval *  pTvMark )

inlinestatic

Mark the current time. Resolution is microseconds.

Parameters

pTvMark

Pointer to timeval structure to be populated with the current system seconds and useconds.

Definition at line 174 of file serdev.c.

Referenced by SerDevRead(), SerDevReadLine(), SerDevWrite(), and timer_elapsed().

{
  if( gettimeofday(pTvMark, NULL) != OK )
  {
    LOGSYSERROR("gettimeofday()");
    timerclear(pTvMark);
  }
}

Variable Documentation

SerDevAttrKvp_T SerDevOptAttrTbl[]

static

Initial value:

=
{





















  {(void *)"*noattr*",   0xffffffff } 
}

SerDevOptAttr table. Dynamic method to determine serial device optional defined attributes for each plaform architecture.

Definition at line 268 of file serdev.c.