QuadratureModulator.h

Go to the documentation of this file.

#ifndef CARMA_DOWNCONVERTER_QUADRATUREMODULATOR_H
#define CARMA_DOWNCONVERTER_QUADRATUREMODULATOR_H

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

#include <map>
#include <string>
#include <vector>

namespace carma {

namespace monitor {
    class QuadMod;
    class QuadModContainer;
    class StateMonitorPointEnum;
    class Xac;
} // End namespace monitor

namespace downconverter {

    class WalshSequence;

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

                QuadratureModulator(
                carma::canbus::nodeType node,
                carma::canbus::CanOutput &io,
                carma::monitor::QuadModContainer & quadModMon );

                virtual ~QuadratureModulator();

        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);

        static carma::canbus::apiType getApiId();

        void updateFrameData();

        void walshTableColumnImminent( unsigned short length,
                                       unsigned char crc );

        void loadWalshTableColumn( unsigned char segmentIndex,
                                   std::vector<unsigned char> segment );

        void setPoutPreset();

        void setPout(double pout);

        void setPoutAtten(unsigned short atten);

        // Enable quadrature modulation and noise gain.
        void enableQuadMod(bool enable);

        // Enable quadrature modulation sans noise gain.
        void enableModulationOnly( bool enable );

        void loadWalshSequence( const WalshSequence & walshSequence );

        bool isEnabled();
        bool checkIfOutPower(double power, double delta);
        bool checkIfInPower(double power, double delta);

    private:

        // Prevent assignment and copy construction.
        QuadratureModulator(const QuadratureModulator &);
        QuadratureModulator &operator=(const QuadratureModulator &);

        // Methods to process individual CAN messages.  These routines are
        // called by processMsg upon receipt of a CAN message.
        void processBlankingFramePacket1( carma::canbus::DataVector & data );
        void processBlankingFramePacket2( carma::canbus::DataVector & data );
        void processBlankingFramePacket3( carma::canbus::DataVector & data );

        // Methods to produce simulated CAN messages.  These routines are
        // called by simulateMsg and then placed in the CAN message queue
        // where they will eventually be processed by processMsg.
        carma::canbus::Message simBlankingFramePacket1();
        carma::canbus::Message simBlankingFramePacket2();
        carma::canbus::Message simBlankingFramePacket3();

        const int inputNo_;   // Corresponds to antenna no (1..8), not index!
        carma::monitor::StateMonitorPointEnum * state_;
        carma::monitor::QuadMod *mon_;
        carma::monitor::Xac *xacMon_;

        double ifInPower_;  // Current IF Input power
        double ifOutPower_; // Current IF Output power
        bool enabled_;      // Is quadrature modulation enabled?
        carma::util::PthreadMutex mutex_;

        }; // End class Quadrature Modulator
} // namespace downconverter
} // namespace carma
#endif