Veethree D7 SDK
Loading...
Searching...
No Matches
Qt Bluetooth examples

All Bluetooth examples use Qt Bluetooth

QML Bluetooth Application

QML Bluetooth app provides basic bluetooth functionality of scanning for available devices and pairing with them. Key functionality includes:

  • Powering on bluetooth if powered off
  • Scan available devices
  • Pair and connect
  • Set discoverable on to accept remote connections

Dependencies

  • Qt 6.10.2 - Requires QtQuick, QBluetooth and QDbus

Usage

Build and deploy the app to the D7.

If the D7's bluetooth is powered off, slide the switch indicator to power on. Once powered on, bluetooth cannot be powered off by this app.

If you want to initiate a pairing request to a remote device such as your phone, click on the 'Scan' button and wait for your device to show up. Make sure the remote device is discoverable in device Bluetooth settings before scanning. If pairing with another D7, click on the 'Make discoverable' button.

Once your remote device shows up, click on the 'Pair' button next to it. This will show a 6 digit (0 padded) confirmation code on the D7 and your remote device. Confirm with "Yes" if the code matches on both devices. If the pairing was completed successfully, the button text changes to 'Unpair'.

If you want to initiate a pairing request to the D7 from your phone or any other device, put the D7 in discoverable mode by clicking on the button 'Make discoverable' and run a scan on your remote device. When the D7 is shown on the 'Available Devices' list, click on it to initiate a pairing request. The same 6 digit confirmation popup will be shown. Confirm if correct or deny.

Note: The application can run on windows and linux hosts but may not be fully functional. This app only supports pairing requests from devices that use a numeric comparison pairing. Extend this app to support other pairing methods.

Using D-Bus for authorized pairing requests

Qt's Bluetooth API supports sending authorized pairing requests through QBluetoothLocalDevice::requestPairing method. However, there are no supported methods to display, confirm and request user to enter passkeys or pin codes. This app handles authorized pairing by creating a BlueZ D-Bus pairing agent. The registered pairing agent handles authorized requests and completes secure pairing. The agent in this app implements only numeric comparison pairing; other methods are unimplemented.

main.cpp has a init_agent_manager method, which registers an agent object as a default agent on org.bluez.AgentManager1 to handle pairing requests. This agent object declared in agent.h must provide all methods of org.BlueZ.Agent interface. The agent class is based on bluez.git simple-agent test. All pairing requests made to the D7 will be handled by this agent while this app is running.

The example code below highlights the main Bluetooth manager class and BlueZ agent object. Please refer to the full example in ~/d7-sdk/examples/gui/qml-bluetooth.

BluetoothManager
#ifndef BLUETOOTH_MANAGER_H
#define BLUETOOTH_MANAGER_H
#include "remote_devices.h"
#include <QBluetoothAddress>
#include <QBluetoothDeviceDiscoveryAgent>
#include <QBluetoothDeviceInfo>
#include <QBluetoothHostInfo>
#include <QBluetoothLocalDevice>
#include <QObject>
class BluetoothManager : public QObject
{
Q_OBJECT
Q_PROPERTY(QString name READ name CONSTANT)
Q_PROPERTY(QString address READ address CONSTANT)
Q_PROPERTY(bool powered READ powered NOTIFY poweredChanged)
Q_PROPERTY(bool scanning READ scanning NOTIFY scanningChanged)
Q_PROPERTY(bool discoverable READ discoverable NOTIFY discoverableChanged)
// Convert QList<QBluetoothDeviceInfo> to QAbstractListModel to be usable in QML
Q_PROPERTY(RemoteDevices *remoteDevices READ remoteDevices NOTIFY remoteDevicesChanged)
QML_ELEMENT
public:
explicit BluetoothManager(QObject *parent = nullptr);
QString name() const { return _name; };
QString address() const { return _address; }
bool powered() const { return _powered; }
bool scanning() const { return _discovery_agent.isActive(); }
bool discoverable() const
{
return _device.hostMode() == QBluetoothLocalDevice::HostDiscoverable;
}
RemoteDevices *remoteDevices() { return &_remote_devices; }
public slots:
void powerOn();
void startDiscovery();
void stopDiscovery();
void requestPairing(const QString &address, bool pairing);
void setDiscoverable();
void remotePairingRequestComplete(const QString &address, bool paired);
signals:
void poweredChanged(bool powered);
void scanningChanged(bool scanning);
void discoverableChanged(bool discoverable);
void remoteDevicesChanged();
private:
QList<QBluetoothHostInfo> _local_adapter;
QBluetoothLocalDevice _device;
QBluetoothDeviceDiscoveryAgent _discovery_agent;
QString _name;
QString _address;
bool _powered;
RemoteDevices _remote_devices;
void updateHostState();
void devicesDiscoveryComplete(const QBluetoothDeviceInfo &info);
void devicesDiscoveryFinished();
void devicesDiscoveryUpdate(const QBluetoothDeviceInfo &info,
QBluetoothDeviceInfo::Fields updated_fields);
void printDiscoveryErrors(QBluetoothDeviceDiscoveryAgent::Error error);
void onPairingFinished(const QBluetoothAddress &address, QBluetoothLocalDevice::Pairing pairing);
};
#endif // BLUETOOTH_MANAGER_H
Agent
#ifndef AGENT_H
#define AGENT_H
#include <qbluetoothaddress.h>
#include <unistd.h>
#include <QtCore/QCoreApplication>
#include <QtDBus/QtDBus>
class Agent : public QObject
{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.bluez.Agent1")
signals:
void getPasskeyConfirmation(const QString &device, quint32 passkey, const QString &device_name);
void canceled();
void pairingFinished(const QString &address, bool paired);
public:
explicit Agent(QObject *parent = nullptr)
: QObject(parent)
{}
Q_INVOKABLE void processPasskeyConfirmation(const QString &device_path, bool response);
public slots:
static void Release() { qDebug() << "Pairing agent released."; }
void Cancel(const QDBusMessage &message);
void RequestConfirmation(const QDBusObjectPath &device,
quint32 passkey,
const QDBusMessage &message);
static void AuthorizeService(const QDBusObjectPath &device,
const QString &uuid,
const QDBusMessage &message);
// These methods are not supported by this app
static void RequestPinCode(const QDBusObjectPath &device, const QDBusMessage &message);
static void DisplayPinCode(const QDBusObjectPath &device,
uint &pincode,
const QDBusMessage &message)
{}
static void RequestPasskey(const QDBusObjectPath &device, const QDBusMessage &message);
static void DisplayPasskey(const QDBusObjectPath &device,
double &passkey,
double &entered,
const QDBusMessage &message)
{}
static void RequestAuthorization(const QDBusObjectPath &device, const QDBusMessage &message);
private:
// Use this to store delayed replies to the caller until user responds from UI
QMap<QString, QDBusMessage> _pending;
static QString getDeviceName(const QString &device_path);
static QString getDeviceAddress(const QString &device_path);
static bool getPairingStatus(const QString &device_path);
static void setDeviceTrusted(const QString &device_path);
};
#endif //AGENT_H
main.cpp
#include "agent.h"
#include <csignal>
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
namespace {
void stop(int signal)
{
if (signal == SIGTERM || signal == SIGINT) {
QCoreApplication::quit();
}
}
void init_agent_manager(Agent &agent)
{
QDBusConnection bus = QDBusConnection::systemBus();
if (!bus.isConnected()) {
qCritical("Cannot connect to the D-Bus system bus");
}
const QString agent_path = "/d7/qt_bt_example/agent";
if (!bus.registerObject(agent_path, &agent, QDBusConnection::ExportAllSlots)) {
qCritical("Failed to register D-Bus object");
}
QDBusInterface manager("org.bluez", "/org/bluez", "org.bluez.AgentManager1", bus);
if (!manager.isValid()) {
qCritical("Failed to connect to AgentManager");
}
// Register agent with default capability KEYBOARD_DISPLAY
QDBusReply<void> reply = manager.call("RegisterAgent", QDBusObjectPath(agent_path), "");
if (!reply.isValid()) {
qCritical() << "Failed to register agent:" << reply.error().message();
}
// Requests to make the application agent the default agent.
reply = manager.call("RequestDefaultAgent", QDBusObjectPath(agent_path));
if (!reply.isValid()) {
qCritical() << "Failed to register agent:" << reply.error().message();
}
}
} // namespace
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
// QBluetooth does not support authorised pairing used by the D7
Agent agent;
// Connect to BlueZ DBus AgentManager and handle pairing with passkeys and PIN
#ifdef __linux__
init_agent_manager(agent);
#endif
QQmlApplicationEngine engine;
engine.rootContext()->setContextProperty("pairing_agent", &agent);
QObject::connect(
&engine,
&QQmlApplicationEngine::objectCreationFailed,
&app,
[]() { QCoreApplication::exit(-1); },
Qt::QueuedConnection);
engine.loadFromModule("vsdk.bluetooth", "Main");
// Handle signals for clean termination
std::signal(SIGINT, stop);
std::signal(SIGTERM, stop);
return app.exec();
}

QML Bluetooth Chat App

This example shows communication with remote devices over RFCOMM using the Serial Port Profile (SPP). This example lets you exchange messages with multiple devices (other D7(s) running the same example or a PC with Bluetooth support) or directly with a phone. It is based on the official Qt Bluetooth Chat example.

Dependencies

  • Qt 6.10.2 - Requires QtQuick, QBluetooth

Application Modes

This application can operate in two modes: server and client:

  • Server Mode: The server device listens for incoming Bluetooth connections and can handle multiple clients simultaneously.
  • Client Mode: A client device initiates a connection to the server. Clients cannot accept incoming connections.

Run instructions

Before building and running this app, make sure your remote devices are paired with the D7 using QML Bluetooth Application.

Build and deploy this app to all the devices you want to connect. Run the app as a server on one designated device. All other devices should run the app in client mode to connect to this server. To set the mode of the app, pass 'server' or 'client' as a command line argument as

./qml-bluetooth-chat-app server

OR

./qml-bluetooth-chat-app client

From Qt Creator, add the command line argument in Projects > Build & Run > {YOUR-KIT} > Run Settings > Run

Usage

General app usage

  1. From the client app, click on the 'Scan services' button to find all matching services on the server.
  2. Click on the remote device name running the server app in the popup screen and click on the 'Connect' button.
  3. Once connected, the chat window shows an appropriate message on both the server and client apps.
  4. To exchange messages, click on the text input field at the bottom of the screen to open the virtual keyboard, type in your message, and hit 'Send'.

Connecting to a phone

To connect to your phone, download the 'Bluetooth Serial Terminal' app. The D7 cannot initiate a connection to the phone because most mobile devices do not advertise a Bluetooth Serial Port Profile service by default and cannot accept incoming requests from the D7. Therefore, the D7 must act as the server, and the phone (running the terminal app) must connect as the client.

  1. From the 'Bluetooth Serial Terminal' app on your phone, click on the hamburger menu and open the 'Devices' tab.
  2. If the server D7 is paired, it will appear under the 'Bluetooth Classic' tab.
  3. Click on the device to initiate a connection.
  4. Once successful, both the D7 and the phone will indicate the connection.

Note: The application can run on windows and linux hosts but may not be fully functional.

The example code below highlights common Bluetooth manager class that manages both server and clients. Please refer to the full example in ~/d7-sdk/examples/gui/qml-bluetooth-chat.

Chat Manager
// Chat serves as a common manager to both server and client
#ifndef CHAT_H
#define CHAT_H
#include "chat_client.h"
#include "chat_server.h"
#include "messages.h"
#include "remote_selector.h"
#include <QBluetoothHostInfo>
#include <QBluetoothLocalDevice>
#include <QObject>
class Chat : public QObject {
Q_OBJECT
Q_PROPERTY(QString localName READ localName CONSTANT)
Q_PROPERTY(Messages *messages READ messages NOTIFY newMessage FINAL)
Q_PROPERTY(RemoteSelector *remoteSelector READ remoteSelector CONSTANT FINAL)
public:
explicit Chat(bool is_server, QObject *parent = nullptr);
~Chat() override;
QString localName() { return _local_name; }
Messages *messages() { return &_messages; };
RemoteSelector *remoteSelector() const { return _remote_selector; };
public slots:
void scanServices();
void sendMessage(const QString &message);
void connectToServer(const QString &service_name);
void cancelScan();
signals:
void sendSocketMessage(const QString &message);
void newMessage();
private slots:
void showMessage(const QString &sender, const QString &message);
void clientConnected(const QString &name);
void clientDisconnected(const QString &name);
void clientDisconnected();
void connected(const QString &name);
void reactOnSocketError(const QString &error);
private:
Messages _messages;
RemoteSelector *_remote_selector = nullptr;
ChatServer *_server = nullptr;
QList<ChatClient *> _clients;
QList<QBluetoothHostInfo> _local_adapter;
QBluetoothLocalDevice _device;
QString _local_name;
};
#endif // CHAT_H
Server
#ifndef CHAT_SERVER_H
#define CHAT_SERVER_H
#include <QBluetoothAddress>
#include <QBluetoothServer>
#include <QBluetoothServiceInfo>
#include <QBluetoothSocket>
#include <QObject>
class ChatServer : public QObject {
Q_OBJECT
public:
explicit ChatServer(QObject *parent = nullptr);
~ChatServer() override;
void startServer(const QBluetoothAddress &local_adapter = QBluetoothAddress(),
const QString &uuid = "");
void stopServer();
public slots:
void sendMessage(const QString &message);
signals:
void messageReceived(const QString &sender, const QString &message);
void clientConnected(const QString &name);
void clientDisconnected(const QString &name);
private slots:
void clientConnected();
void clientDisconnected();
void readSocket();
private:
QBluetoothServer *_server = nullptr;
QBluetoothServiceInfo _service_record;
QList<QBluetoothSocket *> _clients;
QMap<QBluetoothSocket *, QString> _client_info;
};
#endif // CHAT_SERVER_H
Client
#ifndef CHAT_CLIENT_H
#define CHAT_CLIENT_H
#include <QObject>
#include <QBluetoothServiceInfo>
#include <QBluetoothSocket>
class ChatClient : public QObject {
Q_OBJECT
public:
explicit ChatClient(QObject *parent = nullptr);
~ChatClient() override;
void startClient(const QBluetoothServiceInfo &remote_service);
void stopClient();
public slots:
void sendMessage(const QString &message);
signals:
void messageReceived(const QString &sender, const QString &message);
void connected(const QString &name);
void disconnected();
void socketErrorOccurred(const QString &error_string);
private slots:
void readSocket();
void connected();
void onSocketErrorOccurred(QBluetoothSocket::SocketError);
private:
QBluetoothSocket *_socket = nullptr;
};
#endif // CHAT_CLIENT_H

Qt Bluetooth Low Energy (BLE) Server example

Qt Bluetooth Low Energy Server example shows setting up a Generic Attribute Profile (GATT) server that reads analog pin 0 every 3 seconds and sends updates via Bluetooth Low Energy as a GATT Profile Service to a device connected to the D7. This example is based on Qt Bluetooth Low Energy Heart Rate Server. This example demonstrates:

  • Setting up advertising and service UUIDs
  • Advertising analog pin 0 readings as service data

Usage

Run the QML Bluetooth Application and pair your phone with the D7

Download the nRF Connect app on your phone (or any app that supports BLE)

To enable advertising on the D7, open a shell to the D7 and run:

bluetoothctl advertise on

Build and deploy this app to D7

Open the nRf connect app, open the 'Scanner' tab and run 'Scan'. Once the advertiser 'D7-IO' appears click the 'Connect' button next to it. This will open a new 'Client' tab

The 'Client' tab should show an 'Unknown Service' with UUID '21be26a3-be26-4795-9884-e5580a5272c7'. Click to expand and explore

Under this service an unknown characteristic with UUID '29081a08-0c73-465c-93d0-508ebdc9975b' and property 'NOTIFY' should be present. Click the 3 downward arrows next to it to subscribe to these notifications and receive live pin readings.

Note: The application can run on windows and linux hosts but may not be fully functional as bluetooth modules on host machines generally do not support BLE peripheral roles.

main.cpp
// This app demonstrates setting up and advertise a GATT service using Qt Bluetooth Low Energy API
// This example is based on Qt Bluetooth Low Energy Heart Rate Server
#include <libio/analog.h>
#include <QCoreApplication>
#include <QLowEnergyAdvertisingData>
#include <QLowEnergyAdvertisingParameters>
#include <QLowEnergyCharacteristic>
#include <QLowEnergyCharacteristicData>
#include <QLowEnergyController>
#include <QLowEnergyDescriptorData>
#include <QLowEnergyService>
#include <QLowEnergyServiceData>
#include <QTimer>
#if QT_CONFIG(permissions)
#include <QPermissions>
#endif
namespace {
using namespace vsdk::io;
QByteArray read_sensor_value(analog::analog *analog_instance, int8_t pin_handle)
{
QByteArray data;
try {
const auto reading = analog_instance->read_from(pin_handle);
if (reading.status != io_status::ok) {
throw std::runtime_error(fmt::format("status {} with error {}",
static_cast<uint8_t>(reading.status),
to_string(reading.status)));
} else {
qDebug() << "Reading on pin 0: " << reading.value;
data = QByteArray::number(reading.value);
}
} catch (const std::exception &exception) {
qDebug() << fmt::format("Failed to read from pin {}: {}", pin_handle, exception.what());
}
return data;
}
analog::analog *init_analog_sensor(const std::string &sns_name, analog::pin_t pin)
{
profile_builder builder{};
if (!builder.add_one_wire_resistive_sensor(sns_name, pin)) {
qDebug() << fmt::format("Failed to add sensor '{}'", "vrsns_0");
}
auto profile = builder.to_profile();
analog->init(profile);
return analog;
}
qint8 resolve_bluetooth_permissions(QCoreApplication &app)
{
qDebug() << "Resolving Bluetooth Permissions";
auto permission_status = app.checkPermission(QBluetoothPermission{});
// Request if not available
if (permission_status == Qt::PermissionStatus::Undetermined) {
qInfo("Requesting Bluetooth permission ...");
app.requestPermission(QBluetoothPermission{},
[&permission_status](const QPermission &permission) {
qApp->exit();
permission_status = permission.status();
});
// Now, wait for permission request to resolve.
app.exec();
}
// Quit if denied
if (permission_status == Qt::PermissionStatus::Denied) {
// Either explicitly denied, or Bluetooth is off.
qWarning("This application cannot use Bluetooth, the permission was denied");
return 1;
}
qDebug() << "Bluetooth Permitted";
return 0;
}
QLowEnergyAdvertisingData create_advertising_data(const QString &service_uuid,
const QString &advertiser_name)
{
QLowEnergyAdvertisingData advertising_data;
advertising_data.setDiscoverability(QLowEnergyAdvertisingData::DiscoverabilityGeneral);
advertising_data.setLocalName(advertiser_name);
advertising_data.setServices(QList<QBluetoothUuid>() << QBluetoothUuid(QUuid(service_uuid)));
// Advertise other data like manufacturer data
advertising_data.manufacturerData();
return advertising_data;
}
QLowEnergyServiceData create_service_data(const QString &service_uuid)
{
QLowEnergyServiceData service_data;
service_data.setType(QLowEnergyServiceData::ServiceTypePrimary);
service_data.setUuid(QBluetoothUuid(QUuid(service_uuid)));
return service_data;
}
QLowEnergyCharacteristicData create_characteristic(const QString &char_uuid,
const QByteArray &descriptor)
{
QLowEnergyCharacteristicData characteristic;
characteristic.setUuid(QBluetoothUuid(QUuid(char_uuid)));
// Initial value is 0- this is later updated with actual reading
characteristic.setValue(QByteArray(2, 0));
characteristic.setProperties(
QLowEnergyCharacteristic::Notify); // Characteristic of type notify causes notifications
// Add characteristic data descriptor
const QLowEnergyDescriptorData
description(QBluetoothUuid::DescriptorType::CharacteristicUserDescription,
QByteArray(descriptor) // human-readable string
);
characteristic.addDescriptor(description);
return characteristic;
}
void print_error(QLowEnergyController *controller,
QLowEnergyController::Error error_code,
bool &error)
{
qWarning().noquote().nospace() << error_code << " occurred: " << controller->errorString();
if (error_code != QLowEnergyController::RemoteHostClosedError) {
qWarning("Server exiting due to error");
error = true;
}
}
} // namespace
int main(int argc, char *argv[])
{
// Timer to send updates every 3s
const auto update_timer_duration = 3000;
// UUIDs for IO readings generated from linux command `uuidgen`
const QString service_uuid = "21be26a3-be26-4795-9884-e5580a5272c7"; // service uuid
const QString char_pin0_uuid = "29081a08-0c73-465c-93d0-508ebdc9975b"; // characteristic uuid
// Set up analog sensor to read pin 0
constexpr auto sns_name = "vrsns_0";
auto *analog = init_analog_sensor(sns_name, analog::pin_t::vrsns0);
auto rsns_handle = analog->get_handle(sns_name);
assert(rsns_handle != -1);
QCoreApplication app(argc, argv);
// Resolve bluetooth permissions for this app. This function checks if this app can use bluetooth, requests if not and quits if denied
#if QT_CONFIG(permissions)
auto error_code = resolve_bluetooth_permissions(app);
if (error_code != 0) {
return 1;
}
#endif
// Set up advertising data with service uuid and name-
// This indicates what services the D7 offers- i.e analog pin readings
qDebug() << "Creating advertising data";
auto advertising_data = create_advertising_data(service_uuid, "D7-IO");
// Set up the service that was advertised
qDebug() << "Creating service data";
auto service_data = create_service_data(service_uuid);
// Create characteristic data with a human readable descriptor for analog pin 0- Change or add more characteristics
qDebug() << "Creating characteristic data";
auto char_pin0 = create_characteristic(char_pin0_uuid, "Analog Pin 0");
// Add all characteristics to the service
service_data.addCharacteristic(char_pin0);
bool error = false;
// Create QLowEnergyController peripheral and connect to error handler
const std::unique_ptr<QLowEnergyController> controller(QLowEnergyController::createPeripheral());
auto error_handler = [&controller, &error](QLowEnergyController::Error error_code) {
print_error(controller.get(), error_code, error);
};
QObject::connect(controller.get(), &QLowEnergyController::errorOccurred, error_handler);
// Add created service data and start advertising the service for clients to establish a connection
std::unique_ptr<QLowEnergyService> service(controller->addService(service_data));
controller->startAdvertising(QLowEnergyAdvertisingParameters(),
advertising_data,
advertising_data);
// Create timer to update characteristic
QTimer update_timer;
qDebug() << "Starting advertising...";
// Lambda function to read and update characteristic
const auto update_io_data = [&service, &char_pin0_uuid, &analog, &rsns_handle]() {
// read sensor value
auto value = read_sensor_value(analog, rsns_handle);
const QLowEnergyCharacteristic characteristic = service->characteristic(
QBluetoothUuid(QUuid(char_pin0_uuid)));
Q_ASSERT(characteristic.isValid());
// write the update
service->writeCharacteristic(characteristic, value);
};
QObject::connect(&update_timer, &QTimer::timeout, update_io_data);
// Start timer
update_timer.start(update_timer_duration);
if (error)
return 1;
return app.exec();
}
The analog interface.
This object represents a set of user specified analog sensors that are connected to the NAFE.
Definition analog.h:60
analog_result read_from(int8_t handle)
Read a sensor value.
static analog * instance()
Get a pointer to the singleton instance.
This is used to provide a valid profile for the analog class.
Definition profile_builder.h:41
bool add_one_wire_resistive_sensor(std::string label, analog::pin_t positive_a)
Add a one wire resistive sensor.
analog::analog_profile to_profile()
Export the profile.
pin_t
Pin designations.
Definition analog_common.h:169
@ analog
Analog module.
Definition log.h:38
Any entities that belong to the IO library.
constexpr const char * to_string(io_status status)
Definition io_common.h:82
@ ok
Operation successful.
Definition io_common.h:19
@ error
Generic error.
Definition io_common.h:21
The profile builder interface.
CMakeLists.txt
cmake_minimum_required(VERSION 3.19)
project(qt-ble-server LANGUAGES CXX)
# Project name
set(APPNAME qt-ble-server)
find_package(Qt6 REQUIRED COMPONENTS Core Bluetooth)
find_package(vsdk REQUIRED CONFIG COMPONENTS libio)
qt_standard_project_setup()
qt_add_executable(${APPNAME}
main.cpp
)
target_link_libraries(${APPNAME}
PRIVATE
Qt6::Core
Qt6::Bluetooth
vsdk::libio
)
include(GNUInstallDirs)
install(TARGETS ${APPNAME}
BUNDLE DESTINATION .
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
)
Any entities that belong to the Veethree SDK libraries.
Definition can_adapter.h:11