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