SldcMaster.h

Go to the documentation of this file.

#ifndef CARMA_DOWNCONVERTER_SLDCMASTER_H
#define CARMA_DOWNCONVERTER_SLDCMASTER_H

#include "carma/canbus/Master.h"
#include "carma/downconverter/common/LoMonitor.h"
#include "carma/downconverter/common/NoiseSource.h"
#include "carma/downconverter/common/QuadratureModulator.h"
#include "carma/downconverter/spectral/BlockDownconverter.h"
#include "carma/downconverter/spectral/SpectralDownconverter.h"
#include "carma/downconverter/spectral/LoControl.h"
#include "carma/switchyard/Switchyard.h"
#include "carma/util/PthreadCond.h"
#include "carma/util/PthreadMutex.h"

#include <map>
#include <string>

namespace carma {

namespace monitor {
    class SignalPathSubsystem;
    class SldcSubsystem;
}

namespace canbus {
    class Device;
} 

namespace downconverter {

    class SldcMaster : public carma::canbus::Master {
    public:

        SldcMaster( ::carma::monitor::SldcSubsystem & sldcMon,
                    ::carma::monitor::SignalPathSubsystem & signalPathMon );

        SldcMaster( const ::std::vector< CanDio::DevTermPair > & devTermPairs, 
                    bool simOfflineNodes,
                    ::carma::monitor::SldcSubsystem & sldcMon,
                    ::carma::monitor::SignalPathSubsystem & signalPathMon );

        virtual ~SldcMaster();

        void addDevice(carma::canbus::Device *device);

        SpectralDownconverter & getSldc(
            unsigned short inputIndex, 
            unsigned short bandIndex);

        SpectralDownconverter & getGlobalSldc();

        LoControl & getLoControl( );

        LoMonitor & getLoMonitor( );

        NoiseSource & getNoiseSource( );

        QuadratureModulator & getQuadMod( unsigned short inputNo );

        QuadratureModulator & getGlobalQuadMod( );

        BlockDownconverter & getBlockDownconverter( unsigned short inputNo );

        BlockDownconverter & getGlobalBlockDownconverter( );

        ::carma::switchyard::Switchyard & getSwitchyard( );

        ::carma::switchyard::Switchyard & getDcLoSwitchyard( );


        void reset();

        void softReset();

        void start();

        void stop();
        

    protected:

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

        void updateStatus();

    private:

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

        // Helper routine for common initialization
        void initialize();
        static void * runThreadEntry(void *arg);

        pthread_t runThreadId_;
        bool isRunning_;
        carma::util::PthreadMutex isRunningGuard_;
        carma::util::PthreadCond isRunningCond_;

        carma::monitor::SldcSubsystem & sldcMon_;
        carma::monitor::SignalPathSubsystem & signalPathMon_;
        
        typedef ::std::map<
            ::carma::canbus::nodeType, 
            ::carma::downconverter::SpectralDownconverter *> SldcDeviceMap;

        typedef ::std::map<
            ::carma::canbus::nodeType,
            ::carma::downconverter::BlockDownconverter *> BlockDcDeviceMap;

        typedef ::std::map<
            ::carma::canbus::nodeType,
            ::carma::downconverter::QuadratureModulator *> QuadModDeviceMap;
            
        LoControl loControl_;
        LoMonitor loMonitor_;
        NoiseSource noiseSource_;
        QuadModDeviceMap quadMods_;
        BlockDcDeviceMap blockDownconverters_;
        SldcDeviceMap sldcDevices_;
        ::carma::switchyard::Switchyard switchyard_;
        ::carma::switchyard::Switchyard dcLoSwitchyard_;

        QuadratureModulator globalQuadMod_; // Node 0 QuadMod
        SpectralDownconverter globalSldc_; // Node 0 Downconverter
        BlockDownconverter globalBlockDownconverter_;

        const std::string hostname_;

    }; // End class SldcMaster
}} // End namespace carma::downconverter
#endif