AntennaMasterMsg.h

Go to the documentation of this file.

#ifndef ANTENNAMASTERMSG_H
#define ANTENNAMASTERMSG_H

#include <string>

#include "carma/szautil/SignalTask.h"
#include "carma/szautil/GenericMasterTaskMsg.h"

#include "carma/antenna/sza/antenna/control/AntennaControlMsg.h"
#include "carma/antenna/sza/antenna/control/AntennaDriveMsg.h"
#include "carma/antenna/sza/antenna/control/AntennaMonitorMsg.h"
#include "carma/antenna/sza/antenna/control/AntennaRxMsg.h"
#include "carma/antenna/sza/antenna/control/UmacControlMsg.h"
#include "carma/antenna/sza/antenna/control/AntennaTask.h"

namespace sza {
  namespace antenna {
    namespace control {
      
      class AntennaMasterMsg : 
        public sza::util::GenericMasterTaskMsg {
        
        public:
        
        enum MsgType {
          ADOPT_BOARD,    // Record a board adoption request from
                          // another task
          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
          FLAG_BOARD, 
          SCANNER_CONNECTED, // We are dis/connected from/to the archiver
          MONITOR_MSG,    // A message for the monitor task
          PMAC_CONNECTED, // The pmac is dis/connected
          RX_MSG,         // A message for the rx task
          STRIP_CONTROL_MSG,// A message for the strip control task
          SEND_HEARTBEAT, // Initiate a heartbeat.
        };
        
        MsgType type;
        
        union {
          
          struct {
            unsigned short board;
            AntennaTask::Id taskId;
          } adoptBoard;
          
          struct {
            unsigned short board;
            bool flag;
          } flagBoard;
          
          struct {
            bool connected;
          } controlConnected;
          
          struct {
            bool connected;
          } scannerConnected;
          
          struct {
            bool connected;
          } pmacConnected;
          
          //------------------------------------------------------------
          // Message bodies for threads managed by the AntennaMaster
          //------------------------------------------------------------
          
          AntennaControlMsg    controlMsg;   
          
          AntennaDriveMsg    driveMsg;   
          
          AntennaMonitorMsg  monitorMsg; 
          
          AntennaRxMsg       rxMsg;      
          
          UmacControlMsg    umacControlMsg;      

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

        //------------------------------------------------------------
        // Methods for packaging messages intended for this task.
        //------------------------------------------------------------
        
        inline void packSendHeartBeatMsg()
          {
            genericMsgType_ = 
              sza::util::GenericTaskMsg::TASK_SPECIFIC;
            
            type = SEND_HEARTBEAT;
          }
        
        inline void packAdoptBoardMsg(unsigned short board, 
                                      AntennaTask::Id taskId)
          {
            genericMsgType_ = 
              sza::util::GenericTaskMsg::TASK_SPECIFIC;
            
            type = ADOPT_BOARD;
            body.adoptBoard.board = board;
            body.adoptBoard.taskId = taskId;
          } 
        
        inline void packFlagBoardMsg(unsigned short board, bool flag)
          {
            genericMsgType_ = 
              sza::util::GenericTaskMsg::TASK_SPECIFIC;
            
            type = FLAG_BOARD;
            body.flagBoard.board = board;
            body.flagBoard.flag = flag;
          }
        
        inline void packControlConnectedMsg(bool connected)
          {
            genericMsgType_ = 
              sza::util::GenericTaskMsg::TASK_SPECIFIC;
            
            type = CONTROL_CONNECTED;
            
            body.controlConnected.connected = connected;
          }
        
        inline void packScannerConnectedMsg(bool connected)
          {
            genericMsgType_ = 
              sza::util::GenericTaskMsg::TASK_SPECIFIC;
            
            type = SCANNER_CONNECTED;
            
            body.scannerConnected.connected = connected;
          }
        
        inline void packPmacConnectedMsg(bool connected)
          {
            genericMsgType_ = 
              sza::util::GenericTaskMsg::TASK_SPECIFIC;
            
            type = PMAC_CONNECTED;
            
            body.pmacConnected.connected = connected;
          }

      }; // End class AntennaMasterMsg
      
    }; // End namespace control
  }; // End namespace antenna
}; // End namespace sza

#endif // End #ifndef