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