Device.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "ObTypes.h"
#include "Property.h"
#include "MultipleDevices.h"
 
uint32_t ob_device_list_device_count(ob_device_list *list, ob_error **error);
 
const char *ob_device_list_get_device_name(ob_device_list *list, uint32_t index, ob_error **error);
 
int ob_device_list_get_device_pid(ob_device_list *list, uint32_t index, ob_error **error);
 
int ob_device_list_get_device_vid(ob_device_list *list, uint32_t index, ob_error **error);
 
const char *ob_device_list_get_device_uid(ob_device_list *list, uint32_t index, ob_error **error);
 
const char *ob_device_list_get_device_serial_number(ob_device_list *list, uint32_t index, ob_error **error);
 
const char *ob_device_list_get_device_connection_type(ob_device_list *list, uint32_t index, ob_error **error);
 
const char *ob_device_list_get_device_ip_address(ob_device_list *list, uint32_t index, ob_error **error);
 
const char *ob_device_list_get_extension_info(ob_device_list *list, uint32_t index, ob_error **error);
 
ob_device *ob_device_list_get_device(ob_device_list *list, uint32_t index, ob_error **error);
 
ob_device *ob_device_list_get_device_by_serial_number(ob_device_list *list, const char *serial_number, ob_error **error);
 
ob_device *ob_device_list_get_device_by_uid(ob_device_list *list, const char *uid, ob_error **error);
 
void ob_delete_device(ob_device *device, ob_error **error);
 
void ob_delete_device_info(ob_device_info *info, ob_error **error);
 
void ob_delete_device_list(ob_device_list *list, ob_error **error);
 
ob_device_info *ob_device_get_device_info(ob_device *device, ob_error **error);
 
ob_sensor_list *ob_device_get_sensor_list(ob_device *device, ob_error **error);
 
ob_sensor *ob_device_get_sensor(ob_device *device, ob_sensor_type type, ob_error **error);
 
void ob_device_set_int_property(ob_device *device, ob_property_id property_id, int32_t property, ob_error **error);
 
int32_t ob_device_get_int_property(ob_device *device, ob_property_id property_id, ob_error **error);
 
void ob_device_set_float_property(ob_device *device, ob_property_id property_id, float property, ob_error **error);
 
float ob_device_get_float_property(ob_device *device, ob_property_id property_id, ob_error **error);
 
void ob_device_set_bool_property(ob_device *device, ob_property_id property_id, bool property, ob_error **error);
 
bool ob_device_get_bool_property(ob_device *device, ob_property_id property_id, ob_error **error);
 
void ob_device_set_structured_data(ob_device *device, ob_property_id property_id, const void *data, uint32_t data_size, ob_error **error);
 
void ob_device_get_structured_data(ob_device *device, ob_property_id property_id, void *data, uint32_t *data_size, ob_error **error);
 
void ob_device_set_structured_data_ext(ob_device *device, ob_property_id property_id, ob_data_bundle *data_bundle, ob_set_data_callback cb, void *user_data,
                                       ob_error **error);
 
ob_data_bundle *ob_device_get_structured_data_ext(ob_device *device, ob_property_id property_id, ob_error **error);
 
void ob_device_set_raw_data(ob_device *device, ob_property_id property_id, void *data, uint32_t data_size, ob_set_data_callback cb, bool async, void *user_data,
                            ob_error **error);
 
void ob_device_get_raw_data(ob_device *device, ob_property_id property_id, ob_get_data_callback cb, bool async, void *user_data, ob_error **error);
 
ob_protocol_version ob_device_get_protocol_version(ob_device *device, ob_error **error);
 
ob_cmd_version ob_device_get_cmd_version(ob_device *device, ob_property_id property_id, ob_error **error);
 
uint32_t ob_device_get_supported_property_count(ob_device *device, ob_error **error);
 
ob_property_item ob_device_get_supported_property(ob_device *device, uint32_t index, ob_error **error);
 
bool ob_device_is_property_supported(ob_device *device, ob_property_id property_id, ob_permission_type permission, ob_error **error);
 
ob_int_property_range ob_device_get_int_property_range(ob_device *device, ob_property_id property_id, ob_error **error);
 
ob_float_property_range ob_device_get_float_property_range(ob_device *device, ob_property_id property_id, ob_error **error);
 
ob_bool_property_range ob_device_get_bool_property_range(ob_device *device, ob_property_id property_id, ob_error **error);
 
void ob_device_write_ahb(ob_device *device, uint32_t reg, uint32_t mask, uint32_t value, ob_error **error);
 
void ob_device_read_ahb(ob_device *device, uint32_t reg, uint32_t mask, uint32_t *value, ob_error **error);
 
void ob_device_write_i2c(ob_device *device, uint32_t module_id, uint32_t reg, uint32_t mask, uint32_t value, ob_error **error);
 
void ob_device_read_i2c(ob_device *device, uint32_t module_id, uint32_t reg, uint32_t mask, uint32_t *value, ob_error **error);
 
void ob_device_write_flash(ob_device *device, uint32_t offset, const void *data, uint32_t data_size, ob_set_data_callback cb, bool async, void *user_data,
                           ob_error **error);
 
void ob_device_read_flash(ob_device *device, uint32_t offset, uint32_t data_size, ob_get_data_callback cb, bool async, void *user_data, ob_error **error);
 
void ob_device_write_customer_data(ob_device *device, const void *data, uint32_t data_size, ob_error **error);
 
void ob_device_read_customer_data(ob_device *device, void *data, uint32_t *data_size, ob_error **error);
 
void ob_device_upgrade(ob_device *device, const char *path, ob_device_upgrade_callback callback, bool async, void *user_data, ob_error **error);
 
void ob_device_upgrade_from_data(ob_device *device, const char *file_data, uint32_t file_size, ob_device_upgrade_callback callback, bool async, void *user_data,
                                 ob_error **error);
 
ob_device_state ob_device_get_device_state(ob_device *device, ob_error **error);
 
void ob_device_state_changed(ob_device *device, ob_device_state_callback callback, void *user_data, ob_error **error);
 
void ob_device_send_file_to_destination(ob_device *device, const char *file_path, const char *dst_path, ob_file_send_callback callback, bool async,
                                        void *user_data, ob_error **error);
 
bool ob_device_activate_authorization(ob_device *device, const char *auth_code, ob_error **error);
 
void ob_device_write_authorization_code(ob_device *device, const char *auth_code, ob_error **error);
 
ob_camera_param_list *ob_device_get_calibration_camera_param_list(ob_device *device, ob_error **error);
 
ob_depth_work_mode ob_device_get_current_depth_work_mode(ob_device *device, ob_error **error);
 
ob_status ob_device_switch_depth_work_mode(ob_device *device, const ob_depth_work_mode *work_mode, ob_error **error);
 
ob_status ob_device_switch_depth_work_mode_by_name(ob_device *device, const char *mode_name, ob_error **error);
 
ob_depth_work_mode_list *ob_device_get_depth_work_mode_list(ob_device *device, ob_error **error);
 
void ob_device_reboot(ob_device *device, ob_error **error);
 
ob_device_sync_config ob_device_get_sync_config(ob_device *device, ob_error **error);
 
void ob_device_set_sync_config(ob_device *device, ob_device_sync_config device_sync_config, ob_error **error);
 
const char *ob_device_info_name(ob_device_info *info, ob_error **error);
 
int ob_device_info_pid(ob_device_info *info, ob_error **error);
 
int ob_device_info_vid(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_uid(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_serial_number(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_firmware_version(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_usb_type(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_connection_type(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_ip_address(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_hardware_version(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_get_extension_info(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_supported_min_sdk_version(ob_device_info *info, ob_error **error);
 
const char *ob_device_info_asicName(ob_device_info *info, ob_error **error);
 
ob_device_type ob_device_info_device_type(ob_device_info *info, ob_error **error);
 
uint32_t ob_camera_param_list_count(ob_camera_param_list *param_list, ob_error **error);
 
ob_camera_param ob_camera_param_list_get_param(ob_camera_param_list *param_list, uint32_t index, ob_error **error);
 
void ob_delete_camera_param_list(ob_camera_param_list *param_list, ob_error **error);
 
uint32_t ob_depth_work_mode_list_count(ob_depth_work_mode_list *work_mode_list, ob_error **error);
 
ob_depth_work_mode ob_depth_work_mode_list_get_item(ob_depth_work_mode_list *work_mode_list, uint32_t index, ob_error **error);
 
void ob_delete_depth_work_mode_list(ob_depth_work_mode_list *work_mode_list, ob_error **error);
 
void ob_delete_data_bundle(ob_data_bundle *data_bundle, ob_error **error);
 
bool ob_device_is_global_timestamp_supported(ob_device *device, ob_error **error);
 
void ob_device_load_depth_filter_config(ob_device *device, const char *file_path, ob_error **error);
 
void ob_device_reset_default_depth_filter_config(ob_device *device, ob_error **error);
 
const char *ob_device_get_current_preset_name(ob_device *device, ob_error **error);
 
void ob_device_load_preset(ob_device *device, const char *preset_name, ob_error **error);
 
void ob_device_load_preset_from_json_file(ob_device *device, const char *json_file_path, ob_error **error);
 
void ob_device_export_current_settings_as_preset_json_file(ob_device *device, const char *json_file_path, ob_error **error);
 
ob_device_preset_list *ob_device_get_available_preset_list(ob_device *device, ob_error **error);
 
void ob_delete_preset_list(ob_device_preset_list *preset_list, ob_error **error);
 
uint32_t ob_device_preset_list_count(ob_device_preset_list *preset_list, ob_error **error);
 
const char *ob_device_preset_list_get_name(ob_device_preset_list *preset_list, uint32_t index, ob_error **error);
 
bool ob_device_preset_list_has_preset(ob_device_preset_list *preset_list, const char *preset_name, ob_error **error);
 
#ifdef __cplusplus
}
#endif