src/AxisAdapter.cpp

   1 #include "AxisAdapter.h"
   2 #include "TangoHKLAdapter.h"
   3 #include "macros.h"
   4
   5 namespace Diffractometer_ns {
   6
   7         AxisAdapter::AxisAdapter(TangoHKLAdapter * hklAdapter, HklAxis *axis_r, HklAxis *axis_w,
   8                                  HklAxis *axis_r_real, HklAxis *axis_w_real) :
   9                 _hklAdapter(hklAdapter),
  10                 _axis_r(axis_r),
  11                 _axis_w(axis_w),
  12                 _axis_r_real(axis_r_real),
  13                 _axis_w_real(axis_w_real)
  14         {
  15                 _proxy_name = "";
  16                 _proxy_stop_command_name = "Stop";
  17                 _proxy_on_command_name = "On";
  18                 _proxy = NULL;
  19                 this->from_HklAxis();
  20                 _state = Tango::UNKNOWN;
  21         }
  22
  23         AxisAdapter::~AxisAdapter(void)
  24         {
  25         }
  26
  27         std::string const AxisAdapter::get_name(void) const
  28         {
  29                 return ((HklParameter *)(_axis_r))->name;
  30         }
  31
  32         std::string const AxisAdapter::get_proxy_name(void) const
  33         {
  34                 return _proxy_name;
  35         }
  36
  37         bool AxisAdapter::connect(char *proxy_name)
  38         {
  39                 bool res = false;
  40
  41                 _proxy_name = proxy_name;
  42                 try{
  43                         _proxy = new Tango::AttributeProxy(proxy_name);
  44                         if(_proxy){
  45                                 std::vector<double> positions;
  46
  47                                 res = true;
  48
  49                                 // read the read/write position
  50                                 _proxy->read() >> positions;
  51                                 hkl_axis_set_value_unit(_axis_r, positions[0]);
  52                                 hkl_axis_set_value_unit(_axis_w, positions[1]);
  53                                 _read = positions[0];
  54                                 _write = positions[1];
  55
  56                                 // now read the range
  57                                 std::string attr_name = AXIS_ATTRIBUTE_POSITION_NAME;
  58                                 Tango::AttributeInfo info = _proxy->get_config();
  59
  60                                 // Check if min and max value have been set
  61                                 char const *token;
  62                                 token = info.min_value.c_str();
  63                                 if (!strstr(token, "Not specified"))
  64                                         _min = atof(token);
  65
  66                                 token = info.max_value.c_str();
  67                                 if (!strstr(token, "Not specified"))
  68                                         _max = atof(token);
  69                         }
  70                 }catch(Tango::DevFailed &){
  71                         _state = Tango::FAULT;
  72                 }
  73                 return res;
  74         }
  75
  76         bool const AxisAdapter::is_ready(void) const
  77         {
  78                 if (_proxy)
  79                         return true;
  80                 else
  81                         return false;
  82         }
  83
  84         void AxisAdapter::write(double value)
  85         {
  86                 _hklAdapter->write_axis(*this, value);
  87         }
  88
  89         void AxisAdapter::from_HklAxis(void)
  90         {
  91                 _read = hkl_axis_get_value_unit(_axis_r);
  92                 _write = hkl_axis_get_value_unit(_axis_w);
  93                 _read_real = hkl_axis_get_value_unit(_axis_r_real);
  94                 _write_real = hkl_axis_get_value_unit(_axis_w_real);
  95                 hkl_axis_get_range_unit(_axis_r, &_min, &_max);
  96         }
  97
  98         void AxisAdapter::to_HklAxis(void)
  99         {
 100                 hkl_axis_set_value_unit(_axis_r, _read);
 101                 hkl_axis_set_value_unit(_axis_w, _write);
 102                 hkl_axis_set_range_unit(_axis_r, _min, _max);
 103                 hkl_axis_set_range_unit(_axis_w, _min, _max);
 104                 hkl_axis_set_value_unit(_axis_r_real, _read_real);
 105                 hkl_axis_set_value_unit(_axis_w_real, _write_real);
 106                 hkl_axis_set_range_unit(_axis_r_real, _min, _max);
 107                 hkl_axis_set_range_unit(_axis_w_real, _min, _max);
 108         }
 109
 110         void AxisAdapter::from_proxy(bool simulated)
 111         {
 112                 try{
 113                         if(this->is_ready()){
 114                                 std::vector<double> positions;
 115
 116                                 // read the position attribute
 117                                 _proxy->read() >> positions;
 118                                 _read_real = positions[0];
 119                                 _write_real = positions[1];
 120
 121                                 Tango::AttributeInfo info = _proxy->get_config();
 122
 123                                 // Check if min and max value have been set
 124                                 char const *token;
 125                                 token = info.min_value.c_str();
 126                                 if (!strstr(token, "Not specified"))
 127                                         _min = atof(token);
 128
 129                                 token = info.max_value.c_str();
 130                                 if (!strstr(token, "Not specified"))
 131                                         _max = atof(token);
 132
 133                                 // read the state
 134                                 _state = _proxy->state();
 135
 136                                 if(!simulated){
 137                                         _read = _read_real;
 138                                         _write = _write_real;
 139                                 }else{
 140                                         _read = hkl_axis_get_value_unit(_axis_r);
 141                                         _write = hkl_axis_get_value_unit(_axis_w);
 142                                 }
 143                         }
 144                 }
 145                 catch(Tango::DevFailed &)
 146                 {
 147                         _state = Tango::FAULT;
 148                 }
 149         }
 150
 151         void AxisAdapter::to_proxy(void)
 152         {
 153 #ifdef WRITE_TO_PROXY_ALLOWED
 154                 try{
 155                         if(this->is_ready()){
 156                                 Tango::DeviceAttribute attr(_proxy_name, _write_real);
 157                                 _state = Tango::MOVING;
 158                                 _proxy->write(attr);
 159                         }
 160                 }
 161                 catch(Tango::DevFailed &)
 162                 {
 163                         _state = Tango::FAULT;
 164                 }
 165 #endif
 166         }
 167
 168         void AxisAdapter::stop(void)
 169         {
 170                 // let the error propagate if stop failed.
 171                 if(this->is_ready())
 172                         _proxy->get_device_proxy()->command_inout(_proxy_stop_command_name);
 173         }
 174
 175         void AxisAdapter::on(void)
 176         {
 177                 if(this->is_ready())
 178                         try{
 179                                 _proxy->get_device_proxy()->command_inout(_proxy_on_command_name);
 180                         }
 181                         catch (Tango::DevFailed &)
 182                         {
 183                                 _state = Tango::FAULT;
 184                                 // do nothing if the command is not present.
 185                         }
 186         }
 187 }