Skip to content

Commit

Permalink
- c-interace for fmu
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@9675 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
Jens Frenkel committed Aug 24, 2011
1 parent 0b473d4 commit d88b51e
Show file tree
Hide file tree
Showing 10 changed files with 39 additions and 266 deletions.
28 changes: 16 additions & 12 deletions Compiler/susan_codegen/SimCode/SimCodeFMU.tpl
View file
Expand Up @@ -374,9 +374,18 @@ case SIMCODE(__) then
#define MODEL_GUID "{<%guid%>}"

// include fmu header files, typedefs and macros
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "<%fileNamePrefix%>_functions.h"
#include "simulation_init.h"
#include "fmiModelFunctions.h"
#include "fmu_model_interface.h"
#include "<%fileNamePrefix%>_functions.h"
#include "solver_main.h"

#ifdef __cplusplus
extern "C" {
#endif
void setStartValues(ModelInstance *comp);
fmiStatus getEventIndicator(ModelInstance* comp, fmiReal eventIndicators[]);
Expand Down Expand Up @@ -407,6 +416,10 @@ case SIMCODE(__) then
<%getStringFunction(modelInfo)%>
<%setExternalFunction(modelInfo)%>
#ifdef __cplusplus
}
#endif

>>
end fmumodel_identifierFile;

Expand Down Expand Up @@ -866,18 +879,9 @@ match platform
<%\t%> mv modelDescription.xml <%fileNamePrefix%>/modelDescription.xml
<%\t%> cd <%fileNamePrefix%>; zip -r <%fileNamePrefix%>.fmu *

<%fileNamePrefix%>.dll: <%fileNamePrefix%>_FMU2.o <%fileNamePrefix%>.o <%fileNamePrefix%>_records.o
<%\t%> $(CXX) -shared -I. -o <%fileNamePrefix%>.dll <%fileNamePrefix%>_FMU2.o <%fileNamePrefix%>.o <%fileNamePrefix%>_records.o $(CPPFLAGS) <%dirExtra%> <%libsPos1%> <%libsPos2%> $(CFLAGS) $(LDFLAGS) -linteractive $(SENDDATALIBS) <%match System.os() case "OSX" then "-lf2c" else "-Wl,-Bstatic -lf2c -Wl,-Bdynamic"%> -Wl,--kill-at

<%fileNamePrefix%>_FMU2.o:
<%\t%> $(CC) $(CPPFLAGS) $(CFLAGS) -c -o <%fileNamePrefix%>_FMU2.o <%fileNamePrefix%>_FMU.c
<%fileNamePrefix%>.dll: <%fileNamePrefix%>_FMU.o <%fileNamePrefix%>.o <%fileNamePrefix%>_records.o
<%\t%> $(CXX) -shared -I. -o <%fileNamePrefix%>.dll <%fileNamePrefix%>_FMU.o <%fileNamePrefix%>.o <%fileNamePrefix%>_records.o $(CPPFLAGS) <%dirExtra%> <%libsPos1%> <%libsPos2%> $(CFLAGS) $(LDFLAGS) -linteractive $(SENDDATALIBS) <%match System.os() case "OSX" then "-lf2c" else "-Wl,-Bstatic -lf2c -Wl,-Bdynamic"%> -Wl,--kill-at

<%fileNamePrefix%>.o:
<%\t%> $(CC) $(CPPFLAGS) $(CFLAGS) -c -o <%fileNamePrefix%>.o <%fileNamePrefix%>.c

<%fileNamePrefix%>_records.o:
<%\t%> $(CC) $(CPPFLAGS) $(CFLAGS) -c -o <%fileNamePrefix%>_records.o <%fileNamePrefix%>_records.c

<%\t%> mkdir -p <%fileNamePrefix%>
<%\t%> mkdir -p <%fileNamePrefix%>/binaries
<%\t%> mkdir -p <%fileNamePrefix%>/binaries/<%platform%>
Expand Down
241 changes: 3 additions & 238 deletions c_runtime/fmu_model_interface.c
View file
@@ -1,11 +1,6 @@
#ifndef __FMU_MODEL_INTERFACE_C__
#define __FMU_MODEL_INTERFACE_C__

//#include <string>
#include "solver_main.h"
#ifdef __cplusplus
extern "C" {
#endif
// array of value references of states
#if NUMBER_OF_STATES>0
fmiValueReference vrStates[NUMBER_OF_STATES] = STATES;
Expand Down Expand Up @@ -67,234 +62,6 @@ const char* fmiGetVersion() {
return fmiVersion;
}

// ---------------------------------------------------------------------------
// FMI functions: creation and destruction of a model instance
// ---------------------------------------------------------------------------

static DATA *initializeDataStruc2(DATA *returnData)
{
if (returnData->nStates) {
returnData->states = (double*) malloc(sizeof(double)*returnData->nStates);
returnData->statesFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->nStates);
returnData->states_old = (double*) malloc(sizeof(double)*returnData->nStates);
returnData->states_old2 = (double*) malloc(sizeof(double)*returnData->nStates);
assert(returnData->states&&returnData->states_old&&returnData->states_old2);
memset(returnData->states,0,sizeof(double)*returnData->nStates);
memset(returnData->statesFilterOutput,0,sizeof(modelica_boolean)*returnData->nStates);
memset(returnData->states_old,0,sizeof(double)*returnData->nStates);
memset(returnData->states_old2,0,sizeof(double)*returnData->nStates);
} else {
returnData->states = 0;
returnData->statesFilterOutput = 0;
returnData->states_old = 0;
returnData->states_old2 = 0;
}

if (returnData->nStates) {
returnData->statesDerivatives = (double*) malloc(sizeof(double)*returnData->nStates);
returnData->statesDerivativesFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->nStates);
returnData->statesDerivatives_old = (double*) malloc(sizeof(double)*returnData->nStates);
returnData->statesDerivatives_old2 = (double*) malloc(sizeof(double)*returnData->nStates);
returnData->statesDerivativesBackup = (double*) malloc(sizeof(double)*returnData->nStates);
assert(returnData->statesDerivatives&&returnData->statesDerivatives_old&&returnData->statesDerivatives_old2&&returnData->statesDerivativesBackup);
memset(returnData->statesDerivatives,0,sizeof(double)*returnData->nStates);
memset(returnData->statesDerivativesFilterOutput,0,sizeof(modelica_boolean)*returnData->nStates);
memset(returnData->statesDerivatives_old,0,sizeof(double)*returnData->nStates);
memset(returnData->statesDerivatives_old2,0,sizeof(double)*returnData->nStates);
memset(returnData->statesDerivativesBackup,0,sizeof(double)*returnData->nStates);
} else {
returnData->statesDerivatives = 0;
returnData->statesDerivativesFilterOutput = 0;
returnData->statesDerivatives_old = 0;
returnData->statesDerivatives_old2 = 0;
returnData->statesDerivativesBackup = 0;
}

if (returnData->nHelpVars) {
returnData->helpVars = (double*) malloc(sizeof(double)*returnData->nHelpVars);
assert(returnData->helpVars);
memset(returnData->helpVars,0,sizeof(double)*returnData->nHelpVars);
} else {
returnData->helpVars = 0;
}

if (returnData->nAlgebraic) {
returnData->algebraics = (double*) malloc(sizeof(double)*returnData->nAlgebraic);
returnData->algebraicsFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->nAlgebraic);
returnData->algebraics_old = (double*) malloc(sizeof(double)*returnData->nAlgebraic);
returnData->algebraics_old2 = (double*) malloc(sizeof(double)*returnData->nAlgebraic);
assert(returnData->algebraics&&returnData->algebraics_old&&returnData->algebraics_old2);
memset(returnData->algebraics,0,sizeof(double)*returnData->nAlgebraic);
memset(returnData->algebraicsFilterOutput,0,sizeof(modelica_boolean)*returnData->nAlgebraic);
memset(returnData->algebraics_old,0,sizeof(double)*returnData->nAlgebraic);
memset(returnData->algebraics_old2,0,sizeof(double)*returnData->nAlgebraic);
} else {
returnData->algebraics = 0;
returnData->algebraicsFilterOutput = 0;
returnData->algebraics_old = 0;
returnData->algebraics_old2 = 0;
}

if (returnData->stringVariables.nAlgebraic) {
returnData->stringVariables.algebraics = (const char**)malloc(sizeof(char*)*returnData->stringVariables.nAlgebraic);
assert(returnData->stringVariables.algebraics);
memset(returnData->stringVariables.algebraics,0,sizeof(char*)*returnData->stringVariables.nAlgebraic);
} else {
returnData->stringVariables.algebraics=0;
}

if (returnData->intVariables.nAlgebraic) {
returnData->intVariables.algebraics = (modelica_integer*)malloc(sizeof(modelica_integer)*returnData->intVariables.nAlgebraic);
returnData->intVariables.algebraicsFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->intVariables.nAlgebraic);
returnData->intVariables.algebraics_old = (modelica_integer*)malloc(sizeof(modelica_integer)*returnData->intVariables.nAlgebraic);
returnData->intVariables.algebraics_old2 = (modelica_integer*)malloc(sizeof(modelica_integer)*returnData->intVariables.nAlgebraic);
assert(returnData->intVariables.algebraics&&returnData->intVariables.algebraics_old&&returnData->intVariables.algebraics_old2);
memset(returnData->intVariables.algebraics,0,sizeof(modelica_integer)*returnData->intVariables.nAlgebraic);
memset(returnData->intVariables.algebraicsFilterOutput,0,sizeof(modelica_boolean)*returnData->intVariables.nAlgebraic);
memset(returnData->intVariables.algebraics_old,0,sizeof(modelica_integer)*returnData->intVariables.nAlgebraic);
memset(returnData->intVariables.algebraics_old2,0,sizeof(modelica_integer)*returnData->intVariables.nAlgebraic);
} else {
returnData->intVariables.algebraics=0;
returnData->intVariables.algebraicsFilterOutput=0;
returnData->intVariables.algebraics_old = 0;
returnData->intVariables.algebraics_old2 = 0;
}

if (returnData->boolVariables.nAlgebraic) {
returnData->boolVariables.algebraics = (modelica_boolean*)malloc(sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
returnData->boolVariables.algebraicsFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
returnData->boolVariables.algebraics_old = (signed char*)malloc(sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
returnData->boolVariables.algebraics_old2 = (signed char*)malloc(sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
assert(returnData->boolVariables.algebraics&&returnData->boolVariables.algebraics_old&&returnData->boolVariables.algebraics_old2);
memset(returnData->boolVariables.algebraics,0,sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
memset(returnData->boolVariables.algebraicsFilterOutput,0,sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
memset(returnData->boolVariables.algebraics_old,0,sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
memset(returnData->boolVariables.algebraics_old2,0,sizeof(modelica_boolean)*returnData->boolVariables.nAlgebraic);
} else {
returnData->boolVariables.algebraics=0;
returnData->boolVariables.algebraicsFilterOutput=0;
returnData->boolVariables.algebraics_old = 0;
returnData->boolVariables.algebraics_old2 = 0;
}

if (returnData->nParameters) {
returnData->parameters = (double*) malloc(sizeof(double)*returnData->nParameters);
assert(returnData->parameters);
memset(returnData->parameters,0,sizeof(double)*returnData->nParameters);
} else {
returnData->parameters = 0;
}

if (returnData->stringVariables.nParameters) {
returnData->stringVariables.parameters = (const char**)malloc(sizeof(char*)*returnData->stringVariables.nParameters);
assert(returnData->stringVariables.parameters);
memset(returnData->stringVariables.parameters,0,sizeof(char*)*returnData->stringVariables.nParameters);
} else {
returnData->stringVariables.parameters=0;
}

if (returnData->intVariables.nParameters) {
returnData->intVariables.parameters = (modelica_integer*)malloc(sizeof(modelica_integer)*returnData->intVariables.nParameters);
assert(returnData->intVariables.parameters);
memset(returnData->intVariables.parameters,0,sizeof(modelica_integer)*returnData->intVariables.nParameters);
} else {
returnData->intVariables.parameters=0;
}

if (returnData->boolVariables.nParameters) {
returnData->boolVariables.parameters = (modelica_boolean*)malloc(sizeof(modelica_boolean)*returnData->boolVariables.nParameters);
assert(returnData->boolVariables.parameters);
memset(returnData->boolVariables.parameters,0,sizeof(modelica_boolean)*returnData->boolVariables.nParameters);
} else {
returnData->boolVariables.parameters=0;
}

if (returnData->nOutputVars) {
returnData->outputVars = (double*) malloc(sizeof(double)*returnData->nOutputVars);
assert(returnData->outputVars);
memset(returnData->outputVars,0,sizeof(double)*returnData->nOutputVars);
} else {
returnData->outputVars = 0;
}

if (returnData->nInputVars) {
returnData->inputVars = (double*) malloc(sizeof(double)*returnData->nInputVars);
assert(returnData->inputVars);
memset(returnData->inputVars,0,sizeof(double)*returnData->nInputVars);
} else {
returnData->inputVars = 0;
}

if (returnData->nAlias) {
returnData->realAlias = (DATA_REAL_ALIAS*) malloc(sizeof(DATA_REAL_ALIAS)*returnData->nAlias);
assert(returnData->realAlias);
returnData->aliasFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->nAlias);
assert(returnData->aliasFilterOutput);
memset(returnData->realAlias,0,sizeof(DATA_REAL_ALIAS)*returnData->nAlias);
memset(returnData->aliasFilterOutput,0,sizeof(modelica_boolean)*returnData->nAlias);
} else {
returnData->realAlias = 0;
returnData->aliasFilterOutput = 0;
}

if (returnData->intVariables.nAlias) {
returnData->intVariables.alias = (DATA_INT_ALIAS*) malloc(sizeof(DATA_INT_ALIAS)*returnData->intVariables.nAlias);
assert(returnData->intVariables.alias);
returnData->intVariables.aliasFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->intVariables.nAlias);
assert(returnData->intVariables.aliasFilterOutput);
memset(returnData->intVariables.alias,0,sizeof(DATA_INT_ALIAS)*returnData->intVariables.nAlias);
memset(returnData->intVariables.aliasFilterOutput,0,sizeof(modelica_boolean)*returnData->intVariables.nAlias);
} else {
returnData->intVariables.alias = 0;
returnData->intVariables.aliasFilterOutput=0;
}

if (returnData->boolVariables.nAlias) {
returnData->boolVariables.alias = (DATA_BOOL_ALIAS*) malloc(sizeof(DATA_BOOL_ALIAS)*returnData->boolVariables.nAlias);
assert(returnData->boolVariables.alias);
returnData->boolVariables.aliasFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->boolVariables.nAlias);
assert(returnData->boolVariables.aliasFilterOutput);
memset(returnData->boolVariables.alias,0,sizeof(DATA_BOOL_ALIAS)*returnData->boolVariables.nAlias);
memset(returnData->boolVariables.aliasFilterOutput,0,sizeof(modelica_boolean)*returnData->boolVariables.nAlias);
} else {
returnData->boolVariables.alias = 0;
returnData->boolVariables.aliasFilterOutput=0;
}

if (returnData->stringVariables.nAlias) {
returnData->stringVariables.alias = (DATA_STRING_ALIAS*) malloc(sizeof(DATA_STRING_ALIAS)*returnData->stringVariables.nAlias);
assert(returnData->stringVariables.alias);
memset(returnData->stringVariables.alias,0,sizeof(DATA_STRING_ALIAS)*returnData->stringVariables.nAlias);
} else {
returnData->stringVariables.alias = 0;
}

if (returnData->nJacobianvars) {
returnData->jacobianVars = (double*) malloc(sizeof(double)*returnData->nJacobianvars);
assert(returnData->jacobianVars);
memset(returnData->jacobianVars,0,sizeof(double)*returnData->nJacobianvars);
} else {
returnData->jacobianVars = 0;
}

if (returnData->nInitialResiduals) {
returnData->initialResiduals = (double*) malloc(sizeof(double)*returnData->nInitialResiduals);
assert(returnData->initialResiduals);
memset(returnData->initialResiduals,0,sizeof(double)*returnData->nInitialResiduals);
} else {
returnData->initialResiduals = 0;
}

if (returnData->nRawSamples) {
returnData->rawSampleExps = (sample_raw_time*) malloc(sizeof(sample_raw_time)*returnData->nRawSamples);
assert(returnData->rawSampleExps);
memset(returnData->rawSampleExps,0,sizeof(sample_raw_time)*returnData->nRawSamples);
} else {
returnData->rawSampleExps = 0;
}
return returnData;
}

fmiComponent fmiInstantiateModel(fmiString instanceName, fmiString GUID,
fmiCallbackFunctions functions, fmiBoolean loggingOn) {
ModelInstance* comp;
Expand Down Expand Up @@ -351,7 +118,7 @@ fmiComponent fmiInstantiateModel(fmiString instanceName, fmiString GUID,
}
comp->time = &globalData->timeValue;
setLocalData(globalData);
sim_verbose = comp->loggingOn?64:0;
sim_verbose = 0;//comp->loggingOn?64:0;
sim_noemit = 0;
jac_flag = 0;
num_jac_flag = 0;
Expand Down Expand Up @@ -806,7 +573,7 @@ fmiStatus fmiInitialize(fmiComponent c, fmiBoolean toleranceControlled, fmiReal
eventInfo->stateValueReferencesChanged = comp->eventInfo.stateValueReferencesChanged;
eventInfo->stateValuesChanged = comp->eventInfo.stateValuesChanged;
eventInfo->terminateSimulation = comp->eventInfo.terminateSimulation;
eventInfo->upcomingTimeEvent = comp->eventInfo.upcomingTimeEvent;
eventInfo->upcomingTimeEvent = comp->eventInfo.upcomingTimeEvent;
globalData->lastEmittedTime = *comp->time;
globalData->forceEmit = 0;
initSample(*comp->time, 1);
Expand Down Expand Up @@ -942,10 +709,8 @@ fmiStatus fmiSetExternalFunction(fmiComponent c, fmiValueReference vr[], size_t
return fmiError;
}
return fmiOK;
};
#ifdef __cplusplus
}
#endif

// relation functions used in zero crossing detection
fmiReal
FmiLess(fmiReal a, fmiReal b)
Expand Down
13 changes: 8 additions & 5 deletions c_runtime/fmu_model_interface.h
View file
Expand Up @@ -3,12 +3,11 @@
/******************************************************************************
*fmuTemplate.h
******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "fmiModelFunctions.h"
#include "simulation_runtime.h"
//#include "simulation_init.h"

#ifdef __cplusplus
extern "C" {
#endif

// macros used to define variables
#define r(vr) comp->r[vr]
Expand Down Expand Up @@ -60,4 +59,8 @@ FmiGreaterEq(fmiReal a, fmiReal b);
eventIndicators[ind] = exp; \
}

#ifdef __cplusplus
}
#endif

#endif
3 changes: 2 additions & 1 deletion c_runtime/simulation_delay.cpp
View file
Expand Up @@ -55,8 +55,9 @@ typedef struct _ExpressionDelayBuffer
// the delayStructure looks like a matrix (rows = expressionNumber+currentColumnIndex, columns={time, value})
typedef ringbuffer<t_TimeAndValue> t_buffer;
t_buffer **delayStructure;
extern "C" {
extern const int numDelayExpressionIndex;

}
void initDelay(double startTime)
{
// get the start time of the simulation: time.start.
Expand Down
2 changes: 1 addition & 1 deletion c_runtime/simulation_init.cpp
View file
Expand Up @@ -272,7 +272,7 @@ int initialize(const std::string init_method)
}

int
main_initialize(const std::string* method)
main_initialize(const char* method)
{
std::string init_method = std::string("simplex");

Expand Down
8 changes: 4 additions & 4 deletions c_runtime/simulation_init.h
View file
Expand Up @@ -32,16 +32,16 @@
/*
* File: simulation_input.h
*/
#ifndef _SIMULATION_INIT_H
#define _SIMULATION_INIT_H

#ifdef __cplusplus
#include <string>
#include <cstdlib>

#ifndef _SIMULATION_INIT_H
#define _SIMULATION_INIT_H
#ifdef __cplusplus
extern "C" {
#endif
int main_initialize(const std::string*method);
int main_initialize(const char* method);
#ifdef __cplusplus
}
#endif
Expand Down

0 comments on commit d88b51e

Please sign in to comment.