SickLMS1xx.hh

Go to the documentation of this file.

#ifndef SICK_LMS_1XX_HH
#define SICK_LMS_1XX_HH

/* Macros */
#define DEFAULT_SICK_LMS_1XX_IP_ADDRESS                   "192.168.0.1"                 
#define DEFAULT_SICK_LMS_1XX_TCP_PORT                            (2111)                 
#define DEFAULT_SICK_LMS_1XX_CONNECT_TIMEOUT                  (1000000)                 
#define DEFAULT_SICK_LMS_1XX_MESSAGE_TIMEOUT                  (5000000)                 
#define DEFAULT_SICK_LMS_1XX_STATUS_TIMEOUT                  (60000000)                 

#define SICK_LMS_1XX_SCAN_AREA_MIN_ANGLE                      (-450000)                 
#define SICK_LMS_1XX_SCAN_AREA_MAX_ANGLE                      (2250000)                 

/* Definition dependencies */
#include <string>
#include <arpa/inet.h>

#include "SickLIDAR.hh"
#include "SickLMS1xxBufferMonitor.hh"
#include "SickLMS1xxMessage.hh"
#include "SickException.hh"

namespace SickToolbox {

  class SickLMS1xx : public SickLIDAR< SickLMS1xxBufferMonitor, SickLMS1xxMessage > {

  public:
    
    static const int SICK_LMS_1XX_MAX_NUM_MEASUREMENTS = 1082;                         

    enum sick_lms_1xx_status_t {
      
      SICK_LMS_1XX_STATUS_UNKNOWN = 0x00,                                              
      SICK_LMS_1XX_STATUS_INITIALIZATION = 0x01,                                       
      SICK_LMS_1XX_STATUS_CONFIGURATION = 0x02,                                        
      SICK_LMS_1XX_STATUS_IDLE = 0x03,                                                 
      SICK_LMS_1XX_STATUS_ROTATED = 0x04,                                              
      SICK_LMS_1XX_STATUS_IN_PREP = 0x05,                                              
      SICK_LMS_1XX_STATUS_READY = 0x06,                                                
      SICK_LMS_1XX_STATUS_READY_FOR_MEASUREMENT = 0x07                                 
      
    };        
    
    enum sick_lms_1xx_scan_format_t {
      
      SICK_LMS_1XX_SCAN_FORMAT_DIST_SINGLE_PULSE_REFLECT_NONE = 0x00,                   
      SICK_LMS_1XX_SCAN_FORMAT_DIST_SINGLE_PULSE_REFLECT_8BIT = 0x01,                   
      SICK_LMS_1XX_SCAN_FORMAT_DIST_SINGLE_PULSE_REFLECT_16BIT = 0x02,                  
      SICK_LMS_1XX_SCAN_FORMAT_DIST_DOUBLE_PULSE_REFLECT_NONE = 0x03,                   
      SICK_LMS_1XX_SCAN_FORMAT_DIST_DOUBLE_PULSE_REFLECT_8BIT = 0x04,                   
      SICK_LMS_1XX_SCAN_FORMAT_DIST_DOUBLE_PULSE_REFLECT_16BIT = 0x05,                  
      SICK_LMS_1XX_SCAN_FORMAT_UNKNOWN = 0xFF                                           
      
    };

    enum sick_lms_1xx_scan_freq_t {

      SICK_LMS_1XX_SCAN_FREQ_UNKNOWN = 0x00,                                            
      SICK_LMS_1XX_SCAN_FREQ_25 = 0x09C4,                                               
      SICK_LMS_1XX_SCAN_FREQ_50 = 0X1388                                                

    };

    enum sick_lms_1xx_scan_res_t {

      SICK_LMS_1XX_SCAN_RES_UNKNOWN = 0x00,                                             
      SICK_LMS_1XX_SCAN_RES_25 = 0x09C4,                                                
      SICK_LMS_1XX_SCAN_RES_50 = 0x1388                                                 

    };

    SickLMS1xx( const std::string sick_ip_address = DEFAULT_SICK_LMS_1XX_IP_ADDRESS,
                const uint16_t sick_tcp_port = DEFAULT_SICK_LMS_1XX_TCP_PORT );
    
    void Initialize( const bool disp_banner = true ) throw( SickIOException, SickThreadException, SickTimeoutException, SickErrorException );

    void SetSickScanFreqAndRes( const sick_lms_1xx_scan_freq_t scan_freq,
                                const sick_lms_1xx_scan_res_t scan_res ) throw( SickTimeoutException, SickIOException, SickErrorException ); 

    sick_lms_1xx_scan_freq_t GetSickScanFreq( ) const throw ( SickIOException );
    
    sick_lms_1xx_scan_res_t GetSickScanRes( ) const throw ( SickIOException );

    double GetSickStartAngle( ) const throw ( SickIOException );

    double GetSickStopAngle( ) const throw ( SickIOException );    

    void SetSickScanDataFormat( const sick_lms_1xx_scan_format_t scan_format ) throw( SickTimeoutException, SickIOException, SickThreadException, SickErrorException );
    
    void GetSickMeasurements( unsigned int * const range_1_vals,
                              unsigned int * const range_2_vals,
                              unsigned int * const reflect_1_vals,
                              unsigned int * const reflect_2_vals,
                              unsigned int & num_measurements,
                              unsigned int * const dev_status = NULL ) throw ( SickIOException, SickConfigException, SickTimeoutException );

    void Uninitialize( const bool disp_banner = true ) throw( SickIOException, SickTimeoutException, SickErrorException, SickThreadException );

    sick_lms_1xx_scan_freq_t IntToSickScanFreq( const int scan_freq ) const;

    int SickScanFreqToInt( const sick_lms_1xx_scan_freq_t scan_freq ) const;
    
    sick_lms_1xx_scan_res_t DoubleToSickScanRes( const double scan_res ) const;

    double SickScanResToDouble( const sick_lms_1xx_scan_res_t scan_res ) const;
    
    ~SickLMS1xx();

  private:

    typedef struct sick_lms_1xx_scan_config_tag {
      sick_lms_1xx_scan_freq_t sick_scan_freq;                                          
      sick_lms_1xx_scan_res_t sick_scan_res;                                            
      int32_t sick_start_angle;                                                         
      int32_t sick_stop_angle;                                                          
    } sick_lms_1xx_scan_config_t;
    
    std::string _sick_ip_address;

    uint16_t _sick_tcp_port;

    struct sockaddr_in _sick_inet_address_info;

    sick_lms_1xx_scan_config_t _sick_scan_config;

    sick_lms_1xx_scan_format_t _sick_scan_format;    
    
    sick_lms_1xx_status_t _sick_device_status;

    bool _sick_temp_safe;    
    
    bool _sick_streaming;
    
    void _setupConnection( ) throw( SickIOException, SickTimeoutException );

    void _reinitialize( ) throw( SickIOException, SickThreadException, SickTimeoutException, SickErrorException );     

    void _teardownConnection( ) throw( SickIOException );

    void _updateSickStatus( ) throw( SickTimeoutException, SickIOException );

    void _getSickScanConfig( ) throw( SickTimeoutException, SickIOException );

    void _setSickScanConfig( const sick_lms_1xx_scan_freq_t scan_freq,
                             const sick_lms_1xx_scan_res_t scan_res,
                             const int start_angle, const int stop_angle ) throw( SickTimeoutException, SickIOException, SickErrorException );
    
    void _setAuthorizedClientAccessMode( ) throw( SickTimeoutException, SickErrorException, SickIOException );

    void _writeToEEPROM( ) throw( SickTimeoutException, SickIOException );

    void _sendMessage( const SickLMS1xxMessage &send_message ) const throw ( SickIOException );
    
    void _sendMessageAndGetReply( const SickLMS1xxMessage &send_message,
                                  SickLMS1xxMessage &recv_message,
                                  const std::string reply_command_code,
                                  const std::string reply_command,
                                  const unsigned int timeout_value = DEFAULT_SICK_LMS_1XX_MESSAGE_TIMEOUT,
                                  const unsigned int num_tries = 1 ) throw( SickIOException, SickTimeoutException );

    void _recvMessage( SickLMS1xxMessage &sick_message ) const throw ( SickTimeoutException );
    
    void _startMeasuring( ) throw ( SickTimeoutException, SickIOException );

    void _stopMeasuring( ) throw ( SickTimeoutException, SickIOException );

    void _requestDataStream( ) throw ( SickTimeoutException, SickConfigException, SickIOException );
    
    void _startStreamingMeasurements(  )throw( SickTimeoutException, SickIOException );

    void _stopStreamingMeasurements( const bool disp_banner = true ) throw( SickTimeoutException, SickIOException );

    void _checkForMeasuringStatus( unsigned int timeout_value = DEFAULT_SICK_LMS_1XX_STATUS_TIMEOUT ) throw( SickTimeoutException, SickIOException );

    void _setSickScanDataFormat( const sick_lms_1xx_scan_format_t scan_format ) throw( SickTimeoutException, SickIOException, SickThreadException, SickErrorException );
    
    void _restoreMeasuringMode( ) throw( SickTimeoutException, SickIOException );

    bool _validScanArea( const int start_angle, const int stop_angle ) const;
    
    sick_lms_1xx_status_t _intToSickStatus( const int status ) const;

    void _printSickScanConfig( ) const;
    
    void _printInitFooter( ) const;

    std::string _sickScanDataFormatToString( const sick_lms_1xx_scan_format_t scan_format ) const;

    double _convertSickAngleUnitsToDegs( const int sick_angle ) const { return ((double)sick_angle)/10000; }

    unsigned int  _convertSickFreqUnitsToHz( const unsigned int sick_freq ) const { return (unsigned int)(((double)sick_freq)/100); }    
    
    std::string _intToSickConfigErrorStr( const int error ) const;

    bool _findSubString( const char * const str, const char * const substr, const unsigned int str_length, const unsigned int substr_length,
                         unsigned int &substr_pos, unsigned int start_pos = 0 ) const;

    char * _convertNextTokenToUInt( char * const str_buffer, unsigned int & num_val, const char * const delimeter = " " ) const;
    
  };

  typedef SickLMS1xx::sick_lms_1xx_status_t sick_lms_1xx_status_t;

  typedef SickLMS1xx::sick_lms_1xx_scan_format_t sick_lms_1xx_scan_format_t;

  typedef SickLMS1xx::sick_lms_1xx_scan_freq_t sick_lms_1xx_scan_freq_t;

  typedef SickLMS1xx::sick_lms_1xx_scan_res_t sick_lms_1xx_scan_res_t;  

  
} //namespace SickToolbox
  
#endif /* SICK_LMS_1XX_HH */