GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

  • Sign in
  • ActionsCI/CD and automation
  • CodespacesCloud development environments
  • All Features
  • Documentation
  • Training
  • Certifications
  • Build with Copilot
  • Customize Copilot
  • Integrations
  • Trending repos
  • GitHub Sponsors
  • Developer articles
  • Enterprises

This view

  • Original page
  • New address

GeezerVison is showing github.com — GitHub - openDAQ/openDAQ: openDAQ™ data acquisition SDK

BranchesTags
Open more actions menu

Latest commit

 

History

1,750 Commits
1,750 Commits

Folders and files

NameName
Last commit message
Last commit date
.github
.github
 
 
bindings
bindings
 
 
changelog
changelog
 
 
cmake
cmake
 
 
core
core
 
 
docs
docs
 
 
examples
examples
 
 
external
external
 
 
external_modules
external_modules
 
 
media
media
 
 
modules
modules
 
 
shared
shared
 
 
simulator
simulator
 
 
tests
tests
 
 
.clang-format
.clang-format
 
 
.editorconfig
.editorconfig
 
 
.gitattributes
.gitattributes
 
 
.gitignore
.gitignore
 
 
BUILD.md
BUILD.md
 
 
CMake-Options.md
CMake-Options.md
 
 
CMakeBasePresets.json
CMakeBasePresets.json
 
 
CMakeLists.txt
CMakeLists.txt
 
 
CMakePresets.json
CMakePresets.json
 
 
CMakeVendorPresets.json
CMakeVendorPresets.json
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 
antora-playbook-dev.yml
antora-playbook-dev.yml
 
 
antora-playbook.yml
antora-playbook.yml
 
 
opendaq_version
opendaq_version
 
 
opendaq_version_bump.py
opendaq_version_bump.py
 
 

Repository files navigation

openDAQ
SDK that bridges the gap between data acquisition devices, in an era where incompatibility is the norm


openDAQ is a software development kit that allows for easy integration of data acquisition devices into its ecosystem. It provides a simple generic API that allows users to connect to Data Acquisition (DAQ) devices that are compliant with openDAQ and any of its supported open standards. With the SDK, users can configure properties of devices and read their measurement data. It also contains a framework for developing custom signal processing blocks that process and analyse signal data. In a world where DAQ devices do not readily communicate, openDAQ provides a common language for all to speak while also embracing existing standards such as MQTT and XCP via Ethernet.

Features

  • Simple connection to openDAQ-enabled devices, allowing for property visualization/configuration and data streaming.
  • Simple integration of existing data acquisition devices into the openDAQ ecosystem.
  • SDK that runs the same code on both the device (server) and application (client).
  • Signal processing framework that allows for implementation of custom data processing blocks that run on any SDK instance (device or application).
  • OPC UA for structure/property transfer, WebSocket streaming for data.
  • API built of C++ pure abstract classes that can be passed across shared library boundaries regardless of compiler and platform used.
  • C++ pointer wrappers that allow for C++ features to be used in conjunction with the openDAQ pure abstract classes.
  • Wrappers for Python and Delphi (C# in development).

Getting started

  • Downloads →
  • User documentation →
  • API documentation (Doxgen) →

Documentation

The Doxygen documentation can be built by enabling the OPENDAQ_BUILD_DOCUMENTATION cmake flag. The user guide documentation can be built with Antora by following the guide found in docs/Antora/README.md.

Building openDAQ

Supported compilers and platforms:

OS Platform GCC 7+ Clang 9+ MSVC 14.20+ Intel 2025+
Windows
(Visual Studio)
x86, x64 / ✅ ✅ ✅
arm64 ⚠️🛠️ ⚠️🛠️ /
Windows
(MinGW)
x86, x64 ☑️ ☑️ /
Linux x86, x64 ✅ ✅ ☑️
armhfv7, aarch64 ☑️ ☑️ /
MacOS
(>= 10.15)
x64 ☑️ ✅
arm64 ☑️ ☑️
iOS arm64 🛠️ 🛠️
Android aarch64 🛠️ 🛠️
✅ Actively supported (checked with CI)
☑️ Actively supported (no CI)
⚠️ Not actively supported
🛠️ Requires some manual changes or special configuration

Required tools before building

  • CMake 3.24 or higher: https://cmake.org/ (might come with development environment like Visual Studio)
  • Git: https://git-scm.com/
  • Compiler:
    • (msvc) Visual Studio 2017 or higher with installed Workload for C++
    • (gcc windows) MSYS2: http://www.msys2.org, https://github.com/msys2/msys2/wiki/MSYS2-installation
    • (gcc) Ninja build system: https://ninja-build.org/
    • Python3: https://www.python.org/downloads/
  • (optional) Boost C++ Library: https://sourceforge.net/projects/boost/files/boost-binaries/ , http://theboostcpplibraries.com
    • If installed, set CMake option OPENDAQ_ALWAYS_FETCH_BOOST=OFF to allow the SDK to use it.
    • See also document BUILD.md.

Building on Windows

1. Install all required tools / packages.

See Required tools before building above.

2. Clone openDAQ repo.

git clone [email protected]:openDAQ/openDAQ.git
cd openDAQ

3. Generate CMake project for specific compiler / preset.

In the repository root folder execute the following command to list available presets then select the one that fits you and generate CMake project:

cmake --list-presets=all
cmake --preset "x64/msvc-22/full"

ℹ️ If for any reason there is no preset for your compiler (version) you can list the "CMake generators" and specify one to override the closest preset (e.g. to use Visual Studio 2019):

cmake -G
cmake --preset "x64/msvc-17/full" -G "Visual Studio 16 2019"

4. Build the project

Open and build build/x64/msvc-22/full/openDAQ.sln using Visual Studio (if one msvc preset had been used above).

Or use command line:

# build from repository root
cmake --build build/x64/msvc-22/full
# or move to build directory
cd build/x64/msvc-22/full
cmake --build .

For compilers other than msvc, one can add parameter -j 4 to the build command to specify the number of parallel builds (see cmake.org: Build a Project with CMake).

Building on Linux

1. Install all required tools / packages.

For example in Ubuntu

sudo apt-get update
sudo apt-get install -y git build-essential lld cmake ninja-build mono-complete python3

2. Clone openDAQ repo.

git clone [email protected]:openDAQ/openDAQ.git
cd openDAQ

3. Generate CMake project for specific compiler / preset.

In the repository root folder execute the following command to list available presets then select the one that fits you and generate CMake project:

cmake --list-presets=all
cmake --preset "x64/gcc/full/debug"

4. Build the project.

# build from repository root
cmake --build build/x64/gcc/full/debug
# or move to build directory
cd build/x64/gcc/full/debug
cmake --build .

Additional building info

More information about advanced building options can be found in BUILD.md document.

About

openDAQ™ data acquisition SDK

opendaq.com

Topics

data-acquisitionmodule-systemruntimesdk

Resources

Readme
Apache-2.0 license
Activity
Custom properties

Stars

89 stars

Watchers

13 watching

Forks

46 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.