DriveControlImpl.h

Go to the documentation of this file.

#ifndef CARMA_ANTENNA_BIMA_DRIVECONTROL_H
#define CARMA_ANTENNA_BIMA_DRIVECONTROL_H

#include "carma/antenna/bima/control/bimaDriveControl.h"
#include "carma/corba/corba.h"
#include "carma/util/IPQwriter.h"

#include <string>

namespace log4cpp {
    class Category;
}

namespace carma
{
  namespace antenna
    {
      namespace bima
        {

          // Forward declarations
          class DriveCommand;
          class SharedMemory;

          class DriveControlImpl
            {
            public:

              DriveControlImpl( std::string antenna,
                                bool emulate );

              ~DriveControlImpl();

              void stow(carma::antenna::common::DriveControl::Position position,
                        CORBA::ULong seq);

              void stop();

              void trackSnow();

              void trackWind();

              void setMaxRate( float azRate, float elRate );

              void setTolerance( float arcsec );

              void selectAperture(carma::antenna::common::DriveControl::Aperture
                                  aperature);

              void setTiltmeterZero(float aftForward, float leftRight);

              void setAperturePointingConstants(
                                                carma::antenna::common::DriveControl::Aperture aperture,
                                                float azOffset, float elOffset, float sag);

              void setAzMaxRate( float azRate);

              void setElMaxRate( float elRate);


              void setEncoderLimits(long azMin, long azMax,
                                    long elMin, long elMax);

              void setEncoderCountsPerTurn(long az, long el);

              void setAntLocation(double longitude, double latitude,
                                  double altitude);

            private:

              void setNextSequenceNo( CORBA::ULong seq );

            public:

              void setAzel(double az, double el, CORBA::ULong seq);

              void setAz(double az, CORBA::ULong seq);

            private:

              void setAz(double az);

            public:

              void setEl(double el, CORBA::ULong seq);

            private:

              void setEl(double el);

            public:

              void setSlewRate(unsigned long axes,
                               long azRate, long elRate);

              void track(
                const char* source,
                const ::carma::antenna::common::DriveControl::RaDecTriplet & positionTriplet,
                carma::antenna::common::DriveControl::AzWrapMode azWrapMode,
                CORBA::Boolean overTheTop,
                CORBA::ULong seq);

              void updateRaDec(
                const ::carma::antenna::common::DriveControl::RaDecEpoch & position,
                carma::antenna::common::DriveControl::AzWrapMode azWrapMode );

              void updateWeather(float ambientTemp, float barometricPressure,
                                 float relativeHumidity, float dewpoint,
                                 float windSpeed, float windDirection);

              void setMountOffset(double az, double el, CORBA::ULong seq);

              void setAzMountOffset(double az, CORBA::ULong seq);

              void setElMountOffset(double el, CORBA::ULong seq);

            private:

              void setAzMountOffset( double az );

              void setElMountOffset( double el );

            public:

              void setOffset(double az, double el, CORBA::ULong seq);

              void setAzOffset( double az, CORBA::ULong seq );

              void setElOffset(double el, CORBA::ULong seq);

            private:

              void setAzOffset( double az );

              void setElOffset(double el );

            public:

              void setPointingModelCoefs(
                const ::carma::antenna::bima::control::DriveControl::sequence_double& dazCoefs,
                const ::carma::antenna::bima::control::DriveControl::sequence_double& delCoefs);

            void setSafeRange( float azLow, float azHigh,
                              float elLow, float elHigh);

            private:
              static const std::string className_;
              log4cpp::Category &log_;
              bool emulate_;
              bool _safeCalled;
              std::string antenna_;
              carma::antenna::bima::SharedMemory *bimaShm_;
              carma::util::IPQwriter<DriveCommand> *drvWriter_;



            }; // End class DriveControlImpl

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

#endif // CARMA_ANTENNA_BIMA_DRIVECONTROL_H