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