FMI_power_sa.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686
  1. /* ---------------------------------------------------------------------------*
  2. * Sample implementation of an generic master FMU -
  3. * ---------------------------------------------------------------------------*/
  4. /*
  5. Template for a FMU
  6. */
  7. #define MODEL_IDENTIFIER GM
  8. #define MODEL_GUID "{41f87101-edf2-4eef-90f3-42db56d4565f}"
  9. #define FMI2_FUNCTION_PREFIX POWER_SA_
  10. #include <stdio.h>
  11. #include "string.h"
  12. #include "fmi2Functions.h"
  13. #include <float.h>
  14. #include "FMI_power_sa.h"
  15. #include <math.h>
  16. #include "fmi2.h"
  17. #include "sim_support.h"
  18. #define MAX 100000
  19. #define NUMBER_OF_REALS 6
  20. #define NUMBER_OF_STRINGS 0
  21. #define NUMBER_OF_BOOLEANS 0
  22. #define NUMBER_OF_INTEGERS 0
  23. /*
  24. * The input
  25. */
  26. #define _out_i 0
  27. #define _out_omega 1
  28. #define _out_theta 2
  29. #define _in_d 3
  30. #define _in_tau 4
  31. #define _in_u 5
  32. double relativeError(double a, double b){
  33. return fabs((a - b) / a);
  34. }
  35. /*
  36. * Helper function for absolute error
  37. */
  38. double absoluteError(double a, double b){
  39. return fabs(a - b);
  40. }
  41. /*
  42. * is_close function for double comparison
  43. */
  44. int is_close(double a, double b, double REL_TOL, double ABS_TOL){
  45. return ((absoluteError(a,b)<ABS_TOL) && (relativeError(a,b)<REL_TOL));
  46. }
  47. fmi2Status fmi2SetDebugLogging(fmi2Component fc, fmi2Boolean loggingOn, size_t nCategories, const fmi2String categories[])
  48. {
  49. return fmi2OK;
  50. }
  51. fmi2Status fmi2SetString(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, const fmi2String value[])
  52. {
  53. FMUInstance* comp = (FMUInstance *)fc;
  54. memset(comp->out_conditions_executed,0,sizeof(fmi2Boolean)*_NR_OF_OUT_CONDITIONS);
  55. return fmi2Error;
  56. }
  57. fmi2Status fmi2GetString(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, fmi2String value[])
  58. {
  59. return fmi2Error;
  60. }
  61. fmi2Status fmi2SetReal(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, const fmi2Real value[])
  62. {
  63. FMUInstance* comp = (FMUInstance *)fc;
  64. for (int i = 0; i < nvr; i++)
  65. {
  66. comp->r[vr[i]] = value[i];
  67. fmi2Real theval = value[i];
  68. printf("%f\n", theval);
  69. }
  70. fmi2Boolean in_condition[_NR_OF_IN_CONDITIONS];
  71. /*Condition checking:*/
  72. // true
  73. in_condition[0] = 1;
  74. for (int i = 0; i < nvr; i++){
  75. if(in_condition[0] && (vr[i] == _in_u)){
  76. comp->stored_windowsa_u = comp->r[_in_u];
  77. }
  78. if(in_condition[0] && (vr[i] == _in_d)){
  79. comp->stored_windowsa_d = comp->r[_in_d];
  80. }
  81. if(in_condition[0] && (vr[i] == _in_tau)){
  82. comp->stored_tau = comp->r[_in_tau];
  83. }
  84. /* If mealy do update_in and recursive call */
  85. }
  86. //out_condition_executed := empty map
  87. memset(comp->out_conditions_executed,0,sizeof(fmi2Boolean)*_NR_OF_OUT_CONDITIONS);
  88. return fmi2OK;
  89. }
  90. fmi2Status fmi2GetReal(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, fmi2Real value[])
  91. {
  92. FMUInstance* comp = (FMUInstance *)fc;
  93. int isEmpty = 1;
  94. for (int i=0; i<_NR_OF_OUT_CONDITIONS;i++){
  95. if(comp->out_conditions_executed[i] !=0){
  96. isEmpty = 0;
  97. break;
  98. }
  99. }
  100. /*Eval conditions:*/
  101. if(1){
  102. comp->out_conditions_executed[0] = 1;
  103. }
  104. if (isEmpty){
  105. for(int i=0; i<_NR_OF_OUT_CONDITIONS;i++){
  106. if(comp->out_conditions_executed[i]){
  107. comp->r[_out_i] = comp->stored_armature_current;
  108. comp->r[_out_omega] = comp->stored_speed;
  109. comp->r[_out_theta] = comp->stored_displacement;
  110. }
  111. }
  112. }
  113. for (int i = 0; i < nvr; i++)
  114. {
  115. value[i] = comp->r[(vr[i])];
  116. }
  117. return fmi2OK;
  118. }
  119. fmi2Status fmi2SetBoolean(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, const fmi2Boolean value[])
  120. {
  121. FMUInstance* comp = (FMUInstance *)fc;
  122. int i;
  123. for (i = 0; i < nvr; i++)
  124. {
  125. comp->b[vr[i]] = value[i];
  126. }
  127. /*Generated: */
  128. fmi2Boolean in_condition[_NR_OF_IN_CONDITIONS];
  129. /*Condition checking:*/
  130. // true
  131. in_condition[0] = 1;
  132. if(in_condition[0]){
  133. comp->stored_windowsa_u = (fmi2Real) comp->b[_in_u];
  134. comp->stored_windowsa_d = comp->b[_in_d];
  135. /* If mealy do update_in and recursive call */
  136. }
  137. return fmi2OK;
  138. //out_condition_executed := empty map
  139. memset(comp->out_conditions_executed,0,sizeof(fmi2Boolean)*_NR_OF_OUT_CONDITIONS);
  140. return fmi2OK;
  141. }
  142. fmi2Status fmi2GetBoolean(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, fmi2Boolean value[])
  143. {
  144. FMUInstance* comp = (FMUInstance *)fc;
  145. int i;
  146. for (i = 0; i < nvr; i++)
  147. {
  148. value[i] = comp->b[vr[i]];
  149. }
  150. return fmi2OK;
  151. }
  152. fmi2Component fmi2Instantiate(fmi2String instanceName, fmi2Type fmuType, fmi2String fmuGUID, fmi2String fmuLocation, const fmi2CallbackFunctions* functions, fmi2Boolean visible, fmi2Boolean loggingOn)
  153. {
  154. //Declare data structure for fmu instance
  155. FMUInstance* fi;
  156. printf("%s in fmiInstantiate\n",instanceName);
  157. //Perform checks on passed callback functions
  158. if (loggingOn) {
  159. if (!functions->logger);
  160. //return NULL;
  161. }
  162. //Check for instanceName
  163. if (!instanceName || strlen(instanceName)==0) {
  164. // print (and/or log) instanceName is missing
  165. //return NULL;
  166. }
  167. //Check passed GUID to defined model GUID
  168. if (strcmp(fmuGUID, MODEL_GUID))
  169. {
  170. // print (and/or log) GUID doesn't match
  171. //return NULL;
  172. }
  173. //Allocate fmu instance Memory
  174. // TODO check if "canNotUseMemoryManagementFunctions == true/false". If false memory allocation not possible
  175. fi = (FMUInstance *)functions->allocateMemory(1, sizeof(FMUInstance));
  176. if (fi) {
  177. // Think about what to do with variable values. Using these structs and pointers slows down simulation computations. Maybe only necessary for input, output and tunable parameters??
  178. fi->r = functions->allocateMemory(NUMBER_OF_REALS, sizeof(fmi2Real));
  179. fi->i = functions->allocateMemory(NUMBER_OF_INTEGERS, sizeof(fmi2Integer));
  180. fi->b = functions->allocateMemory(NUMBER_OF_BOOLEANS, sizeof(fmi2Boolean));
  181. fi->s = functions->allocateMemory(NUMBER_OF_STRINGS, sizeof(fmi2String));
  182. } // variables in predefined arrays (performance issue) --> makes multiple instances of fmu impossible
  183. fi->instanceName = functions->allocateMemory(1 + strlen(instanceName), sizeof(char));
  184. fi->GUID = functions->allocateMemory(1 + strlen(fmuGUID), sizeof(char));
  185. strcpy((char*)fi->instanceName, instanceName);
  186. strcpy((char*)fi->GUID, fmuGUID);
  187. fi->functions = functions;
  188. fi->loggingOn = loggingOn;
  189. fi->isVisible = visible;
  190. fi->state = fmuInstantiated;
  191. /* Load the inner FMUs:*/
  192. loadDll("PowerSystem.dll", &(fi->fmu[0]), "");
  193. fi->fmuResourceLocation[0] = "PowerSystem";
  194. /*Instantiate inner components*/
  195. for (int i=0; i<1; i++){
  196. fi->c_fmu[i] = fi->fmu[i].instantiate("inner", fmi2CoSimulation, "{547938fa-ae1c-44b9-971b-64c1c3344c33}", fi->fmuResourceLocation[i] , fi->functions, visible, 0);
  197. }
  198. return fi;
  199. }
  200. fmi2Status fmi2SetupExperiment(fmi2Component fc, fmi2Boolean toleranceDefined, fmi2Real tolerance,
  201. fmi2Real startTime, fmi2Boolean stopTimeDefined, fmi2Real stopTime) {
  202. FMUInstance* fi = (FMUInstance*) fc;
  203. printf("%s in fmiSetupExperiment\n",fi->instanceName);
  204. if (fi->state != fmuInstantiated)
  205. {
  206. printf("fmu: %s was not instatiated before calling fmiSetupExperiment\n", fi->instanceName);
  207. return fmi2Error;
  208. }
  209. fi->currentTime = startTime;
  210. fi->stopTimeDefined = stopTimeDefined;
  211. fi->toleranceDefined = toleranceDefined;
  212. if (stopTimeDefined)
  213. {
  214. fi->stopTime = stopTime;
  215. }
  216. /*
  217. * setup inner
  218. */
  219. fmi2Status fmi2Flag = fmi2OK;
  220. fi->state = fmuExperimentSettedUp;
  221. for(int i=0; i<1; i++){
  222. fmi2Flag = fi->fmu[i].setupExperiment(fi->c_fmu[i], toleranceDefined, tolerance, startTime, fmi2True, stopTime);
  223. if (fmi2Flag == fmi2Error){
  224. fi->state = fmuError;
  225. }
  226. }
  227. fi->stored_windowsa_u = 0;
  228. fi->stored_windowsa_d = 0;
  229. fi->stored_tau = 0;
  230. fi->stored_armature_current = 0;
  231. fi->stored_speed = 0;
  232. fi->stored_displacement = 0;
  233. return fmi2Flag;
  234. }
  235. fmi2Status fmi2EnterInitializationMode(fmi2Component fc)
  236. {
  237. FMUInstance* fi = (FMUInstance*) fc;
  238. printf("%s in fmiEnterInitializationMode\n",fi->instanceName);
  239. if (fi->state != fmuExperimentSettedUp)
  240. {
  241. printf("fmu: %s experiment was not set-up before calling fmiEnterInitializationMode\n", fi->instanceName);
  242. return fmi2Error;
  243. }
  244. fi->state = fmuInitMode;
  245. fmi2Status fmi2Flag = fmi2OK;
  246. for(int i=0; i<1; i++){
  247. fmi2Flag = fi->fmu[i].enterInitializationMode(fi->c_fmu[i]);
  248. if (fmi2Flag == fmi2Error){
  249. return fi->state = fmuError;
  250. }
  251. }
  252. return fmi2Flag;
  253. }
  254. fmi2Status fmi2ExitInitializationMode(fmi2Component fc)
  255. {
  256. FMUInstance* fi = (FMUInstance*) fc;
  257. printf("%s in fmiExitInitializationMode\n",fi->instanceName);
  258. if (fi->state != fmuInitMode)
  259. {
  260. printf("fmu: %s did not enter Initialization Mode before calling fmiExitInitializationMode\n", fi->instanceName);
  261. return fmi2Error;
  262. }
  263. // TODO
  264. //initStatus = calculateInitialUnknownValues();
  265. //initialize();
  266. fi->state = fmuInitialized;
  267. fmi2Status fmi2Flag = fmi2OK;
  268. for(int i=0; i<1;i++){
  269. fmi2Flag = fi->fmu[i].exitInitializationMode(fi->c_fmu[i]);
  270. if (fmi2Flag == fmi2Error){
  271. return fi->state = fmuError;
  272. }
  273. }
  274. return fmi2Flag;
  275. }
  276. static fmi2Status DoInnerStep(fmi2Component fc, int index, fmi2Real currentCommPoint, fmi2Real commStepSize){
  277. fmi2Status status = fmi2OK;
  278. FMUInstance* fi = (FMUInstance *)fc;
  279. fmi2Real dt = currentCommPoint - fi->time_last_fmu[index];
  280. fmi2Real h = commStepSize + dt;
  281. if (1){
  282. fmi2ValueReference vr_toPower[3] = {7,8,9};
  283. fmi2Real values[3];
  284. values[0] = fi->stored_windowsa_d;
  285. values[1] = fi->stored_tau;
  286. values[2] = fi->stored_windowsa_u;
  287. fi->fmu[index].setReal(fi->c_fmu[index],vr_toPower, 3, &values[0]);
  288. printf("t: %f, d in %f \n", currentCommPoint, fi->stored_windowsa_d );
  289. printf("t: %f, tau in %f \n", currentCommPoint, fi->stored_tau );
  290. printf("t: %f, u in %f \n", currentCommPoint, fi->stored_windowsa_u );
  291. }
  292. printf("t: %f, h: %f \n", currentCommPoint, h );
  293. status = fi->fmu[index].doStep(fi->c_fmu[index],fi->time_last_fmu[index],h,fmi2True);
  294. if(status != fmi2OK){
  295. printf("Rejected the step size\n");
  296. }
  297. fi->time_last_fmu[index] = currentCommPoint + h;
  298. if (1){
  299. fmi2ValueReference vr_fromPower[3] = {0,1,2};
  300. fmi2Real out_values[3];
  301. fi->fmu[index].getReal(fi->c_fmu[index],vr_fromPower, 3, &out_values[0]);
  302. fi->stored_armature_current = out_values[0];
  303. fi->stored_speed = out_values[1];
  304. fi->stored_displacement = out_values[2];
  305. printf("t: %f, w out %f \n", currentCommPoint, fi->stored_speed );
  306. printf("t: %f, i out %f \n", currentCommPoint, fi->stored_armature_current );
  307. }
  308. return status;
  309. }
  310. fmi2Status fmi2DoStep(fmi2Component fc , fmi2Real currentCommPoint, fmi2Real commStepSize, fmi2Boolean noPrevFMUState)
  311. {
  312. FMUInstance* fi = (FMUInstance *)fc;
  313. fmi2Status simStatus = fmi2OK;
  314. printf("%s in fmiDoStep(), ct:%f, h:%f\n",fi->instanceName,currentCommPoint,commStepSize);
  315. memset(fi->out_conditions_executed,0,sizeof(fmi2Boolean)*_NR_OF_OUT_CONDITIONS);
  316. /*
  317. Calculate the elapsed time since the last transition
  318. */
  319. fmi2Real e = MAX;
  320. fmi2Real elapsed_fmu[_NR_OF_FMUS];
  321. for (int i=0; i<_NR_OF_FMUS; i++){
  322. elapsed_fmu[i] = currentCommPoint - fi->time_last_fmu[i];
  323. e = (elapsed_fmu[i]<e)? elapsed_fmu[i]:e;
  324. }
  325. if(1){
  326. simStatus= DoInnerStep(fc,0,currentCommPoint,commStepSize);
  327. }
  328. memset(fi->in_condition_executed, 0, sizeof(fmi2Boolean)*_NR_OF_IN_CONDITIONS);
  329. return simStatus;
  330. }
  331. fmi2Status fmi2Terminate(fmi2Component fc)
  332. {
  333. FMUInstance* fi = (FMUInstance *)fc;
  334. printf("%s in fmiTerminate\n",fi->instanceName);
  335. // do check if fi may be terminated
  336. for (int i=0;i<1;i++){
  337. fi->fmu[i].terminate(fi->c_fmu[i]);
  338. }
  339. fi->state = fmuTerminated;
  340. return fmi2OK;
  341. }
  342. void fmi2FreeInstance(fmi2Component fc)
  343. {
  344. FMUInstance* fi = (FMUInstance*) fc;
  345. printf("%s in fmiFreeInstance\n",fi->instanceName);
  346. for(int i=0;i<1;i++){
  347. fi->fmu[i].freeInstance(fi->c_fmu[i]);
  348. }
  349. if (fi) {
  350. fi->functions->freeMemory(fi->r);
  351. fi->functions->freeMemory(fi->i);
  352. fi->functions->freeMemory(fi->b);
  353. fi->functions->freeMemory(fi->s);// TODO has to be done with loop
  354. fi->functions->freeMemory((void*)fi->instanceName);
  355. fi->functions->freeMemory((void*)fi->GUID);
  356. fi->functions->freeMemory((void*)fi);
  357. }
  358. }
  359. //To be implemented
  360. const char* fmi2GetVersion() {
  361. printf("Function fmiGetVersion not supported\n");
  362. return NULL;
  363. }
  364. const char* fmi2GetTypesPlatform() {
  365. printf("Function fmiGetTypesPlatform not supported\n");
  366. return NULL;
  367. }
  368. fmi2Status fmi2Reset(fmi2Component fc)
  369. {
  370. printf("Function fmiReset not supported\n");
  371. return fmi2Error;
  372. }
  373. fmi2Status fmi2SetInteger(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, const fmi2Integer value[])
  374. {
  375. FMUInstance * comp = (FMUInstance*) fc;
  376. printf("Function fmiSetInteger not supported\n");
  377. memset(comp->out_conditions_executed,0,sizeof(fmi2Boolean)*_NR_OF_OUT_CONDITIONS);
  378. return fmi2Error;
  379. }
  380. fmi2Status fmi2GetInteger(fmi2Component fc, const fmi2ValueReference vr[], size_t nvr, fmi2Integer value[])
  381. {
  382. printf("Function fmiGetInteger not supported\n");
  383. return fmi2Error;
  384. }
  385. /*******OWN IMPLEMENTATION OF Get/Set FMU state*******/
  386. fmi2Status fmi2GetFMUstate (fmi2Component c, fmi2FMUstate* FMUstate) {
  387. FMUInstance* orig = (FMUInstance*)c;
  388. FMUInstance* fi = (FMUInstance *)FMUstate;
  389. *FMUstate = fi;
  390. fi = orig->functions->allocateMemory(1, sizeof(FMUInstance));
  391. *FMUstate = fi;
  392. fi->functions = orig->functions;
  393. if (fi) {
  394. // Think about what to do with variable values. Using these structs and pointers slows down simulation computations. Maybe only necessary for input, output and tunable parameters??
  395. fi->r = fi->functions->allocateMemory(NUMBER_OF_REALS, sizeof(fmi2Real));
  396. fi->i = fi->functions->allocateMemory(NUMBER_OF_INTEGERS, sizeof(fmi2Integer));
  397. fi->b = fi->functions->allocateMemory(NUMBER_OF_BOOLEANS, sizeof(fmi2Boolean));
  398. fi->s = fi->functions->allocateMemory(NUMBER_OF_STRINGS, sizeof(fmi2String));
  399. } // variables in predefined arrays (performance issue) --> makes multiple instances of fmu impossible
  400. fi->instanceName = orig->functions->allocateMemory(1 + strlen(orig->instanceName), sizeof(char));
  401. fi->GUID = orig->functions->allocateMemory(1 + strlen(orig->GUID), sizeof(char));
  402. strcpy((char *)fi->instanceName, (char *)orig->instanceName);
  403. strcpy((char *)fi->GUID, (char *)orig->GUID);
  404. fi->functions = orig->functions;
  405. fi->loggingOn = orig->loggingOn;
  406. fi->isVisible = orig->isVisible;
  407. fi->state = orig->state;
  408. fi->startTime = orig->startTime;
  409. fi->stopTime = orig->stopTime;
  410. fi->currentTime = orig->currentTime;
  411. /* TODO: Store all the rest here.*/
  412. fi->fmu[0] = orig->fmu[0];
  413. fi->c_fmu[0] = orig->c_fmu[0];
  414. for(int i=0; i<_NR_OF_IN_CONDITIONS;i++){
  415. fi->in_condition_executed[i] = orig->in_condition_executed[i];
  416. }
  417. for(int i=0; i<_NR_OF_OUT_CONDITIONS;i++){
  418. fi->out_conditions_executed[i] = orig->out_conditions_executed[i];
  419. }
  420. for(int i=0;i<_NR_OF_FMUS;i++){
  421. fi->time_last_fmu[i] = orig->time_last_fmu[i];
  422. }
  423. /* Generated */
  424. fi->stored_windowsa_u = orig->stored_windowsa_u;
  425. fi->stored_windowsa_d = orig->stored_windowsa_d;
  426. fi->stored_tau = orig->stored_tau;
  427. fi->stored_armature_current = orig->stored_armature_current;
  428. fi->stored_speed = orig->stored_speed;
  429. fi->stored_displacement = orig->stored_displacement;
  430. fi->toleranceDefined = orig->toleranceDefined;
  431. /*
  432. * This is a hierarchical call. First let the lower FMUs do their state saving
  433. * We will store the saved fmu state in the fi->c_order[i]
  434. */
  435. for(int i=0;i<1;i++){
  436. fi->fmu[i]=orig->fmu[i];
  437. orig->fmu[i].getFMUstate(orig->c_fmu[i],fi->c_fmu[i]);
  438. fi->fmuResourceLocation[i] = fi->functions->allocateMemory(1+strlen(orig->fmuResourceLocation[i]), sizeof(char));
  439. strcpy((char *)fi->fmuResourceLocation[i],(char *)orig->fmuResourceLocation[i]);
  440. /*make shallow copies of the stored fmus*/
  441. }
  442. //copy r
  443. int i=0;
  444. for (i=0; i< NUMBER_OF_REALS;i++){
  445. printf("Setting real: %i %f\n", i, orig->r[i]);
  446. fi->r[i] = orig->r[i];
  447. printf("Setted real: %i %f\n", i, fi->r[i]);
  448. }
  449. //copy s
  450. for (i=0; i< NUMBER_OF_STRINGS;i++){
  451. //fi->s[i] = orig->s[i]; // why are this not deep copies?
  452. fi->s[i] = fi->functions->allocateMemory(1+strlen(orig->s[i]),sizeof(char));
  453. strcpy((char *)fi->s[i],(char *)orig->s[i]);
  454. }
  455. //copy i
  456. for (i=0; i< NUMBER_OF_INTEGERS;i++){
  457. fi->i[i] = orig->i[i];
  458. }
  459. //copy b
  460. for (i=0; i< NUMBER_OF_BOOLEANS;i++){
  461. fi->b[i] = orig->b[i];
  462. }
  463. return fmi2OK;
  464. }
  465. fmi2Status fmi2SetFMUstate (fmi2Component c, fmi2FMUstate FMUstate) {
  466. FMUInstance* orig = (FMUInstance*)FMUstate;
  467. FMUInstance* fi = (FMUInstance*)c;
  468. /*
  469. * First restore the hierarchical fmus.
  470. */
  471. for(int i=0;i<1;i++){
  472. fi->fmu[i].setFMUstate(fi->c_fmu[i],orig->c_fmu[i]);
  473. fi->fmuResourceLocation[i] = orig->functions->allocateMemory(1+strlen(orig->fmuResourceLocation[i]), sizeof(char));
  474. strcpy((char *)fi->fmuResourceLocation[i],(char *)orig->fmuResourceLocation[i]);
  475. }
  476. //set time etc correct, name and GUID should still be ok ;-)
  477. printf("setting time values from %f to %f\n", fi->currentTime, orig->currentTime);
  478. fi->state = orig->state;
  479. fi->startTime = orig->startTime;
  480. fi->stopTime = orig->stopTime;
  481. fi->currentTime = orig->currentTime;
  482. fi->fmu[0] = orig->fmu[0];
  483. fi->c_fmu[0] = orig->c_fmu[0];
  484. for(int i=0; i<_NR_OF_IN_CONDITIONS;i++){
  485. fi->in_condition_executed[i] = orig->in_condition_executed[i];
  486. }
  487. for(int i=0; i<_NR_OF_OUT_CONDITIONS;i++){
  488. fi->out_conditions_executed[i] = orig->out_conditions_executed[i];
  489. }
  490. for(int i=0;i<_NR_OF_FMUS;i++){
  491. fi->time_last_fmu[i] = orig->time_last_fmu[i];
  492. }
  493. /* Generated */
  494. fi->stored_windowsa_u = orig->stored_windowsa_u;
  495. fi->stored_windowsa_d = orig->stored_windowsa_d;
  496. fi->stored_tau = orig->stored_tau;
  497. fi->stored_armature_current = orig->stored_armature_current;
  498. fi->stored_speed = orig->stored_speed;
  499. fi->stored_displacement = orig->stored_displacement;
  500. fi->toleranceDefined = orig->toleranceDefined;
  501. fi->toleranceDefined = orig->toleranceDefined;
  502. printf("setting real values\n");
  503. //copy r
  504. int i=0;
  505. for (i=0; i< NUMBER_OF_REALS;i++){
  506. fi->r[i] = orig->r[i];
  507. }
  508. printf("setting string values\n");
  509. //copy s
  510. for (i=0; i< NUMBER_OF_STRINGS;i++){
  511. fi->s[i] = orig->s[i];
  512. }
  513. //copy i
  514. for (i=0; i< NUMBER_OF_INTEGERS;i++){
  515. fi->i[i] = orig->i[i];
  516. }
  517. //copy b
  518. for (i=0; i< NUMBER_OF_BOOLEANS;i++){
  519. fi->b[i] = orig->b[i];
  520. }
  521. return fmi2OK;
  522. }
  523. /****************************************************/
  524. fmi2Status fmi2FreeFMUstate(fmi2Component c, fmi2FMUstate* FMUstate) {
  525. printf("Function fmiFreeFMUstate not supported\n");
  526. return fmi2Error;
  527. }
  528. fmi2Status fmi2SerializedFMUstateSize(fmi2Component c, fmi2FMUstate FMUstate, size_t *size) {
  529. printf("Function fmiSerializedFMUstateSize not supported\n");
  530. return fmi2Error;
  531. }
  532. fmi2Status fmi2SerializeFMUstate (fmi2Component c, fmi2FMUstate FMUstate, fmi2Byte serializedState[], size_t size) {
  533. printf("Function fmiSerializeFMUstate not supported\n");
  534. return fmi2Error;
  535. }
  536. fmi2Status fmi2DeSerializeFMUstate (fmi2Component c, const fmi2Byte serializedState[], size_t size, fmi2FMUstate* FMUstate) {
  537. printf("Function fmiDeSerializeFMUstate not supported\n");
  538. return fmi2Error;
  539. }
  540. fmi2Status fmi2GetDirectionalDerivative(fmi2Component c, const fmi2ValueReference vUnknown_ref[], size_t nUnknown,
  541. const fmi2ValueReference vKnown_ref[] , size_t nKnown, const fmi2Real dvKnown[], fmi2Real dvUnknown[]) {
  542. printf("Function fmiGetDirectionalDerivative not supported\n");
  543. return fmi2Error;
  544. }
  545. fmi2Status fmi2SetRealInputDerivatives(fmi2Component c, const fmi2ValueReference vr[], size_t nvr,
  546. const fmi2Integer order[], const fmi2Real value[]) {
  547. printf("Function fmiGetDirectionalDerivative not supported\n");
  548. return fmi2Error;
  549. }
  550. fmi2Status fmi2GetRealOutputDerivatives(fmi2Component c, const fmi2ValueReference vr[], size_t nvr,
  551. const fmi2Integer order[], fmi2Real value[]) {
  552. printf("Function fmiGetDirectionalDerivative not supported\n");
  553. return fmi2Error;
  554. }
  555. fmi2Status fmi2CancelStep(fmi2Component c) {
  556. printf("Function fmiGetDirectionalDerivative not supported\n");
  557. return fmi2Error;
  558. }
  559. fmi2Status fmi2GetStatus(fmi2Component c, const fmi2StatusKind s, fmi2Status *value) {
  560. printf("Function fmiGetStatus not supported\n");
  561. return fmi2Error;
  562. }
  563. fmi2Status fmi2GetRealStatus(fmi2Component c, const fmi2StatusKind s, fmi2Real *value) {
  564. if(s == fmi2LastSuccessfulTime){
  565. FMUInstance* comp = (FMUInstance*) c;
  566. *value = comp->currentTime;
  567. return fmi2OK;
  568. }
  569. printf("Function fmiGetRealStatus not supported\n");
  570. return fmi2Error;
  571. }
  572. fmi2Status fmi2GetIntegerStatus(fmi2Component c, const fmi2StatusKind s, fmi2Integer *value) {
  573. printf("Function fmiGetIntegerStatus not supported\n");
  574. return fmi2Error;
  575. }
  576. fmi2Status fmi2GetBooleanStatus(fmi2Component c, const fmi2StatusKind s, fmi2Boolean *value) {
  577. printf("Function fmiGetBooleanStatus not supported\n");
  578. return fmi2Error;
  579. }
  580. fmi2Status fmi2GetStringStatus(fmi2Component c, const fmi2StatusKind s, fmi2String *value) {
  581. printf("Function fmiGetStringStatus not supported\n");
  582. return fmi2Error;
  583. }