src/PseudoAxisAdapter.cpp

   1 #include "TangoHKLAdapter.h"
   2 #include "PseudoAxisAdapter.h"
   3 #include "macros.h"
   4
   5 namespace Diffractometer_ns
   6 {
   7
   8         PseudoAxisAdapter::PseudoAxisAdapter(TangoHKLAdapter &hklAdapter, HklPseudoAxis *pseudo_r, HklPseudoAxis *pseudo_w):
   9                 _hklAdapter(hklAdapter),
  10                 _pseudo_r(pseudo_r),
  11                 _pseudo_w(pseudo_w)
  12         {
  13                 size_t len;
  14                 size_t i, j;
  15                 char const **names;
  16                 std::vector<AxisAdapter> & axes = hklAdapter.get_axes();
  17
  18                 _ready = false;
  19                 _config.state = Tango::UNKNOWN;
  20                 _config.mode = "";
  21                 _config.initialized = false;
  22                 _config.state = Tango::FAULT;
  23                 _config.status = "Not yet initialized";
  24
  25                 _axes.clear();
  26                 len = HKL_LIST_LEN(_pseudo_r->engine->mode->axes_names);
  27                 names = _pseudo_r->engine->mode->axes_names;
  28                 for(i=0; i<len; ++i)
  29                         for(j=0; j<axes.size(); ++j){
  30                                 AxisAdapter & axis = axes[j];
  31                                 if(axis.get_name() == names[i]) {
  32                                         _axes.push_back(&axis);
  33                                         continue;
  34                                 }
  35                         }
  36
  37                 // compute once for all the _mode_names attribute.
  38                 len = HKL_LIST_LEN(_pseudo_r->engine->modes);
  39                 _mode_names.resize(len, 1);
  40                 for(i=0; i<len; ++i)
  41                         _mode_names.data[i] = const_cast<char *>(_pseudo_r->engine->modes[i]->name);
  42         }
  43
  44         PseudoAxisAdapter::~PseudoAxisAdapter(void)
  45         {
  46         }
  47
  48         void PseudoAxisAdapter::update(void)
  49         {
  50                 HklDiffractometer *diffractometer = _hklAdapter.diffractometer();
  51
  52                 _config.read = hkl_parameter_get_value_unit((HklParameter *)_pseudo_r);
  53                 _config.write = hkl_parameter_get_value_unit((HklParameter *)_pseudo_w);
  54
  55                 // the internal part
  56                 if(!diffractometer || !diffractometer->samples){
  57                         _config.state = Tango::FAULT;
  58                         _config.status = "Internal Error";
  59                         return;
  60                 }
  61
  62                 // the sample part
  63                 if(!diffractometer->samples->current){
  64                         _config.state = Tango::FAULT;
  65                         _config.status = "Sample not set";
  66                         return;
  67                 }
  68
  69                 // now compute the state ans status of the pseudo axes.
  70                 _config.state = Tango::STANDBY;
  71                 std::string extra_status;
  72
  73                 _config.status = "REAL Mode: Motors will REALLY move.";
  74                 if (!this->is_ready()) {
  75                         _config.state = Tango::FAULT;
  76                         extra_status = "\nCan not connect to axes proxies";
  77                 } else {
  78                         for(size_t i=0;i<_axes.size();++i) {
  79                                 AxisAdapter const * axis = _axes[i];
  80                                 ::compose_state(_config.state, axis->get_state());
  81                                 if (axis->get_state() != Tango::STANDBY)
  82                                         extra_status += "\n" + axis->get_proxy_name() + " is in " + Tango::DevStateName[axis->get_state()];
  83                         }
  84                 }
  85                 extra_status += "\nPseudoAxe status: ";
  86                 extra_status += Tango::DevStateName[_config.state];
  87                 _config.status += extra_status;
  88
  89                 // update the mode
  90                 _config.mode = const_cast<Tango::DevString>(this->_pseudo_r->engine->mode->name);
  91
  92                 // initialized part
  93                 if(this->_pseudo_r->engine->mode->initialize == NULL)
  94                         _config.initialized = true;
  95         }
  96
  97         PseudoAxisConfig PseudoAxisAdapter::get_config(void)
  98         {
  99                 return _hklAdapter.pseudo_axis_get_config(this);
 100         }
 101
 102         void PseudoAxisAdapter::to_proxies(void)
 103         {
 104 #ifdef WRITE_TO_PROXY_ALLOWED
 105                 if(this->is_ready())
 106                         for (size_t i=0; i<_axes.size(); ++i) {
 107                                 _axes[i]->stop();
 108                                 _axes[i]->from_HklAxis();
 109                                 _axes[i]->set_state(Tango::MOVING);
 110                                 _axes[i]->to_proxy();
 111                         }
 112 #endif
 113         }
 114
 115         bool PseudoAxisAdapter::is_ready(void)
 116         {
 117                 if(!_ready){
 118                         size_t i;
 119
 120                         for(i=0; i<_axes.size(); ++i)
 121                                 if(!_axes[i]->is_ready())
 122                                         return _ready;
 123                         _ready = true;
 124                 }
 125                 return _ready;
 126         }
 127
 128         void PseudoAxisAdapter::set_mode(Tango::DevString const & mode)
 129         {
 130                 _hklAdapter.pseudo_axis_set_mode(this, mode);
 131         }
 132
 133         void PseudoAxisAdapter::get_mode_parameters(Tango::DevVarDoubleStringArray *argout)
 134         {
 135                 _hklAdapter.pseudo_axis_get_mode_parameters(this, argout);
 136         }
 137
 138         void PseudoAxisAdapter::set_mode_parameters(const Tango::DevVarDoubleStringArray *argin)
 139         {
 140                 _hklAdapter.pseudo_axis_set_mode_parameters(this, argin);
 141         }
 142
 143         void PseudoAxisAdapter::set_initialized(Tango::DevBoolean initialized)
 144         {
 145                 _hklAdapter.pseudo_axis_set_initialized(this, initialized);
 146         }
 147
 148         void PseudoAxisAdapter::on(void)
 149         {
 150                 _hklAdapter.pseudo_axis_on(this);
 151         }
 152 }