Skip to content

Commit b56b9a4

Browse files
author
Nicolas Laurent
committed
Implement clocked port inside FMU Container
1 parent 2c864f5 commit b56b9a4

File tree

7 files changed

+485
-118
lines changed

7 files changed

+485
-118
lines changed

‎container/container.c‎

Lines changed: 121 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -63,14 +63,29 @@ void container_init_values(container_t* container) {
6363
return;
6464
}
6565

66+
static void container_get_next_clock_time(container_t *container) {
67+
double t;
68+
unsigned int vr[1];
69+
fmi3IntervalQualifier qualifier;
70+
71+
for (int i=0; i<3; i+=1) {
72+
t = 0;
73+
vr[0] = 3;
74+
qualifier = fmi3IntervalNotYetKnown;
75+
container->fmu[i].fmi_functions.version_3.fmi3GetIntervalDecimal(container->fmu[i].component, vr, 1,&t, &qualifier);
76+
logger(LOGGER_ERROR, "FMU#%d: next_time=%e qualifier=%d", i, t, qualifier);
77+
}
78+
return;
79+
}
6680

6781
static fmu_status_t container_do_step_sequential(container_t *container) {
6882
fmu_status_t status = FMU_STATUS_OK;
6983
double time = container->time_step * container->nb_steps + container->start_time;
7084

85+
logger(LOGGER_ERROR, "container_do_step_sequential()");
7186
for (int i = 0; i < container->nb_fmu; i += 1) {
7287
fmu_t* fmu = &container->fmu[i];
73-
88+
7489
status = fmu_set_inputs(fmu);
7590
if (status != FMU_STATUS_OK) {
7691
logger(LOGGER_ERROR, "Container: FMU#%d failed set inputs.", i);
@@ -91,7 +106,8 @@ static fmu_status_t container_do_step_sequential(container_t *container) {
91106
}
92107

93108
container->nb_steps += 1;
94-
109+
container_get_next_clock_time(container);
110+
logger(LOGGER_ERROR, "container_do_step_sequential()- DONE");
95111
return status;
96112
}
97113

@@ -383,7 +399,10 @@ static int read_conf_local(container_t* container, config_file_t* file) {
383399
ALLOC(booleans, 0);
384400
ALLOC(booleans1, false);
385401
ALLOC(strings, NULL);
386-
402+
/* Strings cannot be NULL */
403+
for (unsigned long i = 0; i < container->nb_local_strings; i += 1)
404+
container->strings[i] = strdup("");
405+
387406
if (container->nb_local_binaries) {
388407
container->binaries = malloc(container->nb_local_binaries * sizeof(*container->binaries));
389408
if (!container->binaries) {
@@ -401,10 +420,6 @@ static int read_conf_local(container_t* container, config_file_t* file) {
401420
ALLOC(clocks, false);
402421
#undef ALLOC
403422

404-
/* Strings cannot be NULL */
405-
for (unsigned long i = 0; i < container->nb_local_strings; i += 1)
406-
container->strings[i] = strdup("");
407-
408423
return 0;
409424
}
410425

@@ -558,43 +573,112 @@ static int read_conf_io(container_t* container, config_file_t* file) {
558573
} \
559574
}
560575

576+
#define READER_FMU_CLOCKED_IO(type, causality) \
577+
if (get_line(file)) { \
578+
logger(LOGGER_ERROR, "Cannot get FMU description for 'clocked " #type "' (" #causality ")"); \
579+
return -1; \
580+
} \
581+
fmu_io->clocked_ ## type . causality = NULL; \
582+
\
583+
if (sscanf(file->line, "%lu %lu", \
584+
&fmu_io->clocked_ ## type .nb_ ## causality, \
585+
&nb_clocked) < 2) { \
586+
logger(LOGGER_ERROR, "Cannot interpret FMU description for 'clocked " #type "' (" #causality ")"); \
587+
return -2; \
588+
}\
589+
\
590+
if (fmu_io->clocked_ ## type .nb_ ## causality > 0) { \
591+
fmu_io->clocked_ ## type . causality = malloc(fmu_io->clocked_ ## type .nb_ ## causality * sizeof(*fmu_io->clocked_ ## type . causality)); \
592+
if (! fmu_io->clocked_ ## type . causality) { \
593+
logger(LOGGER_ERROR, "Read FMU I/O: Memory exhauseted."); \
594+
return -3; \
595+
} \
596+
\
597+
for(unsigned long i = 0; i < fmu_io->clocked_ ## type .nb_ ## causality; i += 1) { \
598+
if (get_line(file)) { \
599+
logger(LOGGER_ERROR, "Cannot get FMU I/O for 'clocked " #type "' (" #causality ")"); \
600+
return -4; \
601+
} \
602+
\
603+
int offset = 0; \
604+
if (sscanf(file->line, "%u %ld%n", \
605+
&fmu_io->clocked_ ## type . causality [i].clock_fmu_vr, \
606+
&fmu_io->clocked_ ## type . causality [i].translations_list.nb, &offset) < 2) { \
607+
logger(LOGGER_ERROR, "Cannot interpret FMU I/O for 'clocked " #type "' (" #causality ")"); \
608+
return -5; \
609+
} \
610+
fmu_io->clocked_ ## type . causality [i].translations_list.translations = malloc( \
611+
fmu_io->clocked_ ## type . causality [i].translations_list.nb * sizeof(*fmu_io->clocked_ ## type . causality [i].translations_list.translations)); \
612+
if (!fmu_io->clocked_ ## type . causality [i].translations_list.translations) { \
613+
logger(LOGGER_ERROR, "Read FMU I/O: Memory exhauseted."); \
614+
return -5; \
615+
} \
616+
for(unsigned long j = 0; i < fmu_io->clocked_ ## type . causality [i].translations_list.nb; j += 1) { \
617+
if (sscanf(file->line+offset, "%u %u%n", \
618+
&fmu_io->clocked_ ## type . causality [i].translations_list.translations[j].vr, \
619+
&fmu_io->clocked_ ## type . causality [i].translations_list.translations[j].fmu_vr, \
620+
&offset) < 2) { \
621+
logger(LOGGER_ERROR, "Cannot interpret details of FMU I/O for 'clocked " #type "' (" #causality ")"); \
622+
} \
623+
fmu_io->clocked_ ## type . causality [i].translations_list.translations[j].vr &= 0xFFFFFF; \
624+
}\
625+
} \
626+
}
627+
628+
629+
561630
static int read_conf_fmu_io_in(fmu_io_t* fmu_io, config_file_t* file) {
562-
READER_FMU_IO(reals64, in);
563-
READER_FMU_IO(reals32, in);
564-
READER_FMU_IO(integers8, in);
565-
READER_FMU_IO(uintegers8, in);
566-
READER_FMU_IO(integers16, in);
567-
READER_FMU_IO(uintegers16, in);
568-
READER_FMU_IO(integers32, in);
569-
READER_FMU_IO(uintegers32, in);
570-
READER_FMU_IO(integers64, in);
571-
READER_FMU_IO(uintegers64, in);
572-
READER_FMU_IO(booleans, in);
573-
READER_FMU_IO(booleans1, in);
574-
READER_FMU_IO(strings, in);
575-
READER_FMU_IO(binaries, in);
576-
READER_FMU_IO(clocks, in);
631+
unsigned long nb_clocked;
632+
633+
#define READER_FMU_IN(type) \
634+
READER_FMU_IO(type, in); \
635+
READER_FMU_CLOCKED_IO(type, in)
636+
637+
READER_FMU_IN(reals64);
638+
READER_FMU_IN(reals32);
639+
READER_FMU_IN(integers8);
640+
READER_FMU_IN(uintegers8);
641+
READER_FMU_IN(integers16);
642+
READER_FMU_IN(uintegers16);
643+
READER_FMU_IN(integers32);
644+
READER_FMU_IN(uintegers32);
645+
READER_FMU_IN(integers64);
646+
READER_FMU_IN(uintegers64);
647+
READER_FMU_IN(booleans);
648+
READER_FMU_IN(booleans1);
649+
READER_FMU_IN(strings);
650+
READER_FMU_IN(binaries);
651+
READER_FMU_IO(clocks, in); /* clock variables cannot be clocked ! */
652+
653+
#undef READER_FMU_IN
577654

578655
return 0;
579656
}
580657

581658

582659
static int read_conf_fmu_io_out(fmu_io_t* fmu_io, config_file_t* file) {
583-
READER_FMU_IO(reals64, out);
584-
READER_FMU_IO(reals32, out);
585-
READER_FMU_IO(integers8, out);
586-
READER_FMU_IO(uintegers8, out);
587-
READER_FMU_IO(integers16, out);
588-
READER_FMU_IO(uintegers16, out);
589-
READER_FMU_IO(integers32, out);
590-
READER_FMU_IO(uintegers32, out);
591-
READER_FMU_IO(integers64, out);
592-
READER_FMU_IO(uintegers64, out);
593-
READER_FMU_IO(booleans, out);
594-
READER_FMU_IO(booleans1, out);
595-
READER_FMU_IO(strings, out);
596-
READER_FMU_IO(binaries, out);
597-
READER_FMU_IO(clocks, out);
660+
unsigned long nb_clocked;
661+
662+
#define READER_FMU_OUT(type) \
663+
READER_FMU_IO(type, out); \
664+
READER_FMU_CLOCKED_IO(type, out)
665+
666+
667+
READER_FMU_OUT(reals64);
668+
READER_FMU_OUT(reals32);
669+
READER_FMU_OUT(integers8);
670+
READER_FMU_OUT(uintegers8);
671+
READER_FMU_OUT(integers16);
672+
READER_FMU_OUT(uintegers16);
673+
READER_FMU_OUT(integers32);
674+
READER_FMU_OUT(uintegers32);
675+
READER_FMU_OUT(integers64);
676+
READER_FMU_OUT(uintegers64);
677+
READER_FMU_OUT(booleans);
678+
READER_FMU_OUT(booleans1);
679+
READER_FMU_OUT(strings);
680+
READER_FMU_OUT(binaries);
681+
READER_FMU_IO(clocks, out); /* clock variables cannot be clocked ! */
598682

599683
return 0;
600684
}

‎container/fmi3.c‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -113,6 +113,7 @@ fmi3Status fmi3EnterInitializationMode(fmi3Instance instance,
113113

114114
container_set_start_values(container, 1);
115115
logger(LOGGER_DEBUG, "fmuSetupExperiment -- OK");
116+
container_init_values(container);
116117

117118
for (int i = 0; i < container->nb_fmu; i += 1) {
118119
fmu_status_t status = fmuEnterInitializationMode(&container->fmu[i]);
@@ -136,6 +137,7 @@ fmi3Status fmi3ExitInitializationMode(fmi3Instance instance){
136137
return fmi3Error;
137138
}
138139
container_init_values(container);
140+
139141
return fmi3OK;
140142
}
141143

@@ -628,7 +630,7 @@ fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance,
628630
fmi3Float64* nextEventTime) {
629631
container_t* container = (container_t*)instance;
630632

631-
__NOT_IMPLEMENTED__
633+
return fmi3OK;
632634
}
633635

634636
/*----------------------------------------------------------------------------
@@ -638,7 +640,7 @@ fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance,
638640
fmi3Status fmi3EnterStepMode(fmi3Instance instance) {
639641
container_t* container = (container_t*)instance;
640642

641-
__NOT_IMPLEMENTED__
643+
return fmi3OK;
642644
}
643645

644646

0 commit comments

Comments
 (0)