ClockMaster.h

Go to the documentation of this file.

#ifndef CARMA_CLOCK_CLOCKMASTER_H
#define CARMA_CLOCK_CLOCKMASTER_H

// Carma includes
#include "carma/corba/corba.h"
#include "carma/canbus/Master.h"
#include "carma/clock/Clock.h"
#include "carma/util/UserException.h"

#include <memory>
#include <pthread.h>

namespace carma {
namespace clock {

    class ClockMaster : public carma::canbus::Master {
    public:

        ClockMaster( bool enableAutowriter,
                     double autoWriteDelayInS );

        ClockMaster( int modulBusNo,
                     int slotNo,
                     double autoWriteDelayInS );

        ClockMaster( int modulBusNo,
                     double autoWriteDelayInS );

        virtual ~ClockMaster();

        bool isDone();

        // Control routines (see IDL for documentation).
        carma::clock::ClockControl_ptr GlobalClock();
        carma::clock::ClockControl_ptr Clock();
        void reset();
        void softReset();
        void quit();

    protected:

        void updateStatus();

    private:

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

        // 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 carmaClockHost app
        // is a CORBA server, it will block on runOrb - thus we call run in
        // a seperate thread in the ClockMaster 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).
        std::auto_ptr< carma::clock::Clock > clock_;
        std::auto_ptr< carma::clock::Clock > globalClock_;
        
        carma::clock::ClockControl_ptr clockControlPtr_;
        carma::clock::ClockControl_ptr globalClockControlPtr_;

        std::string hostname_;
        std::auto_ptr< carma::monitor::MasterClockSubsystem > mon_;

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

        // DEBUG
        pthread_mutex_t doneMutex_;
        bool done_;

    }; // End ClockMaster class
}; // End clock namespace
}; // End carma namespace
#endif