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