AntennaMasterMsg.h

Go to the documentation of this file.

#ifndef ANTENNAMASTERMSG_H
#define ANTENNAMASTERMSG_H

#include <string>

#include "gcp/util/common/SignalTask.h"
#include "gcp/util/common/GenericMasterTaskMsg.h"

#include "gcp/antenna/control/specific/AntennaControlMsg.h"
#include "gcp/antenna/control/specific/AntennaDriveMsg.h"
#include "gcp/antenna/control/specific/AntennaMonitorMsg.h"
#include "gcp/antenna/control/specific/AntennaRxMsg.h"
#include "gcp/antenna/control/specific/AntennaRoachMsg.h"
#include "gcp/antenna/control/specific/AntennaTask.h"

namespace gcp {
  namespace antenna {
    namespace control {
      
      class AntennaMasterMsg : 
    public gcp::util::GenericMasterTaskMsg {
    
    public:
    
    enum MsgType {
      CONTROL_MSG,    // A message for the communications task
      CONTROL_CONNECTED, // We are dis/connected from/to the control host
      DRIVE_MSG,      // A message for the drive task
      SCANNER_CONNECTED, // We are dis/connected from/to the archiver
      MONITOR_MSG,    // A message for the monitor task
      DRIVE_CONNECTED, // The ACU is dis/connected
      RX_MSG,         // A message for the rx task
      RX_CONNECTED,   // A message The rx task is connected/disconnected
      RX_TIMER,       // A message regarding turnign the RX timers on/off
      ROACH_MSG,         // A message for the rx task
      ROACH_CONNECTED,   // A message The rx task is connected/disconnected
      ROACH_TIMER,       // A message regarding turnign the ROACH timers on/off
      SEND_HEARTBEAT, // Initiate a heartbeat.
    };
    
    MsgType type;
    
    union {
      
      struct {
        bool connected;
      } controlConnected;


      struct {
        bool connected;
      } rxConnected;

      struct {
        bool on;
      } rxTimer;

      struct {
        bool connected;
      } roachConnected;

      struct {
        bool on;
      } roachTimer;
      
      struct {
        bool connected;
      } scannerConnected;
      
      struct {
        bool connected;
      } driveConnected;
      
      //------------------------------------------------------------
      // Message bodies for threads managed by the AntennaMaster
      //------------------------------------------------------------
      
      AntennaControlMsg    controlMsg;   
      
      AntennaDriveMsg    driveMsg;   
      
      AntennaMonitorMsg  monitorMsg; 
      
      AntennaRxMsg       rxMsg;        

      AntennaRoachMsg       roachMsg;        

    } body;
    
    //------------------------------------------------------------
    // Methods for accessing task messages managed by this class.
    //------------------------------------------------------------
    
    inline AntennaControlMsg* getControlMsg()
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = CONTROL_MSG;
        return &body.controlMsg;
      }
    
    inline AntennaDriveMsg* getDriveMsg()
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = DRIVE_MSG;
        return &body.driveMsg;
      }
    
    inline AntennaMonitorMsg* getMonitorMsg()
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = MONITOR_MSG;
        return &body.monitorMsg;
      }
    
    inline AntennaRxMsg* getRxMsg()
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = RX_MSG;
        return &body.rxMsg;
      }

    inline AntennaRoachMsg* getRoachMsg()
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = ROACH_MSG;
        return &body.roachMsg;
      }

    //------------------------------------------------------------
    // Methods for packaging messages intended for this task.
    //------------------------------------------------------------
    
    inline void packSendHeartBeatMsg()
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = SEND_HEARTBEAT;
      }
    
    inline void packControlConnectedMsg(bool connected)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = CONTROL_CONNECTED;
        
        body.controlConnected.connected = connected;
      }

    inline void packRxConnectedMsg(bool connected)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = RX_CONNECTED;
        
        body.rxConnected.connected = connected;
      }

    inline void packRxTimerMsg(bool timeOn)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = RX_TIMER;
        
        body.rxTimer.on = timeOn;
      }

    inline void packRoachConnectedMsg(bool connected)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = ROACH_CONNECTED;
        
        body.roachConnected.connected = connected;
      }

    inline void packRoachTimerMsg(bool timeOn)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = ROACH_TIMER;
        
        body.roachTimer.on = timeOn;
      }
    
    inline void packScannerConnectedMsg(bool connected)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = SCANNER_CONNECTED;
        
        body.scannerConnected.connected = connected;
      }
    
    inline void packDriveConnectedMsg(bool connected)
      {
        genericMsgType_ = 
          gcp::util::GenericTaskMsg::TASK_SPECIFIC;
        
        type = DRIVE_CONNECTED;
        
        body.driveConnected.connected = connected;
      }
      
      }; // End class AntennaMasterMsg
      
    }; // End namespace control
  }; // End namespace antenna
} // End namespace gcp

#endif // End #ifndef