Class DeviceBase

Defined in File DeviceBase.hpp

Nested Relationships

Nested Types

Inheritance Relationships

Derived Type

public dai::Device (Class Device)

Class Documentation

class DeviceBase

The core of depthai device for RAII, connects to device and maintains watchdog, timesync, …

Subclassed by dai::Device

Public Types

enum class ReconnectionStatus

Values:

enumerator RECONNECTED

enumerator RECONNECTING

enumerator RECONNECT_FAILED

Public Functions

DeviceBase(): Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

DeviceBase(UsbSpeed maxUsbSpeed)

Connects to device

Parameters:: maxUsbSpeed – Maximum allowed USB speed

DeviceBase(const DeviceInfo &devInfo, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters:

devInfo – DeviceInfo which specifies which device to connect to
maxUsbSpeed – Maximum allowed USB speed

DeviceBase(const DeviceInfo &devInfo, const std::filesystem::path &pathToCmd)

Connects to device specified by devInfo.

Parameters:

devInfo – DeviceInfo which specifies which device to connect to
pathToCmd – Path to custom device firmware

explicit DeviceBase(Config config)

Connects to any available device with custom config.

Parameters:: config – Device custom configuration to boot with

DeviceBase(Config config, const DeviceInfo &devInfo)

Connects to device ‘devInfo’ with custom config.

Parameters:

config – Device custom configuration to boot with
devInfo – DeviceInfo which specifies which device to connect to

explicit DeviceBase(const DeviceInfo &devInfo)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters:: devInfo – DeviceInfo which specifies which device to connect to

DeviceBase(std::string nameOrDeviceId)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters:: nameOrDeviceId – Creates DeviceInfo with nameOrDeviceId to connect to

DeviceBase(std::string nameOrDeviceId, UsbSpeed maxUsbSpeed)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters:

nameOrDeviceId – Creates DeviceInfo with nameOrDeviceId to connect to
maxUsbSpeed – Maximum allowed USB speed

DeviceBase(Config config, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters:

config – Config with which the device will be booted with
maxUsbSpeed – Maximum allowed USB speed

DeviceBase(Config config, const std::filesystem::path &pathToCmd)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameters:

config – Config with which the device will be booted with
pathToCmd – Path to custom device firmware

DeviceBase(Config config, const DeviceInfo &devInfo, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters:

config – Config with which the device will be booted with
devInfo – DeviceInfo which specifies which device to connect to
maxUsbSpeed – Maximum allowed USB speed

DeviceBase(Config config, const DeviceInfo &devInfo, const std::filesystem::path &pathToCmd, bool dumpOnly = false)

Connects to device specified by devInfo.

Parameters:

config – Config with which the device will be booted with
devInfo – DeviceInfo which specifies which device to connect to
pathToCmd – Path to custom device firmware
dumpOnly – If true only the minimal connection is established to retrieve the crash dump

virtual ~DeviceBase(): Device destructor

Note

In the destructor of the derived class, remember to call close()

Platform getPlatform() const

Get the platform of the connected device.

Returns:: Platform Platform enum

std::string getPlatformAsString() const

Get the platform of the connected device as string.

Returns:: std::string String representation of Platform

std::optional<Version> getBootloaderVersion()

Gets Bootloader version if it was booted through Bootloader

Returns:: DeviceBootloader::Version if booted through Bootloader or none otherwise

bool isPipelineRunning()

Checks if devices pipeline is already running

Returns:: True if running, false otherwise

bool startPipeline(const Pipeline &pipeline)

Starts the execution of a given pipeline

Parameters:: pipeline – OpenVINO version of the pipeline must match the one which the device was booted with.
Returns:: True if pipeline started, false otherwise

void setLogLevel(LogLevel level)

Sets the devices logging severity level. This level affects which logs are transferred from device to host.

Parameters:: level – Logging severity

void setNodeLogLevel(int64_t id, LogLevel level)

Sets the logging severity level for a specific node with a given ID.

Parameters:

id – Node ID
level – Logging severity

LogLevel getLogLevel()

Gets current logging severity level of the device.

Returns:: Logging severity level

LogLevel getNodeLogLevel(int64_t id)

Gets the logging severity level for a specific node with a given ID.

Parameters:: id – Node ID
Returns:: Logging severity level

void setProperties(const DeviceProperties &properties)

Sets properties for the device.

Parameters:: properties – DeviceProperties struct with properties to set. Only properties which are supported by the device and have different values than current ones will be applied. Some properties are only applied before starting the pipeline.

DeviceProperties getProperties()

Gets current properties set on the device. Some properties might be not supported by the device, in that case they will have default values.

Returns:: DeviceProperties struct with current device properties

void setCameraTuningBlob(const std::string &uri, uint32_t size)

Sets the camera tuning blob for the device.

Parameters:

uri – URI of the tuning blob retrieved using the asset manager
size – size of the tuning blob in bytes

void setCameraSocketTuningBlobs(const std::unordered_map<CameraBoardSocket, std::pair<std::string, uint32_t>> &blobs)

Sets the camera socket specific tuning blobs for the device.

Parameters:: blobs – Unordered map of CameraBoardSocket to pair of URI and size of the tuning blob in bytes. The URI should be retrieved using the asset manager

void setCameraSocketTuningBlob(CameraBoardSocket socket, const std::string &uri, uint32_t size)

Sets the camera socket specific tuning blob for the device.

Parameters:

socket – CameraBoardSocket for which the tuning blob will be set
uri – URI of the tuning blob retrieved using the asset manager
size – size of the tuning blob in bytes

void setXLinkChunkSize(int sizeBytes)

Sets the chunk size for splitting device-sent XLink packets. A larger value could increase performance, and 0 disables chunking. A negative value is ignored. Device defaults are configured per protocol, currently 64*1024 for both USB and Ethernet.

Parameters:: sizeBytes – XLink chunk size in bytes

int getXLinkChunkSize()

Gets current XLink chunk size.

Returns:: XLink chunk size in bytes

void setSippBufferSize(int sizeBytes)

Sets the size of the SIPP buffer on the device.

Parameters:: sizeBytes – SIPP buffer size in bytes. Device default is 18 * 1024 bytes

void setSippDmaBufferSize(int sizeBytes)

Sets the size of the SIPP DMA buffer on the device.

Parameters:: sizeBytes – SIPP DMA buffer size in bytes. Device default is 16 * 1024 bytes

void setXLinkRateLimit(int maxRateBytesPerSecond, int burstSize = 0, int waitUs = 0)

Sets the maximum transmission rate for the XLink connection on device side, using a simple token bucket algorithm. Useful for bandwidth throttling

Parameters:

maxRateBytesPerSecond – Rate limit in Bytes/second
burstSize – Size in Bytes for how much to attempt to send once, 0 = auto
waitUs – Time in microseconds to wait for replenishing tokens, 0 = auto

DeviceInfo getDeviceInfo() const

Get the Device Info object o the device which is currently running

Returns:: DeviceInfo of the current device in execution

std::string getDeviceName()

Get device name if available

Returns:: device name or empty string if not available

std::string getProductName()

Get product name if available

Returns:: product name or empty string if not available

std::string getMxId()

Get MxId of device

Returns:: MxId of connected device

std::string getDeviceId()

Get DeviceId of device

Returns:: DeviceId of connected device

void setLogOutputLevel(LogLevel level)

Sets logging level which decides printing level to standard output. If lower than setLogLevel, no messages will be printed

Parameters:: level – Standard output printing severity

LogLevel getLogOutputLevel()

Gets logging level which decides printing level to standard output.

Returns:: Standard output printing severity

bool setIrLaserDotProjectorIntensity(float intensity, int mask = -1)

Sets the intensity of the IR Laser Dot Projector. Limits: up to 765mA at 30% frame time duty cycle when exposure time is longer than 30% frame time. Otherwise, duty cycle is 100% of exposure time, with current increased up to max 1200mA to make up for shorter duty cycle. The duty cycle is controlled by left camera STROBE, aligned to start of exposure. The emitter is turned off by default

Parameters:

intensity – Intensity on range 0 to 1, that will determine brightness. 0 or negative to turn off
mask – Optional mask to modify only Left (0x1) or Right (0x2) sides on OAK-D-Pro-W-DEV

Returns:

True on success, false if not found or other failure

bool setIrFloodLightIntensity(float intensity, int mask = -1)

Sets the intensity of the IR Flood Light. Limits: Intensity is directly normalized to 0 - 1500mA current. The duty cycle is 30% when exposure time is longer than 30% frame time. Otherwise, duty cycle is 100% of exposure time. The duty cycle is controlled by the left camera STROBE, aligned to start of exposure. The emitter is turned off by default

Parameters:

intensity – Intensity on range 0 to 1, that will determine brightness, 0 or negative to turn off
mask – Optional mask to modify only Left (0x1) or Right (0x2) sides on OAK-D-Pro-W-DEV

Returns:

True on success, false if not found or other failure

std::vector<std::tuple<std::string, int, int>> getIrDrivers()

Retrieves detected IR laser/LED drivers.

Returns:: Vector of tuples containing: driver name, I2C bus, I2C address. For OAK-D-Pro it should be [{"LM3644", 2, 0x63}]

std::unique_ptr<CrashDump> getState(): Retrieves current device state in a crash dump format. It halts the device temporarily and might affect the running pipeline, it’s best to close the device after this operation. Supported only on RVC2.

std::unique_ptr<CrashDump> getCrashDump(bool clearCrashDump = true)

Retrieves crash dump for debugging.

Parameters:: clearCrashDump – Clear the cached crash dump on device after collection
Returns:: Unique pointer to the CrashDump. Platform-specific crash dump payload may be empty if no crash dump is available.

bool hasCrashDump(): Retrieves whether the is crash dump stored on device or not.

ProfilingData getProfilingData()

Get current accumulated profiling data

Returns:: ProfilingData from the specific device

int addLogCallback(std::function<void(LogMessage)> callback)

Add a callback for device logging. The callback will be called from a separate thread with the LogMessage being passed.

Parameters:: callback – Callback to call whenever a log message arrives
Returns:: Id which can be used to later remove the callback

bool removeLogCallback(int callbackId)

Removes a callback

Parameters:: callbackId – Id of callback to be removed
Returns:: True if callback was removed, false otherwise

void setSystemInformationLoggingRate(float rateHz)

Sets rate of system information logging (“info” severity). Default 1Hz If parameter is less or equal to zero, then system information logging will be disabled

Parameters:: rateHz – Logging rate in Hz

float getSystemInformationLoggingRate()

Gets current rate of system information logging (“info” severity) in Hz.

Returns:: Logging rate in Hz

std::vector<CameraBoardSocket> getConnectedCameras()

Get cameras that are connected to the device

Returns:: Vector of connected cameras

std::vector<ConnectionInterface> getConnectionInterfaces()

Get connection interfaces for device

Returns:: Vector of connection type

std::vector<CameraFeatures> getConnectedCameraFeatures()

Get cameras that are connected to the device with their features/properties

Returns:: Vector of connected camera features

std::vector<StereoPair> getStereoPairs()

Get stereo pairs based on the device type.

Returns:: Vector of stereo pairs

std::vector<StereoPair> getAvailableStereoPairs()

Get stereo pairs taking into account the calibration and connected cameras.

Note

This method will always return a subset of getStereoPairs.

Returns:: Vector of stereo pairs

std::unordered_map<CameraBoardSocket, std::string> getCameraSensorNames()

Get sensor names for cameras that are connected to the device

Returns:: Map/dictionary with camera sensor names, indexed by socket

std::string getConnectedIMU()

Get connected IMU type

Returns:: IMU type

dai::Version getIMUFirmwareVersion()

Get connected IMU firmware version

Returns:: IMU firmware version

dai::Version getEmbeddedIMUFirmwareVersion()

Get embedded IMU firmware version to which IMU can be upgraded

Returns:: Get embedded IMU firmware version to which IMU can be upgraded.

bool startIMUFirmwareUpdate(bool forceUpdate = false)

Starts IMU firmware update asynchronously only if IMU node is not running. If current firmware version is the same as embedded firmware version then it’s no-op. Can be overridden by forceUpdate parameter. State of firmware update can be monitored using getIMUFirmwareUpdateStatus API.

Parameters:: forceUpdate – Force firmware update or not. Will perform FW update regardless of current version and embedded firmware version.
Returns:: Returns whether firmware update can be started. Returns false if IMU node is started.

std::tuple<bool, float> getIMUFirmwareUpdateStatus()

Get IMU firmware update status

Returns:: Whether IMU firmware update is done and last firmware update progress as percentage. return value true and 100 means that the update was successful return value true and other than 100 means that the update failed

MemoryInfo getDdrMemoryUsage()

Retrieves current DDR memory information from device

Returns:: Used, remaining and total ddr memory

MemoryInfo getCmxMemoryUsage()

Retrieves current CMX memory information from device

Returns:: Used, remaining and total cmx memory

MemoryInfo getLeonCssHeapUsage()

Retrieves current CSS Leon CPU heap information from device

Returns:: Used, remaining and total heap memory

MemoryInfo getLeonMssHeapUsage()

Retrieves current MSS Leon CPU heap information from device

Returns:: Used, remaining and total heap memory

ChipTemperature getChipTemperature()

Retrieves current chip temperature as measured by device

Returns:: Temperature of various onboard sensors

CpuUsage getLeonCssCpuUsage()

Retrieves average CSS Leon CPU usage

Returns:: Average CPU usage and sampling duration

CpuUsage getLeonMssCpuUsage()

Retrieves average MSS Leon CPU usage

Returns:: Average CPU usage and sampling duration

int64_t getProcessMemoryUsage()

Retrieves current Rss memory usage of the device process

Returns:: Current Rss memory used

bool isEepromAvailable()

Check if EEPROM is available

Returns:: True if EEPROM is present on board, false otherwise

bool isCalibrationAvailable()

Check if Calibration is available on the device

Returns:: True if calibration is present on device, false otherwise

bool tryFlashCalibration(CalibrationHandler calibrationDataHandler)

Stores the Calibration and Device information to the Device EEPROM

Parameters:: calibrationObj – CalibrationHandler object which is loaded with calibration information.
Returns:: true on successful flash, false on failure

void flashCalibration(CalibrationHandler calibrationDataHandler)

Stores the Calibration and Device information to the Device EEPROM

Throws:: std::runtime_error – if failed to flash the calibration
Parameters:: calibrationObj – CalibrationHandler object which is loaded with calibration information.

void setCalibration(CalibrationHandler calibrationDataHandler)

Sets the Calibration at runtime. This is not persistent and will be lost after device reset.

Throws:: std::runtime_error – if failed to set the calibration
Parameters:: calibrationObj – CalibrationHandler object which is loaded with calibration information.

void setCalibration(const std::optional<EepromData> &eepromData)

Sets the Calibration at runtime using EepromData. This is not persistent and will be lost after device reset.

Throws:: std::runtime_error – if failed to set the calibration
Parameters:: eepromData – EepromData struct which contains the calibration information.

std::shared_ptr<CalibrationHandler> tryGetCalibration()

Retrieves the CalibrationHandler shared pointer; If can not get calibration returns nullptr

Returns:: The CalibrationHandler object containing the non-persistent calibration

CalibrationHandler getCalibration()

Retrieves the CalibrationHandler object containing the non-persistent calibration

Throws:: std::runtime_error – if failed to get the calibration
Returns:: The CalibrationHandler object containing the non-persistent calibration

CalibrationHandler readCalibration()

Fetches the EEPROM data from the device and loads it into CalibrationHandler object If no calibration is flashed, it returns default

Returns:: The CalibrationHandler object containing the calibration currently flashed on device EEPROM

CalibrationHandler readCalibration2()

Fetches the EEPROM data from the device and loads it into CalibrationHandler object

Throws:: std::runtime_error – if no calibration is flashed
Returns:: The CalibrationHandler object containing the calibration currently flashed on device EEPROM

CalibrationHandler readCalibrationOrDefault()

Fetches the EEPROM data from the device and loads it into CalibrationHandler object If no calibration is flashed, it returns default

Returns:: The CalibrationHandler object containing the calibration currently flashed on device EEPROM

void factoryResetCalibration()

Factory reset EEPROM data if factory backup is available.

Throws:: std::runtime_error – If factory reset was unsuccessful

void flashFactoryCalibration(CalibrationHandler calibrationHandler)

Stores the Calibration and Device information to the Device EEPROM in Factory area To perform this action, correct env variable must be set

Throws:: std::runtime_error – if failed to flash the calibration
Returns:: True on successful flash, false on failure

void flashEepromClear()

Destructive action, deletes User area EEPROM contents Requires PROTECTED permissions

Throws:: std::runtime_error – if failed to flash the calibration
Returns:: True on successful flash, false on failure

void flashFactoryEepromClear()

Destructive action, deletes Factory area EEPROM contents Requires FACTORY PROTECTED permissions

Throws:: std::runtime_error – if failed to flash the calibration
Returns:: True on successful flash, false on failure

CalibrationHandler readFactoryCalibration()

Fetches the EEPROM data from Factory area and loads it into CalibrationHandler object

Throws:: std::runtime_error – if no calibration is flashed
Returns:: The CalibrationHandler object containing the calibration currently flashed on device EEPROM in Factory Area

CalibrationHandler readFactoryCalibrationOrDefault()

Fetches the EEPROM data from Factory area and loads it into CalibrationHandler object If no calibration is flashed, it returns default

Returns:: The CalibrationHandler object containing the calibration currently flashed on device EEPROM in Factory Area

std::vector<std::uint8_t> readCalibrationRaw()

Fetches the raw EEPROM data from User area

Throws:: std::runtime_error – if any error occurred
Returns:: Binary dump of User area EEPROM data

std::vector<std::uint8_t> readFactoryCalibrationRaw()

Fetches the raw EEPROM data from Factory area

Throws:: std::runtime_error – if any error occurred
Returns:: Binary dump of Factory area EEPROM data

UsbSpeed getUsbSpeed()

Retrieves USB connection speed

Returns:: USB connection speed of connected device if applicable. Unknown otherwise.

bool isNeuralDepthSupported()

Checks if Neural Depth is supported on the device

Returns:: True if supported, false otherwise

std::vector<DeviceModelZoo> getSupportedDeviceModels()

Returns the subset of device zoo models currently available on the device.

Returns:: Supported device zoo models

void setTimesync(std::chrono::milliseconds period, int numSamples, bool random)

Configures Timesync service on device. It keeps host and device clocks in sync First time timesync is started it waits until the initial sync is completed Afterwards the function changes the following parameters

Parameters:

period – Interval between timesync runs
numSamples – Number of timesync samples per run which are used to compute a better value. Set to zero to disable timesync
random – If true partial timesync requests will be performed at random intervals, otherwise at fixed intervals

void setTimesync(bool enable)

Enables or disables Timesync service on device. It keeps host and device clocks in sync.

Parameters:: enable – Enables or disables consistent timesyncing

void close(): Explicitly closes connection to device.

Note

This function does not need to be explicitly called as destructor closes the device automatically

bool isClosed() const: Is the device already closed (or disconnected)

Warning

This function is thread-unsafe and may return outdated incorrect values. It is only meant for use in simple single-threaded code. Well written code should handle exceptions when calling any DepthAI apis to handle hardware events and multithreaded use.

void registerCrashdumpCallback(std::function<void(std::shared_ptr<CrashDump>)> callback)

Register a callback that will be called when the device crashes. The callback receives a shared pointer to the CrashDump, which can be modified before it is stored. Only one callback can be registered at a time.

Parameters:: callback – Callback to call when a crash dump is collected

void removeCrashdumpCallback(): Removes the registered crash dump callback

bool hasCrashed() const

Check if the device has crashed

Returns:: True if the device has crashed (watchdog timeout detected), false otherwise

void crashDevice(): Crashes the device

Warning

ONLY FOR TESTING PURPOSES, it causes an unrecoverable crash on the device

void overrideCameraFeatures(const std::vector<CameraFeatures> &features, const std::string &imu = "")

Sets connected camera features. Used for holistic record and replay

Parameters:

features – Vector of camera features to set
imu – IMU type to set (if any)

inline std::shared_ptr<XLinkConnection> getConnection(): Returns underlying XLinkConnection

inline std::shared_ptr<const XLinkConnection> getConnection() const: Returns underlying XLinkConnection

void setMaxReconnectionAttempts(int maxAttempts, std::function<void(ReconnectionStatus)> callBack = nullptr)

Sets max number of automatic reconnection attempts

Parameters:

maxAttempts – Maximum number of reconnection attempts, 0 to disable reconnection
callBack – Callback to be called when reconnection is attempted

std::tuple<bool, std::string> setExternalFrameSyncRole(ExternalFrameSyncRole role = ExternalFrameSyncRole::AUTO_DETECT)

Sets external frame sync role for the device

Parameters:: role – External frame sync role to be set, AUTO_DETECT by default
Returns:: Tuple of bool and string. Bool specifies if role was set without failures. String is the error message describing the failure reason.

ExternalFrameSyncRole getExternalFrameSyncRole()

Gets external frame sync role for the device

Returns:: Gets external frame sync role

std::tuple<bool, std::string> setExternalStrobeRelativeLimits(float min, float max)

Sets the relative external strobe limits. Limits the strobe duty cycle, between 0 and 1, as a fraction of the whole period. 0 means always off, 1 means always on. The rising edge of the strobe signal is always synced to end of exposure. The falling edge of the strobe signal is then limited according to the min and max values. Default values are 0.005 and 0.995

Parameters:

min – Minimum strobe value
max – Maximum strobe value

Returns:

Tuple of bool and string. Bool specifies if role was set without failures. String is the error message describing the failure reason.

void setExternalStrobeEnable(bool enable)

Set whether the external strobe should be enabled. External strobe signal is low for the duration of exposure, and high for the rest of the frame.

Parameters:: enable – Enables or disables strobe

void mockCameraFeatures(const std::filesystem::path &replayPath): Mock camera features from a recording. Used for holistic record and replay.

Public Static Functions

static std::chrono::milliseconds getDefaultSearchTime()

Get the Default Search Time for finding devices.

Returns:: Default search time in milliseconds

static std::tuple<bool, DeviceInfo> getAnyAvailableDevice(std::chrono::milliseconds timeout)

Waits for any available device with a timeout

Parameters:: timeout – duration of time to wait for the any device
Returns:: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

static std::tuple<bool, DeviceInfo> getAnyAvailableDevice()

Gets any available device

Returns:: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

static std::tuple<bool, DeviceInfo> getAnyAvailableDevice(std::chrono::milliseconds timeout, std::function<void()> cb)

Waits for any available device with a timeout

Parameters:

timeout – duration of time to wait for the any device
cb – callback function called between pooling intervals

Returns:

Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

static std::tuple<bool, DeviceInfo> getFirstAvailableDevice(bool skipInvalidDevice = true)

Gets first available device. Device can be either in XLINK_UNBOOTED or XLINK_BOOTLOADER state

Returns:: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

static std::tuple<bool, DeviceInfo> getDeviceById(std::string deviceId)

Finds a device by Device ID. Example: 14442C10D13EABCE00

Parameters:: deviceId – Device ID which uniquely specifies a device
Returns:: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

static std::vector<DeviceInfo> getAllAvailableDevices()

Returns all available devices

Returns:: Vector of available devices

static std::vector<DeviceInfo> getAllConnectedDevices()

Returns information of all connected devices. The devices could be both connectable as well as already connected to devices.

Returns:: Vector of connected device information

static std::vector<std::uint8_t> getEmbeddedDeviceBinary(bool usb2Mode, OpenVINO::Version version = OpenVINO::VERSION_UNIVERSAL)

Gets device firmware binary for a specific OpenVINO version

Parameters:

usb2Mode – USB2 mode firmware
version – Version of OpenVINO which firmware will support

Returns:

Firmware binary

static std::vector<std::uint8_t> getEmbeddedDeviceBinary(Config config)

Gets device firmware binary for a specific configuration

Parameters:: config – FW with applied configuration
Returns:: Firmware binary

static ProfilingData getGlobalProfilingData()

Get current global accumulated profiling data

Returns:: ProfilingData from all devices

Public Static Attributes

static constexpr std::chrono::seconds DEFAULT_SEARCH_TIME = {10}: Default search time for constructors which discover devices.

static constexpr float DEFAULT_SYSTEM_INFORMATION_LOGGING_RATE_HZ = {1.0f}: Default rate at which system information is logged.

static constexpr UsbSpeed DEFAULT_USB_SPEED = {UsbSpeed::SUPER}: Default UsbSpeed for device connection.

static constexpr std::chrono::milliseconds DEFAULT_TIMESYNC_PERIOD = {5000}: Default Timesync period.

static constexpr int DEFAULT_TIMESYNC_NUM_SAMPLES = {10}: Default Timesync number of samples per sync.

static constexpr bool DEFAULT_TIMESYNC_RANDOM = {true}: Default Timesync packet interval randomness.

Protected Functions

void tryStartPipeline(const Pipeline &pipeline): a safe way to start a pipeline, which is closed if any exception occurs

virtual bool startPipelineImpl(const Pipeline &pipeline)

Allows the derived classes to handle custom setup for starting the pipeline