microstrain-daq-utils 0.9.0b0__tar.gz

microstrain_daq_utils-0.9.0b0/.gitignore

@@ -0,0 +1,216 @@
+# C# build outputs
+bin/
+obj/
+packages/
+
+# Track the modules directory but ignore its contents
+/modules/*
+!/modules/.gitkeep
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

microstrain_daq_utils-0.9.0b0/MicroStrain.DaqUtils.sln

@@ -0,0 +1,27 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "daq_utils", "daq_utils", "{41A744D0-4583-46C4-8882-656F23A92F44}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DaqUtils", "daq_utils\csharp\DaqUtils.csproj", "{DC7F027B-896B-4428-8C2B-BEDE60E4CD96}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{DC7F027B-896B-4428-8C2B-BEDE60E4CD96}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DC7F027B-896B-4428-8C2B-BEDE60E4CD96}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DC7F027B-896B-4428-8C2B-BEDE60E4CD96}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DC7F027B-896B-4428-8C2B-BEDE60E4CD96}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{DC7F027B-896B-4428-8C2B-BEDE60E4CD96} = {41A744D0-4583-46C4-8882-656F23A92F44}
+	EndGlobalSection
+EndGlobal

microstrain_daq_utils-0.9.0b0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: microstrain-daq-utils
+Version: 0.9.0b0
+Summary: An opinionated library that enhances working with openDAQ modules from MicroStrain by HBK.
+Maintainer-email: MicroStrain by HBK <microstrainsupport@hbkworld.com>
+Requires-Python: >=3.9
+Requires-Dist: opendaq==3.30.3
+Provides-Extra: jupyter
+Requires-Dist: microstrain-daq-jupyter; extra == 'jupyter'

microstrain_daq_utils-0.9.0b0/daq_utils/cpp/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.20)
+
+include(cmake/git_version.cmake)
+get_project_version_from_git_tag("v" REPO_FULL_VERSION REPO_NUMERIC_VERSION)
+
+project(MicroStrainDaqUtils VERSION ${REPO_NUMERIC_VERSION})
+set(PROJECT_VERSION ${REPO_FULL_VERSION})
+
+find_package(openDAQ 3.30.3 EXACT QUIET)
+if(NOT openDAQ_FOUND)
+    include(FetchContent)
+    FetchContent_Declare(
+        openDAQ
+        GIT_REPOSITORY https://github.com/openDAQ/openDAQ.git
+        GIT_TAG        v3.30.3
+    )
+    set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
+    set(OPENDAQ_ENABLE_TESTS OFF CACHE BOOL "" FORCE)
+    set(OPENDAQ_ENABLE_EXAMPLES OFF CACHE BOOL "" FORCE)
+    set(OPENDAQ_ENABLE_SIMULATOR OFF CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(openDAQ)
+endif()
+
+add_library(microstrain_daq_utils
+    src/daq_utils.cpp
+    src/wireless.cpp
+)
+add_library(microstrain::daq_utils ALIAS microstrain_daq_utils)
+
+target_include_directories(microstrain_daq_utils PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(microstrain_daq_utils PRIVATE daq::opendaq)
+target_compile_features(microstrain_daq_utils PUBLIC cxx_std_17)
+
+if(MSVC)
+    target_compile_options(microstrain_daq_utils PRIVATE /MP)
+endif()

microstrain_daq_utils-0.9.0b0/daq_utils/cpp/cmake/git_version.cmake

@@ -0,0 +1,32 @@
+# Extracts the version for a project from the latest git tag.
+#
+# Arguments:
+#     PROJECT_PREFIX - The project prefix in the git tag ("v" in "v1.2.3").
+#
+# Returns:
+#        FULL_VERSION_OUT: The extracted full version string (ex: "1.2.3-beta").
+#     NUMERIC_VERSION_OUT: The extracted numeric version string (ex: "1.2.3").
+#
+function(get_project_version_from_git_tag PROJECT_PREFIX FULL_VERSION_OUT NUMERIC_VERSION_OUT)
+    execute_process(
+        COMMAND git describe --tags --match "${PROJECT_PREFIX}*" --dirty
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_TAG
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    if(GIT_TAG)
+        # Extract full version (e.g., "v1.2.3-alpha" -> "1.2.3-alpha")
+        string(REGEX REPLACE "^${PROJECT_PREFIX}" "" FULL_VERSION_STRING ${GIT_TAG})
+
+        # Extract just numeric version for CMake project() (ex: "1.2.3-alpha" -> "1.2.3")
+        string(REGEX REPLACE "^([0-9]+\\.[0-9]+\\.[0-9]+).*" "\\1" NUMERIC_VERSION_STRING "${FULL_VERSION_STRING}")
+
+        set(${NUMERIC_VERSION_OUT} ${NUMERIC_VERSION_STRING} PARENT_SCOPE)
+        set(${FULL_VERSION_OUT} ${FULL_VERSION_STRING} PARENT_SCOPE)
+    else()
+        message(WARNING "No git tag found matching '${PROJECT_PREFIX}*', using 0.0.0 as a fallback.")
+        set(${NUMERIC_VERSION_OUT} "0.0.0" PARENT_SCOPE)
+        set(${FULL_VERSION_OUT} "0.0.0" PARENT_SCOPE)
+    endif()
+endfunction()

microstrain_daq_utils-0.9.0b0/daq_utils/cpp/include/daq_utils/daq_utils.h

@@ -0,0 +1,146 @@
+#pragma once
+
+#include <initializer_list>
+#include <iosfwd>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <coreobjects/property_object_ptr.h>
+#include <coretypes/enumeration_ptr.h>
+#include <coretypes/struct_ptr.h>
+#include <coretypes/type_manager_ptr.h>
+#include <opendaq/instance_ptr.h>
+
+namespace daq_utils {
+
+struct PropertyInfo {
+    std::string group;
+    std::string name;
+    std::string type;
+};
+
+/// @brief Creates openDAQ typed values (enumerations, structs) without requiring an explicit
+/// type manager or string wrapping.
+///
+/// @example
+///   DaqTypeFactory factory(instance);
+///   daq::EnumerationPtr voltage = factory.MakeEnum("MSCL_Wireless_Voltage", "voltage_3000mV");
+class DaqTypeFactory
+{
+public:
+    /// @param instance The openDAQ instance to retrieve the type manager from.
+    explicit DaqTypeFactory(daq::InstancePtr instance);
+
+    /// @brief Creates an openDAQ Enumeration value.
+    /// @param typeName The registered enum type name.
+    /// @param valueName The enum value name.
+    /// @return The created Enumeration.
+    ///
+    /// @example
+    ///   daq::EnumerationPtr voltage = factory.MakeEnum("MSCL_Wireless_Voltage", "voltage_3000mV");
+    daq::EnumerationPtr MakeEnum(const std::string& typeName, const std::string& valueName);
+
+    /// @brief Creates an openDAQ Struct value.
+    /// @param typeName The registered struct type name.
+    /// @param fields Field name-value pairs. Values must be openDAQ types
+    ///   (Integer(), Float(), Boolean(), Enumeration(), etc.).
+    /// @return The created Struct.
+    ///
+    /// @example
+    ///   daq::StructPtr eq = factory.MakeStruct("MSCL_Wireless_LinearEquation",
+    ///       {{"Slope", daq::Float(1.0)}, {"Offset", daq::Float(0.0)}});
+    daq::StructPtr MakeStruct(
+        const std::string& typeName,
+        std::initializer_list<std::pair<std::string, daq::BaseObjectPtr>> fields);
+
+private:
+    daq::TypeManagerPtr typeManager_;
+};
+
+/// @brief Inspects openDAQ registered types without requiring an explicit instance argument
+/// on each call.
+///
+/// @example
+///   DaqTypeInspector inspector(instance);
+///   inspector.Describe("MSCL_Wireless_ShuntCalCmdInfo");
+///   inspector.Describe("MSCL_Wireless_Voltage");
+class DaqTypeInspector
+{
+public:
+    /// @param instance The openDAQ instance to retrieve the type manager from.
+    explicit DaqTypeInspector(daq::InstancePtr instance);
+
+    /// @brief Prints the fields and values for a registered enum or struct type to stdout.
+    /// @param typeName The full registered type name.
+    void Describe(const std::string& typeName);
+
+    /// @brief Prints the fields and values for a registered enum or struct type to the given stream.
+    /// @param typeName The full registered type name.
+    /// @param out The output stream to write to.
+    void Describe(const std::string& typeName, std::ostream& out);
+
+private:
+    daq::TypeManagerPtr typeManager_;
+};
+
+/// @brief Returns the full dot-notation path of a property or group given its name.
+/// @param root The openDAQ object to search.
+/// @param name The property or group name to find.
+/// @return The dot-notation path, or "Not found" if no match exists.
+///
+/// @example
+///   std::string path = Find(channel, "LostBeaconTimeout");
+///   // => "Setup.Configure.Sampling.LostBeaconTimeout"
+std::string Find(daq::PropertyObjectPtr root, const std::string& name);
+
+/// @brief Returns all property groups and subgroups as dot-notation path strings.
+/// @param root The openDAQ object to query.
+/// @return A list of dot-notation group paths.
+std::vector<std::string> Groups(daq::PropertyObjectPtr root);
+
+/// @brief Prints all property groups and subgroups sorted alphabetically to stdout.
+/// @param root The openDAQ object to query.
+void PrintGroups(daq::PropertyObjectPtr root);
+
+/// @brief Prints all property groups and subgroups sorted alphabetically to the given stream.
+/// @param root The openDAQ object to query.
+/// @param out The output stream to write to.
+void PrintGroups(daq::PropertyObjectPtr root, std::ostream& out);
+
+/// @brief Returns properties as a list of PropertyInfo (group, name, type) entries.
+/// @param root The openDAQ object to query.
+/// @param group Optional dot-notation group path to filter properties.
+/// @return A list of PropertyInfo entries.
+///
+/// @example
+///   std::vector<PropertyInfo> props = Properties(channel, "Setup.Configure.Sampling");
+std::vector<PropertyInfo> Properties(daq::PropertyObjectPtr root, const std::string& group = "");
+
+/// @brief Prints properties as an aligned table sorted alphabetically by group then name to stdout.
+/// @param root The openDAQ object to query.
+/// @param group Optional dot-notation group path to filter properties.
+void PrintProperties(daq::PropertyObjectPtr root, const std::string& group = "");
+
+/// @brief Prints properties as an aligned table sorted alphabetically by group then name
+/// to the given stream.
+/// @param root The openDAQ object to query.
+/// @param group Dot-notation group path to filter properties, or empty string for all.
+/// @param out The output stream to write to.
+void PrintProperties(daq::PropertyObjectPtr root, const std::string& group, std::ostream& out);
+
+/// @brief Calls an openDAQ function property and returns its result.
+/// @param root The root openDAQ property object to start from.
+/// @param path The dot-notation path from the root to the function property.
+/// @param args Optional arguments to pass to the function.
+/// @return The result returned by the function, or an unassigned object for procedures.
+///
+/// @example
+///   daq::BaseObjectPtr result = Call(channel, "Setup.Configure.Apply");
+///   daq::BaseObjectPtr result = Call(channel, "Capabilities.ChannelType", {daq::Integer(1)});
+daq::BaseObjectPtr Call(
+    daq::PropertyObjectPtr root,
+    const std::string& path,
+    std::initializer_list<daq::BaseObjectPtr> args = {});
+
+} // namespace daq_utils

microstrain_daq_utils-0.9.0b0/daq_utils/cpp/include/daq_utils/wireless.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <iosfwd>
+
+#include <opendaq/device_ptr.h>
+
+namespace daq_utils::wireless {
+
+/// @brief Prints a table of all wireless node channels discovered by a base station device.
+/// @param baseStation The openDAQ device representing the wireless base station.
+void ListNodes(daq::DevicePtr baseStation);
+
+/// @brief Prints a table of all wireless node channels discovered by a base station device
+/// to the given stream.
+/// @param baseStation The openDAQ device representing the wireless base station.
+/// @param out The output stream to write to.
+void ListNodes(daq::DevicePtr baseStation, std::ostream& out);
+
+} // namespace daq_utils::wireless