GearBox Project

00001 /*
00002  * GearBox Project: Peer-Reviewed Open-Source Libraries for Robotics
00003  *               http://gearbox.sf.net/
00004  * Copyright (c) 2004-2008 Alex Brooks
00005  *
00006  * This distribution is licensed to you under the terms described in
00007  * the LICENSE file included in this distribution.
00008  *
00009  */
00010 
00011 #ifndef SICK_ACFR_DRIVER_MESSAGES_H
00012 #define SICK_ACFR_DRIVER_MESSAGES_H
00013 
00014 #include <string>
00015 #include <vector>
00016 #include <gbxsickacfr/sickdefines.h>
00017 #include <gbxsickacfr/gbxserialdeviceacfr/gbxserialdeviceacfr.h>
00018 
00019 namespace gbxsickacfr {
00020 
00021     std::string toHexString( const uChar *buf, int bufLen );
00022     inline std::string toHexString( const std::vector<uChar> &buf )
00023     {return toHexString( &(buf[0]), buf.size() );}
00024 
00026     // Generic LMS Response classes:
00027     // 
00028     // - The SICK replies to commands with responses.
00029     // - Responses are of a standard format, but some responses contain
00030     //   extra response-type-specific data.
00031     // - This is handled with the abstract class 'LmsResponseData':
00032     //   - The LmsResponse has a pointer to LmsResponseData, which should
00033     //     be cast to the appropriate type depending on the response type.
00034     //
00035     // (Note that in continuous mode, the measurements continuously
00036     //  sent out by the SICK are 'responses', even though there's no command).
00037     // 
00039 
00040     // Abstract class for representing response-type-specific data.
00041     class LmsResponseData {
00042     public:
00043         virtual ~LmsResponseData() {}
00044 
00045         // human-readable string
00046         virtual std::string toString() const=0;
00047 
00048         virtual bool isError() const { return false; }
00049         virtual bool isWarn() const { return false; }
00050 
00051         // Returns a freshly allocated object of the same type
00052         virtual LmsResponseData *clone() const=0;
00053     };
00054 
00055     // This class represents responses which the SICK uses to reply to commands.
00056     // All response types have the information in this class.
00057     // Some responses also have extra data, which is stored in the 'data' member.
00058     class LmsResponse : public gbxserialdeviceacfr::IResponse {
00059     public:
00060         LmsResponse()
00061             : status(0),
00062               data(NULL)
00063             {}
00064         LmsResponse( const LmsResponse &other );
00065         LmsResponse &operator=( const LmsResponse &other );
00066         ~LmsResponse()
00067             { if (data) delete data; }
00068 
00069         uChar type;
00070         uChar status;
00071         LmsResponseData *data;
00072 
00073         bool isError() const;
00074         bool isWarn() const;
00075 
00076         std::string toString() const;
00077     };
00078     std::string toString( const LmsResponse &r );
00079 
00081     // Response-specific data classes
00082     //
00083     // - The set of classes below all inherit from the abstract
00084     //   'LmsResponseData' class.  They represent the data contained
00085     //   in specific response types.
00086     // - See 'parseResponse' in the .cpp file for details of which 
00087     //   classes go with which response codes.
00088     // 
00090 
00091     class LmsInitResponseData : public LmsResponseData {
00092     public:
00093         std::string description;
00094 
00095         std::string toString() const { return description; }
00096         LmsResponseData *clone() const { return new LmsInitResponseData(*this); }        
00097     };
00098 
00099     class LmsStatusResponseData : public LmsResponseData {
00100     public:
00101         std::string version;
00102         uChar       operatingMode;
00103         uChar       status;
00104         std::string manufacturer;
00105         uChar       variantType;
00106         uint16_t    pollution[POLLUTION_LENGTH];
00107         uint16_t    refPollution[REF_POLLUTION_LENGTH];
00108         uint16_t    calibPollution[CALIB_POLLUTION_LENGTH];
00109         uint16_t    calibRefPollution[CALIB_REF_POLLUTION_LENGTH];
00110         uint16_t    numMotorRevolutions;
00111         uint16_t    refScale1Dark100Pct;
00112         uint16_t    refScale2Dark100Pct;
00113         uint16_t    refScale1Dark66Pct;
00114         uint16_t    refScale2Dark66Pct;
00115         uint16_t    signalAmplitudePct;
00116         uint16_t    currentAngle;
00117         uint16_t    peakThreshold;
00118         uint16_t    angleOfMeasurement;
00119         uint16_t    calibSignalAmplitude;
00120         uint16_t    targetStopThreshold;
00121         uint16_t    targetPeakThreshold;
00122         uint16_t    actualStopThreshold;
00123         uint16_t    actualPeakThreshold;
00124         uChar       measuringMode;
00125         uint16_t    refSingleMeasuredValues;
00126         uint16_t    refMeanMeasuredValues;
00127         uint16_t    scanningAngle;
00128         uint16_t    angularResolution;
00129         uChar       restartMode;
00130         uChar       restartTime;
00131         uint16_t    baudRate;
00132         uChar       evaluationNumber;
00133         uChar       permanentBaudRate;
00134         uChar       lmsAddress;
00135         uChar       fieldSetNumber;
00136         uChar       currentMeasuredValueUnit;
00137         uChar       laserSwitchOff;
00138         std::string softwareVersion;
00139 
00140         std::string toString() const;
00141         LmsResponseData *clone() const { return new LmsStatusResponseData(*this); }
00142     };
00143 
00144     class LmsSwitchOperatingModeResponseData : public LmsResponseData {
00145     public:
00146         uChar success;
00147 
00148         bool isError() const { return success != OPERATING_MODE_RESPONSE_SUCCESS; }
00149         std::string toString() const { return modeSwitchSuccessToString(success); }
00150         LmsResponseData *clone() const { return new LmsSwitchOperatingModeResponseData(*this); }
00151     };
00152 
00153     class LmsConfigurationData : public LmsResponseData {
00154     public:
00155 
00156         // Default values for all these fuckers
00157         LmsConfigurationData();
00158         bool operator==( const LmsConfigurationData &o ) const;
00159         bool operator!=( const LmsConfigurationData &o ) const
00160             { return !(operator==(o)); }
00161 
00162         uint16_t blanking;
00163         uChar    sensitivity;
00164         uChar    availability;
00165         uChar    measuringMode;
00166         uChar    measuredValueUnit;
00167         uChar    transientFieldSet;
00168         uChar    subtractiveFields;   // 14
00169         uChar    multipleEvaluation;
00170         uChar    restart;
00171         uChar    restartTime;
00172         uChar    multipleEvaluationForSuppressed;
00173         uChar    contourARef;
00174         uChar    contourAPosToleranceBand; // 20
00175         uChar    contourANegToleranceBand;
00176         uChar    contourAStartAngle;
00177         uChar    contourAStopAngle;
00178         uChar    contourBRef;
00179         uChar    contourBPosToleranceBand;
00180         uChar    contourBNegToleranceBand;
00181         uChar    contourBStartAngle;
00182         uChar    contourBStopAngle;
00183         uChar    contourARef2;
00184         uChar    contourAPosToleranceBand2; // 30
00185         uChar    contourCNegToleranceBand;
00186         uChar    contourCStartAngle;
00187         uChar    contourCStopAngle;
00188         uChar    pixelOrientedEvaluation;
00189         uChar    singleMeasuredValueEvaluation;
00190         uint16_t restartTimeFields;
00191         uint16_t multipleEvaluationForDazzle;
00192 
00193         std::string toString() const;
00194         LmsResponseData *clone() const { return new LmsConfigurationData(*this); }
00195     };
00196 
00197     class LmsConfigurationResponseData : public LmsResponseData {
00198     public:
00199         LmsConfigurationData config;
00200         uChar                configSuccess;
00201 
00202         std::string toString() const;
00203         LmsResponseData *clone() const { return new LmsConfigurationResponseData(*this); }        
00204         bool isError() const { return configSuccess != CONFIGURATION_SUCCESS; }
00205     };
00206 
00207     class LmsSwitchVariantResponseData : public LmsResponseData {
00208     public:
00209         uChar            success;
00210         uint16_t         scanningAngle;
00211         uint16_t         angularResolution;
00212 
00213         std::string toString() const;
00214         LmsResponseData *clone() const { return new LmsSwitchVariantResponseData(*this); }        
00215         bool isError() const { return success != SWITCH_VARIANT_SUCCESS; }
00216     };
00217 
00218     class LmsMeasurementData : public LmsResponseData {
00219     public:
00220         
00221         // ranges in metres
00222         std::vector<float> ranges;
00223         std::vector<uChar> intensities;
00224 
00225         std::string toString() const;
00226         LmsResponseData *clone() const { return new LmsMeasurementData(*this); }        
00227     };
00228 
00229     class LmsErrorResponseData : public LmsResponseData {
00230     public:
00231         
00232         std::vector<uChar> errorTypes;
00233         std::vector<uChar> errorCodes;
00234 
00235         std::string toString() const;
00236         LmsResponseData *clone() const { return new LmsErrorResponseData(*this); }        
00237         bool isError() const;
00238         bool isWarn() const;
00239     };
00240 
00241     class LmsOperatingDataCounterData : public LmsResponseData {
00242     public:
00243         
00244         int hoursOfOperation;
00245         int numSwitchOns;
00246 
00247         std::string toString() const;
00248         LmsResponseData *clone() const { return new LmsOperatingDataCounterData(*this); }        
00249     };
00250 
00252 
00253     // If a complete telegram was found, returns true and allocates memory in 'response'.
00254     bool parseBufferForResponses( const uChar                     *buffer,
00255                                   int                              bufferLength,
00256                                   LmsResponse                    *&response,
00257                                   int                             &bytesParsed );
00258 
00259     void constructTelegram( std::vector<uChar>       &buffer,
00260                             const std::vector<uChar> &commandAndData );
00261 
00262     // SICK parameters can be changed in installation mode.
00263     void constructRequestInstallationMode( std::vector<uChar> &commandAndData );
00264 
00265     void constructRequestContinuousMode( std::vector<uChar> &commandAndData );
00266     void constructRequestMeasuredOnRequestMode( std::vector<uChar> &commandAndData );
00267 
00268     void constructInitAndReset( std::vector<uChar> &commandAndData );
00269 
00270     void constructStatusRequest( std::vector<uChar> &commandAndData );
00271 
00272     void constructConfigurationRequest( std::vector<uChar> &commandAndData );
00273 
00274     void constructConfigurationCommand( const LmsConfigurationData &c,
00275                                         std::vector<uChar> &commandAndData );
00276 
00277     void constructRequestErrorMessage( std::vector<uChar> &commandAndData );
00278 
00279     void constructSwitchVariant( uint16_t scanningAngle,
00280                                  uint16_t angularResolution,
00281                                  std::vector<uChar> &commandAndData );
00282 
00283     void constructRequestOperatingDataCounter( std::vector<uChar> &commandAndData );
00284         
00285     void constructRequestBaudRate( std::vector<uChar> &commandAndData, int baudRate );
00286 }
00287 
00288 #endif
messages.h
