xCreateTaskStatic error: was not declared in this scope

[ubaldot]

I am having the mentioned error message:

src/main.cpp: In function 'void setup()':
src/main.cpp:55:22: error: 'xTaskCreateStatic' was not declared in this scope
   xTaskHandleBlink = xTaskCreateStatic(task_blink, "Blink", STACK_DEPTH_BLINK, NULL, PRIORITY_BLINK,xStackSizeBlink, &xTCBBlink);
                      ^~~~~~~~~~~~~~~~~
src/main.cpp:55:22: note: suggested alternative: 'xTaskCreate'
   xTaskHandleBlink = xTaskCreateStatic(task_blink, "Blink", STACK_DEPTH_BLINK, NULL, PRIORITY_BLINK,xStackSizeBlink, &xTCBBlink);
                      ^~~~~~~~~~~~~~~~~
                      xTaskCreate

If I adjust the code for using xCreateTask, then everything works.

An excerpt of my code is as follows:

#include "Arduino.h"
#include "HardwareSerial.h"
#include <Arduino_FreeRTOS.h>
#include "FreeRTOSConfig.h"

// Task: Blink
void task_blink(void *pVParameters);
// TCB is the part of memory that keeps the task state
static StaticTask_t xTCBBlink;
static StackType_t xStackSizeBlink[128];

// Task: AnalogRead
void task_analog_read(void *pVParameters);
static StaticTask_t xTCBAnalogRead;
static StackType_t xStackSizeAnalogRead[128];

// Aux functions
void set_pid_gains(float * /*Kp*/, float * /*Ki*/, float * /*Kd*/);
void get_serial_message(union Message * /*message*/);

// the setup function runs once when you press reset or power the board
void setup() {

  // initialize serial communication at 9600 bits per second:
  const unsigned int BAUDRATE = 9600;
  Serial.begin(BAUDRATE);

  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB, on LEONARDO,
      // MICRO, YUN, and other 32u4 based boards.
  }

  // Now set up two tasks to run independently.
  // Blink
  const int STACK_DEPTH_BLINK = 128;
  const int PRIORITY_BLINK = 2; 
  TaskHandle_t xTaskHandleBlink = NULL;
  xTaskHandleBlink = xTaskCreateStatic(task_blink, "Blink", STACK_DEPTH_BLINK, NULL, PRIORITY_BLINK,xStackSizeBlink, &xTCBBlink);

  // AnalogRead
  const int STACK_DEPTH_ANALOG_READ = 128;
  const int PRIORITY_ANALOG_READ = 2; 
  TaskHandle_t xTaskHandleAnalogRead = NULL;
  xTaskHandleAnalogRead = xTaskCreateStatic(task_analog_read, "AnalogRead", STACK_DEPTH_ANALOG_READ, NULL,
              PRIORITY_ANALOG_READ,xStackSizeAnalogRead, &xTCBAnalogRead);
}

void loop() {}

// Tasks and functions implementation follows

and my FreeRTOSConfig.h is the following:

#define configSUPPORT_STATIC_ALLOCATION             1
#define configSUPPORT_DYNAMIC_ALLOCATION            0

I have my main.cpp in ./src and the FreeRTOSConfig.h in ./include.
It would be nice to have some examples that use *Static features. :)

[ubaldot]

Ok, I found. The FreeRTOSConfig.h already exists in .pio/libdeps/uno/FreeRTOS and I have to change #define configSUPPORT_STATIC_ALLOCATION there.

But then the question (and this is out of the scope of this tool but it is in Platformio's scope) arise: for each project the ENTIRE library is copied in .pio/libdeps/uno/FreeRTOS? Hence, if I have 3 projects I have 3 hard-copies of the same library?

[feilipu]

Ok, I found. The FreeRTOSConfig.h already exists in .pio/libdeps/uno/FreeRTOS and I have to change #define configSUPPORT_STATIC_ALLOCATION there.

Yes, but not quite the answer I was going to suggest. The FreeRTOSConfig.h file is found in the library source directory and, as the Arduino IDE compiles its libraries first and the sketch last, that library configuration file is used. Unfortunate, but that is just the way it is. Once you find where library code is stored it is easy to change it to suit your needs.

It would be nice to have some examples that use *Static features. :)

Yes, it would. Static allocation is great for systems where you have very limited memory, and are trying to build a robust deterministic system. Typically where you'd be using FreeRTOS.

But using static allocation is dependent on a static memory size and configuration, which is not really the situation we have supporting a range of ATmega devices with between 2k to 16k of RAM available (or 64k or greater using ATmega2560 and its Extended RAM capability). To support this range of machines one flexible memory allocation system heap3.c was selected which uses the avrlibc malloc() function at its base.

If you want to try static allocation further, have a look at floessie's frt library, which wraps this library and he also has a minimal-static fork but it is a few years old.

Typically you'd just want to look at which machine you have and then change the memory system allocation to use heap1.c,heap2.c, or heap4.c. Examples of these can be found in my avrfreertos repository. Use the configTOTAL_HEAP_SIZE definition found in the board definitions file to match the machine type you have, for example ATmega328p, ATmega1284p, ATmega2560, etc.

[ubaldot]

Yes, but not quite the answer I was going to suggest.

Ah OK! What would that be your answer then?
Mind that I am an embedded systems hobbist and I am exploring the *Static thing with the sole purpose of learning.
So any other view is very appreciated and pedagogical.

But using static allocation is dependent on a static memory size and configuration, which is not really the situation we have supporting a range of ATmega devices with between 2k to 16k of RAM available

Let me try to rephrase: you are saying that by default freertos has dynamic memory allocation to be as more general as possible to cover more boards and to prevent too much hassle for the user in case of dealing with prototypes ad also for portability issues?
But once a board is fixed it could be a good idea to use *Static - even if the heap management seems very good in freertos?

Thanks for the links, I will look into that!

[feilipu]

Yes, but not quite the answer I was going to suggest.

Ah OK! What would that be your answer then?

The FreeRTOSConfig.h file is found in the library source directory and, as the Arduino IDE compiles its libraries first and your sketch last, that library configuration file is used (and others are not).

Default Arduino FreeRTOS has dynamic memory allocation to be as more general as possible to cover more boards and to prevent too much hassle for the user.

Yes. The assumption for Arduino is that the user is an artist or hobbyist or tinkerer or student who just wants to get something done, without necessarily knowing the details. Hence the original setup() and loop() functions being all you needed to get things going. IMHO, more recently people use Arduino for more professional uses, perhaps at their own risk. As this library covers multiple hardware options, I used the memory management based on the avrlibc malloc() function.

But once a board is fixed it could be a good idea to use *Static - even if the heap management seems very good in freertos?

Yes, the best idea is to use static allocation of memory wherever possible. FreeRTOS has great heap management and monitoring options based off static memory. heap1.c allows allocation, but can't free memory. heap2.c allows reallocation, but can't coalesce memory freed (fragmentation). heap4.chelps to avoid fragmentation if you application needs to allocate and free memory often.