SisReceiver.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_COMMON_SISRECEIVER_H
#define CARMA_ANTENNA_COMMON_SISRECEIVER_H

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

// C++ Standard Library Includes
#include <map>


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

namespace carma {

namespace monitor {
    class AntennaCommon;
    class SisReceiver;
    class StateMonitorPointEnum;
    class Xac;
} // End namespace monitor

namespace antenna {
namespace common {

class AntennaIF;

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

    SisReceiver( carma::canbus::nodeType node, 
                 carma::canbus::CanOutput & io,
                 carma::monitor::AntennaCommon & antCommon,
                 carma::monitor::StateMonitorPointEnum & state,
                 carma::monitor::SisReceiver & sis,
                 carma::monitor::Xac & xac,
                 carma::antenna::common::AntennaIF & antIF );

    virtual ~SisReceiver();

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

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

    void processMsg(carma::canbus::msgType mid,
                    carma::canbus::DataVector &data,
                    bool sim);

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

    void updateFrameData();

    // Public control commands.
    void tuneMixer( float frequencyInGhz ) const;

    void setVj( float VjInMilliVolts ) const;

    void setIj( float IjInMicroAmps ) const;

    void setLoAttenuation( float loAttenPercent ) const;

    void setVd( short stageNo, float VdInVolts ) const;

    void setId( short stageNo, float IdInMilliAmps ) const; 

    void setVg( short stageNo, float Vg ) const;

    void doIVCurve( float startInMilliVolts, 
                    float stopInMilliVolts, 
                    float stepInMilliVolts, 
                    int timeDeltaMilliSeconds,
                    int seqNo,
                    bool doPower );

    typedef enum {
        STORED   = 0x00,   
        MESSAGE  = 0x01,   
        IV_CURVE = 0x02    
    } CurrentModeType;
    
    void getVgap( CurrentModeType mode, float Igap ) const;

    void setIgap( float Igap ) const;

    typedef enum {
        VJ_CLOSED = 0x00, 
        VJ_OPEN   = 0x01, 
        VJ_FINITE = 0x02  
    } VjLoopModeType;

    void setVjLoopMode(VjLoopModeType mode) const;

    typedef enum {
        IJ_CLOSED = 0x00, 
        IJ_FINITE = 0x01  
    } IjLoopModeType;

    // These IV Curve definitions exist independently from the idl definitions
    // to maintain separation of canbus device impls from specific control 
    // communication mechanisms.

    void setIjLoopMode(IjLoopModeType mode) const;

    struct IVPoint {
        double fjd; 
        float Ij; 
        float Vj; 
    };

    typedef ::std::vector< IVPoint > IVDataVec;

    struct IVCurve {
        IVDataVec data;
        bool doPowerRequested;
        IVCurve( ) : doPowerRequested( false ) { };
    };

    IVCurve getIVCurve();

    static const carma::canbus::msgType RX_3MM_LEFT_POL_NODE_ID      = 1;
    static const carma::canbus::msgType RX_3MM_RIGHT_POL_NODE_ID     = 2;
    static const carma::canbus::msgType RX_1MM_LEFT_POL_NODE_ID      = 3;
    static const carma::canbus::msgType RX_1MM_RIGHT_POL_NODE_ID     = 4;
    
protected:

    // Method to process IV Curve Point
    virtual void processIVCurvePoint(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket1(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket3(carma::canbus::DataVector &data);

private:

    // Copying or assignment not allowed.
    SisReceiver(const SisReceiver &);
    SisReceiver &operator=(const SisReceiver &);

    // Methods to process individual blanking frame packets.
    virtual void processBlankingFramePacket2(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket4(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket5(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket6(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket7(carma::canbus::DataVector &data);
    virtual void processBlankingFramePacket8(carma::canbus::DataVector &data);

    
    // Methods to produce individual simulated blanking frame CAN packets.
    carma::canbus::Message simBlankingFramePacket1();
    carma::canbus::Message simBlankingFramePacket2();
    carma::canbus::Message simBlankingFramePacket3();
    carma::canbus::Message simBlankingFramePacket4();
    carma::canbus::Message simBlankingFramePacket5();
    carma::canbus::Message simBlankingFramePacket6();
    carma::canbus::Message simBlankingFramePacket7();
    carma::canbus::Message simBlankingFramePacket8();

    // Member variables
    log4cpp::Category &log_; // Reference to system logger.
    carma::monitor::AntennaCommon & common_;
    carma::monitor::StateMonitorPointEnum & state_;
    carma::monitor::SisReceiver & mon_;
    carma::monitor::Xac & xacMon_;
        
    IVCurve ivCurve_; // Last IV curve.
    carma::util::PthreadMutex ivCurveMutex_; // Mutex protecting it..

    // Structure to facilitate the collection of IV Curve points and 
    // assembly into a complete IV curve.
    typedef struct {
        int pendingSequenceNumber;
        unsigned int nPointsExpected;
        unsigned int nPointsReceived;
        IVCurve tempIVCurve; // Temporary IV curve. 
        carma::util::PthreadMutex mutex; // Mutex to protect shared data.
    } IVCurveCollationInfo;

    IVCurveCollationInfo ivCurveCollationInfo_; 
    carma::antenna::common::AntennaIF & antIF_;
    
}; // End class SisReceiver
}}} // End namespace carma::antenna::common
#endif