ArSimpleConnector.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program 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 General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARSIMPLECONNECTOR_H
#define ARSIMPLECONNECTOR_H

#include "ariaTypedefs.h"
#include "ArSerialConnection.h"
#include "ArTcpConnection.h"
#include "ArArgumentBuilder.h"
#include "ArArgumentParser.h"
#include "ariaUtil.h"
#include "ArSick.h"

class ArRobot;




class ArSimpleConnector
{
public:
  AREXPORT ArSimpleConnector(int *argc, char **argv);
  AREXPORT ArSimpleConnector(ArArgumentBuilder *arguments);
  AREXPORT ArSimpleConnector(ArArgumentParser *parser);
  AREXPORT ~ArSimpleConnector(void);
  AREXPORT bool setupRobot(ArRobot *robot);
  AREXPORT bool connectRobot(ArRobot *robot);
  AREXPORT bool setupLaser(ArSick *sick);
  AREXPORT bool setupSecondLaser(ArSick *sick);
  AREXPORT bool setupLaserArbitrary(ArSick *sick, int laserNumber);
  AREXPORT bool connectLaser(ArSick *sick);
  AREXPORT bool connectSecondLaser(ArSick *sick);
  AREXPORT bool connectLaserArbitrary(ArSick *sick, int laserNumber);
  AREXPORT bool parseArgs(void);
  AREXPORT bool parseArgs(ArArgumentParser *parser);
  AREXPORT void logOptions(void) const;
  AREXPORT void setMaxNumLasers(int maxNumLasers = 1);
protected:
  class LaserData
  {
  public:
    LaserData(int number) 
      { myNumber = number; myConnect = false; myPort = NULL; 
      myRemoteTcpPort = 0; myFlipped = false; myFlippedReallySet = false; 
      myPowerControlled = true; myPowerControlledReallySet = false; 
      myDegrees = NULL; mySickDegrees = ArSick::DEGREES180; myIncrement = NULL;
      mySickIncrement = ArSick::INCREMENT_ONE; myUnits = NULL; 
      mySickUnits = ArSick::UNITS_1MM; myBits = NULL; 
      mySickBits = ArSick::BITS_1REFLECTOR; }
    virtual ~LaserData() {}
    int myNumber;
    // if we want to connect the laser
    bool myConnect;
    // the port we want to connect the laser on
    const char *myPort;
    // laser tcp port if we're doing a remote host
    int myRemoteTcpPort;  
    // if we have the laser flipped
    bool myFlipped;
    // if our flipped was really set
    bool myFlippedReallySet;
    // if we are controlling the laser power
    bool myPowerControlled;
    // if our flipped was really set
    bool myPowerControlledReallySet;
    // the degrees we want to use (for the sick)
    const char *myDegrees;
    // the enum value for those degrees
    ArSick::Degrees mySickDegrees;
    // the increment we want to use
    const char *myIncrement;
    // the angular res we want to use (the sick value)
    ArSick::Increment mySickIncrement;
    const char *myUnits;
    // the units we want to use (the sick value)
    ArSick::Units mySickUnits;
    const char *myBits;
    // the units we want to use (the sick value)
    ArSick::Bits mySickBits;
    // our tcp connection
    ArTcpConnection myTcpConn;
    // our serial connection
    ArSerialConnection mySerConn;
  };
  int myMaxNumLasers;
  std::list<LaserData *> myLasers;
  
  AREXPORT bool parseLaserArgs(ArArgumentParser *parser, int laserNumber);
  AREXPORT void logLaserOptions(unsigned int laserNumber) const;
  void reset(void);
  // the robot we've set up (so we can find its params)
  ArRobot *myRobot; 
  // if we're using the sim or not
  bool myUsingSim;
  // if we're connecting via tcp (not to the sim), what remote host
  const char *myRemoteHost;
  // robot port, if there isn't one this'll be NULL, which will just
  // be the default of ArUtil::COM1
  const char *myRobotPort;
  // baud for the serial
  int myRobotBaud;
  // robot tcp port if we're doing a remote host (defaults to 8101)
  int myRemoteRobotTcpPort;
  
  // whether we're connecting to a remote sim or not (so we don't try
  // to open a port for the laser)
  bool myRemoteIsSim;
  // our parser
  ArArgumentParser *myParser;
  bool myOwnParser;


  // a few device connections to use to connect to the robot
  ArTcpConnection myRobotTcpConn;
  ArSerialConnection myRobotSerConn;
  // a few device connections to use to connect to the laser
  ArTcpConnection myLaserTcpConn;
  ArSerialConnection myLaserSerConn;
  // device connections to use to connect to the second laser
  ArTcpConnection myLaserTcpConn2;
  ArSerialConnection myLaserSerConn2;

  ArRetFunctorC<bool, ArSimpleConnector> myParseArgsCB;
  ArConstFunctorC<ArSimpleConnector> myLogOptionsCB;
};

#endif // ARSIMPLECONNECTOR_H

---