DriveEngine.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_OVRO_DRIVEENGINE_H
#define CARMA_ANTENNA_OVRO_DRIVEENGINE_H

#include <memory>
#include <pthread.h>
#include <string>
#include <vector>

namespace carma {

namespace monitor {
    class OvroSubsystem;
} // namespace monitor

namespace services {
    class Angle;
    class Location;
} // namespace services

namespace antenna {
namespace ovro {

    class Drive;
    class Encoder;
    class Tiltmeter;

    struct RaDecEpoch {
        double mjd;         
        double raRadians;   
        double decRadians;  
    };

    typedef ::std::vector< RaDecEpoch > RaDecTriplet;
    typedef RaDecTriplet::iterator RaDecTripletIter;
    typedef RaDecTriplet::const_iterator RaDecTripletConstIter;
        
    class DriveEngine {
    public:

        explicit DriveEngine( Drive & drive,
                              const Encoder & azEncoder,
                              const Encoder & elEncoder,
                              const Tiltmeter & tiltmeter,
                              carma::monitor::OvroSubsystem & mon );

        /* virtual */ ~DriveEngine( );

        void setAzEl( const carma::services::Angle & angle,
                      const carma::services::Angle & elevation );

        void setAz( const carma::services::Angle & azimuth );

        void setEl( const carma::services::Angle & elevation );

        void setRawDriveVoltages( float azVoltage, float elVoltage );

        void setRawDriveRates( float azRateInDegPerMin, 
                               float elRateInDegPerMin );
         
        void setEngineeringMode( bool enable );
        
        void setAzOffset( const carma::services::Angle & offset );

        void setElOffset( const carma::services::Angle & offset );

        void setOffset( const carma::services::Angle & azOffset,
                        const carma::services::Angle & elOffset );

        void setSource( std::string source );

        void setAzMaxRate( double azMaxRateInDegPerSec );

        void setElMaxRate( double elMaxRateInDegPerSec );

        enum WrapType {
            NO_TURN,         /*< Add Nothing to requested AZ EL */
            ADD_TURN,        /*< Add 360 degrees to requested AZ EL */
            SUBTRACT_TURN    /*< Subtract 360 degrees from requested AZ EL */
        };

        void setRaDec( const RaDecTriplet & raDecTriplet,
                       WrapType wrap = NO_TURN );

        void updateRaDec( const RaDecEpoch & raDecEpoch,
                          WrapType wrap = NO_TURN ); 

        void setWeather( double ambientTemp,
                         double barometricPressure,
                         double relativeHumidity,
                         double dewpointTemp,
                         double windSpeed,
                         double windDirection );

        void setLocation( const carma::services::Location & location );

        enum ApertureType {
            OPTICAL,   
            RADIO1MM, 
            RADIO3MM, 
            RADIO1CM,
            APERTURE_COUNT
        };

        void selectAperture( ApertureType aperture );
            
        void setAperturePointingConstants( 
            ApertureType aperture,
            const carma::services::Angle & azOffset,
            const carma::services::Angle & elOffset,
            const carma::services::Angle & sag );

        void setMountPointingConstants(
            const carma::services::Angle & azEncoderZero,
            const carma::services::Angle & elEncoderZero,
            const carma::services::Angle & nonOrthogonalityOfAxes,
            const carma::services::Angle & azimuthVerticalityNorthSouth,
            const carma::services::Angle & azimuthVerticalityEastWest );

        void setTiltmeterZeros( 
            const carma::services::Angle & aftForwardZero, 
            const carma::services::Angle & leftRightZero ); 

        void setAzEncoderZero( const carma::services::Angle & azEncoderZero );
                                
        void setElEncoderZero( const carma::services::Angle & azEncoderZero );

        void setMountOffsets( const carma::services::Angle & azMountOffset,
                              const carma::services::Angle & elMountOffset );

        void setAzMountOffset( const carma::services::Angle & azMountOffset );

        void setElMountOffset( const carma::services::Angle & elMountOffset );

        void snow( );

        void stop( );

        void stowZenith( );

        void setSafeRange( const carma::services::Angle & azLow,
                           const carma::services::Angle & azHigh,
                           const carma::services::Angle & elLow,
                           const carma::services::Angle & elHigh );
        
        void stowSafe( );

        void setSequenceNumber( unsigned long seqNo );

        void setTolerance( const carma::services::Angle & tolerance );

        void updateConfigurationData( );

        void freezeTilt( );

        void thawTilt( );

        void toggleBacklashCorrection( bool enable );

    protected:

        // Nothing

    private:

        void writeMonitorData( );

        void driveLoopThread( );

        static void driveLoopThreadEntry( DriveEngine & This );

        class Acquisition;
        class DriveState;
        class Limits;
        class Pointing;
        class Servo;
        class SourcePosition;
        class Timing;
        class Tracking;

        struct EngineeringInfo;

        Drive & drive_;
        ::std::auto_ptr< Acquisition > acquisition_;
        ::std::auto_ptr< DriveState > driveState_;
        ::std::auto_ptr< EngineeringInfo > engineering_;
        ::std::auto_ptr< Limits > limits_;
        ::std::auto_ptr< Pointing > pointing_;
        ::std::auto_ptr< Servo > azServo_;
        ::std::auto_ptr< Servo > elServo_;
        ::std::auto_ptr< SourcePosition > sourcePosition_;
        ::std::auto_ptr< Timing > timing_;
        ::std::auto_ptr< Tracking > tracking_;
        ::pthread_t driveLoopThreadId_;
        ::pthread_mutex_t mutex_;

    }; // class DriveEngine

}}} // namespace carma::antenna::ovro
#endif