Drive.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_OVRO_CANBUS_DRIVE_H
#define CARMA_ANTENNA_OVRO_CANBUS_DRIVE_H

#include "carma/canbus/devices/XacDevice.h"
#include "carma/monitor/OvroSubsystem.h"

namespace carma {

namespace services {
    class Angle;
    class Table;
} // End namespace services

namespace antenna {
namespace ovro {

    class Drive : public carma::canbus::devices::XacDevice {
    public:

        explicit Drive( carma::canbus::CanOutput & canOutput,
                        carma::monitor::OvroSubsystem & monitorSubsys,
                        unsigned short antNo,
                        const std::string confFilename = 
                            "antenna/ovro/drive.conf" );

        virtual ~Drive( );

        void setAzElDriveRates( double azRateInRadPerS, 
                                double elRateInRadPerS, 
                                const carma::services::Angle & elevation );

        void stop( );

        struct TimestampedAzOverlapState {
            TimestampedAzOverlapState( );
            double mjd;
            bool azOverlapDetected;
        };

        TimestampedAzOverlapState getAzOverlapState( ) const;


        bool getControllerOvertemp() const;

        bool isDriveEnabled( ) const;

        bool isAtHwLimit( ) const;

        bool isInEngineeringMode( ) const;

        enum BaseSwitchState {
            OFF,            // Off (disabled)
            REMOTE_CONTROL, // Computer control
            LOCAL_CONTROL   // Handpaddle control
        };
        
        BaseSwitchState getBaseSwitchState( ) const;

        carma::canbus::MsgIdInfoMap getHalfSecMonitors( ) const;

        carma::canbus::MsgIdInfoMap getSlowMonitors( ) const;
        
        void processMsg( carma::canbus::msgType messageId,
                         ::std::vector< carma::canbus::byteType > & data,
                         bool sim );

        carma::canbus::Message simulateMsg( carma::canbus::msgType messageId );

        void setRawDriveVoltages( float azRawVolts, float elRawVolts );

        void setEngineeringMode( bool enable );

        void updateConfDataFromFile( );

        void writeMonitorData( );

    protected:

    private:
        
        void enableDrives( bool enable );

        void setDriveVoltages( float azVolts, float elVolts );

        void setMaxVoltage( float azMaxVolts, float elMaxVolts );

        void initialize( ); // Issued in response to an initReq

        void updateFrameData( );

        void processBlankingFramePacket1( carma::canbus::DataVector & data ); 
        void processBlankingFramePacket2( carma::canbus::DataVector & data ); 
        void processBlankingFramePacket3( carma::canbus::DataVector & data ); 
        void processBlankingFramePacket4( carma::canbus::DataVector & data ); 
        void processBlankingFramePacket5( carma::canbus::DataVector & data ); 
        void processBlankingFramePacket6( carma::canbus::DataVector & data ); 
        void processBlankingFramePacket7( carma::canbus::DataVector & data ); 

        carma::canbus::Message simulateBlankingFramePacket1( ); 
        carma::canbus::Message simulateBlankingFramePacket2( ); 
        carma::canbus::Message simulateBlankingFramePacket3( ); 
        carma::canbus::Message simulateBlankingFramePacket4( ); 
        carma::canbus::Message simulateBlankingFramePacket5( ); 
        carma::canbus::Message simulateBlankingFramePacket6( ); 
        carma::canbus::Message simulateBlankingFramePacket7( ); 
        
        carma::monitor::OvroSubsystem & mon_;
        carma::monitor::OvroSubsystem::DriveModule & driveMon_;
        carma::monitor::OvroSubsystem::Limit & limitMon_;
        carma::monitor::OvroSubsystem::Track & trackMon_;
        carma::monitor::AntennaCommon & comMon_;

        const unsigned short antNo_;
        const ::std::string configFilename_;

        struct SimInfo;
        struct Shared;
        std::auto_ptr< Shared > shared_;
        std::auto_ptr< carma::services::Table > table_;

    }; // class Drive

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