esp-idf: Conditional inclusion of components with same functions

Question

I'm working on a project which requires to develop the firmware for several esp32. All the microcontrollers share a common code that takes care of wifi and mqtt, however they all have a different behavior, which is defined in a specific component. The structure of my project is something like this:

    - CMakeLists.txt
    - Makefile
    - sdkconfig
    - main
        - CMakeLists.txt
        - main.c
    - components
        - wifi_fsm
            - wifi_fsm.h
            - wifi_fsm.c
            - CMakeLists.txt
        - mqtt_fsm
            - mqtt_fsm.h
            - mqtt_fsm.c
            - CMakeLists.txt
        - entity_1
            - entity_1.h
            - entity_1.c
            - CMakeLists.txt
        - entity2
            - entity2.h
            - entity2.c
            - CMakeLists.txt
        ...

Each entity defines some functions with standard names, which implement specific logic for the entity itself and which are called within the shared code (main, wifi_fsm, mqtt_fsm).

void init_entity();                  // called in main.c
void http_get(char *buf);            // called in wifi_fsm
void http_put(char *buf);
void mqtt_msg_read(char *buf);       // called in mqtt_fsm
void mqtt_msg_write(char *buf);

My idea was to have a conditional statement to include at will a specific behavior, so that depending on the entity included, the compiler would link the calls to the functions above to those found in the specific included library. Therefore, at the beginning of main.c I just added the following lines with the goal of having to change the only defined pre-processor symbol to compile for different enity behaviors.

#define ENTITY_1

#ifdef ENTITY_1
  #include "entity_1.h"
#elif defined ENTITY_2
  #include "entity_2.h"
#elif ...
#endif

#include "wifi_fsm.h"
#include "mqtt_fsm.h"

void app_main(void)
{
   while(1){
     ...
   }
}

On the one hand the compiler apparently works fine, giving successful compilation without errors or warnings, meaning that the include chain works correctlty otherwise a duplicate name error for the standard functions would be thrown. On the other hand, it always links against the first entity in alphabetical order, executing for instance the code included in the init_entity() of the component entity_1. If I rename the standard functions in entity_1, then it links against entity_2.

I can potentially use pointers to standard calls to be linked to specific functions in each entity if the approach above is wrong, but I would like to understand first what is wrong in my approach.

EDIT in response to Bodo's request (content of the CMakeFile.txt)

Project:

cmake_minimum_required(VERSION 3.5)

include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(proj)

Main:

set(COMPONENT_REQUIRES )
set(COMPONENT_PRIV_REQUIRES )

set(COMPONENT_SRCS "main.c")
set(COMPONENT_ADD_INCLUDEDIRS "")

register_component()

Component:

set(COMPONENT_SRCDIRS "src")
set(COMPONENT_ADD_INCLUDEDIRS "include")

set(COMPONENT_REQUIRES log freertos driver nvs_flash esp_http_server mqtt)

register_component()

Answer 1

This answer is based on guessing because I don't have enough information. For the same reason it is incomplete in some parts or may not fully match the use case of the question.

The details about how the project will be built seems to be hidden in a cmake include file like project.cmake or nested include files.

My guess is that the build system creates libraries from the source code of every individual component and then links the main object file with the libraries. In this case, the linker will find a symbol like init_entity in the first library that fulfills the dependency. This means the library (=component) listed first in the linker command line will be used.

If the linker command line would explicitly list the object files entity_1.o and entity_2.o, I would expect an error message about a duplicate symbol init_entity.

I can propose two ways to solve the problem:

1. Make sure only the selected entity is used to build the program.

2. Make the identifier names unique in all entities and use preprocessor macros to choose the right one depending on the selected entity.

---

For the first approach you can use conditionals in CMakeLists.txt. See https://stackoverflow.com/a/15212881/10622916 for an example. Maybe the register_component() is responsible for adding the component to the build. In this case you could wrap this in a condition.

BUT modifying the CMakeLists.txt might be wrong if the files are generated automatically.

---

For the second approach you should rename the identifiers in the entities to make them unique. The corresponding header files can define a macro to replace the common name intended for the identifier with the specific identifier of the selected entity.

In the code that uses the selected entity you will always use the common name, not the individual names.

Example:

entity_1.c:

#include "entity_1.h"

void init_entity_1(void)
{
}

entity_2.c:

#include "entity_2.h"

void init_entity_2(void)
{
}

entity_1.h:

void init_entity_1(void);
// This replaces the token/identifier "init_entity" with "init_entity_1" in subsequent source lines
#define init_entity init_entity_1
// or depending on the parameter list something like
// #define init_entity() init_entity_1()
// #define init_entity(x,y,z) init_entity_1(y,x,z)

entity_2.h:

void init_entity_2(void);
#define init_entity init_entity_2

main.c

#define ENTITY_1

#ifdef ENTITY_1
  #include "entity_1.h"
#elif defined ENTITY_2
  #include "entity_2.h"
#elif ...
#endif


void some_function(void)
{
    init_entity();
}

In this example case with #define ENTITY_1, the preprocessor will change some_function to

void some_function(void)
{
    init_entity_1();
}

before the compilation step and the linker will use init_entity_1 from entity_1.c. An optimizing linker may then omit the object file entity_2.o or the corresponding library because it is unused.