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