orbbec-sdk-sys 0.1.2+2.5.5

Low-level Rust bindings for https://github.com/orbbec/OrbbecSDK_v2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

#include "BootDevice.hpp"

#include "DevicePids.hpp"
#include "InternalTypes.hpp"

#include "utils/Utils.hpp"
#include "environment/EnvConfig.hpp"
#include "usb/uvc/UvcDevicePort.hpp"
#include "monitor/DeviceMonitor.hpp"
#include "firmwareupdater/FirmwareUpdater.hpp"
#include "property/PropertyServer.hpp"
#include "property/VendorPropertyAccessor.hpp"
#include "property/CommonPropertyAccessors.hpp"
#include "property/InternalProperty.hpp"

#include <algorithm>

namespace libobsensor {

BootDevice::BootDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
    init();
}

BootDevice::~BootDevice() noexcept {}

void BootDevice::init() {
    auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this]() {
        auto sourcePortInfoList     = enumInfo_->getSourcePortInfoList();
        auto sourcePortInfo         = sourcePortInfoList.front();  // assume only one source port
        auto port                   = getSourcePort(sourcePortInfo);
        auto vendorPropertyAccessor = std::make_shared<VendorPropertyAccessor>(this, port);
        return vendorPropertyAccessor;
    });

    auto propertyServer = std::make_shared<PropertyServer>(this);
    propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
    propertyServer->registerProperty(OB_STRUCT_ASIC_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
    propertyServer->registerProperty(OB_PROP_REBOOT_DEVICE_BOOL, "", "w", vendorPropertyAccessor);
    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);

    fetchDeviceInfo();

    registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this]() {
        auto sourcePortInfoList = enumInfo_->getSourcePortInfoList();
        auto sourcePortInfo     = sourcePortInfoList.front();  // assume only one source port
        auto port               = getSourcePort(sourcePortInfo);
        auto devMonitor         = std::make_shared<DeviceMonitor>(this, port);
        return devMonitor;
    });

    registerComponent(OB_DEV_COMPONENT_FIRMWARE_UPDATER, [this]() {
        std::shared_ptr<FirmwareUpdater> firmwareUpdater;
        TRY_EXECUTE({ firmwareUpdater = std::make_shared<FirmwareUpdater>(this); })
        return firmwareUpdater;
    });
}

void BootDevice::fetchDeviceInfo() {

    auto propServer                   = getPropertyServer();
    auto version                      = propServer->getStructureDataT<OBVersionInfo>(OB_STRUCT_VERSION);
    if(enumInfo_->getConnectionType() == "Ethernet") {
        auto deviceInfo                   = std::make_shared<NetDeviceInfo>();
        auto portInfo                     = enumInfo_->getSourcePortInfoList().front();
        auto netPortInfo                  = std::dynamic_pointer_cast<const NetSourcePortInfo>(portInfo);
        deviceInfo->ipAddress_            = netPortInfo->address;
        deviceInfo_                       = deviceInfo;
        deviceInfo_->name_                = version.deviceName;
        deviceInfo_->fwVersion_           = version.firmwareVersion;
        deviceInfo_->deviceSn_            = version.serialNumber;
        deviceInfo_->asicName_            = version.depthChip;
        deviceInfo_->hwVersion_           = version.hardwareVersion;
        deviceInfo_->type_                = static_cast<uint16_t>(version.deviceType);
        deviceInfo_->supportedSdkVersion_ = version.sdkVersion;
        deviceInfo_->pid_                 = enumInfo_->getPid();
        deviceInfo_->vid_                 = enumInfo_->getVid();
        deviceInfo_->uid_                 = enumInfo_->getUid();
        deviceInfo_->connectionType_      = enumInfo_->getConnectionType();
    }
    else {
        deviceInfo_                       = std::make_shared<DeviceInfo>();
        deviceInfo_->name_                = version.deviceName;
        deviceInfo_->fwVersion_           = version.firmwareVersion;
        deviceInfo_->deviceSn_            = version.serialNumber;
        deviceInfo_->asicName_            = version.depthChip;
        deviceInfo_->hwVersion_           = version.hardwareVersion;
        deviceInfo_->type_                = static_cast<uint16_t>(version.deviceType);
        deviceInfo_->supportedSdkVersion_ = version.sdkVersion;
        deviceInfo_->pid_                 = enumInfo_->getPid();
        deviceInfo_->vid_                 = enumInfo_->getVid();
        deviceInfo_->uid_                 = enumInfo_->getUid();
        deviceInfo_->connectionType_      = enumInfo_->getConnectionType();
    }


    // remove the prefix "Orbbec " from the device name if contained
    if(deviceInfo_->name_.find("Orbbec ") == 0) {
        deviceInfo_->name_ = deviceInfo_->name_.substr(7);
    }
    deviceInfo_->fullName_ = "Orbbec " + deviceInfo_->name_;

    // mark the device as a multi-sensor device with same clock at default
    extensionInfo_["AllSensorsUsingSameClock"] = "true";

}


}  // namespace libobsensor