AntennaControlMsg.h

#ifndef GCP_ASSEMBLER_ANTENNACONTROLMSG_H
#define GCP_ASSEMBLER_ANTENNACONTROLMSG_H

#include "gcp/util/common/AntNum.h"
#include "gcp/util/common/Debug.h"

#include "gcp/util/common/GenericTaskMsg.h"
#include "gcp/antenna/control/specific/AntennaMasterMsg.h"

// Do not move these around.  GCC3.2.2 is easily confused

#include "gcp/control/code/unix/libunix_src/specific/rtcnetcoms.h"
#include "gcp/control/code/unix/libunix_src/common/tcpip.h"

namespace gcp {
namespace mediator {
    
    class AntennaControlMsg :
      public gcp::util::GenericTaskMsg {
      
      public:
      
      enum MsgType {
    
    // Flag an antenna as reachable/unreachable
    
    FLAG_ANTENNA,
    
    // We are starting/finishing recording initialization sequence

    INIT,

    // The start of an initialization script

    BEGIN_INIT,

    // The end of an initialization script

    END_INIT,

    // A net command to be sent directly to the antenna socket.
    
    NETCMD,
    
    // A message intended for the master task
    
    ANTENNA_MASTER_MSG,

    // Weather data
    
    WEATHER
      };
      
      MsgType type;
      
      union {
    
    struct {
      unsigned antenna; // The mask of antennas which changed
                // state
      bool flag;        // True to flag, false to unflag.
      
    } flagAntenna;
    
    struct { 
      bool start; 
    } init;

    struct {
      gcp::control::NetCmdId opcode;
      gcp::control::RtcNetCmd cmd;
    } netCmd;
    
    gcp::antenna::control::AntennaMasterMsg antennaMasterMsg;
    
      } body;
      
      gcp::util::AntNum::Id antennas;

      bool init_;

      //------------------------------------------------------------
      // Methods for returning pointers to messages for threads
      // managed by this task.
      //------------------------------------------------------------
      
      // Don't muck with the value of init_ here -- if it is set, we
      // don't it to be reset just by a call to this method to
      // retrieve it.

      inline gcp::antenna::control::AntennaMasterMsg* getMasterMsg()
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;

      type = ANTENNA_MASTER_MSG;

      return &body.antennaMasterMsg;
    }
      
      //------------------------------------------------------------
      // Methods for packing messages to the AntennaControl
      // task
      //------------------------------------------------------------
      
      inline void packBeginInitMsg() {
    initialize();

    type = BEGIN_INIT;
      }

      inline void packEndInitMsg() {
    initialize();

    type = END_INIT;
      }

      inline void packInitMsg(bool start) {
    initialize();

    type = INIT;

    body.init.start = start;
      }
      
      inline void packFlagAntennaMsg(unsigned antenna, bool flag) {
    initialize();
    
    DBPRINT(true, gcp::util::Debug::DEBUG6, "");

    type = FLAG_ANTENNA;

    body.flagAntenna.antenna = antenna;
    body.flagAntenna.flag = flag;
      }
      
      inline void packRtcNetCmdMsg(gcp::control::RtcNetCmd* cmd, 
                   gcp::control::NetCmdId opcode) {
    initialize();

    antennas = (gcp::util::AntNum::Id)cmd->antennas;
    
    type = NETCMD;

    body.netCmd.cmd = *cmd;
    body.netCmd.opcode = opcode;
      }
      
      private:

      // Private initialization method

      inline void initialize() {
    genericMsgType_ = 
      gcp::util::GenericTaskMsg::TASK_SPECIFIC;
    init_ = false;
      }
    
    }; // End class AntennaControlMsg
    
} // End namespace mediator
} // End namespace gcp

#endif // End #ifndef