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

   1 /*
   2     Copyright (C) 2012 Modelon AB
   3
   4     This program is free software: you can redistribute it and/or modify
   5     it under the terms of the BSD style license.
   6
   7      This program is distributed in the hope that it will be useful,
   8     but WITHOUT ANY WARRANTY; without even the implied warranty of
   9     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10     FMILIB_License.txt file for more details.
  11
  12     You should have received a copy of the FMILIB_License.txt file
  13     along with this program. If not, contact Modelon AB <http://www.modelon.com>.
  14 */
  15
  16 #include <assert.h>
  17 #include <string.h>
  18 #include <stdio.h>
  19 #include <FMI/fmi_util.h>
  20 #include <FMI/fmi_zip_unzip.h>
  21
  22 char* fmi_construct_dll_dir_name(jm_callbacks* callbacks, const char* fmu_unzipped_path) {
  23         char* dir_path;
  24         size_t len;
  25
  26         assert( fmu_unzipped_path && callbacks);
  27
  28         len =
  29                 strlen(fmu_unzipped_path) + strlen(FMI_FILE_SEP)
  30                 + strlen(FMI_BINARIES) + strlen(FMI_FILE_SEP)
  31                 + strlen(FMI_PLATFORM) + strlen(FMI_FILE_SEP) + 1;
  32
  33         dir_path = (char*)callbacks->malloc(len);
  34         if (dir_path == NULL) {
  35                 jm_log_fatal(callbacks, "FMIUT", "Failed to allocate memory.");
  36                 return NULL;
  37         }
  38
  39         sprintf(dir_path, "%s%s%s%s%s%s", fmu_unzipped_path, FMI_FILE_SEP, FMI_BINARIES, FMI_FILE_SEP, FMI_PLATFORM, FMI_FILE_SEP);/*safe */
  40
  41         return dir_path;
  42 }
  43
  44 char* fmi_construct_dll_file_name(jm_callbacks* callbacks, const char* dll_dir_name, const char* model_identifier) {
  45         char* fname;
  46         size_t len;
  47         assert(callbacks && model_identifier);
  48         len =
  49                 strlen(dll_dir_name) +
  50                 strlen(model_identifier)
  51                 + strlen(FMI_DLL_EXT) + 1;
  52         fname = (char*)callbacks->malloc(len);
  53         if (fname == NULL) {
  54                 jm_log_fatal(callbacks, "FMIUT", "Failed to allocate memory.");
  55                 return NULL;
  56         }
  57         sprintf(fname, "%s%s%s", dll_dir_name, model_identifier, FMI_DLL_EXT);/*safe */
  58
  59         return fname;
  60 }
  61
  62 ////
  63
  64 #include <stdio.h>
  65 #include <stdlib.h>
  66 #include <stdarg.h>
  67 #include <string.h>
  68 #include <errno.h>
  69
  70 #include <fmilib.h>
  71
  72 #ifdef __cplusplus
  73 extern "C" {
  74 #endif
  75
  76 typedef struct {
  77         char *name;
  78         char *description;
  79         char *declaredType;
  80         long vr;
  81         // 0 = real
  82         // 1 = integer
  83         // 2 = boolean
  84         // 3 = string
  85         // 4 = enumeration
  86         int type;
  87         // 0 = constant
  88         // 1 = parameter
  89         // 2 = discrete
  90         // 3 = continuous
  91         // 4 = unknown
  92         int variability;
  93         // 0 = input
  94         // 1 = output
  95         // 2 = internal
  96         // 3 = none
  97         // 4 = unknown
  98         int causality;
  99 } FMIL_Variable;
 100
 101 typedef struct {
 102         char *name;
 103         char *description;
 104         char *quantity;
 105         char *unit;
 106 } FMIL_DeclaredType;
 107
 108 __declspec(dllexport) int FMI_CS_LOAD(const char *zipFilePath, const char *unzipFolder, void **fmuPointer, int *fmuVersion, const char **error);
 109
 110 __declspec(dllexport) int FMI1_CS_UNLOAD(void* fmu, const char **error);
 111 __declspec(dllexport) FMIL_Variable *FMI1_CS_GET_VARIABLES(void* fmu, int *count, const char **error);
 112 __declspec(dllexport) FMIL_DeclaredType *FMI1_CS_GET_DECLARED_TYPES(void* fmu, int *count, const char **error);
 113 __declspec(dllexport) int FMI1_CS_INSTANTIATE(void* fmu, const char *instanceName, const char **error);
 114 __declspec(dllexport) int FMI1_CS_INITIALIZE(void* fmu, const char **error);
 115 __declspec(dllexport) int FMI1_CS_STEP(void* fmu, double masterTime, double stepSize, const char **error);
 116 __declspec(dllexport) int FMI1_CS_SET_REAL(void* fmu, int vr, double value, const char **error);
 117 __declspec(dllexport) double FMI1_CS_GET_REAL(void* fmu, int vr, const char **error);
 118 __declspec(dllexport) int FMI1_CS_GET_REALS(void* fmu, int *vrs, double *values, int count, const char **error);
 119
 120 __declspec(dllexport) int FMI2_CS_UNLOAD(void* fmu, const char **error);
 121 __declspec(dllexport) FMIL_Variable *FMI2_CS_GET_VARIABLES(void* fmu, int *count, const char **error);
 122 __declspec(dllexport) FMIL_DeclaredType *FMI2_CS_GET_DECLARED_TYPES(void* fmu, int *count, const char **error);
 123 __declspec(dllexport) int FMI2_CS_INSTANTIATE(void* fmu, const char *instanceName, const char **error);
 124 __declspec(dllexport) int FMI2_CS_INITIALIZE(void* fmu, const char **error);
 125 __declspec(dllexport) int FMI2_CS_STEP(void* fmu, double masterTime, double stepSize, const char **error);
 126 __declspec(dllexport) int FMI2_CS_SET_REAL(void* fmu, int vr, double value, const char **error);
 127 __declspec(dllexport) double FMI2_CS_GET_REAL(void* fmu, int vr, const char **error);
 128 __declspec(dllexport) int FMI2_CS_GET_REALS(void* fmu, int *vrs, double *values, int count, const char **error);
 129
 130 #ifdef __cplusplus
 131 }
 132 #endif
 133
 134 #define BUFFER 4096
 135
 136 /* Logger function used by the C-API */
 137 void importlogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)
 138 {
 139         printf("module = %s, log level = %d: %s\n", module, log_level, message);
 140 }
 141
 142 /* Logger function used by the FMU internally */
 143 void fmilogger(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...)
 144 {
 145         char msg[BUFFER];
 146     int len;
 147         va_list argp;
 148         va_start(argp, message);
 149         /*len=jm_vsnprintf(msg, BUFFER, message, argp);
 150         printf("fmiStatus = %d;  %s (%s): %s\n", status, instanceName, category, msg);
 151     if(len > BUFFER) {
 152         printf("Warning: message was trancated");
 153     }*/
 154 }
 155
 156 int FMI_CS_LOAD(char *zipFilePath, char *unzipFolder, void **fmuPointer, int *fmuVersion, const char **error) {
 157
 158         fmi1_callback_functions_t callBackFunctions;
 159         fmi2_callback_functions_t callBackFunctions2;
 160         fmi_import_context_t* context;
 161         fmi_version_enu_t version;
 162     jm_status_enu_t status;
 163         fmi1_import_t *fmu;
 164         fmi2_import_t *fmu2;
 165         jm_callbacks* callbacks;
 166
 167         callbacks = (jm_callbacks *)calloc(1, sizeof(jm_callbacks));
 168
 169         callbacks->malloc = malloc;
 170     callbacks->calloc = calloc;
 171     callbacks->realloc = realloc;
 172     callbacks->free = free;
 173     callbacks->logger = importlogger;
 174     callbacks->log_level = jm_log_level_debug;
 175     callbacks->context = 0;
 176
 177         context = fmi_import_allocate_context(callbacks);
 178
 179         version = fmi_import_get_fmi_version(context, zipFilePath, unzipFolder);
 180
 181         if (version == fmi_version_1_enu ) {
 182                 fmu = fmi1_import_parse_xml(context, unzipFolder);
 183                 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) {
 184                         *error = "Provided FMU is version 1 but wrong type me (Model Exchange) when it should be cs (Co-Simulation)";
 185                         return 2; // wrong type, should be co-simulation
 186                 }
 187
 188                 callBackFunctions.logger = fmilogger;
 189                 callBackFunctions.allocateMemory = calloc;
 190                 callBackFunctions.freeMemory = free;
 191
 192                 status = fmi1_import_create_dllfmu(fmu, callBackFunctions, 0);
 193                 if (status == jm_status_error) {
 194                         *error = fmi1_import_get_last_error(fmu);
 195                         return 3;
 196                 }
 197
 198                 *fmuPointer = fmu;
 199                 *fmuVersion = 1;
 200         } else if (version == fmi_version_2_0_enu) {
 201                 fmu2 = fmi2_import_parse_xml(context, unzipFolder, 0);
 202
 203                 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) {
 204                         *error = "Provided FMU is version 2.0 but wrong type me (Model Exchange) when it should be cs (Co-Simulation)";
 205                         return 2; // wrong type, should be co-simulation
 206                 }
 207
 208                 callBackFunctions2.logger = fmi2_log_forwarding;
 209                 callBackFunctions2.allocateMemory = calloc;
 210                 callBackFunctions2.freeMemory = free;
 211                 callBackFunctions2.componentEnvironment = fmu2;
 212
 213                 status = fmi2_import_create_dllfmu(fmu2, fmi2_fmu_kind_cs, &callBackFunctions2);
 214                 if (status == jm_status_error) {
 215                         *error = fmi2_import_get_last_error(fmu2);
 216                         return 3;
 217                 }
 218
 219                 *fmuPointer = fmu2;
 220                 *fmuVersion = 2;
 221         }
 222
 223         fmi_import_free_context(context);
 224
 225         return 0; // success
 226 }
 227
 228 int FMI1_CS_UNLOAD(void *fmu_, const char **error) {
 229         fmi1_import_t *fmu = (fmi1_import_t *)fmu_;
 230         fmi1_import_destroy_dllfmu(fmu);
 231         fmi1_import_free(fmu);
 232         return 0;
 233 }
 234
 235 int FMI2_CS_UNLOAD(void *fmu_, const char **error) {
 236         fmi2_import_t *fmu = (fmi2_import_t *)fmu_;
 237         fmi2_import_destroy_dllfmu(fmu);
 238         fmi2_import_free(fmu);
 239         return 0;
 240 }
 241
 242 /*
 243  if(!vt) {
 244         printf("No type definition\n");
 245         return;
 246     }
 247
 248     quan = fmi1_import_get_type_quantity(vt);
 249
 250     printf("Type %s\n description: %s\n",  fmi1_import_get_type_name(vt), fmi1_import_get_type_description(vt));
 251
 252     printf("Base type: %s\n", fmi1_base_type_to_string(fmi1_import_get_base_type(vt)));
 253
 254     if(quan) {
 255         printf("Quantity: %s\n", quan);
 256     }
 257     switch(fmi1_import_get_base_type(vt)) {
 258     case fmi1_base_type_real: {
 259         fmi1_import_real_typedef_t* rt = fmi1_import_get_type_as_real(vt);
 260         fmi1_real_t min = fmi1_import_get_real_type_min(rt);
 261         fmi1_real_t max = fmi1_import_get_real_type_max(rt);
 262         fmi1_real_t nom = fmi1_import_get_real_type_nominal(rt);
 263         fmi1_import_unit_t* u = fmi1_import_get_real_type_unit(rt);
 264         fmi1_import_display_unit_t* du = fmi1_import_get_type_display_unit(rt);
 265
 266         printf("Min %g, max %g, nominal %g\n", min, max, nom);
 267
 268         if(u) {
 269             printf("Unit: %s\n", fmi1_import_get_unit_name(u));
 270         }
 271         if(du) {
 272             printf("Display unit: %s, gain: %g, offset: %g, is relative: %s",
 273                    fmi1_import_get_display_unit_name(du),
 274                    fmi1_import_get_display_unit_gain(du),
 275                    fmi1_import_get_display_unit_offset(du),
 276                    fmi1_import_get_real_type_is_relative_quantity(rt)?"yes":"no"
 277                    );
 278         }
 279
 280         break;
 281     }
 282     case fmi1_base_type_int:{
 283         fmi1_import_integer_typedef_t* it = fmi1_import_get_type_as_int(vt);
 284         int min = fmi1_import_get_integer_type_min(it);
 285         int max = fmi1_import_get_integer_type_max(it);
 286         printf("Min %d, max %d\n", min, max);
 287         break;
 288     }
 289     case fmi1_base_type_bool:{
 290         break;
 291     }
 292     case fmi1_base_type_str:{
 293         break;
 294     }
 295     case fmi1_base_type_enum:{
 296         fmi1_import_enumeration_typedef_t* et = fmi1_import_get_type_as_enum(vt);
 297         int min = fmi1_import_get_enum_type_min(et);
 298         int max = fmi1_import_get_enum_type_max(et);
 299         printf("Min %d, max %d\n", min, max);
 300         {
 301             size_t ni;
 302                         unsigned i;
 303             ni = fmi1_import_get_enum_type_size(et);
 304                         i = (unsigned)(ni);
 305                         assert( i == ni);
 306             printf("There are %u items \n",(unsigned)ni);
 307             for(i = 0; i < ni; i++) {
 308                 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));
 309             }
 310         }
 311         break;
 312     }
 313     default:
 314         printf("Error in fmiGetBaseType()\n");
 315     }
 316 */
 317
 318
 319 FMIL_Variable *FMI1_CS_GET_VARIABLES(void *fmu, int *count, const char **error) {
 320
 321     int i;
 322         FMIL_Variable *result;
 323     fmi1_import_variable_list_t* vl = fmi1_import_get_variable_list((fmi1_import_t *)fmu);
 324         fmi1_import_variable_typedef_t* type;
 325
 326     count[0] = fmi1_import_get_variable_list_size(vl);
 327
 328         result = (FMIL_Variable *)malloc(count[0]*sizeof(FMIL_Variable));
 329
 330     for(i = 0; i < count[0]; i++) {
 331
 332         fmi1_import_variable_t* var = fmi1_import_get_variable(vl, i);
 333         if(!var) {
 334
 335                         printf("Something wrong with variable %d \n",i);
 336                         return 0;
 337
 338                 } else {
 339
 340                         result[i].name = fmi1_import_get_variable_name(var);
 341                         result[i].description = fmi1_import_get_variable_description(var);
 342
 343                         switch  (fmi1_import_get_variability(var)) {
 344                         case fmi1_variability_enu_constant:
 345                                 result[i].variability = 0;
 346                                 break;
 347                         case fmi1_variability_enu_parameter:
 348                                 result[i].variability = 1;
 349                                 break;
 350                         case fmi1_variability_enu_discrete:
 351                                 result[i].variability = 2;
 352                                 break;
 353                         case fmi1_variability_enu_continuous:
 354                                 result[i].variability = 3;
 355                                 break;
 356                         case fmi1_variability_enu_unknown:
 357                                 result[i].variability = 4;
 358                                 break;
 359                         }
 360
 361                         switch  (fmi1_import_get_causality(var)) {
 362                         case fmi1_causality_enu_input:
 363                                 result[i].causality = 0;
 364                                 break;
 365                         case fmi1_causality_enu_output:
 366                                 result[i].causality = 1;
 367                                 break;
 368                         case fmi1_causality_enu_internal:
 369                                 result[i].causality = 2;
 370                                 break;
 371                         case fmi1_causality_enu_none:
 372                                 result[i].causality = 3;
 373                                 break;
 374                         case fmi1_causality_enu_unknown:
 375                                 result[i].causality = 4;
 376                                 break;
 377                         }
 378
 379                         switch  (fmi1_import_get_variable_base_type(var)) {
 380                         case fmi1_base_type_real:
 381                                 result[i].type = 0;
 382                                 break;
 383                         case fmi1_base_type_int:
 384                                 result[i].type = 1;
 385                                 break;
 386                         case fmi1_base_type_bool:
 387                                 result[i].type = 2;
 388                                 break;
 389                         case fmi1_base_type_str:
 390                                 result[i].type = 3;
 391                                 break;
 392                         case fmi1_base_type_enum:
 393                                 result[i].type = 4;
 394                                 break;
 395                         }
 396
 397                         result[i].vr = fmi1_import_get_variable_vr(var);
 398
 399                         type = fmi1_import_get_variable_declared_type(var);
 400                         if(type) {
 401                                 result[i].declaredType = fmi1_import_get_type_name(type);
 402                         } else {
 403                                 result[i].declaredType = 0;
 404                         }
 405
 406                 }
 407
 408     }
 409
 410     fmi1_import_free_variable_list(vl);
 411
 412         return result;
 413
 414 }
 415
 416 FMIL_Variable *FMI2_CS_GET_VARIABLES(void *fmu, int *count, const char **error) {
 417
 418     int i;
 419         FMIL_Variable *result;
 420     fmi2_import_variable_list_t* vl = fmi2_import_get_variable_list((fmi2_import_t *)fmu, 0);
 421         fmi2_import_variable_typedef_t* type;
 422
 423     count[0] = fmi2_import_get_variable_list_size(vl);
 424
 425         result = (FMIL_Variable *)malloc(count[0]*sizeof(FMIL_Variable));
 426
 427     for(i = 0; i < count[0]; i++) {
 428
 429         fmi2_import_variable_t* var = fmi2_import_get_variable(vl, i);
 430         if(!var) {
 431
 432                         printf("Something wrong with variable %d \n",i);
 433                         return 0;
 434
 435                 } else {
 436
 437                         result[i].name = fmi2_import_get_variable_name(var);
 438                         result[i].description = fmi2_import_get_variable_description(var);
 439
 440                         switch  (fmi2_import_get_variability(var)) {
 441                         case fmi2_variability_enu_constant:
 442                                 result[i].variability = 0;
 443                                 break;
 444                         case fmi2_variability_enu_fixed:
 445                         case fmi2_variability_enu_tunable:
 446                                 result[i].variability = 1;
 447                                 break;
 448                         case fmi2_variability_enu_discrete:
 449                                 result[i].variability = 2;
 450                                 break;
 451                         case fmi2_variability_enu_continuous:
 452                                 result[i].variability = 3;
 453                                 break;
 454                         case fmi2_variability_enu_unknown:
 455                                 result[i].variability = 4;
 456                                 break;
 457                         }
 458
 459                         switch  (fmi2_import_get_causality(var)) {
 460                         case fmi2_causality_enu_input:
 461                                 result[i].causality = 0;
 462                                 break;
 463                         case fmi2_causality_enu_output:
 464                                 result[i].causality = 1;
 465                                 break;
 466                         case fmi2_causality_enu_local:
 467                                 result[i].causality = 2;
 468                                 break;
 469                         case fmi2_causality_enu_independent:
 470                                 result[i].causality = 3;
 471                                 break;
 472                         case fmi2_causality_enu_unknown:
 473                                 result[i].causality = 4;
 474                                 break;
 475                         }
 476
 477                         switch  (fmi2_import_get_variable_base_type(var)) {
 478                         case fmi2_base_type_real:
 479                                 result[i].type = 0;
 480                                 break;
 481                         case fmi2_base_type_int:
 482                                 result[i].type = 1;
 483                                 break;
 484                         case fmi2_base_type_bool:
 485                                 result[i].type = 2;
 486                                 break;
 487                         case fmi2_base_type_str:
 488                                 result[i].type = 3;
 489                                 break;
 490                         case fmi2_base_type_enum:
 491                                 result[i].type = 4;
 492                                 break;
 493                         }
 494
 495                         result[i].vr = fmi2_import_get_variable_vr(var);
 496
 497                         type = fmi2_import_get_variable_declared_type(var);
 498                         if(type) {
 499                                 result[i].declaredType = fmi2_import_get_type_name(type);
 500                         } else {
 501                                 result[i].declaredType = 0;
 502                         }
 503
 504                 }
 505
 506     }
 507
 508     fmi2_import_free_variable_list(vl);
 509
 510         return result;
 511
 512 }
 513
 514 FMIL_DeclaredType *FMI1_CS_GET_DECLARED_TYPES(void *fmu, int *count, const char **error) {
 515
 516         FMIL_DeclaredType *result;
 517     fmi1_import_type_definitions_t* td = fmi1_import_get_type_definitions((fmi1_import_t *)fmu);
 518         fmi1_import_variable_typedef_t* type;
 519     unsigned i, ntd = (unsigned)fmi1_import_get_type_definition_number(td);
 520
 521     count[0] = ntd;
 522
 523         result = (FMIL_DeclaredType *)malloc(count[0]*sizeof(FMIL_DeclaredType));
 524
 525     for(i = 0; i < ntd; i++) {
 526       type = fmi1_import_get_typedef(td, i);
 527       result[i].name = fmi1_import_get_type_name(type);
 528       result[i].description = fmi1_import_get_type_description(type);
 529           result[i].quantity = fmi1_import_get_type_quantity(type);
 530       result[i].unit = 0;
 531
 532           switch(fmi1_import_get_base_type(type)) {
 533                    case fmi1_base_type_real: {
 534                                 fmi1_import_real_typedef_t* rt = fmi1_import_get_type_as_real(type);
 535                         fmi1_import_unit_t* u = fmi1_import_get_real_type_unit(rt);
 536                                 if(u) result[i].unit = fmi1_import_get_unit_name(u);
 537                    }
 538           }
 539
 540     }
 541
 542         return result;
 543
 544 }
 545
 546 FMIL_DeclaredType *FMI2_CS_GET_DECLARED_TYPES(void *fmu, int *count, const char **error) {
 547
 548         FMIL_DeclaredType *result;
 549     fmi2_import_type_definitions_t* td = fmi2_import_get_type_definitions((fmi2_import_t *)fmu);
 550         fmi2_import_variable_typedef_t* type;
 551     unsigned i, ntd = (unsigned)fmi2_import_get_type_definition_number(td);
 552
 553     count[0] = ntd;
 554
 555         result = (FMIL_DeclaredType *)malloc(count[0]*sizeof(FMIL_DeclaredType));
 556
 557     for(i = 0; i < ntd; i++) {
 558       type = fmi2_import_get_typedef(td, i);
 559       result[i].name = fmi2_import_get_type_name(type);
 560       result[i].description = fmi2_import_get_type_description(type);
 561           result[i].quantity = fmi2_import_get_type_quantity(type);
 562       result[i].unit = 0;
 563
 564           switch(fmi2_import_get_base_type(type)) {
 565                    case fmi2_base_type_real: {
 566                                 fmi2_import_real_typedef_t* rt = fmi2_import_get_type_as_real(type);
 567                         fmi2_import_unit_t* u = fmi2_import_get_real_type_unit(rt);
 568                                 if(u) result[i].unit = fmi2_import_get_unit_name(u);
 569                    }
 570           }
 571
 572     }
 573
 574         return result;
 575
 576 }
 577
 578 int FMI1_CS_INSTANTIATE(void *fmu, const char *instanceName, const char **error) {
 579
 580         fmi1_string_t fmuLocation;
 581         fmi1_string_t mimeType;
 582         fmi1_real_t timeout;
 583         fmi1_boolean_t visible;
 584         fmi1_boolean_t interactive;
 585         fmi1_boolean_t loggingOn;
 586
 587         jm_status_enu_t jmstatus;
 588
 589         fmuLocation = "";
 590         mimeType = "";
 591         timeout = 0;
 592         visible = fmi1_false;
 593         interactive = fmi1_false;
 594         loggingOn = fmi1_true;
 595
 596         jmstatus = fmi1_import_instantiate_slave((fmi1_import_t*)fmu, instanceName, NULL, NULL, timeout, fmi1_false, fmi1_false);
 597         if (jmstatus == jm_status_error) {
 598                 *error = fmi1_import_get_last_error((fmi1_import_t*)fmu);
 599                 return 1;
 600         }
 601         return 0;
 602 }
 603
 604 int FMI2_CS_INSTANTIATE(void *fmu, const char *instanceName, const char **error) {
 605
 606         fmi2_string_t fmuLocation;
 607         fmi2_string_t mimeType;
 608         fmi2_real_t timeout;
 609         fmi2_boolean_t visible;
 610         fmi2_boolean_t interactive;
 611         fmi2_boolean_t loggingOn;
 612         jm_status_enu_t jmstatus;
 613
 614         fmuLocation = "";
 615         mimeType = "";
 616         timeout = 0;
 617         visible = fmi2_false;
 618         jmstatus = fmi2_import_instantiate((fmi2_import_t*)fmu, instanceName, fmi2_cosimulation, NULL, visible);
 619         if (jmstatus == jm_status_error) {
 620                 *error = fmi2_import_get_last_error((fmi2_import_t*)fmu);
 621                 return 1;
 622         }
 623         return 0;
 624 }
 625
 626 int FMI1_CS_INITIALIZE(void *fmu, const char **error) {
 627
 628         fmi1_status_t status;
 629         fmi1_real_t tStart;
 630         fmi1_real_t tStop;
 631         fmi1_boolean_t StopTimeDefined;
 632
 633         tStart = 0;
 634         tStop = 10;
 635         StopTimeDefined = fmi1_false;
 636
 637         status = fmi1_import_initialize_slave((fmi1_import_t *)fmu, tStart, StopTimeDefined, tStop);
 638         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 639                 printf("fmi1_capi_initialize_slave:              Failed\n");
 640                 return 0;
 641         } else {
 642                 printf("fmi1_capi_initialize_slave:              Success\n");
 643         }
 644         return 0;
 645
 646 }
 647
 648 int FMI2_CS_INITIALIZE(void *fmu, const char **error) {
 649
 650         fmi2_real_t tStart;
 651         fmi2_real_t tStop;
 652         fmi2_boolean_t StopTimeDefined;
 653         fmi2_real_t relativeTol = 1e-4;
 654
 655         fmi2_status_t fmistatus;
 656
 657         tStart = 0;
 658         tStop = 10;
 659         StopTimeDefined = fmi1_false;
 660
 661         fmistatus = fmi2_import_setup_experiment((fmi2_import_t*)fmu, fmi2_true, relativeTol, tStart, StopTimeDefined, tStop);
 662     if(fmistatus != fmi2_status_ok) {
 663         *error = ("fmi2_import_setup_experiment failed\n");
 664                 return 1;
 665     }
 666
 667     fmistatus = fmi2_import_enter_initialization_mode((fmi2_import_t*)fmu);
 668     if(fmistatus != fmi2_status_ok) {
 669         *error = ("fmi2_import_enter_initialization_mode failed\n");
 670                 return 1;
 671     }
 672
 673     fmistatus = fmi2_import_exit_initialization_mode((fmi2_import_t*)fmu);
 674     if(fmistatus != fmi2_status_ok) {
 675         *error = ("fmi2_import_exit_initialization_mode failed\n");
 676                 return 1;
 677     }
 678
 679         return 0;
 680 }
 681
 682 int FMI1_CS_STEP(void *fmu, double masterTime, double stepSize, const char **error) {
 683
 684     fmi1_status_t status;
 685
 686         status = fmi1_import_do_step((fmi1_import_t *)fmu, (fmi1_real_t)masterTime, (fmi1_real_t)stepSize, fmi1_true);
 687         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 688                 *error = "Error happened during stepping!";
 689                 return 1;
 690         }
 691         return 0;
 692 }
 693
 694 int FMI2_CS_STEP(void *fmu, double masterTime, double stepSize, const char **error) {
 695
 696     fmi2_status_t status;
 697
 698         status = fmi2_import_do_step((fmi2_import_t *)fmu, (fmi2_real_t)masterTime, (fmi2_real_t)stepSize, fmi2_true);
 699         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 700                 *error = "Error happened during stepping!";
 701                 return 1;
 702         }
 703         return 0;
 704 }
 705
 706 int FMI1_CS_SET_REAL(void *fmu, long valueId, double value, const char **error) {
 707
 708         fmi1_status_t status;
 709
 710         fmi1_value_reference_t vr = valueId;
 711         status = fmi1_import_set_real((fmi1_import_t *)fmu, &vr, 1, &value);
 712         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 713                 *error = "Error happened during setting real value!";
 714                 return 1;
 715         }
 716         return 0;
 717 }
 718
 719 int FMI2_CS_SET_REAL(void *fmu, long valueId, double value, const char **error) {
 720
 721         fmi2_status_t status;
 722
 723         fmi2_value_reference_t vr = valueId;
 724         status = fmi2_import_set_real((fmi2_import_t *)fmu, &vr, 1, &value);
 725         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 726                 *error = "Error happened during setting real value!";
 727                 return 1;
 728         }
 729         return 0;
 730 }
 731
 732 double FMI1_CS_GET_REAL(void *fmu, int valueReference, const char **error) {
 733
 734         fmi1_value_reference_t vr = valueReference;
 735         fmi1_real_t value;
 736
 737         fmi1_status_t status;
 738
 739         status = fmi1_import_get_real((fmi1_import_t *)fmu, &vr, 1, &value);
 740         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 741                 *error = "Error happened during getting real value!";
 742         }
 743         return value;
 744 }
 745
 746 double FMI2_CS_GET_REAL(void *fmu, int valueReference, const char **error) {
 747
 748         fmi2_value_reference_t vr = valueReference;
 749         fmi2_real_t value;
 750
 751         fmi2_status_t status;
 752
 753         status = fmi2_import_get_real((fmi2_import_t *)fmu, &vr, 1, &value);
 754         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 755                 *error = "Error happened during setting real value!";
 756         }
 757         return value;
 758 }
 759
 760 int FMI1_CS_GET_REALS(void *fmu, int *valueReferences, double *result, int count, const char **error) {
 761
 762         fmi1_value_reference_t *vrs = valueReferences;
 763         fmi1_real_t value;
 764
 765         fmi1_status_t status;
 766
 767         status = fmi1_import_get_real((fmi1_import_t *)fmu, vrs, count, result);
 768         if (status == fmi1_status_error || status == fmi1_status_fatal) {
 769                 *error = "Error happened during getting reals value!";
 770         }
 771         return 0;
 772 }
 773
 774 int FMI2_CS_GET_REALS(void *fmu, int *valueReferences, double *result, int count, const char **error) {
 775
 776         fmi2_value_reference_t *vrs = valueReferences;
 777         fmi2_real_t value;
 778
 779         fmi2_status_t status;
 780
 781         status = fmi2_import_get_real((fmi2_import_t *)fmu, vrs, count, result);
 782         if (status == fmi2_status_error || status == fmi2_status_fatal) {
 783                 *error = "Error happened during getting reals value!";
 784         }
 785         return 0;
 786
 787 }