1 #include "TangoHKLAdapter.h"
2 #include "PseudoAxes.h"
3 #include "PseudoAxesAttrib.h"
4 #include "PseudoAxesAdapter.h"
5 #include "Diffractometer.h"
7 namespace Diffractometer_ns
10 PseudoAxesAdapter::PseudoAxesAdapter(TangoHKLAdapter
*hklAdapter
, size_t idx
,
11 HklPseudoAxisEngine
*engine_r
,
12 HklPseudoAxisEngine
*engine_w
):
13 _hklAdapter(hklAdapter
),
21 len
= HKL_LIST_LEN(_engine_r
->pseudoAxes
);
23 _write
.resize(len
, 1);
25 // update the _mode_names
26 len
= HKL_LIST_LEN(_engine_r
->modes
);
27 _mode_names
.resize(len
, 1);
29 _mode_names
.data
[i
] = const_cast<char *>(_engine_r
->modes
[i
]->name
);
31 // update the _pseudo_axis_names and create the dynamic attributes
32 len
= HKL_LIST_LEN(_engine_r
->pseudoAxes
);
33 _pseudo_axis_names
.resize(len
, 1);
38 name
= ((HklParameter
*)(_engine_r
->pseudoAxes
[i
]))->name
;
39 _pseudo_axis_names
.data
[i
] = const_cast<char *>(name
);
40 att
= new PseudoAxesAxisAttrib(name
, *this, i
);
41 _dynamic_attribute_pseudo_axes_axis
.push_back(att
);
44 // compute the proxy name
45 _proxy_name
= _hklAdapter
->get_device()->get_name();
46 _proxy_name
+= "-sim-";
47 _proxy_name
+= _engine_r
->name
;
49 this->update_axes_i(_engine_r
);
51 // update the state and status
52 _state
= Tango::STANDBY
;
58 PseudoAxesAdapter::~PseudoAxesAdapter(void)
62 for(i
=0; i
<_dynamic_attribute_pseudo_axes_axis
.size(); ++i
)
63 delete _dynamic_attribute_pseudo_axes_axis
[i
];
66 PseudoAxesConfig
PseudoAxesAdapter::get_config(void)
68 return _hklAdapter
->pseudo_axes_get_config(_idx
);
71 char const * PseudoAxesAdapter::get_name(void) const
73 return _hklAdapter
->diffractometer()->engines_r
->engines
[_idx
]->name
;
76 void PseudoAxesAdapter::write(Matrix
<double> const & write
) throw (Tango::DevFailed
)
78 _hklAdapter
->pseudo_axes_write(_idx
, write
);
81 void PseudoAxesAdapter::set_axis_value(size_t idx
, double value
)
83 _write
.data
[idx
] = value
;
87 Tango::DevString
*PseudoAxesAdapter::get_mode(void)
89 return _hklAdapter
->pseudo_axes_get_mode(_idx
);
92 void PseudoAxesAdapter::set_mode(const Tango::DevString name
)
94 _hklAdapter
->pseudo_axes_set_mode(_idx
, name
);
97 Tango::DevBoolean
PseudoAxesAdapter::get_initialized(void)
99 return _hklAdapter
->pseudo_axes_get_initialized(_idx
);
102 void PseudoAxesAdapter::set_initialized(const Tango::DevBoolean initialized
)
104 _hklAdapter
->pseudo_axes_set_initialized(_idx
, initialized
);
107 Matrix
<char *> & PseudoAxesAdapter::get_mode_parameters_names(void)
109 return _hklAdapter
->pseudo_axes_get_mode_parameters_names(_idx
);
112 Matrix
<double> const & PseudoAxesAdapter::get_mode_parameters(void)
114 return _hklAdapter
->pseudo_axes_get_mode_parameters(_idx
);
117 void PseudoAxesAdapter::set_mode_parameters(Matrix
<double> const & values
)
119 _hklAdapter
->pseudo_axes_set_mode_parameters(_idx
, values
);
122 void PseudoAxesAdapter::init(void)
124 _hklAdapter
->pseudo_axes_init(_idx
);
127 void PseudoAxesAdapter::add_dynamic_attributes(void)
129 _hklAdapter
->pseudo_axes_add_dynamic_attributes(_idx
);
132 void PseudoAxesAdapter::remove_dynamic_attributes(void)
134 _hklAdapter
->pseudo_axes_remove_dynamic_attributes(_idx
);
137 void PseudoAxesAdapter::load(void)
146 void PseudoAxesAdapter::update_axes_i(HklPseudoAxisEngine
*engine
)
152 // fill the _axes with the right AxisAdapters
153 std::vector
<AxisAdapter
> & axes
= _hklAdapter
->get_axes();
154 len
= HKL_LIST_LEN(engine
->mode
->axes_names
);
155 names
= engine
->mode
->axes_names
;
158 for(j
=0; j
<axes
.size(); ++j
){
159 AxisAdapter
& axis
= axes
[j
];
160 if(axis
.get_name() == names
[i
]) {
161 _axes
.push_back(&axis
);
167 void PseudoAxesAdapter::update(void)
170 std::string status_extra
;
172 // update the read part.
173 len
= HKL_LIST_LEN(_engine_r
->pseudoAxes
);
174 for(i
=0; i
<len
; ++i
){
175 _read
.data
[i
] = hkl_parameter_get_value_unit((HklParameter
*)_engine_r
->pseudoAxes
[i
]);
176 _write
.data
[i
] = hkl_parameter_get_value_unit((HklParameter
*)_engine_w
->pseudoAxes
[i
]);
180 _status
= "PseudoAxes status: ";
182 // now compute the state and status
183 if(!_hklAdapter
->_auto_update_from_proxies
)
184 _state
= Tango::STANDBY
;
186 _state
= Tango::STANDBY
;
187 for(i
=0;i
<_axes
.size();++i
) {
188 AxisAdapter
const * axis
= _axes
[i
];
189 ::compose_state(_state
, axis
->get_state());
190 if (axis
->get_state() != Tango::STANDBY
)
191 status_extra
+= "\n" + axis
->get_proxy_name() + " is in " + Tango::DevStateName
[axis
->get_state()];
194 _status
+= Tango::DevStateName
[_state
];
195 _status
+= status_extra
;
198 void PseudoAxesAdapter::save(void)
200 Tango::DbData mode_prop
;
201 Tango::DbData data_put
;
202 HklPseudoAxisEngine
*engine
;
205 // first erase the old mode properties
206 mode_prop
.push_back(Tango::DbDatum("Mode"));
207 _device
->get_db_device()->get_attribute_property(mode_prop
);
208 long number_of_prop
= 0;
209 mode_prop
[0] >> number_of_prop
;
210 if(number_of_prop
> 0)
211 _device
->get_db_device()->delete_attribute_property(mode_prop
);
213 // Step 2 : create the Mode properties
214 engine
= _hklAdapter
->diffractometer()->engines_r
->engines
[_idx
];
215 Tango::DbDatum
properties("Mode");
216 // Put number of properties (= nb of samples + 1)
217 len
= HKL_LIST_LEN(engine
->modes
);
218 properties
<< (long)(len
);
219 data_put
.push_back(properties
);
221 for(i
=0; i
<len
; ++i
){
222 HklPseudoAxisEngineMode
*mode
;
223 std::vector
<std::string
> lines
;
227 mode
= engine
->modes
[i
];
228 for(j
=0; j
<HKL_LIST_LEN(mode
->parameters
); ++j
){
232 name
= mode
->parameters
[j
].name
;
233 value
= hkl_parameter_get_value_unit(&mode
->parameters
[j
]);
234 snprintf(line
, 255, "%s=%f", name
, value
);
235 lines
.push_back(line
);
238 // Try to create property
240 Tango::DbDatum
property(mode
->name
);
242 data_put
.push_back(property
);
245 //update database for this property
246 _device
->get_db_device()->put_attribute_property(data_put
);
249 void PseudoAxesAdapter::load_1(void)
251 unsigned long nb_properties
;
253 // Get the Crystal Attributes properties.
254 Tango::DbData properties
;
255 properties
.push_back(Tango::DbDatum("Mode"));
256 _device
->get_db_device()->get_attribute_property(properties
);
258 // the first one is the number of properties
259 properties
[0] >> nb_properties
;
261 if (nb_properties
> 1) {
263 HklPseudoAxisEngine
*engine_r
, *engine_w
, *engine_r_real
, *engine_w_real
;
265 engine_r
= _hklAdapter
->diffractometer()->engines_r
->engines
[_idx
];
266 engine_w
= _hklAdapter
->diffractometer()->engines_w
->engines
[_idx
];
267 engine_r_real
= _hklAdapter
->diffractometer()->engines_r_real
->engines
[_idx
];
268 engine_w_real
= _hklAdapter
->diffractometer()->engines_w_real
->engines
[_idx
];
270 for(i
=1; i
<=nb_properties
; ++i
) {
271 size_t idx_m
, j
, len
;
273 std::vector
<std::string
> lines
;
275 // first find the PseudoAxisEngineMode idx from its name
276 name
= properties
[i
].name
.c_str();
277 len
= HKL_LIST_LEN(engine_r
->modes
);
278 for(idx_m
=0; idx_m
<len
; ++idx_m
)
279 if(!strcmp(name
, engine_r
->modes
[idx_m
]->name
))
281 if(idx_m
>=len
) // did not find the right mode name
284 // Extract the mode parameters from the properties
285 properties
[i
] >> lines
;
287 // extract the parameters values
288 for(j
=0; j
<lines
.size(); j
++) {
291 char *line
= strdup(lines
[j
].c_str());
293 char *key
= strtok_r(line
, "=", &last
);
295 for(idx_p
=0; idx_p
<len
; ++idx_p
)
296 if(!strcmp(key
, engine_r
->modes
[idx_m
]->parameters
[idx_p
].name
))
301 value
= atof(strtok_r(NULL
,";", &last
));
302 hkl_parameter_set_value_unit(&engine_r
->modes
[idx_m
]->parameters
[idx_p
], value
);
303 hkl_parameter_set_value_unit(&engine_w
->modes
[idx_m
]->parameters
[idx_p
], value
);
304 hkl_parameter_set_value_unit(&engine_r_real
->modes
[idx_m
]->parameters
[idx_p
], value
);
305 hkl_parameter_set_value_unit(&engine_w_real
->modes
[idx_m
]->parameters
[idx_p
], value
);
309 }// End for each property