Master.h

Go to the documentation of this file.

#ifndef CARMA_CANBUS_MASTER_H 
#define CARMA_CANBUS_MASTER_H

// System includes
#include <pthread.h>

// C++ Standard Library includes
#include <map>
#include <string>

// Carma includes
#include "carma/canbus/CanDio.h"
#include "carma/util/PthreadMutex.h"

namespace carma {
  namespace canbus {

      // Forward dec
      class Device;

      class Master : public CanDio {
      public:

          Master( bool simOfflineNodes = true );

          Master(
            int boardId, 
            bool simOfflineNodes = false, 
            bool reset = false,
            bool terminate = true );

          Master(
            int boardId, 
            int modulbusId, 
            bool simOfflineNodes = false,
            bool reset = false,
            bool terminate = true );

          Master( const ::std::vector< DevTermPair > & devTermPairs,
                  bool simOfflineNodes = false,
                  bool reset = false );

          virtual ~Master();

          void run();

          void stop();

      protected:

          void addDevice(Device *device);

          void removeDevice(apiType api, nodeType node);

          Device* getDevice(apiType api, nodeType node);

          int getOnlineNodeCount() const;

          int getOfflineNodeCount() const;

          int getUnknownPacketCount() const;

          int getDonglelessPacketCount() const;
           
          unsigned int getLatePacketCount();

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

          virtual void updateStatus() = 0;

          void softwareReset();

          virtual void setTime();

      protected:

          // Undefined and inaccessible to prevent copying.
          Master(const Master &);
          Master &operator=(const Master &);

          void updateDevicesStates();

          static void *timerThreadEntry(void *arg);

          void runTimerThread(); 

          static void *readThreadEntry(void *arg);

          virtual void runReadThread(); 

          std::map<keyType, Device*> devices_; 
          mutable pthread_mutex_t deviceMutex_;
          int nOnlineNodes_;       // Number of nodes in !OFFLINE state
          int nOfflineNodes_;      // Number of nodes in OFFLINE state
          int nUnknownPackets_;    // Number of packets unrecognized by master
          int nDonglelessPackets_; // Number of packets from node 512
          pthread_t timerThreadId_;
          pthread_t readThreadId_;
          const int simOfflineNodes_;

          bool running_;  // Is master running (needed for proper cleanup)
          carma::util::PthreadMutex runningMutex_;

      }; // End of class Master
  } // End namespace canbus 
} // End namespace carma
#endif // End #ifndef CARMA_CANBUS_MASTER_H