d400-options.cpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2016 Intel Corporation. All Rights Reserved.
3 
4 
6 #include "d400-options.h"
7 
8 #include <rsutils/string/from.h>
9 #include <src/hid-sensor.h>
10 
11 namespace librealsense
12 {
13 
15  : _hw_monitor(hwm), _option(opt)
16  {}
17 
19  {
20  if (!is_enabled() || !_hw_monitor)
21  throw wrong_api_call_sequence_exception("query is available during streaming only");
22 
23  float temperature = -1;
24  try {
26  auto res = _hw_monitor->send(cmd);
27  temperature = static_cast<float>(res[0]);
28  }
29  catch (...)
30  {
31  throw wrong_api_call_sequence_exception("hw monitor command for asic temperature failed");
32  }
33 
34  return temperature;
35  }
36 
38  {
39  return option_range{ -40, 125, 0, 0 };
40  }
41 
43  : _hw_monitor(hwm), _option(opt)
44  {}
45 
47  {
48  if (!is_enabled() || !_hw_monitor)
49  throw wrong_api_call_sequence_exception("query is available during streaming only");
50 
51  float temperature;
52  try {
54  auto res = _hw_monitor->send(cmd);
55  temperature = static_cast<float>(res[0]);
56  }
57  catch (...)
58  {
59  throw wrong_api_call_sequence_exception("hw monitor command for projector temperature failed");
60  }
61 
62  return temperature;
63  }
64 
66  {
67  return option_range{ -40, 125, 0, 0 };
68  }
69 
71  const std::weak_ptr< sensor_base > & depth_ep,
73  std::shared_ptr< limits_option > exposure_limit_enable,
74  bool new_opcode )
75  : option_base( range )
76  , _hwm( hwm )
77  , _sensor( depth_ep )
78  , _exposure_limit_toggle( exposure_limit_enable )
79  , _new_opcode( new_opcode )
80  {
81  _range = [range]()
82  {
83  return range;
84  };
85  if (auto toggle = _exposure_limit_toggle.lock())
86  toggle->set_cached_limit(range.max);
87  }
88 
90  {
91  if (!is_valid(value))
92  throw invalid_value_exception("set(enable_auto_exposure) failed! Invalid Auto-Exposure mode request " + std::to_string(value));
93 
94  if (auto toggle = _exposure_limit_toggle.lock())
95  {
96  toggle->set_cached_limit(value);
97  if (toggle->query() == 0.f)
98  toggle->set(1);
99  }
100 
101  if( _new_opcode )
103  else
105 
106  _record_action( *this );
107 
108  }
109 
111  {
113 
114  if( ret < get_range().min || ret > get_range().max )
115  {
116  if( auto toggle = _exposure_limit_toggle.lock() )
117  return toggle->get_cached_limit();
118  }
119  return ret;
120  }
121 
123  {
124  return *_range;
125  }
126 
128  {
129  if( auto strong = _sensor.lock() )
130  return strong->is_opened();
131  return false;
132  }
133 
135  {
136  // get structure: min ae, min gain, max ae, max gain
137  command cmd_get( ds::GETAELIMITS );
138  std::vector< uint8_t > ret = _hwm.send( cmd_get );
139  if( ret.empty() )
140  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
141 
142  static const int max_gain_offset = 12;
143  // set structure: min ae, max ae, min gain, max gain
145  cmd.param1 = 0;
146  cmd.param2 = static_cast< int >( value );
147  cmd.param3 = 0;
148  cmd.param4 = *( reinterpret_cast< uint32_t * >( ret.data() + max_gain_offset ) );
149  _hwm.send( cmd );
150  }
151 
153  {
154  command cmd_get( ds::AUTO_CALIB );
155  cmd_get.param1 = 5;
156  std::vector< uint8_t > ret = _hwm.send( cmd_get );
157  if( ret.empty() )
158  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
159 
160  static const int max_gain_offset = 4;
162  cmd.param1 = 4;
163  cmd.param2 = static_cast< int >( value );
164  cmd.param3 = *( reinterpret_cast< uint32_t * >( ret.data() + max_gain_offset ) );
165  _hwm.send( cmd );
166  }
167 
169  {
170  // get structure: min ae, min gain, max ae, max gain
172 
173  auto res = _hwm.send( cmd );
174  if( res.empty() )
175  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
176 
177  static const int max_ae_offset = 8;
178  return static_cast< float >( *( reinterpret_cast< uint32_t * >( res.data() + max_ae_offset ) ) );
179  }
180 
182  {
184  cmd.param1 = 5;
185 
186  auto res = _hwm.send( cmd );
187  if( res.empty() )
188  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
189 
190  return static_cast< float >( *( reinterpret_cast< uint32_t * >( res.data() ) ) );
191  }
192 
194  const std::weak_ptr< sensor_base > & depth_ep,
196  std::shared_ptr< limits_option > gain_limit_enable,
197  bool new_opcode )
198  : option_base( range )
199  , _hwm( hwm )
200  , _sensor( depth_ep )
201  , _gain_limit_toggle( gain_limit_enable )
202  , _new_opcode( new_opcode )
203  {
204  _range = [range]()
205  {
206  return range;
207  };
208  if (auto toggle = _gain_limit_toggle.lock())
209  toggle->set_cached_limit(range.max);
210  }
211 
212 
214  {
215  if (!is_valid(value))
216  throw invalid_value_exception("set(enable_auto_gain) failed! Invalid Auto-Gain mode request " + std::to_string(value));
217 
218  if (auto toggle = _gain_limit_toggle.lock())
219  {
220  toggle->set_cached_limit(value);
221  if (toggle->query() == 0.f)
222  toggle->set(1);
223  }
224 
225  if( _new_opcode )
227  else
229 
230  _record_action( *this );
231 
232  }
233 
235  {
237 
238  if (ret< get_range().min || ret > get_range().max)
239  {
240  if (auto toggle = _gain_limit_toggle.lock())
241  return toggle->get_cached_limit();
242  }
243  return ret;
244  }
245 
247  {
248  return *_range;
249  }
250 
252  {
253  if( auto strong = _sensor.lock() )
254  return strong->is_opened();
255  return false;
256  }
257 
259  {
260  // get structure: min ae, min gain, max ae, max gain
261  command cmd_get( ds::GETAELIMITS );
262  std::vector< uint8_t > ret = _hwm.send( cmd_get );
263  if( ret.empty() )
264  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
265 
266  static const int max_ae_offset = 8;
267  // set structure: min ae, max ae, min gain, max gain
269  cmd.param1 = 0;
270  cmd.param2 = *( reinterpret_cast< uint32_t * >( ret.data() + max_ae_offset ) );
271  cmd.param3 = 0;
272  cmd.param4 = static_cast< int >( value );
273  _hwm.send( cmd );
274  }
275 
277  {
278  command cmd_get( ds::AUTO_CALIB );
279  cmd_get.param1 = 5;
280  std::vector< uint8_t > ret = _hwm.send( cmd_get );
281  if( ret.empty() )
282  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
283 
285  cmd.param1 = 4;
286  cmd.param2 = *( reinterpret_cast< uint32_t * >( ret.data() ) );
287  cmd.param3 = static_cast< int >( value );
288  _hwm.send( cmd );
289  }
290 
292  {
293  // get structure: min ae, min gain, max ae, max gain
295 
296  auto res = _hwm.send( cmd );
297  if( res.empty() )
298  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
299 
300  static const int max_gain_offset = 12;
301  return static_cast< float >( *( reinterpret_cast< uint32_t * >( res.data() + max_gain_offset ) ) );
302  }
303 
305  {
307  cmd.param1 = 5;
308 
309  auto res = _hwm.send( cmd );
310  if( res.empty() )
311  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
312 
313  static const int max_gain_offset = 4;
314  return static_cast< float >( *( reinterpret_cast< uint32_t * >( res.data() + max_gain_offset ) ) );
315  }
316 
318  rs2_option option, option_range range, const char * description, hw_monitor & hwm, bool new_opcode )
319  : _option( option )
320  , _toggle_range( range )
321  , _description( description )
322  , _hwm( hwm )
323  , _new_opcode( new_opcode ){}
324 
325  void limits_option::set( float value )
326  {
327  auto set_limit = _cached_limit;
328  if( value == 0 ) // 0: gain auto-limit is disabled, 1 : gain auto-limit is enabled (all range 16-248 is valid)
329  set_limit = 0;
330 
331  if( _new_opcode )
332  set_using_new_opcode(value, set_limit );
333  else
334  set_using_old_opcode( value, set_limit );
335  }
336 
337  float limits_option::query() const
338  {
339  int offset = 0;
340  std::vector< uint8_t > res;
341  if( _new_opcode )
342  {
343  offset = 8;
345  offset = 12;
346  res = query_using_new_opcode();
347  }
348  else
349  {
351  offset = 4;
352  res = query_using_old_opcode();
353  }
354 
355  if( res.empty() )
356  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
357  float limit_val = static_cast< float >( *( reinterpret_cast< uint32_t * >( res.data() + offset ) ) );
358 
359  if( limit_val == 0 )
360  return 0;
361  return 1;
362  }
363 
364  void limits_option::set_using_new_opcode( float value, float set_limit )
365  {
366  // get structure: min ae, min gain, max ae, max gain
367  command cmd_get( ds::GETAELIMITS );
368  std::vector< uint8_t > ret = _hwm.send( cmd_get );
369  if( ret.empty() )
370  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
371 
372  int offset = 8;
373  // set structure: min ae, max ae, min gain, max gain
375  cmd.param1 = 0;
376  cmd.param2 = *( reinterpret_cast< uint32_t * >( ret.data() + offset ) );
377  cmd.param3 = 0;
378  cmd.param4 = static_cast< int >( set_limit );
380  {
381  offset = 12;
382  cmd.param2 = static_cast< int >( set_limit );
383  cmd.param4 = *( reinterpret_cast< uint32_t * >( ret.data() + offset ) );
384  }
385  _hwm.send( cmd );
386  }
387 
388  void limits_option::set_using_old_opcode( float value, float set_limit )
389  {
390  command cmd_get( ds::AUTO_CALIB );
391  cmd_get.param1 = 5;
392  std::vector< uint8_t > ret = _hwm.send( cmd_get );
393  if( ret.empty() )
394  throw invalid_value_exception( "auto_exposure_limit_option::query result is empty!" );
395 
396  int offset = 0;
398  cmd.param1 = 4;
399  cmd.param2 = *( reinterpret_cast< uint32_t * >( ret.data() + offset ) );
400  cmd.param3 = static_cast< int >( set_limit );
402  {
403  offset = 4;
404  cmd.param2 = static_cast< int >( set_limit );
405  cmd.param3 = *( reinterpret_cast< uint32_t * >( ret.data() + offset ) );
406  }
407  _hwm.send( cmd );
408  }
409 
410  std::vector< uint8_t > limits_option::query_using_new_opcode() const
411  {
412  // get structure: min ae, min gain, max ae, max gain
414  return _hwm.send( cmd );
415  }
416 
417  std::vector< uint8_t > limits_option::query_using_old_opcode() const
418  {
420  cmd.param1 = 5;
421  return _hwm.send( cmd );
422  }
423 
425  std::shared_ptr<d400_thermal_monitor> monitor,
426  std::shared_ptr<option> toggle) :
427  _thermal_monitor(monitor),
428  _thermal_toggle(toggle)
429  {
430  }
431 
433  {
434  auto val = _thermal_toggle->query();
435  return val;
436  }
437 
439  {
440  if (value < 0)
441  throw invalid_value_exception("Invalid input for thermal compensation toggle: " + std::to_string(value));
442 
443  _thermal_toggle->set(value);
444  _recording_function(*this);
445  }
446 
448  {
449  return "Toggle thermal compensation adjustments mechanism";
450  }
451 
453  {
454  if (value == 0)
455  {
456  return "Disabled";
457  }
458  else
459  {
460  return "Enabled";
461  }
462  }
463 
464  //Work-around the control latency
465  void librealsense::thermal_compensation::create_snapshot(std::shared_ptr<option>& snapshot) const
466  {
467  snapshot = std::make_shared<const_value_option>(get_description(), 0.f);
468  }
469 
471  {
472  auto strong = _sensor.lock();
473  if( ! strong )
474  throw invalid_value_exception( "Hid sensor is not alive for setting" );
475 
476  if( strong->is_streaming() )
477  throw invalid_value_exception( "setting this option during streaming is not allowed!" );
478 
479  if(!is_valid(value))
480  throw invalid_value_exception( "set(gyro_sensitivity) failed! Invalid Gyro sensitivity resolution request "
481  + std::to_string( value ) );
482 
483  _value = value;
484  strong->set_imu_sensitivity( RS2_STREAM_GYRO, value );
485  }
486 
488  {
489  return _value;
490  }
491 
492 
494  {
495  switch( static_cast< int >( val ) )
496  {
498  return "61.0 mDeg/Sec";
499  }
501  return "30.5 mDeg/Sec";
502  }
504  return "15.3 mDeg/Sec";
505  }
507  return "7.6 mDeg/Sec";
508  }
510  return "3.8 mDeg/Sec";
511  }
512  default:
513  throw invalid_value_exception( "value not found" );
514  }
515  }
516 
518  {
519  return "gyro sensitivity resolutions, lowers the dynamic range for a more accurate readings";
520  }
521 
523  {
524  if( auto strong = _sensor.lock() )
525  return strong->is_opened();
526  return false;
527  }
528 
529 
530  }
531 
librealsense
Definition: algo.h:18
librealsense::auto_exposure_limit_option::_range
rsutils::lazy< option_range > _range
Definition: d400-options.h:83
librealsense::auto_exposure_limit_option::get_range
virtual option_range get_range() const override
Definition: d400-options.cpp:122
test-fw-update.cmd
list cmd
Definition: test-fw-update.py:141
librealsense::projector_temperature_option_mipi::get_range
option_range get_range() const override
Definition: d400-options.cpp:65
RS2_GYRO_SENSITIVITY_30_5_MILLI_DEG_SEC
@ RS2_GYRO_SENSITIVITY_30_5_MILLI_DEG_SEC
Definition: rs_option.h:282
min
int min(int a, int b)
Definition: lz4s.c:73
librealsense::invalid_value_exception
Definition: librealsense-exception.h:114
librealsense::asic_temperature_option_mipi::query
float query() const override
Definition: d400-options.cpp:18
std::to_string
std::string to_string(T value)
Definition: android_helpers.h:16
librealsense::auto_gain_limit_option::_gain_limit_toggle
std::weak_ptr< limits_option > _gain_limit_toggle
Definition: d400-options.h:119
librealsense::ds::SETAELIMITS
@ SETAELIMITS
Definition: ds-private.h:127
RS2_OPTION_AUTO_GAIN_LIMIT_TOGGLE
@ RS2_OPTION_AUTO_GAIN_LIMIT_TOGGLE
Definition: rs_option.h:121
RS2_GYRO_SENSITIVITY_3_8_MILLI_DEG_SEC
@ RS2_GYRO_SENSITIVITY_3_8_MILLI_DEG_SEC
Definition: rs_option.h:285
librealsense::option_base
Definition: option.h:91
librealsense::auto_exposure_limit_option::set_using_old_opcode
void set_using_old_opcode(float value)
Definition: d400-options.cpp:152
librealsense::gyro_sensitivity_option::is_read_only
virtual bool is_read_only() const override
Definition: d400-options.cpp:522
librealsense::limits_option::_new_opcode
bool _new_opcode
Definition: d400-options.h:160
librealsense::asic_temperature_option_mipi::get_range
option_range get_range() const override
Definition: d400-options.cpp:37
offset
GLintptr offset
Definition: glad/glad/glad.h:2737
librealsense::auto_gain_limit_option::set_using_new_opcode
void set_using_new_opcode(float value)
Definition: d400-options.cpp:258
librealsense::asic_temperature_option_mipi::asic_temperature_option_mipi
asic_temperature_option_mipi(std::shared_ptr< hw_monitor > hwm, rs2_option opt)
Definition: d400-options.cpp:14
librealsense::limits_option::query_using_new_opcode
std::vector< uint8_t > query_using_new_opcode() const
Definition: d400-options.cpp:410
librealsense::limits_option::query_using_old_opcode
std::vector< uint8_t > query_using_old_opcode() const
Definition: d400-options.cpp:417
librealsense::limits_option::query
virtual float query() const override
Definition: d400-options.cpp:337
librealsense::limits_option::set_using_old_opcode
void set_using_old_opcode(float value, float set_limit)
Definition: d400-options.cpp:388
librealsense::limits_option::_cached_limit
float _cached_limit
Definition: d400-options.h:157
librealsense::asic_temperature_option_mipi::_hw_monitor
std::shared_ptr< hw_monitor > _hw_monitor
Definition: d400-options.h:34
from.h
librealsense::ds::GTEMP
@ GTEMP
Definition: ds-private.h:100
librealsense::wrong_api_call_sequence_exception
Definition: librealsense-exception.h:124
librealsense::auto_gain_limit_option::query
virtual float query() const override
Definition: d400-options.cpp:234
librealsense::ds::GETAELIMITS
@ GETAELIMITS
Definition: ds-private.h:126
librealsense::hw_monitor::send
virtual std::vector< uint8_t > send(std::vector< uint8_t > const &data) const
Definition: hw-monitor.cpp:140
librealsense::auto_exposure_limit_option::_exposure_limit_toggle
std::weak_ptr< limits_option > _exposure_limit_toggle
Definition: d400-options.h:86
librealsense::auto_exposure_limit_option::set_using_new_opcode
void set_using_new_opcode(float value)
Definition: d400-options.cpp:134
librealsense::limits_option::set_using_new_opcode
void set_using_new_opcode(float value, float set_limit)
Definition: d400-options.cpp:364
librealsense::auto_gain_limit_option::_range
rsutils::lazy< option_range > _range
Definition: d400-options.h:116
librealsense::command::param1
uint32_t param1
Definition: hw-monitor.h:250
librealsense::hw_monitor
Definition: hw-monitor.h:271
hid-sensor.h
RS2_OPTION_AUTO_EXPOSURE_LIMIT_TOGGLE
@ RS2_OPTION_AUTO_EXPOSURE_LIMIT_TOGGLE
Definition: rs_option.h:120
librealsense::option_range
Definition: option-interface.h:14
val
GLuint GLfloat * val
Definition: glad/glad/glad.h:3411
librealsense::thermal_compensation::query
float query() const override
Definition: d400-options.cpp:432
librealsense::is_valid
bool is_valid(rs2_option value)
Definition: to-string.cpp:478
librealsense::projector_temperature_option_mipi::projector_temperature_option_mipi
projector_temperature_option_mipi(std::shared_ptr< hw_monitor > hwm, rs2_option opt)
Definition: d400-options.cpp:42
librealsense::gyro_sensitivity_option::set
virtual void set(float value) override
Definition: d400-options.cpp:470
uint32_t
unsigned int uint32_t
Definition: stdint.h:80
librealsense::option_base::is_valid
bool is_valid(float value) const
Definition: option.cpp:16
librealsense::thermal_compensation::get_value_description
const char * get_value_description(float value) const override
Definition: d400-options.cpp:452
librealsense::gyro_sensitivity_option::get_description
virtual const char * get_description() const override
Definition: d400-options.cpp:517
RS2_STREAM_GYRO
@ RS2_STREAM_GYRO
Definition: rs_sensor.h:50
librealsense::limits_option::limits_option
limits_option(rs2_option option, option_range range, const char *description, hw_monitor &hwm, bool new_opcode=false)
Definition: d400-options.cpp:317
librealsense::auto_gain_limit_option::query_using_new_opcode
float query_using_new_opcode() const
Definition: d400-options.cpp:291
d400-options.h
value
GLfloat value
Definition: glad/glad/glad.h:2099
librealsense::thermal_compensation::create_snapshot
void create_snapshot(std::shared_ptr< option > &snapshot) const override
Definition: d400-options.cpp:465
f
GLdouble f
Definition: glad/glad/glad.h:1517
librealsense::limits_option::set
virtual void set(float value) override
Definition: d400-options.cpp:325
librealsense::ds::AUTO_CALIB
@ AUTO_CALIB
Definition: ds-private.h:125
librealsense::auto_exposure_limit_option::query_using_new_opcode
float query_using_new_opcode() const
Definition: d400-options.cpp:168
toggle
Definition: rs-measure.cpp:24
librealsense::auto_gain_limit_option::_hwm
hw_monitor & _hwm
Definition: d400-options.h:117
librealsense::auto_exposure_limit_option::_sensor
std::weak_ptr< sensor_base > _sensor
Definition: d400-options.h:85
librealsense::auto_exposure_limit_option::auto_exposure_limit_option
auto_exposure_limit_option(hw_monitor &hwm, const std::weak_ptr< sensor_base > &depth_ep, option_range range, std::shared_ptr< limits_option > exposure_limit_enable, bool ae_gain_limits_new_opcode=false)
Definition: d400-options.cpp:70
librealsense::auto_gain_limit_option::auto_gain_limit_option
auto_gain_limit_option(hw_monitor &hwm, const std::weak_ptr< sensor_base > &depth_ep, option_range range, std::shared_ptr< limits_option > gain_limit_enable, bool new_opcode=false)
Definition: d400-options.cpp:193
librealsense::auto_exposure_limit_option::set
virtual void set(float value) override
Definition: d400-options.cpp:89
d400-thermal-monitor.h
librealsense::auto_gain_limit_option::get_range
virtual option_range get_range() const override
Definition: d400-options.cpp:246
rs2_option
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls,...
Definition: rs_option.h:26
librealsense::auto_gain_limit_option::set_using_old_opcode
void set_using_old_opcode(float value)
Definition: d400-options.cpp:276
librealsense::auto_exposure_limit_option::is_read_only
virtual bool is_read_only() const override
Definition: d400-options.cpp:127
librealsense::auto_exposure_limit_option::_new_opcode
bool _new_opcode
Definition: d400-options.h:87
librealsense::gyro_sensitivity_option::query
virtual float query() const override
Definition: d400-options.cpp:487
librealsense::thermal_compensation::thermal_compensation
thermal_compensation(std::shared_ptr< d400_thermal_monitor > monitor, std::shared_ptr< option > toggle)
Definition: d400-options.cpp:424
librealsense::auto_exposure_limit_option::query
virtual float query() const override
Definition: d400-options.cpp:110
librealsense::auto_exposure_limit_option::_hwm
hw_monitor & _hwm
Definition: d400-options.h:84
librealsense::auto_gain_limit_option::set
virtual void set(float value) override
Definition: d400-options.cpp:213
librealsense::auto_gain_limit_option::query_using_old_opcode
float query_using_old_opcode() const
Definition: d400-options.cpp:304
librealsense::gyro_sensitivity_option::get_value_description
const char * get_value_description(float value) const override
Definition: d400-options.cpp:493
librealsense::thermal_compensation::set
void set(float value) override
Definition: d400-options.cpp:438
librealsense::auto_gain_limit_option::is_read_only
virtual bool is_read_only() const override
Definition: d400-options.cpp:251
librealsense::auto_gain_limit_option::_new_opcode
bool _new_opcode
Definition: d400-options.h:120
librealsense::projector_temperature_option_mipi::query
float query() const override
Definition: d400-options.cpp:46
RS2_GYRO_SENSITIVITY_15_3_MILLI_DEG_SEC
@ RS2_GYRO_SENSITIVITY_15_3_MILLI_DEG_SEC
Definition: rs_option.h:283
librealsense::asic_temperature_option_mipi::is_enabled
bool is_enabled() const override
Definition: d400-options.h:26
librealsense::option
Definition: option-interface.h:22
librealsense::limits_option::_option
rs2_option _option
Definition: d400-options.h:154
range
GLsizei range
Definition: glad/glad/glad.h:1535
librealsense::auto_gain_limit_option::_sensor
std::weak_ptr< sensor_base > _sensor
Definition: d400-options.h:118
RS2_GYRO_SENSITIVITY_61_0_MILLI_DEG_SEC
@ RS2_GYRO_SENSITIVITY_61_0_MILLI_DEG_SEC
Definition: rs_option.h:281
librealsense::auto_exposure_limit_option::query_using_old_opcode
float query_using_old_opcode() const
Definition: d400-options.cpp:181
librealsense::projector_temperature_option_mipi::is_enabled
bool is_enabled() const override
Definition: d400-options.h:44
RS2_GYRO_SENSITIVITY_7_6_MILLI_DEG_SEC
@ RS2_GYRO_SENSITIVITY_7_6_MILLI_DEG_SEC
Definition: rs_option.h:284
librealsense::auto_gain_limit_option::_record_action
std::function< void(const option &)> _record_action
Definition: d400-options.h:115
librealsense::auto_exposure_limit_option::_record_action
std::function< void(const option &)> _record_action
Definition: d400-options.h:82
librealsense::command
Definition: hw-monitor.h:247
librealsense::projector_temperature_option_mipi::_hw_monitor
std::shared_ptr< hw_monitor > _hw_monitor
Definition: d400-options.h:52
librealsense::limits_option::_hwm
hw_monitor & _hwm
Definition: d400-options.h:159
librealsense::thermal_compensation::get_description
const char * get_description() const override
Definition: d400-options.cpp:447
librealsense::ds::ASIC_TEMP_MIPI
@ ASIC_TEMP_MIPI
Definition: ds-private.h:119


librealsense2
Author(s): LibRealSense ROS Team
autogenerated on Fri Aug 2 2024 08:30:02