LoberotatorMaster.h

Go to the documentation of this file.

#ifndef CARMA_LOBEROTATORMASTER_H
#define CARMA_LOBEROTATORMASTER_H

// System includes
#include <pthread.h>

// Carma includes
#include "carma/canbus/Master.h"
#include "carma/loberotator/Chassis.h"
#include "carma/loberotator/Loberotator.h"
#include "carma/switchyard/Switchyard.h"
#include "carma/monitor/LoberotatorSubsystem.h"
#include "carma/monitor/SignalPathSubsystem.h"
#include "carma/util/Time.h"

#include <utility>

namespace carma {

namespace corba {

    class Server;

}


namespace loberotator {

    class LoberotatorMaster :
        public carma::loberotator::Chassis,
        public carma::canbus::Master {
    public:

        LoberotatorMaster(int holdoff, double autoWriteDelayInS,
                          double syautoWriteDelayInS);

        LoberotatorMaster( int board, int bus,
                           int holdoff, bool simulate,
                           double autoWriteDelayInS,
                           double syautoWriteDelayInS);

        carma::loberotator::Loberotator & getGlobalLoberotator( );
        
        carma::switchyard::Switchyard & getLoSwitchyard();

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

        bool isDone();

    protected:

        void updateStatus();

        virtual ~LoberotatorMaster();

    private:

       // The timer delay after the frame boundary for updating
        // the phase and rate
        // There is an inherent statistical delay of about 1.5msec
        // before the timer is serviced. It also takes on average
        // 0.7msec to actually do the update. Additionally, the messages take
        // about 3msec on the wire to go out. So we have a fixed delay of
        // 1.5 + 0.7 + 1.5 = 4,
        static const int FIXED_HOLDOFF = 4;
        int holdoff_;

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

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

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

        // DEBUG
        void quit();

        // 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 carmaLoberotatorHost app
        // is a CORBA server, it will block on runOrb - thus we call run in
        // a separate thread in the LoberotatorMaster 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).
        carma::loberotator::Loberotator* globalLrb_;
        carma::util::Time time_;
        carma::monitor::LoberotatorSubsystem* mon_;

        carma::monitor::SignalPathSubsystem signalPathMon_;
        carma::switchyard::Switchyard loSwitchyard_;
        carma::switchyard::Switchyard llSwitchyard_;

        // Are we emulating the underlying Janz hardware?
        const bool emulate_;

        std::string hostname_;

        // Static needed to call update in thread
        static void updateThreadStaticWrapper(LoberotatorMaster& lrm);
        // Thread scheduled update of phase & rate
        void updateThread();
        pthread_t updateThread_;
        void updatePhaseAndRate() const;

        // DEBUG
        pthread_mutex_t doneMutex_;
        bool done_;

    }; // End LoberotatorMaster class
 }; // End loberotator namespace
}; // End carma namespace

#endif // CARMA_LOBEROTATORMASTER_H