GroundSens.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP 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 3 of the License, or
// (at your option) any later version.
//
// MIP 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 MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------






#ifndef __GROUND_SENSOR_H_
#define __GROUND_SENSOR_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <stdlib.h>
#include <string>
#include <sstream>
#include <vector>
#include <assert.h>
#include <pthread.h>
#include <stdint.h>


#include <baselib.h>
#include <Resource.h>

namespace MipResources{

/* @{ */

class GroundSensPar{
 private:
  Decimal  _linRangeMin;  
  Decimal  _linRangeMax;  
  Decimal  _linRes;    
  Angle  _angRangeMax;  
  Angle  _angRangeMin;  
  Angle  _angRes;    
  uint32_t _numRays;    
  Decimal  _rate;     
  Pose   _pose;     
  string  _name;
 protected:
  void setLinRangeMin(Decimal value){
   assert(value>=0.0);
   _linRangeMin=value;
  }
  void setLinRangeMax(Decimal value){
//    cout << "value: " << value << endl;
//    cout << "_linRangeMin: " << _linRangeMin << endl;
   assert(value>_linRangeMin);
   _linRangeMax=value;
  }
  void setLinRes(Decimal value){
   assert(value<(_linRangeMax-_linRangeMin));
   _linRes=value;
  }
  void setAngRangeMax(Angle value){
   /*TODO inserire check*/
   _angRangeMax=value;
  }
  void setAngRangeMin(Angle value){
   /*TODO inserire check*/
   _angRangeMin=value;
  }
  void setAngRes(Angle value){
   /*TODO inserire check*/
   _angRes=value;
  }
  void setNumRays(uint32_t value){
   /*TODO inserire check*/
   _numRays=value;
  }
  void setRate(Decimal value){
   /*TODO inserire check*/
   assert(value>0);
   _rate=value;
  }
  void setPose(Pose value){
   _pose=value;
  }
  void setName(string value){
   _name=value;
  }
 public:
  GroundSensPar();
  
  GroundSensPar(const GroundSensPar &s);
  
  GroundSensPar& operator=(const GroundSensPar& s);
  
  Decimal linRangeMax(){
   return _linRangeMax;
  }
  Decimal linRangeMin(){
   return _linRangeMin;
  }
  Decimal linRes(){
   return _linRes;
  }
  Angle angRangeMax(){
   return _angRangeMax;
  }
  Angle angRangeMin(){
   return _angRangeMin;
  }
  Angle angRes(){
   return _angRes;
  }
  string numRays(){
   return _name;
  }
  Pose pose(){
   return _pose;
  }
  string name(){
   return _name;
  }
  inline string print();
};

using namespace MipBaselib;

class GroundSens : public Resource{
 private:
  bool _scanning;
 
 protected:
  GroundSensPar *_par; 
  Scan _scan; 
  bool on;   
  /*batch scanning*/
  virtual vector<int> _singleGroundScan()=0;
  
  /*start stop continuous scanning*/
  virtual void _startScan(unsigned int num)=0;
  
  virtual void _stopScan()=0;
  
 public:
  virtual ResourcePlate getPlate() const =0;
  
  GroundSens();
  
   ~GroundSens();
  
  GroundSensPar* par();

//   /*updated scanning*/
//   /// \brief get an updated scan
//   /// \return \b true if the get if all is ok (remeber that scan is a MutExed Resource), \b false otherwise
//   /// \param s a scan in which the current scan is copied, if return is true
//   bool updatedScan(Scan& s){
//    if(_scanning){/*se sto scansionando allora lo prendo negli stored*/
//     return storedScan(s,Time(0,0));
//    }else{/*altriemnti ne chiedo uno singolo*/
//     s = _singleScan(); 
//     return true;
//    }
//   };
  
  /*updated ground scanning*/
  bool updatedScan(vector<int>& s);
  
  /*start stop continuous scanning*/
  void startScan(unsigned int num);

  void stopScan();
  
  /*get a scan in a continuous scanning*/
  /*virtual*/ bool storedScan(Scan& s,Time timeout);
};

 /* @} */
 
}; //end namespace MipResources




#endif