simgear/io/sg_serial.cxx

   1 // sg_serial.cxx -- Serial I/O routines
   2 //
   3 // Written by Curtis Olson, started November 1999.
   4 //
   5 // Copyright (C) 1999  Curtis L. Olson - http://www.flightgear.org/~curt
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23 #include <cstdlib>
  24 #include <cstring>
  25
  26 #include <simgear/compiler.h>
  27
  28 #include <string>
  29
  30 #include <simgear/debug/logstream.hxx>
  31 #include <simgear/serial/serial.hxx>
  32
  33 #include "sg_serial.hxx"
  34
  35 using std::string;
  36
  37
  38 SGSerial::SGSerial( const string& device_name, const string& baud_rate ) :
  39     save_len(0)
  40 {
  41     set_type( sgSerialType );
  42     device = device_name;
  43     baud = baud_rate;
  44 }
  45
  46
  47 SGSerial::~SGSerial() {
  48 }
  49
  50
  51 // open the serial port based on specified direction
  52 bool SGSerial::open( const SGProtocolDir d ) {
  53     set_dir( d );
  54
  55     if ( ! port.open_port( device ) ) {
  56         SG_LOG( SG_IO, SG_ALERT, "Error opening device: " << device );
  57         return false;
  58     }
  59
  60     // cout << "fd = " << port.fd << endl;
  61
  62     if ( ! port.set_baud( std::atoi( baud.c_str() ) ) ) {
  63         SG_LOG( SG_IO, SG_ALERT, "Error setting baud: " << baud );
  64         return false;
  65     }
  66
  67     return true;
  68 }
  69
  70
  71 // Read data from port.  If we don't get enough data, save what we did
  72 // get in the save buffer and return 0.  The save buffer will be
  73 // prepended to subsequent reads until we get as much as is requested.
  74
  75 int SGSerial::read( char *buf, int length ) {
  76     int result;
  77
  78     // read a chunk, keep in the save buffer until we have the
  79     // requested amount read
  80
  81     char *buf_ptr = save_buf + save_len;
  82     result = port.read_port( buf_ptr, length - save_len );
  83
  84     if ( result + save_len == length ) {
  85         std::strncpy( buf, save_buf, length );
  86         save_len = 0;
  87
  88         return length;
  89     }
  90
  91     return 0;
  92 }
  93
  94
  95 // read data from port
  96 int SGSerial::readline( char *buf, int length ) {
  97     int result;
  98
  99     // read a chunk, keep in the save buffer until we have the
 100     // requested amount read
 101
 102     char *buf_ptr = save_buf + save_len;
 103     result = port.read_port( buf_ptr, SG_IO_MAX_MSG_SIZE - save_len );
 104     save_len += result;
 105
 106     // look for the end of line in save_buf
 107     int i;
 108     for ( i = 0; i < save_len && save_buf[i] != '\n'; ++i );
 109     if ( save_buf[i] == '\n' ) {
 110         result = i + 1;
 111     } else {
 112         // no end of line yet
 113         return 0;
 114     }
 115
 116     // we found an end of line
 117
 118     // copy to external buffer
 119     std::strncpy( buf, save_buf, result );
 120     buf[result] = '\0';
 121     SG_LOG( SG_IO, SG_INFO, "fg_serial line = " << buf );
 122
 123     // shift save buffer
 124     for ( i = result; i < save_len; ++i ) {
 125         save_buf[ i - result ] = save_buf[i];
 126     }
 127     save_len -= result;
 128
 129     return result;
 130 }
 131
 132
 133 // write data to port
 134 int SGSerial::write( const char *buf, const int length ) {
 135     int result = port.write_port( buf, length );
 136
 137     if ( result != length ) {
 138         SG_LOG( SG_IO, SG_WARN, "Error writing data: " << device );
 139     }
 140
 141     return result;
 142 }
 143
 144
 145 // write null terminated string to port
 146 int SGSerial::writestring( const char *str ) {
 147     int length = std::strlen( str );
 148     return write( str, length );
 149 }
 150
 151
 152 // close the port
 153 bool SGSerial::close() {
 154     if ( ! port.close_port() ) {
 155         return false;
 156     }
 157
 158     return true;
 159 }