src/PseudoAxesAdapter.cpp

   1 #include "TangoHKLAdapter.h"
   2 #include "PseudoAxesAttrib.h"
   3 #include "PseudoAxesAdapter.h"
   4 #include "Diffractometer.h"
   5
   6 namespace Diffractometer_ns
   7 {
   8
   9         PseudoAxesAdapter::PseudoAxesAdapter(TangoHKLAdapter *hklAdapter, size_t idx):
  10                 _hklAdapter(hklAdapter),
  11                 _idx(idx)
  12         {
  13                 HklPseudoAxisEngine *engine;
  14                 size_t i;
  15                 size_t len;
  16
  17                 engine = _hklAdapter->diffractometer()->engines_r->engines[_idx];
  18                 len = HKL_LIST_LEN(engine->pseudoAxes);
  19                 _read.resize(len, 1);
  20                 _write.resize(len, 1);
  21
  22                 // update the _mode_names
  23                 len = HKL_LIST_LEN(engine->modes);
  24                 _mode_names.resize(len, 1);
  25                 for(i=0; i<len; ++i)
  26                         _mode_names.data[i] = const_cast<char *>(engine->modes[i]->name);
  27
  28                 // update the _pseudo_axis_names and create the dynamic attributes
  29                 len = HKL_LIST_LEN(engine->pseudoAxes);
  30                 _pseudo_axis_names.resize(len , 1);
  31                 for(i=0; i<len; ++i){
  32                         Tango::Attr *att;
  33                         const char *name;
  34
  35                         name = ((HklParameter *)(engine->pseudoAxes[i]))->name;
  36                         _pseudo_axis_names.data[i] = const_cast<char *>(name);
  37                         att = new PseudoAxesAxisAttrib(name, *this, i);
  38                         _dynamic_attribute_pseudo_axes_axis.push_back(att);
  39                 }
  40
  41                 // compute the proxy name
  42                 _proxy_name = _hklAdapter->get_device()->get_name();
  43                 _proxy_name += "-sim-";
  44                 _proxy_name += engine->name;
  45
  46                 this->update_axes_i(engine);
  47
  48                 // update the state and status
  49                 _state = Tango::STANDBY;
  50                 _status = "READY";
  51
  52                 _device = NULL;
  53         }
  54
  55         char const * PseudoAxesAdapter::get_name(void) const
  56         {
  57                 return _hklAdapter->diffractometer()->engines_r->engines[_idx]->name;
  58         }
  59
  60         void PseudoAxesAdapter::write(Matrix<double> const & write)
  61         {
  62                 _hklAdapter->pseudo_axes_write(_idx, write);
  63         }
  64
  65         void PseudoAxesAdapter::set_axis_value(size_t idx, double value)
  66         {
  67                 _write.data[idx] = value;
  68                 this->write(_write);
  69         }
  70
  71         Tango::DevString *PseudoAxesAdapter::get_mode(void)
  72         {
  73                 return _hklAdapter->pseudo_axes_get_mode(_idx);
  74         }
  75
  76         void PseudoAxesAdapter::set_mode(const Tango::DevString name)
  77         {
  78                 _hklAdapter->pseudo_axes_set_mode(_idx, name);
  79         }
  80
  81         Matrix<char *> & PseudoAxesAdapter::get_mode_parameters_names(void)
  82         {
  83                 return _hklAdapter->pseudo_axes_get_mode_parameters_names(_idx);
  84         }
  85
  86         Matrix<double> const & PseudoAxesAdapter::get_mode_parameters(void)
  87         {
  88                 return _hklAdapter->pseudo_axes_get_mode_parameters(_idx);
  89         }
  90
  91         void PseudoAxesAdapter::set_mode_parameters(Matrix<double> const & values)
  92         {
  93                 _hklAdapter->pseudo_axes_set_mode_parameters(_idx, values);
  94         }
  95
  96         void PseudoAxesAdapter::init(void)
  97         {
  98                 _hklAdapter->pseudo_axes_init(_idx);
  99         }
 100
 101         void PseudoAxesAdapter::add_dynamic_attributes(void)
 102         {
 103                 _hklAdapter->pseudo_axes_add_dynamic_attributes(_idx);
 104         }
 105
 106         void PseudoAxesAdapter::remove_dynamic_attributes(void)
 107         {
 108                 _hklAdapter->pseudo_axes_remove_dynamic_attributes(_idx);
 109         }
 110
 111         /******************/
 112         /* private method */
 113         /******************/
 114
 115         void PseudoAxesAdapter::update_axes_i(HklPseudoAxisEngine *engine)
 116         {
 117                 size_t i, j;
 118                 size_t len;
 119                 char const **names;
 120
 121                 // fill the _axes with the right AxisAdapters
 122                 std::vector<AxisAdapter> & axes = _hklAdapter->get_axes();
 123                 len = HKL_LIST_LEN(engine->mode->axes_names);
 124                 names = engine->mode->axes_names;
 125                 _axes.clear();
 126                 for(i=0; i<len; ++i)
 127                         for(j=0; j<axes.size(); ++j){
 128                                 AxisAdapter & axis = axes[j];
 129                                 if(axis.get_name() == names[i]) {
 130                                         _axes.push_back(&axis);
 131                                         continue;
 132                                 }
 133                         }
 134         }
 135
 136         void PseudoAxesAdapter::update_state_and_status_i(void)
 137         {
 138                 std::string status_extra;
 139
 140                 _status = "PseudoAxes status: ";
 141
 142                 // now compute the state and status
 143                 if(_hklAdapter->simulated)
 144                         _state = Tango::STANDBY;
 145                 else{
 146                         size_t i;
 147
 148                         _state = Tango::STANDBY;
 149                         for(i=0;i<_axes.size();++i) {
 150                                 AxisAdapter const * axis = _axes[i];
 151                                 ::compose_state(_state, axis->get_state());
 152                                 if (axis->get_state() != Tango::STANDBY)
 153                                         status_extra += "\n" + axis->get_device_name() + " is in " + Tango::DevStateName[axis->get_state()];
 154                         }
 155                 }
 156                 _status += Tango::DevStateName[_state];
 157                 _status += status_extra;
 158         }
 159 }