IFCanMaster.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_BIMA_IFCANMASTER_H
#define CARMA_ANTENNA_BIMA_IFCANMASTER_H

// Carma includes
#include "carma/corba/corba.h"
#include "carma/antenna/bima/CMReceiver.h"
#include "carma/monitor/BimaSubsystem.h"
#include "carma/antenna/bima/TelemetryCommand.h"
#include "carma/antenna/bima/AntennaIFClient.h"
#include "carma/antenna/bima/control/AntennaControlImpl.h"
#include "carma/antenna/bima/Rx.h"
#include "carma/canbus/Master.h"
#include "carma/canbus/exceptions.h"
#include "carma/canbus/Utilities.h"
#include "carma/util/ErrorException.h"
#include "carma/util/Program.h"
#include "carma/util/ScopedPthreadMutexLock.h"
#include "carma/util/PthreadCond.h"
#include "carma/util/PthreadMutex.h"
#include "carma/antenna/bima/SharedMemory.h"
#include "carma/antenna/bima/ProcessMonitor.h"

#include "carma/antenna/bima/AntennaIF.h"

// NOTE, this puts itself in the carma::antenna::ovro
// name space to utilize ovro's written code
#include "carma/antenna/bima/Tiltmeter.h"

// STL includes
#include <map>

namespace log4cpp {
    // Forward declaration.
    class Category;
} // End namespace log4cpp

namespace carma
{
  namespace monitor
  {
    class BimaSubsystem; // Forward declaration.
  }

  namespace antenna
  {

    namespace common 
    {
      class Varactor;
    }

    namespace bima
    {
      class AntennaNameResolver;
      class SisReceiver;
      class CMReceiver;

class IFCanMaster : public carma::canbus::Master
{
 public:

    IFCanMaster(carma::util::IPQreader<TelemetryCommand> &ifr,
                Rx &rx, 
                carma::monitor::BimaSubsystem &mon,
                AntennaNameResolver & anr,
                Configuration &config);

    IFCanMaster( int board, int bus,
                 carma::util::IPQreader<TelemetryCommand> &ifr,
                 Rx &rx,
                 carma::monitor::BimaSubsystem &mon,
                 AntennaNameResolver & anr,
                 Configuration &config);

    ~IFCanMaster();

    void start();

    void stop();

    static void *startWriterThread( void *arg );
    void writerThread( void );

    AntennaIF& getAntennaIFPol1() { return *_aifPol1; };
    AntennaIF& getAntennaIFPol2() { return *_aifPol2; };
    AntennaControlImpl& getAntennaControl() { return *_ant; };
    CMReceiver& getCmRxControl() { return *_cmrx; };
    carma::antenna::ovro::Tiltmeter& getTiltmeter() { return *_tiltMeter; };
    
    void reset(); 
    
    void setInitialized( bool state );

   protected:

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

    void updateStatus();

    void softReset();


private:

    // Disallow assignment and copy construction.
    IFCanMaster(const IFCanMaster &);
    IFCanMaster &operator=(const IFCanMaster &);

    // Run thread entry point.
    static void *runThreadEntry(void *arg);

    // Redefine run such that it is private.
    void run();

    // Initialize helper routine to perform common creation tasks 
    // (i.e. those common among all three constructors).
    void initialize(Configuration &config);

    // Keep id around so that we can destroy it when need be.
    pthread_t runThreadId_;  
    bool isRunning_;
    carma::util::PthreadMutex isRunningGuard_;
    carma::util::PthreadCond isRunningCond_;

    // Define the devices that will exist on this network.
    // Also, since these aren't CORBA servants, they don't need to be
    // allocated on the heap.  This is a bit different than in the past 
    // but it avoids the mismanagement of the memory...
    carma::antenna::bima::AntennaIF *_aifPol1;
    carma::antenna::bima::AntennaIF *_aifPol2;

    // OVRO type of tiltmeter, currently only on carma7/bima1
    // This is picked up from bima/Tiltmeter.h above!
    // that has modifications to its interface (namely a different
    // monitor subsystem..
    carma::antenna::ovro::Tiltmeter *_tiltMeter;

    // This is used to talk to the SIS Receiver CAN module.
    carma::antenna::bima::SisReceiver *_sisrx;

    carma::antenna::common::Varactor *_varactor;

    carma::antenna::bima::CMReceiver *_cmrx;
    
    // The sole reason for AntennaControl's existence anymore
    // is apparently to provide a way to reset the primary
    // CAN bus...  The IF system on the BIMA antennas is
    // the only shared system between OVRO and BIMA and
    // it is the only class that has a copy of the "master"
    // which provides the method to reset... Hence this is
    // where AntennaControl ends up... Oh.  My.  God.
    carma::antenna::bima::AntennaControlImpl *_ant;

    carma::monitor::BimaSubsystem& mon_;
    log4cpp::Category& log_;
    carma::util::IPQreader<TelemetryCommand> &_ifReader;

    AntennaNameResolver & anr_;
    SharedMemory *_bimaShm;

   }; // End class IFCanMaster    

 }
}
} // End namespace carma::antenna::bima

#endif // CARMA_ANTENNA_BIMA_IFCANMASTER_H