WbdcMaster.h

Go to the documentation of this file.

#ifndef CARMA_DOWNCONVERTER_WBDCMASTER_H
#define CARMA_DOWNCONVERTER_WBDCMASTER_H

#include "carma/canbus/Master.h"
#include "carma/downconverter/common/DownconverterControl.h"
#include "carma/downconverter/common/QuadModControl.h"
#include "carma/downconverter/common/LoMonitorControl.h"
#include "carma/downconverter/common/NoiseSourceControl.h"
#include "carma/downconverter/common/SldcLoControl.h"
#include "carma/downconverter/spectral/BlockDownconverterControl.h"
#include "carma/downconverter/spectral/SpectralDownconverterControl.h"

#include <map>
#include <pthread.h>
#include <tao/Basic_Types.h>

namespace carma {

namespace corba {
    class Server;
}

namespace monitor {
    // Forward dec
    class WbdcSubsystem;
}

namespace downconverter {

    class Downconverter;
    class LoMonitor;
    class NoiseSource;
    class QuadratureModulator;

    class WbdcMaster : public carma::canbus::Master {
    public:

        WbdcMaster( carma::corba::Server & server, 
                    carma::monitor::WbdcSubsystem & mon );

        WbdcMaster( carma::corba::Server & server, 
                    int modulBusNo, int slotNo,
                    carma::monitor::WbdcSubsystem & mon );

        WbdcMaster( carma::corba::Server & server, 
                    int modulBusNo,
                    carma::monitor::WbdcSubsystem & mon );

        virtual ~WbdcMaster();

        bool isDone();

    protected:

        void updateStatus();

    public: 

        // Our CORBA IDL Defined control methods.  These implement the IDL
        // defined System interface. They are declared private to assure that
        // they are only accessible via CORBA (doesn't care about privacy).
        carma::downconverter::DownconverterControl_ptr GlobalDownconverter();
        carma::downconverter::DownconverterControl_ptr Downconverter(
            short input, short band);
        carma::downconverter::SpectralDownconverterControl_ptr
        SpectralDownconverter( CORBA::Short input, CORBA::Short band );
        carma::downconverter::QuadModControl_ptr GlobalQuadMod();
        carma::downconverter::QuadModControl_ptr QuadMod(short input);
        carma::downconverter::NoiseSourceControl_ptr GlobalNoiseSource();
        carma::downconverter::NoiseSourceControl_ptr NoiseSource();
        carma::downconverter::LoMonitorControl_ptr GlobalLoMonitor();
        carma::downconverter::LoMonitorControl_ptr LoMonitor();
        carma::downconverter::SldcLoControl_ptr LoControl();
        carma::downconverter::BlockDownconverterControl_ptr
        BlockDownconverter( CORBA::Short inputNo );
        carma::downconverter::BlockDownconverterControl_ptr
        GlobalBlockDownconverter( );

        void selectSidebandFrequency(
            carma::downconverter::DownconverterControl::SidebandType sideband,
            CORBA::Double lofreq,
            CORBA::UShort bandNo);
        void selectFilter(
            carma::downconverter::DownconverterControl::FilterType filter,
            CORBA::UShort bandNo );
        void setPsysPreset( CORBA::UShort inputNo, CORBA::UShort bandNo );
        void setPsys( CORBA::Float psys,
                      CORBA::UShort inputNo,
                      CORBA::UShort bandNo );
        void reset();
        void softReset();
        // DEBUG
        void quit();
    
    private:

        // Copying and assignment are not allowed
        WbdcMaster(const WbdcMaster &);
        WbdcMaster &operator=(const WbdcMaster &);

        // Helper routines to consolidate initialization among 3 constructors.
        void initialize();
        void addDevices();

        // Consolidate removal of devices - used on destruction.
        void removeDevices();

        // Run thread entry point.  Entry points are needed in order to assure
        // that the actual run method is not subject to the c-style linkage
        // rules (static) that are required of the pthread entry point.
        static void *runThreadEntry(void *arg);

        // Redefine run such that it is private. Since the carmaWbdcHost app
        // is a CORBA server, it will block on runOrb - thus we call run in
        // a seperate thread in the WbdcMaster constructor to get the CANbus
        // side of things moving independently.
        void run();

        // Keep the run thread id around so that we can properly destroy the
        // thread upon destruction.
        pthread_t runThreadId_;

        // Node 0 'Global control' device objects. (Aren't added to Master
        // device map via addDevice).
        typedef std::map< carma::canbus::nodeType,
                          carma::downconverter::Downconverter *> DcByNodeMap;

        DcByNodeMap downconverters_;
        carma::downconverter::Downconverter * globalDc_;
        carma::downconverter::QuadratureModulator * globalQm_;
        carma::downconverter::LoMonitor * globalLoMon_;
        
        typedef std::pair< short, short > InputBandNoPair;
        typedef std::map< InputBandNoPair, 
                          carma::downconverter::DownconverterControl_ptr >
            DownconverterControlsMap;
        typedef std::map< short, 
                          carma::downconverter::QuadModControl_ptr >
            QuadModControlsMap;

        carma::downconverter::DownconverterControl_ptr globalDcControl_;
        carma::downconverter::QuadModControl_ptr globalQmControl_;
        carma::downconverter::LoMonitorControl_ptr globalLoMonControl_;

        DownconverterControlsMap dcControls_;
        QuadModControlsMap qmControls_;
        carma::downconverter::NoiseSourceControl_ptr nsControl_;
        carma::downconverter::LoMonitorControl_ptr loMonControl_;
        carma::corba::Server & server_;

        carma::monitor::WbdcSubsystem & mon_;

        const bool emulate_;            // Emulate Janz Hardware
        const std::string hostname_;    // Hostname we're running on

        // DEBUG
        pthread_mutex_t doneMutex_;
        bool done_;

    }; // End WbdcMaster class
}; // End downconverter namespace
}; // End carma namespace
#endif