PlayerConnect.h

Go to the documentation of this file.

/* Copyright (C) 2002 Dominic Letourneau (dominic.letourneau@courrier.usherb.ca)

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   This library 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
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef _PLAYERCONNECT_H_
#define _PLAYERCONNECT_H_

#include "playerclient.h"
#include "Object.h"
#include "BufferedNode.h"

namespace RobotFlow {

class PlayerClientWrap : public FD::Object {

 private:

  PlayerClient m_client;
  PositionProxy *m_positionProxy;
  GripperProxy *m_gripperProxy;
  LaserProxy *m_laserProxy;
  LaserProxy *m_laser2Proxy;
  PtzProxy *m_ptzProxy;
  SonarProxy *m_sonarProxy;
  BlobfinderProxy *m_blobFinderProxy;
  GpsProxy *m_gpsProxy;


  void createProxies(bool startPositionProxy, bool startGripperProxy,
                     bool startLaserProxy, bool startPTZProxy,
                     bool startSonarProxy, bool startBlobFinderProxy,
                     bool startGPSProxy, bool startLaser2Proxy)
  {

    //create all proxies
    if(startPositionProxy)
    {
       m_positionProxy = new PositionProxy(&m_client,0,'a');
    }
    if(startGripperProxy)
    {
       m_gripperProxy =  new GripperProxy(&m_client,0,'a');
    }
    if(startLaserProxy)
    {
       m_laserProxy = new LaserProxy(&m_client,0,'a');
    }
    if(startPTZProxy)
    {
       m_ptzProxy =  new PtzProxy(&m_client,0,'a');
    }
    if(startSonarProxy)
    {
       m_sonarProxy =  new SonarProxy(&m_client,0,'a');
    }
    if(startBlobFinderProxy)
    {
       m_blobFinderProxy =  new BlobfinderProxy(&m_client,0,'a');
    }
    if(startGPSProxy)
    {
       m_gpsProxy =  new GpsProxy(&m_client,0,'a');
    }
    if(startLaser2Proxy)
    {
       m_laser2Proxy = new LaserProxy(&m_client,1,'a');
    }
  }

  void destroyProxies() 
  {
    // delete all proxies
    if (m_positionProxy) 
    {
       delete m_positionProxy;
       m_positionProxy = NULL;
    }
    
    if (m_gripperProxy) 
    {
       delete m_gripperProxy;
       m_gripperProxy = NULL;
    }

    if (m_laserProxy)
    {
       delete m_laserProxy;
       m_laserProxy = NULL;
    }

    if (m_ptzProxy)
    {
       delete m_ptzProxy;
       m_ptzProxy = NULL;
    }

    if (m_sonarProxy)
    {
       delete m_sonarProxy;
       m_sonarProxy = NULL;
    }

    if (m_blobFinderProxy)
    {
       delete m_blobFinderProxy;
       m_blobFinderProxy = NULL;
    }

    if (m_gpsProxy)
    {
       delete m_gpsProxy;
       m_gpsProxy = NULL;
    }

    if (m_laser2Proxy)
    {
       delete m_laser2Proxy;
       m_laser2Proxy = NULL;
    }
  }

 public:

  PlayerClientWrap(const char* hostname=NULL, int port=PLAYER_PORTNUM, 
                   bool startPositionProxy = true, bool startGripperProxy = true,
                   bool startLaserProxy = true, bool startPTZProxy = true,
                   bool startSonarProxy = true, bool startBlobFinderProxy = true,
                   bool startGPSProxy = true, bool startLaser2Proxy = true)
    : m_client(hostname,port), m_positionProxy(NULL),
    m_gripperProxy(NULL), m_laserProxy(NULL), m_ptzProxy(NULL),
    m_sonarProxy (NULL), m_blobFinderProxy(NULL), m_gpsProxy(NULL), m_laser2Proxy(NULL)
  {

    createProxies(startPositionProxy, startGripperProxy, startLaserProxy,
                  startPTZProxy,startSonarProxy, startBlobFinderProxy,
                  startGPSProxy, startLaser2Proxy);

  }

  ~PlayerClientWrap() {
    destroyProxies();
  }
  
  PositionProxy * getPositionProxy() {return m_positionProxy;}

  GripperProxy * getGripperProxy() {return m_gripperProxy;}

  LaserProxy * getLaserProxy() {return m_laserProxy;}

  PtzProxy * getPtzProxy() {return m_ptzProxy;}

  SonarProxy *getSonarProxy() {return m_sonarProxy;}

  BlobfinderProxy * getBlobFinderProxy() {return m_blobFinderProxy;}

  GpsProxy * getGpsProxy() {return m_gpsProxy;}

  LaserProxy * getLaser2Proxy() {return m_laser2Proxy;}

  // check if we are connected
  bool Connected() { return (m_client.Connected());}

  int Connect(const char* hostname, int port) {
    return (m_client.Connect(hostname,port));
  }

  int Connect(const char* hostname) { 
    return (m_client.Connect(hostname,PLAYER_PORTNUM)); 
  }

  int Connect() { 
    return(m_client.Connect("localhost",PLAYER_PORTNUM)); 
  }

  int Disconnect() {
    return (m_client.Disconnect());
  }

  
  PlayerClient & get_player_client() {return m_client;}

  void printOn(std::ostream &out = std::cout) const {
    out<<"<PlayerClientWrap>\n";
  }
};


class PlayerConnect : public FD::BufferedNode {
  
  FD::ObjectRef m_client;

  bool m_isInit;

  int m_port;
  std::string m_host;
  int  m_frequency;
  bool m_startPositionProxy;
  bool m_startGripperProxy;
  bool m_startLaserProxy;
  bool m_startLaser2Proxy;
  bool m_startPTZProxy;
  bool m_startSonarProxy;
  bool m_startBlobFinderProxy;
  bool m_startGPSProxy;
  int m_outputID;
  PositionProxy *m_positionProxy;

public:

  PlayerConnect(std::string nodeName, FD::ParameterSet params);

  virtual ~PlayerConnect();
     
  void calculate(int output_id, int count, FD::Buffer &out);

};

}//namespace RobotFlow
#endif

---