OvroMaster.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_OVRO_OVROMASTER_H
#define CARMA_ANTENNA_OVRO_OVROMASTER_H

// Carma includes
#include "carma/antenna/common/CMReceiver.h"
#include "carma/antenna/common/LOReferenceMonitor.h"
#include "carma/antenna/common/SisReceiver.h"
#include "carma/antenna/common/Tiltmeter.h"
#include "carma/antenna/common/Varactor.h"
#include "carma/antenna/ovro/canbus/AntennaIF.h"
#include "carma/antenna/ovro/canbus/CryoCompressor.h"
#include "carma/antenna/ovro/canbus/CryoTemperatures.h"
#include "carma/antenna/ovro/canbus/Drive.h"
#include "carma/antenna/ovro/canbus/Encoder.h"
#include "carma/antenna/ovro/canbus/EnvironmentalMonitor.h"
#include "carma/antenna/ovro/canbus/GunnPll.h"
#include "carma/antenna/ovro/canbus/Optics.h"
#include "carma/antenna/ovro/canbus/RxTemperatures.h"
#include "carma/antenna/ovro/canbus/SecondaryMirror.h"
#include "carma/antenna/ovro/canbus/SharedOpticsSeqNo.h"
#include "carma/antenna/ovro/canbus/YigPll.h"
#include "carma/antenna/ovro/control/DriveEngine.h"
#include "carma/canbus/Master.h"
#include "carma/util/PthreadCond.h"
#include "carma/util/PthreadMutex.h"

// STL includes
#include <map>
#include <memory>

namespace log4cpp {
    // Forward declaration.
    class Category;
} // End namespace log4cpp

namespace carma {

namespace monitor {
    // Forward declaration.
    class OvroSubsystem;
} // End namespace monitor

namespace antenna {
namespace ovro {

class OvroMaster : public carma::canbus::Master {
public:

    explicit OvroMaster( unsigned short antNo, 
                         bool simOfflineNodes,
                         carma::monitor::OvroSubsystem & ovroSubsystem );

    explicit OvroMaster(
        int board, 
        unsigned short antNo, 
        bool simOfflineNodes,
        bool reset,
        bool terminate, 
        carma::monitor::OvroSubsystem & ovroSubsystem );

    explicit OvroMaster(
        int board, 
        int bus, 
        unsigned short antNo, 
        bool simOfflineNodes,
        bool reset,
        bool terminate,
        carma::monitor::OvroSubsystem & ovroSubsystem );

    virtual ~OvroMaster();

    void start();

    void stop();

    enum AntennaIFType {
        IF1,
        IF2
    };

    AntennaIF& getAntennaIF( enum AntennaIFType ifType );

    CryoCompressor& getCryoCompressor();

    CryoTemperatures& getCryoTemperatures();

    DriveEngine & getDriveEngine( );

    Tiltmeter& getTiltmeter();

    SecondaryMirror& getSecondary();

    Optics& getOptics();

    EnvironmentalMonitor& getEnvironmentalMonitor();

    YigPll& getYigPll();

    RxTemperatures& getRxTemperatureController();

    enum SisRxType {
        SIS_RX1MM,
        SIS_RX3MM
    };

    enum SisRxPolType {
        SINGLE, // Single Pol, doesn't matter which kind of polarization.
        LEFT_CIRCULAR,
        RIGHT_CIRCULAR
    };

    carma::antenna::common::SisReceiver& 
    getSisReceiver( enum SisRxType rx,
                    enum SisRxPolType pol );

    carma::antenna::common::CMReceiver &
    getCMReceiver( );

    enum GunnType {
        LO1CM,
        LO1MM,
        LO3MM,
        LOANY
    };

    GunnPll& getGunn(enum GunnType gunn);

    carma::antenna::common::Varactor & getVaractor( );

    carma::antenna::common::LOReferenceMonitor& getLOReferenceMonitor();

    void reset(); 
    
    void setInitialization( bool state );

protected:

    carma::canbus::MsgBriefMap getControls() const;

    void updateStatus();

    void softReset();

private:

    // Disallow assignment and copy construction.
    OvroMaster(const OvroMaster &);
    OvroMaster &operator=(const OvroMaster &);

    // Run thread entry point.
    static void *runThreadEntry(void *arg);

    // Redefine run such that it is private.
    void run();

    // Initialize helper routine to perform common creation tasks 
    // (i.e. those common among all three constructors).
    void initialize(unsigned short antNo);

    log4cpp::Category& log_;

    // Keep id around so that we can destroy it when need be.
    pthread_t runThreadId_;  
    bool isRunning_;
    carma::util::PthreadMutex isRunningGuard_;
    carma::util::PthreadCond isRunningCond_;

    // Define the devices that will exist on this network.
    // Also, since these aren't CORBA servants, they don't need to be
    // allocated on the heap.  This is a bit different than in the past 
    // and it avoids the mismanagement of the memory...
    SharedOpticsSeqNo sharedOpticsSeqNo_;
    CryoCompressor compressor_;
    CryoTemperatures dewar_;
    EnvironmentalMonitor enviro_;
    AntennaIF ifLeftPol_;
    AntennaIF ifRightPol_;
    carma::antenna::common::LOReferenceMonitor loref_;
    Optics optics_;
    RxTemperatures rxtemp_;
    SecondaryMirror secondary_;
    Tiltmeter tiltmeter_;
    YigPll yig_;
    GunnPll gunn1mm_;
    GunnPll gunn3mm_;
    carma::antenna::common::Varactor gunn1cm_;
    carma::antenna::common::SisReceiver rx1mmLeftPol_;
    carma::antenna::common::SisReceiver rx1mmRightPol_;
    carma::antenna::common::SisReceiver rx3mm_;
    carma::antenna::common::CMReceiver rx1cm_;
    
    // WARNING: the following are initialization order dependent on each other.
    Drive drive_; 
    Encoder azEncoder_; 
    Encoder elEncoder_; 
    DriveEngine driveEngine_; 
    // Initialization order dependent
    
    // Monitor system reference
    carma::monitor::OvroSubsystem & mon_;

    const ::std::string hostname_;
    bool initialized_;

}; // End class OvroMaster    
}}} // End namespace carma::antenna::ovro
#endif