✨ QDMI Environment Implementation

cmake/prefix_defs.txt

@@ -24,3 +24,16 @@ QDMI_Site
 QDMI_Site_impl_d
 QDMI_Operation
 QDMI_Operation_impl_d
+QDMI_TelemetrySensor
+QDMI_TelemetrySensor_impl_d
+QDMI_Device_TelemetrySensor_Query
+QDMI_Device_TelemetrySensor_Query_impl_d
+QDMI_device_session_query_telemetrysensor_property
+QDMI_device_session_create_device_telemetrysensor_query
+QDMI_device_telemetrysensor_query_set_parameter
+QDMI_device_telemetrysensor_query_submit
+QDMI_device_telemetrysensor_query_get_results
+QDMI_device_telemetrysensor_query_check_status
+QDMI_device_telemetrysensor_query_wait
+QDMI_device_telemetrysensor_query_cancel
+QDMI_device_telemetrysensor_query_free

examples/device/device.cpp

@@ -28,12 +28,16 @@
 #include <array>
 #include <cmath>
 #include <complex>
+#include <cstddef>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
+#include <ctime>
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <map>
+#include <memory>
 #include <random>
 #include <string>
 #include <unordered_map>
@@ -77,6 +81,23 @@
   std::string name;
 };
 
+struct CXX_QDMI_TelemetrySensor_impl_d {
+  std::string id;
+  std::string unit;
+  time_t sampling_rate;
+};
+
+struct CXX_QDMI_Device_TelemetrySensor_Query_impl_d {
+  std::unique_ptr<time_t> start_time = nullptr;
+  std::unique_ptr<time_t> end_time = nullptr;
+  size_t timeout = 0;
+  CXX_QDMI_TelemetrySensor telemetry_sensor = nullptr;
+  std::vector<time_t> result_timestamps;
+  std::vector<double> result_values;
+  QDMI_TelemetrySensor_Query_Status status =
+      QDMI_TELEMETRYSENSOR_QUERY_STATUS_CREATED;
+};
+
 namespace {
 /**
  * @brief Static function to maintain the device state.
@@ -159,6 +180,11 @@
 constexpr std::array<const CXX_QDMI_Site_impl_d *, 5> CXX_DEVICE_SITES = {
     &SITE0, &SITE1, &SITE2, &SITE3, &SITE4};
 
+const CXX_QDMI_TelemetrySensor_impl_d ENVSEN{"t4k", "K", 60};
+
+constexpr std::array<const CXX_QDMI_TelemetrySensor_impl_d *, 1>
+    CXX_DEVICE_TELEMETRYSENSORS{&ENVSEN};
+
 constexpr std::array<const CXX_QDMI_Site_impl_d *, 20>
     // clang-format off
     DEVICE_COUPLING_MAP = {
@@ -773,6 +799,9 @@
   ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_NEEDSCALIBRATION, size_t, 0,
                             prop, size, value, size_ret)
 
+  ADD_LIST_PROPERTY(QDMI_DEVICE_PROPERTY_TELEMETRYSENSORS,
+                    CXX_QDMI_TelemetrySensor, CXX_DEVICE_TELEMETRYSENSORS, prop,
+                    size, value, size_ret)
   ADD_SINGLE_VALUE_PROPERTY(
       QDMI_DEVICE_PROPERTY_PULSESUPPORT, QDMI_Device_Pulse_Support_Level,
       QDMI_DEVICE_PULSE_SUPPORT_LEVEL_NONE, prop, size, value, size_ret)
@@ -889,3 +918,226 @@
   }
   return QDMI_ERROR_NOTSUPPORTED;
 } /// [DOXYGEN FUNCTION END]
+
+int CXX_QDMI_device_session_query_telemetrysensor_property(
+    CXX_QDMI_Device_Session session, CXX_QDMI_TelemetrySensor telemetry_sensor,
+    const QDMI_TelemetrySensor_Property prop, const size_t size, void *value,
+    size_t *size_ret) {
+  if (session == nullptr || telemetry_sensor == nullptr ||
+      (value != nullptr && size == 0) ||
+      (prop >= QDMI_TELEMETRYSENSOR_PROPERTY_MAX &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM1 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM2 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM3 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM4 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM5)) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  ADD_STRING_PROPERTY(QDMI_TELEMETRYSENSOR_PROPERTY_ID,
+                      telemetry_sensor->id.c_str(), prop, size, value, size_ret)
+  ADD_STRING_PROPERTY(QDMI_TELEMETRYSENSOR_PROPERTY_UNIT,
+                      telemetry_sensor->unit.c_str(), prop, size, value,
+                      size_ret)
+  ADD_SINGLE_VALUE_PROPERTY(QDMI_TELEMETRYSENSOR_PROPERTY_SAMPLINGRATE, time_t,
+                            telemetry_sensor->sampling_rate, prop, size, value,
+                            size_ret)
+  return QDMI_ERROR_NOTSUPPORTED;
+}
+
+int CXX_QDMI_device_session_create_device_telemetrysensor_query(
+    CXX_QDMI_Device_Session session,
+    CXX_QDMI_Device_TelemetrySensor_Query *query) {
+
+  if (session == nullptr || query == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  if (session->status != CXX_QDMI_DEVICE_SESSION_STATUS::INITIALIZED) {
+    return QDMI_ERROR_BADSTATE;
+  }
+  *query = new CXX_QDMI_Device_TelemetrySensor_Query_impl_d();
+  (*query)->start_time = nullptr;
+  (*query)->end_time = nullptr;
+  (*query)->telemetry_sensor = nullptr;
+  (*query)->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_CREATED;
+
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_set_parameter(
+    CXX_QDMI_Device_TelemetrySensor_Query query,
+    const QDMI_Device_TelemetrySensor_Query_Parameter param, const size_t size,
+    const void *value) {
+
+  if (query == nullptr || (value != nullptr && size == 0) ||
+      (param >= QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_MAX &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM1 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM2 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM3 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM4 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM5) ||
+      value == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  switch (param) {
+  case QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_STARTTIME: {
+    if (size < sizeof(time_t)) {
+      return QDMI_ERROR_INVALIDARGUMENT;
+    }
+    query->start_time =
+        std::make_unique<time_t>(*static_cast<const time_t *>(value));
+    return QDMI_SUCCESS;
+  }
+  case QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_ENDTIME: {
+    if (size < sizeof(time_t)) {
+      return QDMI_ERROR_INVALIDARGUMENT;
+    }
+    query->end_time =
+        std::make_unique<time_t>(*static_cast<const time_t *>(value));
+    return QDMI_SUCCESS;
+  }
+  case QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_TELEMETRYSENSOR: {
+    if (size < sizeof(CXX_QDMI_TelemetrySensor)) {
+      return QDMI_ERROR_INVALIDARGUMENT;
+    }
+    query->telemetry_sensor =
+        *static_cast<const CXX_QDMI_TelemetrySensor *>(value);
+    return QDMI_SUCCESS;
+  }
+  default:
+    return QDMI_ERROR_NOTSUPPORTED;
+  }
+}
+
+int CXX_QDMI_device_telemetrysensor_query_submit(
+    CXX_QDMI_Device_TelemetrySensor_Query query) {
+
+  if (query == nullptr || query->telemetry_sensor == nullptr ||
+      query->start_time == nullptr || query->end_time == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  // here, the actual submission.
+
+  // for demonstration purposes
+  query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_RUNNING;
+
+  time_t time_difference = *query->end_time - *query->start_time;
+
+  const auto sampling_rate = query->telemetry_sensor->sampling_rate;
+
+  const auto result_length =
+      static_cast<size_t>(time_difference / sampling_rate);
+  query->result_timestamps.clear();
+  query->result_timestamps.reserve(result_length);
+
+  query->result_values.clear();
+  query->result_values.reserve(result_length);
+
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_real_distribution<> dis(0.0, RAND_MAX);
+  for (unsigned int i = 0; i < result_length; i++) {
+
+    time_t next_time = *query->start_time + sampling_rate * i;
+    query->result_timestamps.emplace_back(next_time);
+
+    query->result_values.emplace_back(dis(gen));
+  }
+
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_get_results(
+    CXX_QDMI_Device_TelemetrySensor_Query query,
+    const QDMI_TelemetrySensor_Query_Result result, const size_t size,
+    void *data, size_t *size_ret) {
+
+  if (query == nullptr || (data != nullptr && size == 0) ||
+      (result >= QDMI_TELEMETRYSENSOR_QUERY_RESULT_MAX &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM1 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM2 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM3 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM4 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM5)) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  size_t required_size = query->result_values.size();
+  switch (result) {
+  case QDMI_TELEMETRYSENSOR_QUERY_RESULT_TIMESTAMPS:
+    required_size *= sizeof(time_t);
+    if (data != nullptr) {
+      if (size < required_size) {
+        return QDMI_ERROR_INVALIDARGUMENT;
+      }
+      memcpy(data, query->result_timestamps.data(), required_size);
+    }
+
+    if ((size_ret) != nullptr) {
+      *(size_ret) = required_size;
+    }
+    return QDMI_SUCCESS;
+  case QDMI_TELEMETRYSENSOR_QUERY_RESULT_VALUES:
+
+    required_size *= sizeof(double);
+    if (data != nullptr) {
+      if (size < required_size) {
+        return QDMI_ERROR_INVALIDARGUMENT;
+      }
+      memcpy(data, query->result_values.data(), required_size);
+    }
+    if ((size_ret) != nullptr) {
+      *(size_ret) = required_size;
+    }
+    return QDMI_SUCCESS;
+
+  default:
+    return QDMI_ERROR_NOTSUPPORTED;
+  }
+}
+
+int CXX_QDMI_device_telemetrysensor_query_check_status(
+    CXX_QDMI_Device_TelemetrySensor_Query query,
+    QDMI_TelemetrySensor_Query_Status *status) {
+  if (query == nullptr || status == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  // randomly decide whether job is done or not
+  if (query->status == QDMI_TELEMETRYSENSOR_QUERY_STATUS_RUNNING &&
+      CXX_QDMI_generate_bit()) {
+    query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_DONE;
+  }
+
+  *status = query->status;
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_wait(
+    CXX_QDMI_Device_TelemetrySensor_Query query, const size_t timeout) {
+
+  if (query == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_DONE;
+  query->timeout = timeout;
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_cancel(
+    CXX_QDMI_Device_TelemetrySensor_Query query) {
+
+  if (query == nullptr ||
+      query->status == QDMI_TELEMETRYSENSOR_QUERY_STATUS_DONE) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_CANCELED;
+
+  return QDMI_SUCCESS;
+}
+
+void CXX_QDMI_device_telemetrysensor_query_free(
+    CXX_QDMI_Device_TelemetrySensor_Query query) {
+  delete query;
+}