SickLMS2xx.hh

Go to the documentation of this file.

#ifndef SICK_LMS_2XX_HH
#define SICK_LMS_2XX_HH

/* Implementation dependencies */
#include <string>
#include <iostream>
#include <termios.h>

#include "SickLIDAR.hh"
#include "SickException.hh"

#include "SickLMS2xxBufferMonitor.hh"
#include "SickLMS2xxMessage.hh"

/* Macro definitions */
#define DEFAULT_SICK_LMS_2XX_SICK_BAUD                                       (B9600)  
#define DEFAULT_SICK_LMS_2XX_HOST_ADDRESS                                     (0x80)  
#define DEFAULT_SICK_LMS_2XX_SICK_ADDRESS                                     (0x00)  
#define DEFAULT_SICK_LMS_2XX_SICK_PASSWORD                                "SICK_LMS"  
#define DEFAULT_SICK_LMS_2XX_SICK_MESSAGE_TIMEOUT                (unsigned int)(1e6)  
#define DEFAULT_SICK_LMS_2XX_SICK_SWITCH_MODE_TIMEOUT            (unsigned int)(3e6)  
#define DEFAULT_SICK_LMS_2XX_SICK_MEAN_VALUES_MESSAGE_TIMEOUT   (unsigned int)(15e6)  
#define DEFAULT_SICK_LMS_2XX_SICK_CONFIG_MESSAGE_TIMEOUT        (unsigned int)(15e6)  
#define DEFAULT_SICK_LMS_2XX_BYTE_INTERVAL                                      (55)  
#define DEFAULT_SICK_LMS_2XX_NUM_TRIES                                           (3)  
    
/* Associate the namespace */
namespace SickToolbox {

  class SickLMS2xx : public SickLIDAR< SickLMS2xxBufferMonitor, SickLMS2xxMessage >
  { 

  public:
    
    static const uint16_t SICK_MAX_NUM_MEASUREMENTS = 721;                     

    enum sick_lms_2xx_type_t {
      
      /* Supported 200 models */
      SICK_LMS_TYPE_200_30106,                                                 
      
      /* Supported 211 models */
      SICK_LMS_TYPE_211_30106,                                                 
      SICK_LMS_TYPE_211_30206,                                                 
      SICK_LMS_TYPE_211_S07,                                                   
      SICK_LMS_TYPE_211_S14,                                                   
      SICK_LMS_TYPE_211_S15,                                                   
      SICK_LMS_TYPE_211_S19,                                                   
      SICK_LMS_TYPE_211_S20,                                                   

      /* Supported 220 models */
      SICK_LMS_TYPE_220_30106,                                                 

      /* Supported 221 models */
      SICK_LMS_TYPE_221_30106,                                                 
      SICK_LMS_TYPE_221_30206,                                                 
      SICK_LMS_TYPE_221_S07,                                                   
      SICK_LMS_TYPE_221_S14,                                                   
      SICK_LMS_TYPE_221_S15,                                                   
      SICK_LMS_TYPE_221_S16,                                                   
      SICK_LMS_TYPE_221_S19,                                                   
      SICK_LMS_TYPE_221_S20,                                                   

      /* Supported 291 models */
      SICK_LMS_TYPE_291_S05,                                                   
      SICK_LMS_TYPE_291_S14,                                                   
      SICK_LMS_TYPE_291_S15,                                                   

      /* Any unknown model */
      SICK_LMS_TYPE_UNKNOWN = 0xFF                                             

    };
    
    enum sick_lms_2xx_variant_t {
      SICK_LMS_VARIANT_2XX_TYPE_6 = 0x00,                                      
      SICK_LMS_VARIANT_SPECIAL = 0x01,                                         
      SICK_LMS_VARIANT_UNKNOWN = 0xFF                                          
    };

    enum sick_lms_2xx_scan_angle_t {
      SICK_SCAN_ANGLE_90 = 90,                                                 
      SICK_SCAN_ANGLE_100 = 100,                                               
      SICK_SCAN_ANGLE_180 = 180,                                               
      SICK_SCAN_ANGLE_UNKNOWN = 0xFF                                           
    };
    
    enum sick_lms_2xx_scan_resolution_t {
      SICK_SCAN_RESOLUTION_25 = 25,                                            
      SICK_SCAN_RESOLUTION_50 = 50,                                            
      SICK_SCAN_RESOLUTION_100 = 100,                                          
      SICK_SCAN_RESOLUTION_UNKNOWN = 0xFF                                      
    };

    enum sick_lms_2xx_measuring_units_t {
      SICK_MEASURING_UNITS_CM = 0x00,                                          
      SICK_MEASURING_UNITS_MM = 0x01,                                          
      SICK_MEASURING_UNITS_UNKNOWN = 0xFF                                      
    };

    enum sick_lms_2xx_sensitivity_t {
      SICK_SENSITIVITY_STANDARD = 0x00,                                        
      SICK_SENSITIVITY_MEDIUM = 0x01,                                          
      SICK_SENSITIVITY_LOW = 0x02,                                             
      SICK_SENSITIVITY_HIGH = 0x03,                                            
      SICK_SENSITIVITY_UNKNOWN = 0xFF                                          
    };

    enum sick_lms_2xx_peak_threshold_t {
      SICK_PEAK_THRESHOLD_DETECTION_WITH_NO_BLACK_EXTENSION = 0x00,            
      SICK_PEAK_THRESHOLD_DETECTION_WITH_BLACK_EXTENSION = 0x01,               
      SICK_PEAK_THRESHOLD_NO_DETECTION_WITH_NO_BLACK_EXTENSION = 0x02,         
      SICK_PEAK_THRESHOLD_NO_DETECTION_WITH_BLACK_EXTENSION = 0x03,            
      SICK_PEAK_THRESHOLD_UNKNOWN = 0xFF                                       
    };

    enum sick_lms_2xx_status_t {
      SICK_STATUS_OK = 0x00,                                                   
      SICK_STATUS_ERROR = 0x01,                                                
      SICK_STATUS_UNKNOWN = 0xFF                                               
    };
    
    enum sick_lms_2xx_measuring_mode_t { 
      SICK_MS_MODE_8_OR_80_FA_FB_DAZZLE = 0x00,                                
      SICK_MS_MODE_8_OR_80_REFLECTOR = 0x01,                                   
      SICK_MS_MODE_8_OR_80_FA_FB_FC = 0x02,                                    
      SICK_MS_MODE_16_REFLECTOR = 0x03,                                        
      SICK_MS_MODE_16_FA_FB = 0x04,                                            
      SICK_MS_MODE_32_REFLECTOR = 0x05,                                        
      SICK_MS_MODE_32_FA = 0x06,                                               
      SICK_MS_MODE_32_IMMEDIATE = 0x0F,                                        
      SICK_MS_MODE_REFLECTIVITY = 0x3F,                                        
      SICK_MS_MODE_UNKNOWN = 0xFF                                              
    };
    
    enum sick_lms_2xx_operating_mode_t {
      SICK_OP_MODE_INSTALLATION = 0x00,                                        
      SICK_OP_MODE_DIAGNOSTIC = 0x10,                                          
      SICK_OP_MODE_MONITOR_STREAM_MIN_VALUE_FOR_EACH_SEGMENT = 0x20,           
      SICK_OP_MODE_MONITOR_TRIGGER_MIN_VALUE_ON_OBJECT = 0x21,                 
      SICK_OP_MODE_MONITOR_STREAM_MIN_VERT_DIST_TO_OBJECT = 0x22,              
      SICK_OP_MODE_MONITOR_TRIGGER_MIN_VERT_DIST_TO_OBJECT = 0x23,             
      SICK_OP_MODE_MONITOR_STREAM_VALUES = 0x24,                               
      SICK_OP_MODE_MONITOR_REQUEST_VALUES = 0x25,                              
      SICK_OP_MODE_MONITOR_STREAM_MEAN_VALUES = 0x26,                          
      SICK_OP_MODE_MONITOR_STREAM_VALUES_SUBRANGE = 0x27,                      
      SICK_OP_MODE_MONITOR_STREAM_MEAN_VALUES_SUBRANGE = 0x28,                 
      SICK_OP_MODE_MONITOR_STREAM_VALUES_WITH_FIELDS = 0x29,                   
      SICK_OP_MODE_MONITOR_STREAM_VALUES_FROM_PARTIAL_SCAN = 0x2A,             
      SICK_OP_MODE_MONITOR_STREAM_RANGE_AND_REFLECT_FROM_PARTIAL_SCAN = 0x2B,  
      SICK_OP_MODE_MONITOR_STREAM_MIN_VALUES_FOR_EACH_SEGMENT_SUBRANGE = 0x2C, 
      SICK_OP_MODE_MONITOR_NAVIGATION = 0x2E,                                  
      SICK_OP_MODE_MONITOR_STREAM_RANGE_AND_REFLECT = 0x50,                    
      SICK_OP_MODE_UNKNOWN = 0xFF                                              
    };

    enum sick_lms_2xx_baud_t {
      SICK_BAUD_9600 = 0x42,                                                   
      SICK_BAUD_19200 = 0x41,                                                  
      SICK_BAUD_38400 = 0x40,                                                  
      SICK_BAUD_500K = 0x48,                                                   
      SICK_BAUD_UNKNOWN = 0xFF                                                 
    };

    static const uint8_t SICK_FLAG_AVAILABILITY_DEFAULT = 0x00;                
    static const uint8_t SICK_FLAG_AVAILABILITY_HIGH = 0x01;                   
    static const uint8_t SICK_FLAG_AVAILABILITY_REAL_TIME_INDICES = 0x02;      
    static const uint8_t SICK_FLAG_AVAILABILITY_DAZZLE_NO_EFFECT = 0x04;       
  
    typedef struct sick_lms_2xx_operating_status_tag {
      uint16_t sick_scan_angle;                                                
      uint16_t sick_scan_resolution;                                           
      uint16_t sick_num_motor_revs;                                            
      uint8_t sick_operating_mode;                                             
      uint8_t sick_measuring_mode;                                             
      uint8_t sick_laser_mode;                                                 
      uint8_t sick_device_status;                                              
      uint8_t sick_measuring_units;                                            
      uint8_t sick_address;                                                    
      uint8_t sick_variant;                                                    
    } sick_lms_2xx_operating_status_t;
    
    typedef struct sick_lms_2xx_software_status_tag {
      uint8_t sick_system_software_version[8];                                 
      uint8_t sick_prom_software_version[8];                                   
    } sick_lms_2xx_software_status_t;
    
    typedef struct sick_lms_2xx_restart_status_tag {
      uint16_t sick_restart_time;                                              
      uint8_t sick_restart_mode;                                               
    } sick_lms_2xx_restart_status_t;
    
    typedef struct sick_lms_2xx_pollution_status_tag {
      uint16_t sick_pollution_vals[8];                                         
      uint16_t sick_pollution_calibration_vals[8];                             
      uint16_t sick_reference_pollution_vals[4];                               
      uint16_t sick_reference_pollution_calibration_vals[4];                   
    } sick_lms_2xx_pollution_status_t;
    
    typedef struct sick_lms_2xx_signal_status_tag {
      uint16_t sick_reference_scale_1_dark_100;                                
      uint16_t sick_reference_scale_2_dark_100;                                
      uint16_t sick_reference_scale_1_dark_66;                                 
      uint16_t sick_reference_scale_2_dark_66;                                 
      uint16_t sick_signal_amplitude;                                          
      uint16_t sick_current_angle;                                             
      uint16_t sick_peak_threshold;                                            
      uint16_t sick_angle_of_measurement;                                      
      uint16_t sick_signal_amplitude_calibration_val;                          
      uint16_t sick_stop_threshold_target_value;                               
      uint16_t sick_peak_threshold_target_value;                               
      uint16_t sick_stop_threshold_actual_value;                               
      uint16_t sick_peak_threshold_actual_value;                               
      uint16_t sick_reference_target_single_measured_vals;                     
      uint16_t sick_reference_target_mean_measured_vals;                       
    } sick_lms_2xx_signal_status_t;
    
    typedef struct sick_lms_2xx_field_status_tag {
      uint8_t sick_field_evaluation_number;                                    
      uint8_t sick_field_set_number;                                           
      uint8_t sick_multiple_evaluation_offset_field_2;                         
    } sick_lms_2xx_field_status_t;
    
    typedef struct sick_lms_2xx_baud_status_tag {
      uint16_t sick_baud_rate;                                                 
      uint8_t sick_permanent_baud_rate;                                        
    } sick_lms_2xx_baud_status_t;
    
    typedef struct sick_lms_2xx_device_config_tag {
      uint16_t sick_blanking;                                                  
      uint16_t sick_fields_b_c_restart_times;                                  
      uint16_t sick_dazzling_multiple_evaluation;                              
      uint8_t sick_peak_threshold;                                             
      uint8_t sick_stop_threshold;                                             
      uint8_t sick_availability_level;                                         
      uint8_t sick_measuring_mode;                                             
      uint8_t sick_measuring_units;                                            
      uint8_t sick_temporary_field;                                            
      uint8_t sick_subtractive_fields;                                         
      uint8_t sick_multiple_evaluation;                                        
      uint8_t sick_restart;                                                    
      uint8_t sick_restart_time;                                               
      uint8_t sick_multiple_evaluation_suppressed_objects;                     
      uint8_t sick_contour_a_reference;                                        
      uint8_t sick_contour_a_positive_tolerance_band;                          
      uint8_t sick_contour_a_negative_tolerance_band;                          
      uint8_t sick_contour_a_start_angle;                                      
      uint8_t sick_contour_a_stop_angle;                                       
      uint8_t sick_contour_b_reference;                                        
      uint8_t sick_contour_b_positive_tolerance_band;                          
      uint8_t sick_contour_b_negative_tolerance_band;                          
      uint8_t sick_contour_b_start_angle;                                      
      uint8_t sick_contour_b_stop_angle;                                       
      uint8_t sick_contour_c_reference;                                        
      uint8_t sick_contour_c_positive_tolerance_band;                          
      uint8_t sick_contour_c_negative_tolerance_band;                          
      uint8_t sick_contour_c_start_angle;                                      
      uint8_t sick_contour_c_stop_angle;                                       
      uint8_t sick_pixel_oriented_evaluation;                                  
      uint8_t sick_single_measured_value_evaluation_mode;                      
    } sick_lms_2xx_device_config_t;
    
    typedef struct sick_lms_2xx_scan_profile_b0_tag {
      uint16_t sick_num_measurements;                                          
      uint16_t sick_measurements[SICK_MAX_NUM_MEASUREMENTS];                   
      uint8_t sick_field_a_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_field_b_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_field_c_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_telegram_index;                                             
      uint8_t sick_real_time_scan_index;                                       
      uint8_t sick_partial_scan_index;                                         
    } sick_lms_2xx_scan_profile_b0_t;
    
    typedef struct sick_lms_2xx_scan_profile_b6_tag {
      uint16_t sick_num_measurements;                                          
      uint16_t sick_measurements[SICK_MAX_NUM_MEASUREMENTS];                   
      uint8_t sick_sample_size;                                                
      uint8_t sick_telegram_index;                                             
      uint8_t sick_real_time_scan_index;                                       
    } sick_lms_2xx_scan_profile_b6_t;
    
    typedef struct sick_lms_2xx_scan_profile_b7_tag {
      uint16_t sick_subrange_start_index;                                      
      uint16_t sick_subrange_stop_index;                                       
      uint16_t sick_num_measurements;                                          
      uint16_t sick_measurements[SICK_MAX_NUM_MEASUREMENTS];                   
      uint8_t sick_field_a_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_field_b_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_field_c_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_telegram_index;                                             
      uint8_t sick_real_time_scan_index;                                       
      uint8_t sick_partial_scan_index;                                         
    } sick_lms_2xx_scan_profile_b7_t;
    
    typedef struct sick_lms_2xx_scan_profile_bf_tag {
      uint16_t sick_subrange_start_index;                                      
      uint16_t sick_subrange_stop_index;                                       
      uint16_t sick_num_measurements;                                          
      uint16_t sick_measurements[SICK_MAX_NUM_MEASUREMENTS];                   
      uint8_t sick_sample_size;                                                
      uint8_t sick_telegram_index;                                             
      uint8_t sick_real_time_scan_index;                                       
    } sick_lms_2xx_scan_profile_bf_t;
    
    typedef struct sick_lms_2xx_scan_profile_c4_tag {
      uint16_t sick_num_range_measurements;                                    
      uint16_t sick_num_reflect_measurements;                                  
      uint16_t sick_range_measurements[SICK_MAX_NUM_MEASUREMENTS];             
      uint16_t sick_reflect_measurements[SICK_MAX_NUM_MEASUREMENTS];           
      uint16_t sick_reflect_subrange_start_index;                              
      uint16_t sick_reflect_subrange_stop_index;                               
      uint8_t sick_field_a_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_field_b_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_field_c_values[SICK_MAX_NUM_MEASUREMENTS];                  
      uint8_t sick_telegram_index;                                             
      uint8_t sick_real_time_scan_index;                                       
    } sick_lms_2xx_scan_profile_c4_t;
    
    SickLMS2xx( const std::string sick_device_path );
    
    ~SickLMS2xx( );
    
    void Initialize( const sick_lms_2xx_baud_t desired_baud_rate, const uint32_t delay = 0 )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void Uninitialize( ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    std::string GetSickDevicePath( ) const;
    
    sick_lms_2xx_type_t GetSickType( ) const throw( SickConfigException );

    double GetSickScanAngle( ) const throw( SickConfigException );

    double GetSickScanResolution( ) const throw( SickConfigException );

    void SetSickMeasuringUnits( const sick_lms_2xx_measuring_units_t sick_units = SICK_MEASURING_UNITS_MM )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    SickLMS2xx::sick_lms_2xx_measuring_units_t GetSickMeasuringUnits( ) const throw( SickConfigException );
    
    void SetSickSensitivity( const sick_lms_2xx_sensitivity_t sick_sensitivity = SICK_SENSITIVITY_STANDARD )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    sick_lms_2xx_sensitivity_t GetSickSensitivity( ) const throw( SickConfigException );

    void SetSickPeakThreshold( const sick_lms_2xx_peak_threshold_t sick_peak_threshold = SICK_PEAK_THRESHOLD_DETECTION_WITH_NO_BLACK_EXTENSION )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );
    
    sick_lms_2xx_peak_threshold_t GetSickPeakThreshold( ) const throw( SickConfigException );;
    
    void SetSickMeasuringMode( const sick_lms_2xx_measuring_mode_t sick_measuring_mode = SICK_MS_MODE_8_OR_80_FA_FB_DAZZLE )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    sick_lms_2xx_measuring_mode_t GetSickMeasuringMode( ) const throw( SickConfigException );

    sick_lms_2xx_operating_mode_t GetSickOperatingMode( ) const throw( SickConfigException );
    
    void SetSickAvailability( const uint8_t sick_availability_flags = SICK_FLAG_AVAILABILITY_DEFAULT )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    uint8_t GetSickAvailability( ) const throw( SickConfigException );
    
    void SetSickVariant( const sick_lms_2xx_scan_angle_t scan_angle, const sick_lms_2xx_scan_resolution_t scan_resolution )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void GetSickScan( unsigned int * const measurement_values,
                      unsigned int & num_measurement_values,
                      unsigned int * const sick_field_a_values = NULL,
                      unsigned int * const sick_field_b_values = NULL,
                      unsigned int * const sick_field_c_values = NULL,
                      unsigned int * const sick_telegram_index = NULL,
                      unsigned int * const sick_real_time_scan_index = NULL ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void GetSickScan( unsigned int * const range_values,
                      unsigned int * const reflect_values,
                      unsigned int & num_range_measurements,
                      unsigned int & num_reflect_measurements,
                      unsigned int * const sick_field_a_values = NULL,
                      unsigned int * const sick_field_b_values = NULL,
                      unsigned int * const sick_field_c_values = NULL,
                      unsigned int * const sick_telegram_index = NULL,
                      unsigned int * const sick_real_time_scan_index = NULL ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void GetSickScanSubrange( const uint16_t sick_subrange_start_index,
                              const uint16_t sick_subrange_stop_index,
                              unsigned int * const measurement_values,
                              unsigned int & num_measurement_values,
                              unsigned int * const sick_field_a_values = NULL,
                              unsigned int * const sick_field_b_values = NULL,
                              unsigned int * const sick_field_c_values = NULL,
                              unsigned int * const sick_telegram_index = NULL,
                              unsigned int * const sick_real_time_scan_index = NULL ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);
    
    void GetSickPartialScan( unsigned int * const measurement_values,
                             unsigned int & num_measurement_values,
                             unsigned int & partial_scan_index,
                             unsigned int * const sick_field_a_values = NULL,
                             unsigned int * const sick_field_b_values = NULL,
                             unsigned int * const sick_field_c_values = NULL,
                             unsigned int * const sick_telegram_index = NULL,
                             unsigned int * const sick_real_time_scan_index = NULL ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void GetSickMeanValues( const uint8_t sick_sample_size,
                            unsigned int * const measurement_values,
                            unsigned int & num_measurement_values,
                            unsigned int * const sick_telegram_index = NULL,
                            unsigned int * const sick_real_time_index = NULL ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    void GetSickMeanValuesSubrange( const uint8_t sick_sample_size,
                                    const uint16_t sick_subrange_start_index,
                                    const uint16_t sick_subrange_stop_index,
                                    unsigned int * const measurement_values,
                                    unsigned int & num_measurement_values,
                                    unsigned int * const sick_telegram_index = NULL,
                                    unsigned int * const sick_real_time_index = NULL ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    sick_lms_2xx_status_t GetSickStatus( ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );

    bool IsSickLMS2xxFast( ) const throw( SickConfigException );
    
    void ResetSick( ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );
    
    std::string GetSickStatusAsString( ) const;
    
    std::string GetSickSoftwareVersionAsString( ) const;
    
    std::string GetSickConfigAsString( ) const;
    
    void PrintSickStatus( ) const;

    void PrintSickSoftwareVersion( ) const;

    void PrintSickConfig( ) const;

    /*
     * NOTE: The following methods are given to make working with our
     *       predefined types a bit more manageable.
     */

    static std::string SickTypeToString( const sick_lms_2xx_type_t sick_type );

    static sick_lms_2xx_scan_angle_t IntToSickScanAngle( const int scan_angle_int );

    static sick_lms_2xx_scan_resolution_t IntToSickScanResolution( const int scan_resolution_int );
    
    static sick_lms_2xx_scan_resolution_t DoubleToSickScanResolution( const double scan_resolution_double );
    
    static std::string SickBaudToString( const sick_lms_2xx_baud_t baud_rate );

    static sick_lms_2xx_baud_t IntToSickBaud( const int baud_int );
    
    static sick_lms_2xx_baud_t StringToSickBaud( const std::string baud_str );

    static std::string SickStatusToString( const sick_lms_2xx_status_t sick_status );
    
    static std::string SickMeasuringModeToString( const sick_lms_2xx_measuring_mode_t sick_measuring_mode );

    static std::string SickOperatingModeToString( const sick_lms_2xx_operating_mode_t sick_operating_mode );
    
    static std::string SickSensitivityToString( const sick_lms_2xx_sensitivity_t sick_sensitivity );

    static std::string SickPeakThresholdToString( const sick_lms_2xx_peak_threshold_t sick_peak_threshold );
    
    static std::string SickMeasuringUnitsToString( const sick_lms_2xx_measuring_units_t sick_units );    

  protected:

    std::string _sick_device_path;

    sick_lms_2xx_baud_t _curr_session_baud;

    sick_lms_2xx_baud_t _desired_session_baud;
    
    sick_lms_2xx_type_t _sick_type;

    sick_lms_2xx_operating_status_t _sick_operating_status;

    sick_lms_2xx_software_status_t _sick_software_status;

    sick_lms_2xx_restart_status_t _sick_restart_status;

    sick_lms_2xx_pollution_status_t _sick_pollution_status;

    sick_lms_2xx_signal_status_t _sick_signal_status;

    sick_lms_2xx_field_status_t _sick_field_status;

    sick_lms_2xx_baud_status_t _sick_baud_status;

    sick_lms_2xx_device_config_t _sick_device_config;

    uint8_t _sick_mean_value_sample_size;

    uint16_t _sick_values_subrange_start_index;

    uint16_t _sick_values_subrange_stop_index;
    
    struct termios _old_term;

    void _setupConnection() throw( SickIOException, SickThreadException );
    void _setupConnection(const uint32_t delay ) throw( SickIOException, SickThreadException );

    void _teardownConnection( ) throw( SickIOException );

    void _sendMessageAndGetReply( const SickLMS2xxMessage &sick_send_message,
                                  SickLMS2xxMessage &sick_recv_message,
                                  const unsigned int timeout_value,
                                  const unsigned int num_tries ) throw( SickIOException, SickThreadException, SickTimeoutException ); 

    void _sendMessageAndGetReply( const SickLMS2xxMessage &sick_send_message,
                                  SickLMS2xxMessage &sick_recv_message,
                                  const uint8_t reply_code,
                                  const unsigned int timeout_value,
                                  const unsigned int num_tries ) throw( SickIOException, SickThreadException, SickTimeoutException ); 
    
    void _flushTerminalBuffer( ) throw ( SickThreadException );
    
    void _setSessionBaud( const sick_lms_2xx_baud_t baud_rate ) throw( SickIOException, SickThreadException, SickTimeoutException );

    bool _testSickBaud( const sick_lms_2xx_baud_t baud_rate ) throw( SickIOException, SickThreadException );

    void _setTerminalBaud( const sick_lms_2xx_baud_t sick_baud ) throw( SickIOException, SickThreadException );

    void _getSickType( ) throw( SickTimeoutException, SickIOException, SickThreadException );

    void _getSickConfig( ) throw( SickTimeoutException, SickIOException, SickThreadException );

    void _setSickConfig( const sick_lms_2xx_device_config_t &sick_config ) throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException );
    
    void _getSickStatus( ) throw( SickTimeoutException, SickIOException, SickThreadException );

    void _getSickErrors( unsigned int * const num_sick_errors = NULL,
                         uint8_t * const error_type_buffer = NULL,
                         uint8_t * const error_num_buffer = NULL ) throw( SickTimeoutException, SickIOException, SickThreadException );

    void _setSickOpModeInstallation( )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeDiagnostic( )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorRequestValues( )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorStreamValues( )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorStreamRangeAndReflectivity( )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorStreamValuesFromPartialScan( )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorStreamMeanValues( const uint8_t sample_size )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorStreamValuesSubrange( const uint16_t subrange_start_index, const uint16_t subrange_stop_index )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);

    void _setSickOpModeMonitorStreamMeanValuesSubrange( const uint16_t sample_size, const uint16_t subrange_start_index, const uint16_t subrange_stop_index )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);
    
    void _switchSickOperatingMode( const uint8_t sick_mode, const uint8_t * const mode_params = NULL )
      throw( SickConfigException, SickTimeoutException, SickIOException, SickThreadException);
    
    void _parseSickScanProfileB0( const uint8_t * const src_buffer, sick_lms_2xx_scan_profile_b0_t &sick_scan_profile ) const;

    void _parseSickScanProfileB6( const uint8_t * const src_buffer, sick_lms_2xx_scan_profile_b6_t &sick_scan_profile ) const;

    void _parseSickScanProfileB7( const uint8_t * const src_buffer, sick_lms_2xx_scan_profile_b7_t &sick_scan_profile ) const;

    void _parseSickScanProfileBF( const uint8_t * const src_buffer, sick_lms_2xx_scan_profile_bf_t &sick_scan_profile ) const;
    
    void _parseSickScanProfileC4( const uint8_t * const src_buffer, sick_lms_2xx_scan_profile_c4_t &sick_scan_profile ) const;

    void _parseSickConfigProfile( const uint8_t * const src_buffer, sick_lms_2xx_device_config_t &sick_device_config ) const;

    void _extractSickMeasurementValues( const uint8_t * const byte_sequence, const uint16_t num_measurements, uint16_t * const measured_values,
                                        uint8_t * const field_a_values = NULL, uint8_t * const field_b_values = NULL, uint8_t * const field_c_values = NULL ) const;
    
    bool _returningRealTimeIndices( ) const { return _sick_device_config.sick_availability_level & SICK_FLAG_AVAILABILITY_REAL_TIME_INDICES; }

    bool _validSickMeasuringUnits( const sick_lms_2xx_measuring_units_t sick_units ) const;

    bool _validSickScanAngle( const sick_lms_2xx_scan_angle_t sick_scan_angle ) const;

    bool _validSickScanResolution( const sick_lms_2xx_scan_resolution_t sick_scan_resolution ) const;

    bool _validSickSensitivity( const sick_lms_2xx_sensitivity_t sick_sensitivity ) const;

    bool _validSickPeakThreshold( const sick_lms_2xx_peak_threshold_t sick_peak_threshold ) const;
    
    bool _validSickMeasuringMode( const sick_lms_2xx_measuring_mode_t sick_measuring_mode ) const;

    bool _isSickLMS200( ) const;
    
    bool _isSickLMS211( ) const;
    
    bool _isSickLMS220( ) const;
    
    bool _isSickLMS221( ) const;
    
    bool _isSickLMS291( ) const;

    bool _isSickUnknown( ) const;
    
    sick_lms_2xx_baud_t _baudToSickBaud( const int baud_rate ) const;

    std::string _sickAvailabilityToString( const uint8_t availability_code ) const;

    std::string _sickRestartToString( const uint8_t restart_code ) const;
    
    std::string _sickTemporaryFieldToString( const uint8_t temp_field_code ) const;

    std::string _sickSubtractiveFieldsToString( const uint8_t subt_field_code ) const;

    std::string _sickContourFunctionToString( const uint8_t contour_function_code ) const;
    
    std::string _sickVariantToString( const unsigned int sick_variant ) const;

  };

  typedef SickLMS2xx::sick_lms_2xx_type_t sick_lms_2xx_type_t;

  typedef SickLMS2xx::sick_lms_2xx_variant_t sick_lms_2xx_variant_t;

  typedef SickLMS2xx::sick_lms_2xx_scan_angle_t sick_lms_2xx_scan_angle_t;

  typedef SickLMS2xx::sick_lms_2xx_scan_resolution_t sick_lms_2xx_scan_resolution_t;

  typedef SickLMS2xx::sick_lms_2xx_measuring_units_t sick_lms_2xx_measuring_units_t;

  typedef SickLMS2xx::sick_lms_2xx_sensitivity_t sick_lms_2xx_sensitivity_t;

  typedef SickLMS2xx::sick_lms_2xx_peak_threshold_t sick_lms_2xx_peak_threshold_t;
  
  typedef SickLMS2xx::sick_lms_2xx_status_t sick_lms_2xx_status_t;

  typedef SickLMS2xx::sick_lms_2xx_measuring_mode_t sick_lms_2xx_measuring_mode_t;

  typedef SickLMS2xx::sick_lms_2xx_operating_mode_t sick_lms_2xx_operating_mode_t;

  typedef SickLMS2xx::sick_lms_2xx_baud_t sick_lms_2xx_baud_t;
  
} //namespace SickToolbox
  
#endif //SICK_LMS_2XX_HH