binary updates

Author: markaren

ecospy/EcosSimulation.py

@@ -1,6 +1,6 @@
 from .lib import dll, EcosLib
 from .EcosSimulationStructure import EcosSimulationStructure
-from ctypes import c_bool, c_int, c_void_p, c_double, c_char_p, c_size_t, POINTER, Structure, CFUNCTYPE, byref, \
+from ctypes import c_bool, c_int, c_void_p, c_double, c_char_p, c_size_t, c_uint8, POINTER, Structure, CFUNCTYPE, byref, \
     create_string_buffer
 
 
@@ -98,6 +98,10 @@ def __init__(self, step_size: float, ssp_path: str = None, structure: EcosSimula
         self._set_string.argtypes = [c_void_p, c_char_p, c_char_p]
         self._set_string.restype = c_bool
 
+        self._set_binary = dll.ecos_simulation_set_binary
+        self._set_binary.argtypes = [c_void_p, c_char_p, POINTER(c_uint8), c_size_t]
+        self._set_binary.restype = c_bool
+
         self._create_listener = dll.ecos_simulation_listener_create
         self._create_listener.argtypes = [ListenerConfig]
         self._create_listener.restype = c_void_p
@@ -314,6 +318,10 @@ def set_string(self, identifier: str, value: str):
         if not self._set_string(self.sim, identifier.encode(), value.encode()):
             raise Exception(EcosLib.get_last_error())
 
+    def set_binary(self, identifier: str, value: bytes):
+        if not self._set_binary(self.sim, identifier.encode(), (value_type := (c_uint8 * len(value))(*value)), len(value)):
+            raise Exception(EcosLib.get_last_error())
+
     def init(self, start_time: int = 0, parameter_set: str = None):
         """
         Initialize the simulation with a start time and an optional parameter set.

include/ecos/ecos.h

@@ -3,6 +3,7 @@
 #define LIBECOS_ECOS_H
 
 #include <cstddef>
+#include <cstdint>
 
 /* Visibility macros */
 #if defined(_WIN32) || defined(__CYGWIN__)
@@ -65,11 +66,13 @@ LIBECOS_API bool ecos_simulation_get_integer(ecos_simulation_t* sim, const char*
 LIBECOS_API bool ecos_simulation_get_real(ecos_simulation_t* sim, const char* identifier, double* value);
 LIBECOS_API bool ecos_simulation_get_bool(ecos_simulation_t* sim, const char* identifier, bool* value);
 LIBECOS_API bool ecos_simulation_get_string(ecos_simulation_t* sim, const char* identifier, char* value);
+LIBECOS_API bool ecos_simulation_get_binary(ecos_simulation_t* sim, const char* identifier, uint8_t* value, size_t* len);
 
 LIBECOS_API bool ecos_simulation_set_integer(ecos_simulation_t* sim, const char* identifier, int value);
 LIBECOS_API bool ecos_simulation_set_real(ecos_simulation_t* sim, const char* identifier, double value);
 LIBECOS_API bool ecos_simulation_set_bool(ecos_simulation_t* sim, const char* identifier, bool value);
 LIBECOS_API bool ecos_simulation_set_string(ecos_simulation_t* sim, const char* identifier, const char* value);
+LIBECOS_API bool ecos_simulation_set_binary(ecos_simulation_t* sim, const char* identifier, const uint8_t* value, size_t len);
 
 LIBECOS_API bool ecos_simulation_terminate(ecos_simulation_t* sim);
 LIBECOS_API bool ecos_simulation_reset(ecos_simulation_t* sim);
@@ -100,7 +103,7 @@ typedef struct ecos_simulation_listener_config
 
 LIBECOS_API ecos_simulation_listener_t* ecos_simulation_listener_create(ecos_simulation_listener_config config);
 
-//Note: this function transfers ownership of listener to simulation
+// Note: this function transfers ownership of listener to simulation
 LIBECOS_API void ecos_simulation_add_listener(ecos_simulation_t* sim, const char* name, ecos_simulation_listener_t* listener);
 LIBECOS_API void ecos_simulation_remove_listener(ecos_simulation_t* sim, const char* name);
 

include/ecos/property.hpp

@@ -150,6 +150,9 @@ class properties
         for (auto& p : boolProperties_ | std::views::values) {
             p.applySet();
         }
+        for (auto& p : binaryProperties_ | std::views::values) {
+            p.applySet();
+        }
 
         for (const auto& l : listeners_) {
             l->post_sets();
@@ -190,6 +193,15 @@ class properties
         return nullptr;
     }
 
+    property_t<std::vector<uint8_t>>* get_binary_property(const std::string& name)
+    {
+        if (binaryProperties_.contains(name)) {
+            auto& property = binaryProperties_.at(name);
+            return &property;
+        }
+        return nullptr;
+    }
+
     property_t<bool>* get_bool_property(const std::string& name)
     {
         if (boolProperties_.contains(name)) {
@@ -219,6 +231,11 @@ class properties
         return stringProperties_;
     }
 
+    [[nodiscard]] const std::unordered_map<std::string, property_t<std::vector<uint8_t>>>& get_binaries()
+    {
+        return binaryProperties_;
+    }
+
     void add_real_property(property_t<double> p)
     {
         realProperties_.emplace(p.id().variable_name(), std::move(p));
@@ -234,6 +251,11 @@ class properties
         stringProperties_.emplace(p.id().variable_name(), std::move(p));
     }
 
+    void add_binary_property(property_t<std::vector<uint8_t>> p)
+    {
+        binaryProperties_.emplace(p.id().variable_name(), std::move(p));
+    }
+
     void add_bool_property(property_t<bool> p)
     {
         boolProperties_.emplace(p.id().variable_name(), std::move(p));
@@ -262,6 +284,9 @@ class properties
         std::ranges::transform(stringProperties_, std::back_inserter(names), [](auto& pair) {
             return pair.first;
         });
+        std::ranges::transform(binaryProperties_, std::back_inserter(names), [](auto& pair) {
+            return pair.first;
+        });
         return names;
     }
 
@@ -276,6 +301,7 @@ class properties
     std::unordered_map<std::string, property_t<bool>> boolProperties_;
     std::unordered_map<std::string, property_t<double>> realProperties_;
     std::unordered_map<std::string, property_t<std::string>> stringProperties_;
+    std::unordered_map<std::string, property_t<std::vector<uint8_t>>> binaryProperties_;
 };
 
 } // namespace ecos

include/ecos/simulation.hpp

@@ -92,6 +92,7 @@ class simulation
     [[nodiscard]] property_t<double>* get_real_property(const variable_identifier& identifier) const;
     [[nodiscard]] property_t<int>* get_int_property(const variable_identifier& identifier) const;
     [[nodiscard]] property_t<std::string>* get_string_property(const variable_identifier& identifier) const;
+    [[nodiscard]] property_t<std::vector<uint8_t>>* get_binary_property(const variable_identifier& identifier) const;
     [[nodiscard]] property_t<bool>* get_bool_property(const variable_identifier& identifier) const;
 
     [[nodiscard]] const std::vector<std::unique_ptr<model_instance>>& get_instances() const;

src/ecos/ecos.cpp

@@ -352,6 +352,26 @@ bool ecos_simulation_get_string(ecos_simulation_t* sim, const char* identifier,
     }
 }
 
+bool ecos_simulation_get_binary(ecos_simulation_t* sim, const char* identifier, uint8_t* value, size_t* len)
+{
+    try {
+        const auto prop = sim->cpp_sim->get_binary_property(identifier);
+        if (!prop) {
+            g_last_error_msg = "No string property named" + std::string(identifier) + " found!";
+            return false;
+        }
+        const auto propValue = prop->get_value();
+        std::memcpy(value, propValue.data(), propValue.size());
+        *len = propValue.size();
+
+        return true;
+    } catch (...) {
+        handle_current_exception();
+        return false;
+    }
+}
+
+
 bool ecos_simulation_set_integer(ecos_simulation_t* sim, const char* identifier, int value)
 {
     try {
@@ -416,6 +436,22 @@ bool ecos_simulation_set_string(ecos_simulation_t* sim, const char* identifier,
     }
 }
 
+bool ecos_simulation_set_binary(ecos_simulation_t* sim, const char* identifier, const uint8_t* value, size_t len)
+{
+    try {
+        const auto prop = sim->cpp_sim->get_binary_property(identifier);
+        if (!prop) {
+            g_last_error_msg = "No binary property " + std::string(identifier) + " found!";
+            return false;
+        }
+        prop->set_value(std::vector(value, value + len));
+        return true;
+    } catch (...) {
+        handle_current_exception();
+        return false;
+    }
+}
+
 
 void ecos_simulation_add_listener(ecos_simulation_t* sim, const char* name, ecos_simulation_listener_t* listener)
 {

src/ecos/fmi/fmi_model_instance.hpp

@@ -4,8 +4,8 @@
 
 #include "fmilibcpp/buffered_slave.hpp"
 
-#include "ecos/model_instance.hpp"
 #include "ecos/logger/logger.hpp"
+#include "ecos/model_instance.hpp"
 
 namespace ecos
 {
@@ -101,6 +101,21 @@ class fmi_model_instance : public model_instance
                         return bBuf.back();
                     });
                 properties_.add_bool_property(std::move(p));
+            } else if (v.is_binary()) {
+                auto p = property_t<std::vector<uint8_t>>(
+                   {slave_->instanceName, propertyName},
+                   [&v, this] {
+                       vrBuf[0] = v.vr;
+                       slave_->get_binary(vrBuf, binBuf);
+                       return binBuf.back();
+                   },
+                   [&v, this](auto value) {
+                       vrBuf[0] = v.vr;
+                       binBuf[0] = value;
+                       slave_->set_binary(vrBuf, binBuf);
+                       return binBuf.back();
+                   });
+                properties_.add_binary_property(std::move(p));
             } else {
                 throw std::runtime_error("Assertion error");
             }
@@ -164,6 +179,7 @@ class fmi_model_instance : public model_instance
     std::vector<int> iBuf = std::vector<int>(1);
     std::vector<bool> bBuf = std::vector<bool>(1);
     std::vector<std::string> sBuf = std::vector<std::string>(1);
+    std::vector<std::vector<uint8_t>> binBuf = std::vector<std::vector<uint8_t>>(1);
     std::unique_ptr<fmilibcpp::buffered_slave> slave_;
 
     struct prop_lister : property_listener

src/ecos/simulation.cpp

@@ -342,6 +342,17 @@ property_t<std::string>* simulation::get_string_property(const variable_identifi
     return nullptr;
 }
 
+property_t<std::vector<uint8_t>>* simulation::get_binary_property(const variable_identifier& identifier) const
+{
+    for (const auto& instance : pimpl_->instances_) {
+        if (instance->instanceName() == identifier.instance_name()) {
+            auto p = instance->get_properties().get_binary_property(identifier.variable_name());
+            if (p) return p;
+        }
+    }
+    return nullptr;
+}
+
 property_t<bool>* simulation::get_bool_property(const variable_identifier& identifier) const
 {
     for (const auto& instance : pimpl_->instances_) {

src/fmilibcpp/buffered_slave.hpp

@@ -4,10 +4,10 @@
 
 #include "slave.hpp"
 
+#include <memory>
 #include <set>
 #include <unordered_map>
 #include <utility>
-#include <memory>
 
 namespace fmilibcpp
 {
@@ -116,6 +116,18 @@ class buffered_slave : public slave
         return true;
     }
 
+    bool get_binary(const std::vector<value_ref>& vrs, std::vector<std::vector<uint8_t>>& values) override
+    {
+        for (unsigned i = 0; i < vrs.size(); i++) {
+            const value_ref vr = vrs[i];
+            if (std::ranges::find(bytesToFetch_, vr) == bytesToFetch_.end()) {
+                mark_for_reading(get_model_description().get_by_vr<std::vector<uint8_t>>(vr)->name);
+            }
+            values[i] = bytesGetCache_.at(vr);
+        }
+        return true;
+    }
+
     bool set_integer(const std::vector<value_ref>& vrs, const std::vector<int>& values) override
     {
         for (unsigned i = 0; i < vrs.size(); i++) {
@@ -152,6 +164,15 @@ class buffered_slave : public slave
         return true;
     }
 
+    bool set_binary(const std::vector<value_ref>& vrs, const std::vector<std::vector<uint8_t>>& values) override
+    {
+        for (unsigned i = 0; i < vrs.size(); i++) {
+            const value_ref vr = vrs[i];
+            bytesSetCache_[vr] = values[i];
+        }
+        return true;
+    }
+
     void transferCachedSets()
     {
         if (!integerSetCache_.empty()) {
@@ -194,6 +215,16 @@ class buffered_slave : public slave
             slave_->set_boolean(vrs, values);
             boolSetCache_.clear();
         }
+        if (!bytesSetCache_.empty()) {
+            std::vector<value_ref> vrs;
+            std::vector<std::vector<uint8_t>> values;
+            for (const auto& [vr, value] : bytesSetCache_) {
+                vrs.emplace_back(vr);
+                values.emplace_back(value);
+            }
+            slave_->set_binary(vrs, values);
+            bytesSetCache_.clear();
+        }
     }
 
     void receiveCachedGets()
@@ -238,6 +269,16 @@ class buffered_slave : public slave
                 booleanGetCache_[vr] = __booleanGetCache_[i];
             }
         }
+        if (!bytesToFetch_.empty()) {
+            __bytesGetCache_.resize(bytesToFetch_.size());
+            slave_->get_binary(bytesToFetch_, __bytesGetCache_);
+
+            bytesGetCache_.clear();
+            for (unsigned i = 0; i < bytesToFetch_.size(); i++) {
+                const value_ref vr = bytesToFetch_[i];
+                bytesGetCache_[vr] = __bytesGetCache_[i];
+            }
+        }
     }
 
     void mark_for_reading(const std::string& variableName)
@@ -260,6 +301,8 @@ class buffered_slave : public slave
             stringsToFetch_.emplace_back(vr);
         } else if (v->is_boolean()) {
             booleansToFetch_.emplace_back(vr);
+        } else if (v->is_binary()) {
+            bytesToFetch_.emplace_back(vr);
         }
 
         marked_variables.insert(variableName);
@@ -273,6 +316,8 @@ class buffered_slave : public slave
                 stringGetCache_[vr] = slave_->get_string(vr);
             } else if (v->is_boolean()) {
                 booleanGetCache_[vr] = slave_->get_boolean(vr);
+            } else if (v->is_binary()) {
+                bytesGetCache_[vr] = slave_->get_binary(vr);
             }
         }
     }
@@ -289,21 +334,25 @@ class buffered_slave : public slave
     std::unordered_map<value_ref, double> realSetCache_;
     std::unordered_map<value_ref, std::string> stringSetCache_;
     std::unordered_map<value_ref, bool> boolSetCache_;
+    std::unordered_map<value_ref, std::vector<uint8_t>> bytesSetCache_;
 
     std::unordered_map<value_ref, int> integerGetCache_;
     std::unordered_map<value_ref, double> realGetCache_;
     std::unordered_map<value_ref, std::string> stringGetCache_;
     std::unordered_map<value_ref, bool> booleanGetCache_;
+    std::unordered_map<value_ref, std::vector<uint8_t>> bytesGetCache_;
 
     std::vector<int> __integerGetCache_;
     std::vector<double> __realGetCache_;
     std::vector<std::string> __stringGetCache_;
     std::vector<bool> __booleanGetCache_;
+    std::vector<std::vector<uint8_t>> __bytesGetCache_;
 
     std::vector<value_ref> integersToFetch_;
     std::vector<value_ref> realsToFetch_;
     std::vector<value_ref> stringsToFetch_;
     std::vector<value_ref> booleansToFetch_;
+    std::vector<value_ref> bytesToFetch_;
 
     std::set<std::string> marked_variables;