YigPll.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_OVRO_YIGPLL_H
#define CARMA_ANTENNA_OVRO_YIGPLL_H

// Carma includes
#include "carma/canbus/devices/XacDevice.h"
#include "carma/canbus/Types.h"
#include "carma/monitor/OvroSubsystem.h"
#include "carma/util/PthreadCond.h"
#include "carma/util/PthreadMutex.h"

namespace log4cpp {
    // Forward dec
    class Category;
} // End namespace log4cpp

namespace carma {
namespace antenna {
namespace ovro {

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

    YigPll( carma::canbus::nodeType node, 
            carma::canbus::CanOutput & io,
            carma::monitor::OvroSubsystem & mon );

    ~YigPll();

    std::map<carma::canbus::msgType, std::string> getHalfSecMonitors() const;

    std::map<carma::canbus::msgType, std::string> getSlowMonitors() const;

    void processMsg(carma::canbus::msgType mid,
                    std::vector<carma::canbus::byteType> &data, 
                    bool sim);

    carma::canbus::Message simulateMsg(carma::canbus::msgType mid);
    
    void updateFrameData();
    
    // Public control commands.
    
    typedef enum LockResult {
        YIG_LOCKED,    
        YIG_UNLOCKED,  
        YIG_TIMEDOUT   
    } LockResultType;
        
    void setYigFrequencyAndLockNoBlock( double freqInGhz );

    LockResultType setYigFrequencyAndLock( double freqInGhz );
    
    void setYigFrequencyWithoutLock( double freqInGhz );

    void extractTuneTable();

    void toggleSweep(bool on);

    void setDampingResistance(unsigned short damping);

protected:
    
    // There are no protected methods.

private:

    // Disable assignment and copy construction.
    YigPll(const YigPll &);
    YigPll &operator=(const YigPll &);
    
    // Routines to process individual blanking frame CAN packets.
    // These routines are called by processMsg.
    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);

    // Routine to process state change broadcast message.
    void processLockStateChangePacket(carma::canbus::DataVector &data);

    // Routines to produce individual simulated blanking frame CAN packets.
    // These routines are called by simulateMsg.
    carma::canbus::Message simBlankingFramePacket1();
    carma::canbus::Message simBlankingFramePacket2();
    carma::canbus::Message simBlankingFramePacket3();
    carma::canbus::Message simBlankingFramePacket4();
    carma::canbus::Message simBlankingFramePacket5();
    carma::canbus::Message simBlankingFramePacket6();
    
    // Member variables
    log4cpp::Category &log_;  // Reference to the system logger
    carma::monitor::AntennaCommon &common_; // Reference to common MPs.
    carma::monitor::OvroSubsystem::Yig &mon_;
    
    typedef enum { // For internal state machine 
        IDLE,
        WAITING,
        UNLOCKED,
        LOCKED
    } SequenceStateType;

    // To cause the lockYigFrequency command to block while waiting for
    // the yig to lock, we incorporate a condition variable which is wrapped 
    // up in the below structure (along with the state (contains predicate data)
    // and associated mutex).  The processLockStateChange command is responsible
    // for updating the state and signalling to lockYigFrequency (the waiter),
    // when finished.
    struct {
        volatile SequenceStateType state; // Predicate state LOCKED || UNLOCKED
        carma::util::PthreadMutex mutex;  // Mutex to wait on lock
        carma::util::PthreadCond cond;    // Condition variable to signal lock
    } lockSequence_;

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