AntennaMaster.h

Go to the documentation of this file.

#ifndef ANTENNAMASTER_H
#define ANTENNAMASTER_H

// C++ includes

#include <string>
#include <vector>

// C includes

#include <signal.h>

// The base class include

#include "carma/szautil/AntNum.h"
#include "carma/szautil/Directives.h"
#include "carma/szautil/GenericMasterTask.h"
#include "carma/szautil/SignalTask.h"

// SZA includes

#include "carma/antenna/sza/antenna/control/AntennaTask.h"
#include "carma/antenna/sza/antenna/control/AntennaMasterMsg.h"
#include "carma/antenna/sza/antenna/control/SzaShare.h"
#include "carma/antenna/sza/antenna/control/SzaTask.h"

#define ANTENNA_HEARTBEAT_SIGNAL SIGRTMIN+1
#define ANTENNA_DRIVE_SIGNAL     SIGRTMIN+2
#define ANTENNA_MONITOR_SIGNAL   SIGRTMIN+3
#define STROBE_PMAC_SIGNAL       SIGRTMIN+4
#define CONNECT_SIGNAL           SIGRTMIN+5

// This timer will cause parent tasks to send a heartbeat request to
// their children

#define ANTENNA_HEARTBEAT_SEC    5         

// Every second, the pmac will be sent new positions.

#define ANTENNA_DRIVE_SEC        1         

// The drive system strobe will fire a quarter second out of sync with
// the pmac data strobe, so that data from PMAC DPRAM are already in
// shared memory when the monitoring data strobe arrives.

#define ANTENNA_DRIVE_DELAY_NSEC 500000000 // Delay after the integral
                                           // second boundary.  On
                                           // receipt of this signal,
                                           // the tracker task will
                                           // deliver a new commanded
                                           // position to the pmac,
                                           // valid 1.5 seconds in the
                                           // future.

// We will read out the entire shared memory object every half-second.

#define ANTENNA_MONITOR_NSEC     500000000 // 2Hz data pulse

// Every half-second, we will read out the pmac DPRAM into shared
// memory, in preparation for the data strobe which will cause the
// shared memory to be read and sent back to the control computer.  We
// don't want to read the DPRAM on the strobe, because the
// interlocking and readout operations from the pmac can be slow.

#define STROBE_PMAC_NSEC         500000000 

// The pmac strobe will fire a quarter second out of sync with the
// data strobe, so that data from PMAC DPRAM are already in shared
// memory when the data strobe arrives.

#define STROBE_PMAC_DELAY_NSEC   250000000 // Delay after the integral
                                           // second boundary.  This
                                           // puts the pmac strobe out
                                           // of sync with the monitor
                                           // strobe by a quarter
                                           // second.

#define CONNECT_SEC         2              // Connect timer

#define ANTENNAMASTER_TASK_FWD_FN(fn) void (fn)(AntennaMasterMsg* msg)

namespace sza {
  namespace antenna {
    namespace control {
      
      class AntennaDrive;
      class AntennaControl;
      class AntennaMonitor;
      class AntennaRx;
      class UmacControl;
      
      class AntennaMaster : 
        public SzaTask,
        public sza::util::GenericMasterTask<AntennaMasterMsg> {
        
        public:
        
        AntennaMaster(std::string host, 
                      std::string nameServer, 
                      const std::string& objectName,
                      std::string eventServer, 
                      const std::string& eventChannelName,
                      std::string notifyServer, 
                      bool simulateCanbus,
                      const sza::util::AntNum& antNum,
                      bool simPmac=false,
                      unsigned ifNodeId=1,
                      bool connect=true,
                      bool newcaltert=true,
                      unsigned nArg=0,
                      char** argv=0,
                      bool ignoreWrapLogic=true);
        
        ~AntennaMaster();
        
        sza::antenna::control::AntennaControl* AntennaControl();
        
        sza::antenna::control::AntennaDrive*   AntennaDrive();
        
        sza::antenna::control::AntennaMonitor* AntennaMonitor();
        
        sza::antenna::control::AntennaRx*      AntennaRx();
        
        sza::antenna::control::UmacControl*   UmacControl();

        void restartServices();
        
        //------------------------------------------------------------
        // Public methods for sending messages to this task.
        //------------------------------------------------------------
        
        SIGNALTASK_HANDLER_FN(doNothing);
        
        static SIGNALTASK_HANDLER_FN(sendSendHeartBeatMsg);
        
        static SIGNALTASK_HANDLER_FN(sendShutDownMsg);
        
        static SIGNALTASK_HANDLER_FN(sendPackDataFrameMsg);
        
        static SIGNALTASK_HANDLER_FN(sendDriveTickMsg);
        
        static SIGNALTASK_HANDLER_FN(sendConnectControlMsg);
        
        static SIGNALTASK_HANDLER_FN(sendConnectPmacMsg);
        
        static SIGNALTASK_HANDLER_FN(sendConnectScannerMsg);

        static SIGNALTASK_HANDLER_FN(sendStrobePmacMsg);
        
        void sendAdoptBoardMsg(unsigned short, AntennaTask::Id taskId);
        
        //------------------------------------------------------------
        // Communications methods
        //------------------------------------------------------------
        
        static ANTENNAMASTER_TASK_FWD_FN(forwardMasterMsg);
        
        //------------------------------------------------------------
        // Public accessor methods
        //------------------------------------------------------------
        
        SzaShare* getShare();
        
        sza::util::AntNum* getAnt();
        
        inline std::string host() {return host_;}
        
        inline std::string nameServer() {return nameServer_;}
        
        inline std::string objectName() {return objectName_;}
        
        inline std::string eventServer() {return eventServer_;}
        
        inline std::string notifyServer() {return notifyServer_;}

        inline std::string eventChannelName() {return eventChannelName_;}
        
        inline unsigned getIFNodeId() {
          return ifNodeId_;
        }

        void setArgs(unsigned nArg, char** argv);
        std::vector<std::string> getArgs();

        bool newCaltert() {
          return newCaltert_;
        }

        bool ignoreWrapLogic() {
          return ignoreWrapLogic_;
        }

        private:

        bool newCaltert_;

        // Argument string passed to the main program which
        // instantiated this object

        unsigned int nArg_;
        std::vector<std::string> args_;

        unsigned ifNodeId_;

        // True if connecting to the control system

        bool connect_;

        bool simPmac_;

        // True if ignoring wrap logic

        bool ignoreWrapLogic_;

        static AntennaMaster* master_;
        
        sza::util::AntNum* antNum_;
        
        std::string host_;
        
        std::string nameServer_;
        
        std::string objectName_;
        
        std::string eventServer_;
        
        std::string notifyServer_;

        std::string eventChannelName_;
        
        //------------------------------------------------------------
        // Thread management methods
        //------------------------------------------------------------
        
#if DIR_HAVE_CARMA

        static THREAD_START(startAntennaCanBus);
#endif

        static THREAD_START(startAntennaDrive);
        
        static THREAD_START(startAntennaMonitor);
        
        static THREAD_START(startAntennaControl);
        
        static THREAD_START(startAntennaRx);
        
        static THREAD_START(startAntennaSignal);
        
        static THREAD_START(startUmacControl);
        
        //------------------------------------------------------------
        // Thread cleanup handlers methods
        
        static THREAD_CLEAN(cleanAntennaDrive);
        
        static THREAD_CLEAN(cleanAntennaMonitor);
        
        static THREAD_CLEAN(cleanAntennaCanbus);

        static THREAD_CLEAN(cleanAntennaControl);
        
        static THREAD_CLEAN(cleanAntennaRx);
        
        static THREAD_CLEAN(cleanAntennaSignal);
        
        static THREAD_CLEAN(cleanUmacControl);

        //------------------------------------------------------------
        // Ping routines for the (pingable) subsystem threads
        
        static THREAD_PING(pingAntennaControl);

        static THREAD_PING(pingAntennaDrive);
        
        static THREAD_PING(pingAntennaMonitor);
        
        static THREAD_PING(pingAntennaRx);
        
        //------------------------------------------------------------
        // Pointers to the subsystem resources.  These pointers are
        // initialized by the subsystem threads on startup
        
        sza::antenna::control::AntennaControl*      controlTask_;
        
        sza::antenna::control::AntennaDrive*      driveTask_; 
        
        sza::antenna::control::AntennaRx*         rxTask_; 
        
        sza::antenna::control::AntennaMonitor*    monitorTask_; 

        sza::antenna::control::UmacControl*       umacControlTask_; 
        
        //------------------------------------------------------------
        // Members pertaining to communication with this task
        
        void processMsg(AntennaMasterMsg* taskMsg);
        
        //------------------------------------------------------------
        // Message forwarding methods.  These are private, as they
        // should not be used directly by tasks to send messages to
        // each other, or they will run the risk of a message getting
        // dropped if these methods are called before the recipient's
        // queue exists.
        //
        // Messages to all tasks should be sent to the master, whose
        // message queue is guaranteed to exist before any other tasks
        // are spawned, and which will not service messages until all
        // spawned tasks have allocated their resources.  This
        // guarantees that no messages will be lost, but simply queued
        // until the master calls its serviceMsgQ() method.
        
        static ANTENNAMASTER_TASK_FWD_FN(forwardControlMsg);
        
        static ANTENNAMASTER_TASK_FWD_FN(forwardDriveMsg);
        
        static ANTENNAMASTER_TASK_FWD_FN(forwardMonitorMsg);
        
        static ANTENNAMASTER_TASK_FWD_FN(forwardRxMsg);
        
        static ANTENNAMASTER_TASK_FWD_FN(forwardUmacControlMsg);

        ANTENNAMASTER_TASK_FWD_FN(**brd_fns_); 
        
        void initBoardFlagging();
        
        //------------------------------------------------------------
        // Private send methods for messages intended for the
        // AntennaMaster
        //------------------------------------------------------------
        
        static SIGNALTASK_HANDLER_FN(sendRestartMsg);
        
        void recordAdoption(AntennaMasterMsg* msg);
        
        void flagBoard(AntennaMasterMsg* msg);    
        
        //------------------------------------------------------------
        // Methods pertaining to timers managed by this task
        
        void sendHeartBeat();
        
        void installTimers();
        
        void installSignals();
        
      }; // End class AntennaMaster
      
    }; // End namespace control
  }; // End namespace antenna
}; // End namespace sza

#endif