org.simantics.fmil.core/native/FMUSimulator/src/fmi_util.c

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <stdarg.h>
   5 #include <string.h>
   6 #include <errno.h>
   7
   8 #include <fmilib.h>
   9
  10 #include <fmi1_cs.h>
  11
  12 #define BUFFER 4096
  13
  14 /* Logger function used by the C-API */
  15 void importlogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)
  16 {
  17         printf("module = %s, log level = %d: %s\n", module, log_level, message);
  18 }
  19
  20 /* Logger function used by the FMU internally */
  21 void fmilogger(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...)
  22 {
  23         char msg[BUFFER];
  24     int len;
  25         va_list argp;
  26         va_start(argp, message);
  27         len = vsnprintf(msg, BUFFER, message, argp);
  28         printf("fmiStatus = %d;  %s (%s): %s\n", status, instanceName, category, msg);
  29     if(len > BUFFER) {
  30         printf("Warning: Message was truncated.\n");
  31     }
  32 }
  33
  34 int FMI_CS_LOAD(const char *zipFilePath, const char *unzipFolder, void **fmuPointer, int *fmuVersion, const char **error) {
  35
  36         fmi1_callback_functions_t callBackFunctions;
  37         fmi2_callback_functions_t callBackFunctions2;
  38         fmi_import_context_t* context;
  39         fmi_version_enu_t version;
  40     jm_status_enu_t status;
  41         fmi1_import_t *fmu;
  42         fmi2_import_t *fmu2;
  43         jm_callbacks* callbacks;
  44
  45         callbacks = (jm_callbacks *)calloc(1, sizeof(jm_callbacks));
  46
  47         callbacks->malloc = malloc;
  48     callbacks->calloc = calloc;
  49     callbacks->realloc = realloc;
  50     callbacks->free = free;
  51     callbacks->logger = importlogger;
  52 #ifdef _DEBUG
  53     callbacks->log_level = jm_log_level_debug;
  54 #else
  55         callbacks->log_level = jm_log_level_warning;
  56 #endif
  57     callbacks->context = 0;
  58
  59         context = fmi_import_allocate_context(callbacks);
  60
  61         version = fmi_import_get_fmi_version(context, zipFilePath, unzipFolder);
  62
  63         if (version == fmi_version_1_enu ) {
  64                 fmu = fmi1_import_parse_xml(context, unzipFolder);
  65                 if (fmi1_import_get_fmu_kind(fmu) != fmi1_fmu_kind_enu_cs_standalone && fmi1_import_get_fmu_kind(fmu) != fmi1_fmu_kind_enu_cs_tool) {
  66                         *error = "Provided FMU is version 1 but wrong type me (Model Exchange) when it should be cs (Co-Simulation)";
  67                         return 2; /* wrong type, should be co-simulation */
  68                 }
  69
  70                 callBackFunctions.logger = fmilogger;
  71                 callBackFunctions.allocateMemory = calloc;
  72                 callBackFunctions.freeMemory = free;
  73
  74                 status = fmi1_import_create_dllfmu(fmu, callBackFunctions, 0);
  75                 if (status == jm_status_error) {
  76                         *error = fmi1_import_get_last_error(fmu);
  77                         return 3;
  78                 }
  79
  80                 *fmuPointer = fmu;
  81                 *fmuVersion = 1;
  82         } else if (version == fmi_version_2_0_enu) {
  83                 fmu2 = fmi2_import_parse_xml(context, unzipFolder, 0);
  84
  85                 if (fmi2_import_get_fmu_kind(fmu2) != fmi1_fmu_kind_enu_cs_standalone && fmi2_import_get_fmu_kind(fmu2) != fmi1_fmu_kind_enu_cs_tool) {
  86                         *error = "Provided FMU is version 2.0 but wrong type me (Model Exchange) when it should be cs (Co-Simulation)";
  87                         return 2; /* wrong type, should be co-simulation */
  88                 }
  89
  90                 callBackFunctions2.logger = fmi2_log_forwarding;
  91                 callBackFunctions2.allocateMemory = calloc;
  92                 callBackFunctions2.freeMemory = free;
  93                 callBackFunctions2.componentEnvironment = fmu2;
  94
  95                 status = fmi2_import_create_dllfmu(fmu2, fmi2_fmu_kind_cs, &callBackFunctions2);
  96                 if (status == jm_status_error) {
  97                         *error = fmi2_import_get_last_error(fmu2);
  98                         return 3;
  99                 }
 100
 101                 *fmuPointer = fmu2;
 102                 *fmuVersion = 2;
 103         } else {
 104             *error = "Couldn't find version of FMU - possibly incorrect file!";
 105             return 1;
 106         }
 107
 108         fmi_import_free_context(context);
 109
 110         return 0; /* success */
 111 }
 112
 113 int FMI1_CS_UNLOAD(void *fmu_, const char **error) {
 114         fmi1_import_t *fmu = (fmi1_import_t *)fmu_;
 115         fmi1_import_terminate(fmu);
 116         fmi1_import_destroy_dllfmu(fmu);
 117         fmi1_import_free(fmu);
 118         return 0;
 119 }
 120
 121 int FMI2_CS_UNLOAD(void *fmu_, const char **error) {
 122         fmi2_import_t *fmu = (fmi2_import_t *)fmu_;
 123         fmi2_import_terminate(fmu);
 124         fmi2_import_destroy_dllfmu(fmu);
 125         fmi2_import_free(fmu);
 126         return 0;
 127 }
 128
 129 /*
 130  if(!vt) {
 131         printf("No type definition\n");
 132         return;
 133     }
 134
 135     quan = fmi1_import_get_type_quantity(vt);
 136
 137     printf("Type %s\n description: %s\n",  fmi1_import_get_type_name(vt), fmi1_import_get_type_description(vt));
 138
 139     printf("Base type: %s\n", fmi1_base_type_to_string(fmi1_import_get_base_type(vt)));
 140
 141     if(quan) {
 142         printf("Quantity: %s\n", quan);
 143     }
 144     switch(fmi1_import_get_base_type(vt)) {
 145     case fmi1_base_type_real: {
 146         fmi1_import_real_typedef_t* rt = fmi1_import_get_type_as_real(vt);
 147         fmi1_real_t min = fmi1_import_get_real_type_min(rt);
 148         fmi1_real_t max = fmi1_import_get_real_type_max(rt);
 149         fmi1_real_t nom = fmi1_import_get_real_type_nominal(rt);
 150         fmi1_import_unit_t* u = fmi1_import_get_real_type_unit(rt);
 151         fmi1_import_display_unit_t* du = fmi1_import_get_type_display_unit(rt);
 152
 153         printf("Min %g, max %g, nominal %g\n", min, max, nom);
 154
 155         if(u) {
 156             printf("Unit: %s\n", fmi1_import_get_unit_name(u));
 157         }
 158         if(du) {
 159             printf("Display unit: %s, gain: %g, offset: %g, is relative: %s",
 160                    fmi1_import_get_display_unit_name(du),
 161                    fmi1_import_get_display_unit_gain(du),
 162                    fmi1_import_get_display_unit_offset(du),
 163                    fmi1_import_get_real_type_is_relative_quantity(rt)?"yes":"no"
 164                    );
 165         }
 166
 167         break;
 168     }
 169     case fmi1_base_type_int:{
 170         fmi1_import_integer_typedef_t* it = fmi1_import_get_type_as_int(vt);
 171         int min = fmi1_import_get_integer_type_min(it);
 172         int max = fmi1_import_get_integer_type_max(it);
 173         printf("Min %d, max %d\n", min, max);
 174         break;
 175     }
 176     case fmi1_base_type_bool:{
 177         break;
 178     }
 179     case fmi1_base_type_str:{
 180         break;
 181     }
 182     case fmi1_base_type_enum:{
 183         fmi1_import_enumeration_typedef_t* et = fmi1_import_get_type_as_enum(vt);
 184         int min = fmi1_import_get_enum_type_min(et);
 185         int max = fmi1_import_get_enum_type_max(et);
 186         printf("Min %d, max %d\n", min, max);
 187         {
 188             size_t ni;
 189                         unsigned i;
 190             ni = fmi1_import_get_enum_type_size(et);
 191                         i = (unsigned)(ni);
 192                         assert( i == ni);
 193             printf("There are %u items \n",(unsigned)ni);
 194             for(i = 0; i < ni; i++) {
 195                 printf("[%u] %s (%s) \n", (unsigned)i+1, fmi1_import_get_enum_type_item_name(et, i), fmi1_import_get_enum_type_item_description(et, i));
 196             }
 197         }
 198         break;
 199     }
 200     default:
 201         printf("Error in fmiGetBaseType()\n");
 202     }
 203 */
 204
 205
 206 FMIL_Variable *FMI1_CS_GET_VARIABLES(void *fmu, int *count, const char **error) {
 207
 208     int i;
 209         FMIL_Variable *result;
 210     fmi1_import_variable_list_t* vl = fmi1_import_get_variable_list((fmi1_import_t *)fmu);
 211         fmi1_import_variable_typedef_t* type;
 212
 213     count[0] = (int)fmi1_import_get_variable_list_size(vl);
 214
 215         result = (FMIL_Variable *)malloc(count[0]*sizeof(FMIL_Variable));
 216
 217     for(i = 0; i < count[0]; i++) {
 218
 219         fmi1_import_variable_t* var = fmi1_import_get_variable(vl, i);
 220         if(!var) {
 221
 222                         printf("Something wrong with variable %d \n",i);
 223                         return 0;
 224
 225                 } else {
 226
 227                         result[i].name = fmi1_import_get_variable_name(var);
 228                         result[i].description = fmi1_import_get_variable_description(var);
 229
 230                         switch  (fmi1_import_get_variability(var)) {
 231                         case fmi1_variability_enu_constant:
 232                                 result[i].variability = 0;
 233                                 break;
 234                         case fmi1_variability_enu_parameter:
 235                                 result[i].variability = 1;
 236                                 break;
 237                         case fmi1_variability_enu_discrete:
 238                                 result[i].variability = 2;
 239                                 break;
 240                         case fmi1_variability_enu_continuous:
 241                                 result[i].variability = 3;
 242                                 break;
 243                         case fmi1_variability_enu_unknown:
 244                                 result[i].variability = 4;
 245                                 break;
 246                         }
 247
 248                         switch  (fmi1_import_get_causality(var)) {
 249                         case fmi1_causality_enu_input:
 250                                 result[i].causality = 0;
 251                                 break;
 252                         case fmi1_causality_enu_output:
 253                                 result[i].causality = 1;
 254                                 break;
 255                         case fmi1_causality_enu_internal:
 256                                 result[i].causality = 2;
 257                                 break;
 258                         case fmi1_causality_enu_none:
 259                                 result[i].causality = 3;
 260                                 break;
 261                         case fmi1_causality_enu_unknown:
 262                                 result[i].causality = 4;
 263                                 break;
 264                         }
 265
 266                         switch  (fmi1_import_get_variable_base_type(var)) {
 267                         case fmi1_base_type_real:
 268                                 result[i].type = 0;
 269                                 break;
 270                         case fmi1_base_type_int:
 271                                 result[i].type = 1;
 272                                 break;
 273                         case fmi1_base_type_bool:
 274                                 result[i].type = 2;
 275                                 break;
 276                         case fmi1_base_type_str:
 277                                 result[i].type = 3;
 278                                 break;
 279                         case fmi1_base_type_enum:
 280                                 result[i].type = 4;
 281                                 break;
 282                         }
 283
 284                         result[i].vr = fmi1_import_get_variable_vr(var);
 285
 286                         type = fmi1_import_get_variable_declared_type(var);
 287                         if(type) {
 288                                 result[i].declaredType = fmi1_import_get_type_name(type);
 289                         } else {
 290                                 result[i].declaredType = 0;
 291                         }
 292
 293                 }
 294
 295     }
 296
 297     fmi1_import_free_variable_list(vl);
 298
 299         return result;
 300
 301 }
 302
 303 FMIL_Variable *FMI2_CS_GET_VARIABLES(void *fmu, int *count, const char **error) {
 304
 305     int i;
 306         FMIL_Variable *result;
 307     fmi2_import_variable_list_t* vl = fmi2_import_get_variable_list((fmi2_import_t *)fmu, 0);
 308         fmi2_import_variable_typedef_t* type;
 309
 310     count[0] = (int)fmi2_import_get_variable_list_size(vl);
 311
 312         result = (FMIL_Variable *)malloc(count[0]*sizeof(FMIL_Variable));
 313
 314     for(i = 0; i < count[0]; i++) {
 315
 316         fmi2_import_variable_t* var = fmi2_import_get_variable(vl, i);
 317         if(!var) {
 318
 319                         printf("Something wrong with variable %d \n",i);
 320                         return 0;
 321
 322                 } else {
 323
 324                         result[i].name = fmi2_import_get_variable_name(var);
 325                         result[i].description = fmi2_import_get_variable_description(var);
 326
 327                         switch  (fmi2_import_get_variability(var)) {
 328                         case fmi2_variability_enu_constant:
 329                                 result[i].variability = 0;
 330                                 break;
 331                         case fmi2_variability_enu_fixed:
 332                         case fmi2_variability_enu_tunable:
 333                                 result[i].variability = 1;
 334                                 break;
 335                         case fmi2_variability_enu_discrete:
 336                                 result[i].variability = 2;
 337                                 break;
 338                         case fmi2_variability_enu_continuous:
 339                                 result[i].variability = 3;
 340                                 break;
 341                         case fmi2_variability_enu_unknown:
 342                                 result[i].variability = 4;
 343                                 break;
 344                         }
 345
 346                         switch  (fmi2_import_get_causality(var)) {
 347                         case fmi2_causality_enu_input:
 348                                 result[i].causality = 0;
 349                                 break;
 350                         case fmi2_causality_enu_output:
 351                                 result[i].causality = 1;
 352                                 break;
 353                         case fmi2_causality_enu_local:
 354                                 result[i].causality = 2;
 355                                 break;
 356                         case fmi2_causality_enu_independent:
 357                                 result[i].causality = 3;
 358                                 break;
 359                         case fmi2_causality_enu_unknown:
 360                                 result[i].causality = 4;
 361                                 break;
 362                         }
 363
 364                         switch  (fmi2_import_get_variable_base_type(var)) {
 365                         case fmi2_base_type_real:
 366                                 result[i].type = 0;
 367                                 break;
 368                         case fmi2_base_type_int:
 369                                 result[i].type = 1;
 370                                 break;
 371                         case fmi2_base_type_bool:
 372                                 result[i].type = 2;
 373                                 break;
 374                         case fmi2_base_type_str:
 375                                 result[i].type = 3;
 376                                 break;
 377                         case fmi2_base_type_enum:
 378                                 result[i].type = 4;
 379                                 break;
 380                         }
 381
 382                         result[i].vr = fmi2_import_get_variable_vr(var);
 383
 384                         type = fmi2_import_get_variable_declared_type(var);
 385                         if(type) {
 386                                 result[i].declaredType = fmi2_import_get_type_name(type);
 387                         } else {
 388                                 result[i].declaredType = 0;
 389                         }
 390
 391                 }
 392
 393     }
 394
 395     fmi2_import_free_variable_list(vl);
 396
 397         return result;
 398
 399 }
 400
 401 FMIL_DeclaredType *FMI1_CS_GET_DECLARED_TYPES(void *fmu, int *count, const char **error) {
 402
 403         FMIL_DeclaredType *result;
 404     fmi1_import_type_definitions_t* td = fmi1_import_get_type_definitions((fmi1_import_t *)fmu);
 405         fmi1_import_variable_typedef_t* type;
 406     unsigned i, ntd = (unsigned)fmi1_import_get_type_definition_number(td);
 407
 408     count[0] = ntd;
 409
 410         result = (FMIL_DeclaredType *)malloc(count[0]*sizeof(FMIL_DeclaredType));
 411
 412     for(i = 0; i < ntd; i++) {
 413       type = fmi1_import_get_typedef(td, i);
 414       result[i].name = fmi1_import_get_type_name(type);
 415       result[i].description = fmi1_import_get_type_description(type);
 416           result[i].quantity = fmi1_import_get_type_quantity(type);
 417       result[i].unit = 0;
 418
 419           switch(fmi1_import_get_base_type(type)) {
 420                    case fmi1_base_type_real: {
 421                                 fmi1_import_real_typedef_t* rt = fmi1_import_get_type_as_real(type);
 422                         fmi1_import_unit_t* u = fmi1_import_get_real_type_unit(rt);
 423                                 if(u) result[i].unit = fmi1_import_get_unit_name(u);
 424                    }
 425           }
 426
 427     }
 428
 429         return result;
 430
 431 }
 432
 433 FMIL_DeclaredType *FMI2_CS_GET_DECLARED_TYPES(void *fmu, int *count, const char **error) {
 434
 435         FMIL_DeclaredType *result;
 436     fmi2_import_type_definitions_t* td = fmi2_import_get_type_definitions((fmi2_import_t *)fmu);
 437         fmi2_import_variable_typedef_t* type;
 438     unsigned i, ntd = (unsigned)fmi2_import_get_type_definition_number(td);
 439
 440     count[0] = ntd;
 441
 442         result = (FMIL_DeclaredType *)malloc(count[0]*sizeof(FMIL_DeclaredType));
 443
 444     for(i = 0; i < ntd; i++) {
 445       type = fmi2_import_get_typedef(td, i);
 446       result[i].name = fmi2_import_get_type_name(type);
 447       result[i].description = fmi2_import_get_type_description(type);
 448           result[i].quantity = fmi2_import_get_type_quantity(type);
 449       result[i].unit = 0;
 450
 451           switch(fmi2_import_get_base_type(type)) {
 452                    case fmi2_base_type_real: {
 453                                 fmi2_import_real_typedef_t* rt = fmi2_import_get_type_as_real(type);
 454                         fmi2_import_unit_t* u = fmi2_import_get_real_type_unit(rt);
 455                                 if(u) result[i].unit = fmi2_import_get_unit_name(u);
 456                    }
 457           }
 458
 459     }
 460
 461         return result;
 462
 463 }
 464
 465 int FMI1_CS_INSTANTIATE(void *fmu, const char *instanceName, const char **error) {
 466
 467         fmi1_string_t fmuLocation;
 468         fmi1_string_t mimeType;
 469         fmi1_real_t timeout;
 470         fmi1_boolean_t visible;
 471         fmi1_boolean_t interactive;
 472         fmi1_boolean_t loggingOn;
 473
 474         jm_status_enu_t jmstatus;
 475
 476         fmuLocation = "";
 477         mimeType = "";
 478         timeout = 0;
 479         visible = fmi1_false;
 480         interactive = fmi1_false;
 481         loggingOn = fmi1_true;
 482
 483         jmstatus = fmi1_import_instantiate_slave((fmi1_import_t*)fmu, instanceName, NULL, NULL, timeout, fmi1_false, fmi1_false);
 484         if (jmstatus == jm_status_error) {
 485                 *error = fmi1_import_get_last_error((fmi1_import_t*)fmu);
 486                 return 1;
 487         }
 488         return 0;
 489 }
 490
 491 int FMI2_CS_INSTANTIATE(void *fmu, const char *instanceName, const char **error) {
 492
 493         fmi2_string_t fmuLocation;
 494         fmi2_string_t mimeType;
 495         fmi2_real_t timeout;
 496         fmi2_boolean_t visible;
 497         jm_status_enu_t jmstatus;
 498
 499         fmuLocation = "";
 500         mimeType = "";
 501         timeout = 0;
 502         visible = fmi2_false;
 503         // With NULL value for resourceLocation, its value is taken from the `fmu` argument
 504         jmstatus = fmi2_import_instantiate((fmi2_import_t*)fmu, instanceName, fmi2_cosimulation, NULL, visible);
 505         if (jmstatus == jm_status_error) {
 506                 *error = fmi2_import_get_last_error((fmi2_import_t*)fmu);
 507                 return 1;
 508         }
 509         return 0;
 510 }
 511
 512 int FMI1_CS_INITIALIZE(void *fmu, const char **error) {
 513
 514         fmi1_status_t status;
 515         fmi1_real_t tStart;
 516         fmi1_real_t tStop;
 517         fmi1_boolean_t StopTimeDefined;
 518
 519         tStart = 0;
 520         tStop = 10;
 521         StopTimeDefined = fmi1_false;
 522
 523         status = fmi1_import_initialize_slave((fmi1_import_t *)fmu, tStart, StopTimeDefined, tStop);
 524         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 525                 printf("fmi1_capi_initialize_slave:              Failed\n");
 526                 return 0;
 527         } else {
 528                 printf("fmi1_capi_initialize_slave:              Success\n");
 529         }
 530         return 0;
 531
 532 }
 533
 534 int FMI2_CS_INITIALIZE(void *fmu, const char **error) {
 535
 536         fmi2_real_t tStart;
 537         fmi2_real_t tStop;
 538         fmi2_boolean_t StopTimeDefined;
 539         fmi2_real_t relativeTol = 1e-4;
 540
 541         fmi2_status_t fmistatus;
 542
 543         tStart = 0;
 544         tStop = 10;
 545         StopTimeDefined = fmi1_false;
 546
 547         fmistatus = fmi2_import_setup_experiment((fmi2_import_t*)fmu, fmi2_true, relativeTol, tStart, StopTimeDefined, tStop);
 548     if(fmistatus != fmi2_status_ok) {
 549         *error = ("fmi2_import_setup_experiment failed\n");
 550                 return 1;
 551     }
 552
 553     fmistatus = fmi2_import_enter_initialization_mode((fmi2_import_t*)fmu);
 554     if(fmistatus != fmi2_status_ok) {
 555         *error = ("fmi2_import_enter_initialization_mode failed\n");
 556                 return 1;
 557     }
 558
 559     fmistatus = fmi2_import_exit_initialization_mode((fmi2_import_t*)fmu);
 560     if(fmistatus != fmi2_status_ok) {
 561         *error = ("fmi2_import_exit_initialization_mode failed\n");
 562                 return 1;
 563     }
 564
 565         return 0;
 566 }
 567
 568 int FMI1_CS_STEP(void *fmu, double masterTime, double stepSize, const char **error) {
 569
 570     fmi1_status_t status;
 571
 572         status = fmi1_import_do_step((fmi1_import_t *)fmu, (fmi1_real_t)masterTime, (fmi1_real_t)stepSize, fmi1_true);
 573         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 574                 *error = "Error happened during stepping!";
 575                 return 1;
 576         } else if (status == fmi1_status_pending) {
 577                 return 2;
 578         }
 579         return 0;
 580 }
 581
 582 int FMI2_CS_STEP(void *fmu, double masterTime, double stepSize, const char **error) {
 583
 584     fmi2_status_t status;
 585
 586         status = fmi2_import_do_step((fmi2_import_t *)fmu, (fmi2_real_t)masterTime, (fmi2_real_t)stepSize, fmi2_true);
 587         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 588                 *error = "Error happened during stepping!";
 589                 return 1;
 590         } else if (status == fmi2_status_pending) {
 591                 return 2;
 592         }
 593         return 0;
 594 }
 595
 596 // FMI1 setters
 597
 598 int FMI1_CS_SET_REAL(void *fmu, int valueId, double value, const char **error) {
 599
 600         fmi1_status_t status;
 601         fmi1_real_t valueTmp = value;
 602
 603         fmi1_value_reference_t vr = valueId;
 604         status = fmi1_import_set_real((fmi1_import_t *)fmu, &vr, 1, &valueTmp);
 605         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 606                 *error = "Error happened during setting real value!";
 607                 return 1;
 608         }
 609         return 0;
 610 }
 611
 612 int FMI1_CS_SET_INTEGER(void *fmu, int valueId, int value, const char **error) {
 613
 614         fmi1_status_t status;
 615         fmi1_integer_t valueTmp = value;
 616
 617         fmi1_value_reference_t vr = valueId;
 618         status = fmi1_import_set_integer((fmi1_import_t *)fmu, &vr, 1, &valueTmp);
 619         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 620                 *error = "Error happened during setting integer value!";
 621                 return 1;
 622         }
 623         return 0;
 624 }
 625
 626 int FMI1_CS_SET_BOOLEAN(void *fmu, int valueId, int value, const char **error) {
 627
 628         fmi1_status_t status;
 629         fmi1_boolean_t valueTmp = value != 0;
 630
 631         fmi1_value_reference_t vr = valueId;
 632         status = fmi1_import_set_boolean((fmi1_import_t *)fmu, &vr, 1, &valueTmp);
 633         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 634                 *error = "Error happened during setting boolean value!";
 635                 return 1;
 636         }
 637         return 0;
 638 }
 639
 640 int FMI1_CS_SET_STRING(void *fmu, int valueId, const char *value, const char **error) {
 641
 642         fmi1_status_t status;
 643         fmi1_string_t valueTmp = value;
 644
 645         fmi1_value_reference_t vr = valueId;
 646         status = fmi1_import_set_string((fmi1_import_t *)fmu, &vr, 1, &valueTmp);
 647         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 648                 *error = "Error happened during setting string value!";
 649                 return 1;
 650         }
 651         return 0;
 652 }
 653
 654 // FMI2 setters
 655
 656 int FMI2_CS_SET_REAL(void *fmu, int valueId, double value, const char **error) {
 657
 658         fmi2_status_t status;
 659         fmi2_real_t valueTmp = value;
 660
 661         fmi2_value_reference_t vr = valueId;
 662         status = fmi2_import_set_real((fmi2_import_t *)fmu, &vr, 1, &valueTmp);
 663         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 664                 *error = "Error happened during setting real value!";
 665                 return 1;
 666         }
 667         return 0;
 668 }
 669
 670 int FMI2_CS_SET_INTEGER(void *fmu, int valueId, int value, const char **error) {
 671
 672         fmi2_status_t status;
 673         fmi2_integer_t valueTmp = value;
 674
 675         fmi2_value_reference_t vr = valueId;
 676         status = fmi2_import_set_integer((fmi2_import_t *)fmu, &vr, 1, &valueTmp);
 677         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 678                 *error = "Error happened during setting integer value!";
 679                 return 1;
 680         }
 681         return 0;
 682 }
 683
 684 int FMI2_CS_SET_BOOLEAN(void *fmu, int valueId, int value, const char **error) {
 685
 686         fmi2_status_t status;
 687         fmi2_boolean_t valueTmp = value != 0;
 688
 689         fmi2_value_reference_t vr = valueId;
 690         status = fmi2_import_set_boolean((fmi2_import_t *)fmu, &vr, 1, &valueTmp);
 691         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 692                 *error = "Error happened during setting boolean value!";
 693                 return 1;
 694         }
 695         return 0;
 696 }
 697
 698 int FMI2_CS_SET_STRING(void *fmu, int valueId, const char *value, const char **error) {
 699
 700         fmi2_status_t status;
 701         fmi2_string_t valueTmp = value;
 702
 703         fmi2_value_reference_t vr = valueId;
 704         status = fmi2_import_set_string((fmi2_import_t *)fmu, &vr, 1, &valueTmp);
 705         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 706                 *error = "Error happened during setting string value!";
 707                 return 1;
 708         }
 709         return 0;
 710 }
 711
 712 // FMI1 getters
 713
 714 double FMI1_CS_GET_REAL(void *fmu, int valueReference, const char **error) {
 715
 716         fmi1_value_reference_t vr = valueReference;
 717         fmi1_real_t value;
 718
 719         fmi1_status_t status;
 720
 721         status = fmi1_import_get_real((fmi1_import_t *)fmu, &vr, 1, &value);
 722         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 723                 *error = "Error happened during getting real value!";
 724         }
 725         return value;
 726 }
 727
 728 int FMI1_CS_GET_INTEGER(void *fmu, int valueReference, const char **error) {
 729
 730         fmi1_value_reference_t vr = valueReference;
 731         fmi1_integer_t value;
 732
 733         fmi1_status_t status;
 734
 735         status = fmi1_import_get_integer((fmi1_import_t *)fmu, &vr, 1, &value);
 736         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 737                 *error = "Error happened during getting integer value!";
 738         }
 739         return value;
 740 }
 741
 742 int FMI1_CS_GET_BOOLEAN(void *fmu, int valueReference, const char **error) {
 743
 744         fmi1_value_reference_t vr = valueReference;
 745         fmi1_boolean_t value;
 746
 747         fmi1_status_t status;
 748
 749         status = fmi1_import_get_boolean((fmi1_import_t *)fmu, &vr, 1, &value);
 750         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 751                 *error = "Error happened during getting boolean value!";
 752         }
 753         return value;
 754 }
 755
 756 const char *FMI1_CS_GET_STRING(void *fmu, int valueReference, const char **error) {
 757
 758         fmi1_value_reference_t vr = valueReference;
 759         fmi1_string_t value;
 760
 761         fmi1_status_t status;
 762
 763         status = fmi1_import_get_string((fmi1_import_t *)fmu, &vr, 1, &value);
 764         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 765                 *error = "Error happened during getting string value!";
 766         }
 767         return value;
 768 }
 769
 770 // FMI2 getters
 771
 772 double FMI2_CS_GET_REAL(void *fmu, int valueReference, const char **error) {
 773
 774         fmi2_value_reference_t vr = valueReference;
 775         fmi2_real_t value;
 776
 777         fmi2_status_t status;
 778
 779         status = fmi2_import_get_real((fmi2_import_t *)fmu, &vr, 1, &value);
 780         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 781                 *error = "Error happened during getting real value!";
 782         }
 783         return value;
 784 }
 785
 786 int FMI2_CS_GET_INTEGER(void *fmu, int valueReference, const char **error) {
 787
 788         fmi2_value_reference_t vr = valueReference;
 789         fmi2_integer_t value;
 790
 791         fmi2_status_t status;
 792
 793         status = fmi2_import_get_integer((fmi2_import_t *)fmu, &vr, 1, &value);
 794         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 795                 *error = "Error happened during getting integer value!";
 796         }
 797         return value;
 798 }
 799
 800 int FMI2_CS_GET_BOOLEAN(void *fmu, int valueReference, const char **error) {
 801
 802         fmi2_value_reference_t vr = valueReference;
 803         fmi2_boolean_t value;
 804
 805         fmi2_status_t status;
 806
 807         status = fmi2_import_get_boolean((fmi2_import_t *)fmu, &vr, 1, &value);
 808         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 809                 *error = "Error happened during getting boolean value!";
 810         }
 811         return value;
 812 }
 813
 814 const char *FMI2_CS_GET_STRING(void *fmu, int valueReference, const char **error) {
 815
 816         fmi2_value_reference_t vr = valueReference;
 817         fmi2_string_t value;
 818
 819         fmi2_status_t status;
 820
 821         status = fmi2_import_get_string((fmi2_import_t *)fmu, &vr, 1, &value);
 822         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 823                 *error = "Error happened during getting string value!";
 824         }
 825         return value;
 826 }
 827
 828 // FMI1 array getters
 829
 830 int FMI1_CS_GET_REALS(void *fmu, int *valueReferences, double *result, int count, const char **error) {
 831
 832         fmi1_value_reference_t *vrs = (fmi1_value_reference_t*)valueReferences;
 833         fmi1_status_t status;
 834
 835         status = fmi1_import_get_real((fmi1_import_t *)fmu, vrs, count, result);
 836         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 837                 *error = "Error happened during getting real values!";
 838         }
 839         return 0;
 840 }
 841
 842 int FMI1_CS_GET_INTEGERS(void *fmu, int *valueReferences, int *result, int count, const char **error) {
 843
 844         fmi1_value_reference_t *vrs = (fmi1_value_reference_t*)valueReferences;
 845         fmi1_status_t status;
 846
 847         status = fmi1_import_get_integer((fmi1_import_t *)fmu, vrs, count, result);
 848         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 849                 *error = "Error happened during getting integer values!";
 850         }
 851         return 0;
 852 }
 853
 854 int FMI1_CS_GET_BOOLEANS(void *fmu, int *valueReferences, char *result, int count, const char **error) {
 855
 856         fmi1_value_reference_t *vrs = (fmi1_value_reference_t*)valueReferences;
 857         fmi1_status_t status;
 858
 859         status = fmi1_import_get_boolean((fmi1_import_t *)fmu, vrs, count, result);
 860         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 861                 *error = "Error happened during getting boolean values!";
 862         }
 863         return 0;
 864 }
 865
 866 int FMI1_CS_GET_STRINGS(void *fmu, int *valueReferences, const char **result, int count, const char **error) {
 867
 868         fmi1_value_reference_t *vrs = (fmi1_value_reference_t*)valueReferences;
 869         fmi1_status_t status;
 870
 871         status = fmi1_import_get_string((fmi1_import_t *)fmu, vrs, count, result);
 872         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 873                 *error = "Error happened during getting string values!";
 874         }
 875         return 0;
 876 }
 877
 878 // FMI2 array getters
 879
 880 int FMI2_CS_GET_REALS(void *fmu, int *valueReferences, double *result, int count, const char **error) {
 881
 882         fmi2_value_reference_t *vrs = (fmi2_value_reference_t*) valueReferences;
 883         fmi2_status_t status;
 884
 885         status = fmi2_import_get_real((fmi2_import_t *)fmu, vrs, count, result);
 886         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 887                 *error = "Error happened during getting real values!";
 888         }
 889         return 0;
 890
 891 }
 892
 893 int FMI2_CS_GET_INTEGERS(void *fmu, int *valueReferences, int *result, int count, const char **error) {
 894
 895         fmi2_value_reference_t *vrs = (fmi2_value_reference_t*)valueReferences;
 896         fmi2_status_t status;
 897
 898         status = fmi2_import_get_integer((fmi2_import_t *)fmu, vrs, count, result);
 899         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 900                 *error = "Error happened during getting integer values!";
 901         }
 902         return 0;
 903
 904 }
 905
 906 int FMI2_CS_GET_BOOLEANS(void *fmu, int *valueReferences, int *result, int count, const char **error) {
 907
 908         fmi2_value_reference_t *vrs = (fmi2_value_reference_t*)valueReferences;
 909         fmi2_status_t status;
 910
 911         status = fmi2_import_get_boolean((fmi2_import_t *)fmu, vrs, count, result);
 912         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 913                 *error = "Error happened during getting boolean values!";
 914         }
 915         return 0;
 916
 917 }
 918
 919 int FMI2_CS_GET_STRINGS(void *fmu, int *valueReferences, const char **result, int count, const char **error) {
 920
 921         fmi2_value_reference_t *vrs = (fmi2_value_reference_t*) valueReferences;
 922         fmi2_status_t status;
 923
 924         status = fmi2_import_get_string((fmi2_import_t *)fmu, vrs, count, result);
 925         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 926                 *error = "Error happened during getting string values!";
 927         }
 928         return 0;
 929
 930 }