Generic OpenMoco C++ serial library

// We only need softserial on devices with only one UART
#if not defined (_TOUCH_SLIDE_)
#define _INCLUDE_SOFTSERIAL__
#endif

#ifdef _INCLUDE_SOFTSERIAL__
#include <NewSoftSerial.h>
#endif

#ifndef OPENMOCO_SERIAL_H
#define OPENMOCO_SERIAL_H

// maximum command data length
#define SER_COM_BUFFER_LEN 9

// how many ms to wait for a serial command to complete?
#define SERIAL_TIMEOUT 15000

class OMSerial{
private:
  boolean use_hardware_serial;
       
  HardwareSerial *_HardwareSerial;
#ifdef _INCLUDE_SOFTSERIAL__
  NewSoftSerial *_NewSoftSerial;
#endif
       
  void begin(long speed);
  int available(void);
  int read(void);
  void print(char n, int base);
public:
  byte command_val;
  byte com_byte_count;
  byte input_serial_buffer[SER_COM_BUFFER_LEN];
  unsigned long serial_time;

  byte serial_got_command();
  byte get_response();

  void serial_write_command( char command_byte, char data_length_byte);
  void serial_write( byte val );
  void serial_write( int16_t val );
  void serial_write( unsigned int val );
  void serial_write( unsigned long val );
  void serial_write( long val );
  void run(void);
  OMSerial(HardwareSerial *HardwareSerialObj, long speed);
#ifdef _INCLUDE_SOFTSERIAL__
  OMSerial(NewSoftSerial *NewSoftSerialObj, long speed);
#endif
  virtual void serial_execute_command(byte command) {};

};

#endif

OMSerial::OMSerial(HardwareSerial *HardwareSerialObj, long speed){
  serial_time = 0;
  _HardwareSerial = HardwareSerialObj;
  use_hardware_serial = true;
  _HardwareSerial->begin(speed);
}

#ifdef _INCLUDE_SOFTSERIAL__
OMSerial::OMSerial(NewSoftSerial *NewSoftSerialObj, long speed){
  serial_time = 0;
  _NewSoftSerial = NewSoftSerialObj;
  use_hardware_serial = false;
  _NewSoftSerial->begin(speed);
}
#endif

void OMSerial::begin(long speed){
  if (use_hardware_serial)
    _HardwareSerial->begin(speed);
#ifdef _INCLUDE_SOFTSERIAL__
  else
    _NewSoftSerial->begin(speed);
#endif
}

int OMSerial::available(void){
  if (use_hardware_serial)
        return _HardwareSerial->available();
#ifdef _INCLUDE_SOFTSERIAL__
  else
        return _NewSoftSerial->available();
#endif
}

int OMSerial::read(void){
  if (use_hardware_serial)
        return _HardwareSerial->read();
#ifdef _INCLUDE_SOFTSERIAL__
  else
        return _NewSoftSerial->read();
#endif
}

void OMSerial::print(char n, int base){
  if (use_hardware_serial)
        _HardwareSerial->print(n,base);
#ifdef _INCLUDE_SOFTSERIAL__
  else
    _NewSoftSerial->print(n, base);
       
#endif
}

void OMSerial::run(void){

  byte ser_com = serial_got_command();

  if( ser_com ) {
    // we have a command, execute it.
    serial_execute_command( ser_com );
  }
}

byte OMSerial::serial_got_command() {

  command_val    = 0;
  com_byte_count = 0;

  if( available() ) {
    // hardware serial (host pc?) has data ready for us
    command_val = (byte) read();

    if( command_val > 0 ) {
      // wait until we have data
      while( ! available() ) {
        ;
      }
      // get data length    
      com_byte_count = (byte) read();
    }

  }
  else {
    // serial does not have data in the buffer
    return( 0 );
  }

  // check for overflow
  // note: we will still be in error condition, as
  // there will be values left in the serial buffer
  // on the next read, from this command

  if(com_byte_count > SER_COM_BUFFER_LEN)
    com_byte_count = SER_COM_BUFFER_LEN;

  // clear out any previous command data
  memset(input_serial_buffer, 0, sizeof(char) * SER_COM_BUFFER_LEN);

  serial_time = millis();

  // populate command data buffer
  for( int i = 1; i <= com_byte_count; i++ ) {
    // get com_byte_count character values from the serial
    // buffer

      // wait until we have data ready
    while( ! available() ) {
      if( millis() - serial_time > SERIAL_TIMEOUT ) {
        // timed out waiting for complete input
        // send 'fail' response
        serial_write((byte)0);
        serial_write((byte)0);
        return( 0 );  
      }
    }

    input_serial_buffer[i - 1] = (byte) read();    
  }

  return( command_val );
}

byte OMSerial::get_response() {
       
        // clear out any old data received
        memset(input_serial_buffer, 0, SER_COM_BUFFER_LEN);
       
        // wait for response from engine
        while( ! available() ) {
                ;
        }
       
        byte response = (byte) read();
       
        // wait until we have a response length
        while( ! available() ) {
                ;
        }
        // get data length    
       
        byte byte_count = (byte) read();
       
        // if no data, return the response code
        if( byte_count == 0 )
                return(response);
       
        for( byte i = 0; i < byte_count; i++) {
                while( ! available() ) {
                        ;
                }  
                input_serial_buffer[i] = read();
        }
       
        return(response);
}

void OMSerial::serial_write( byte val ) {

  print(val, BYTE);

}

void OMSerial::serial_write_command( char command_byte, char data_length_byte){
        print(command_byte, BYTE);
        print(data_length_byte, BYTE);
}

// Signed version
void OMSerial::serial_write( int16_t val ) {
  print( val >> 8, BYTE );
  print(val, BYTE);
       
}

void OMSerial::serial_write( unsigned int val ) {

  print( val >> 8, BYTE );
  print(val, BYTE);

}

void OMSerial::serial_write( unsigned long val ) {

  print( val >> 24, BYTE );
  print( val >> 16, BYTE );
  print( val >> 8, BYTE );
  print(val, BYTE);

}

void OMSerial::serial_write( long val ) {

  print( val >> 24, BYTE );
  print( val >> 16, BYTE );
  print( val >> 8, BYTE );
  print(val, BYTE);

}

void TTSSerial::serial_execute_command(byte command){
  boolean fail = false;
  char buf[100];
  int16_t x,y;

  switch(command){
    case 1:
      // Just a demo; clear the previous coordinates from the screen
      // The code that handles the serial command will be here
      break;

    default:
      // We couldn't find the command that was sent
      fail = true;
      break;
  }

  // send serial response
  if( fail ) {
    serial_write((byte)0);
    serial_write((byte)0);
  }
  else {
    serial_write((byte)1);
    serial_write((byte)0);
  }
}

// Get the serial connection running on Serial and baudrate 9600
TTSSerial::TTSSerial(): OMSerial( &Serial, 9600 ){
}

OMSerial *arduino = new TTSSerial();

void TTSSerial::serial_execute_command(byte command){
  boolean fail = false;
  char buf[100];
  int16_t x,y;

  switch(command){
  default:
    // We couldn't find the command that was sent
    fail = true;
    break;
  }

  // send serial response
  if( fail ) {
    serial_write((byte)0);
    serial_write((byte)0);
  }
  else {
    serial_write((byte)1);
    serial_write((byte)0);
  }
}

TTSSerial::TTSSerial():
OMSerial( new NewSoftSerial(SLIDE_RX_PIN, SLIDE_TX_PIN), 9600 ){
}

OMSerial *tts = new TTSSerial();