Problems with xMessageBufferReceive.

[ubaldot]

As a pedagogical exercise, I wrote an app with one task that blink a led and push some string in a Message buffer. (task1)
Messages from the Message Buffer are sent over serial from another task (task2).
I further used a binary semaphore and a mutex for regulating the access to the Message Buffer and the Serial.

My problem is that everything get stuck when I use xMessageBufferReceive().
Below a reproducible code, where I marked the non working part.
If you comment that section and uncomment e.g. the line above ( /* Serial.println("TEST"); */) you will see that everything works.
What I am doing wrong?

#include "FreeRTOSVariant.h"
#include "HardwareSerial.h"
#include "portable.h"
#include "projdefs.h"
#include <Arduino.h>
#include <message_buffer.h>
#include <semphr.h>

// Global variables: semaphore and message buffer
/* Create a message buffer to send data to the serial*/
const size_t MESSAGE_SIZE = 100;
MessageBufferHandle_t xMessageBuffer = xMessageBufferCreate(MESSAGE_SIZE);

/* Create a semaphore to control access to the message buffer */
// TODO: do we really need static?
static SemaphoreHandle_t xSemaphoreMessageBuffer = xSemaphoreCreateBinary();
static SemaphoreHandle_t xSemaphoreSerialPort = xSemaphoreCreateMutex();

// Task functions prototypes
void task_blink(void *pVParameters);
void task_serial(void *pVParameters);

void setup() {

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

  // TODO: is it really needed?
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB, on LEONARDO,
  }

  // Release all the semaphore at the very beginning.
  xSemaphoreGive(xSemaphoreMessageBuffer);
  xSemaphoreGive(xSemaphoreSerialPort);

  // Task: Blink
  const size_t STACK_SIZE_BLINK = 128;
  const uint8_t PRIORITY_BLINK = 2;
  TaskHandle_t xTaskHandleBlink;

  xTaskCreate(task_blink, "Blink", STACK_SIZE_BLINK, NULL, PRIORITY_BLINK,
              &xTaskHandleBlink);

  // Task: Serial
  const size_t STACK_SIZE_SERIAL = 128;
  const uint8_t PRIORITY_SERIAL = 2;
  TaskHandle_t xTaskHandleSerial;

  xTaskCreate(task_serial, "Serial", STACK_SIZE_SERIAL, NULL, PRIORITY_SERIAL,
              &xTaskHandleSerial);
}
// Skip loop. OBS! IdleTask cannot be used!
void loop() {}

// Task implementation
void task_blink(void *pVParameters) // This is a task.
{
  (void)pVParameters;
  const int TASK_PERIOD = 1000;

  // initialize digital LED_BUILTIN on pin 13 as an output.
  pinMode(LED_BUILTIN, OUTPUT);
  static uint8_t counter = 0;
  const size_t MAX_COUNT = 2;

  // Condition for sending a message over the serial port
  boolean isMessageBufferSemaphoreTaken;
  boolean isMessageShortEnough;

  while (true) {
    static bool led_state = false;
    // send something every MAX_COUNT*TASK_PERIOD seconds.

    if (!led_state) {
      digitalWrite(LED_BUILTIN, HIGH);
      led_state = true;
    } else {
      digitalWrite(LED_BUILTIN, LOW);
      led_state = false;
    }

    char message[] = "dog";
    if (counter == MAX_COUNT) {

      // Debug
      /* Serial.print("Available space in message buffer: "); */
      /* Serial.println(xMessageBufferSpacesAvailable((xMessageBuffer))); */

      // Check if you can send a message
      isMessageBufferSemaphoreTaken =
          xSemaphoreTake(xSemaphoreMessageBuffer, 1000 / portTICK_PERIOD_MS) ==
          pdTRUE;
      isMessageShortEnough =
          xMessageBufferSpacesAvailable((xMessageBuffer)) > strlen(message);

      if (isMessageBufferSemaphoreTaken && isMessageShortEnough) {
        xMessageBufferSend(xMessageBuffer, message, sizeof(message), 0);
        /* Serial.println("Message sent!"); */
        xSemaphoreGive(xSemaphoreMessageBuffer);
      }
      counter = 0;
    } else {
      counter++;
    }

    // Task Schedule
    const TickType_t X_DELAY = TASK_PERIOD / portTICK_PERIOD_MS;
    vTaskDelay(X_DELAY); // one tick delay (15ms)
  }
}

void task_serial(void *pVParameters) // This is a task.
{
  (void)pVParameters;
  const uint8_t TASK_PERIOD = 200;
  uint8_t received_data[MESSAGE_SIZE];
  size_t received_bytes;
  received_bytes = 0;

  boolean isMessageBufferSemaphoreTaken;
  boolean isSerialSemaphoreTaken;
  boolean isMessageBufferEmpty;

  while (true) {
    // Conditions for writing on the serial

    isSerialSemaphoreTaken =
        xSemaphoreTake(xSemaphoreSerialPort, 1000 / portTICK_PERIOD_MS) ==
        pdTRUE;
    isMessageBufferSemaphoreTaken =
        xSemaphoreTake(xSemaphoreMessageBuffer, 1000 / portTICK_PERIOD_MS) ==
        pdTRUE;
    isMessageBufferEmpty = xMessageBufferIsEmpty(xMessageBuffer) == pdTRUE;

    if (isSerialSemaphoreTaken) {
      if (isMessageBufferSemaphoreTaken) {
        if (!isMessageBufferEmpty) {
          /* Serial.println("TEST"); */

          /* ------------- BEGIN NON-WORKING PART!!! -----------*/
          received_bytes = xMessageBufferReceive(xMessageBuffer, received_data,
                                                 sizeof(received_data), 0);
          Serial.println(received_bytes);
          /* ------------- END NON-WORKING PART!!! -----------*/
        }
        xSemaphoreGive(xSemaphoreMessageBuffer);
        /* Serial.println("(serial) Semaphore MessageBuffer released."); */
      }
      xSemaphoreGive(xSemaphoreSerialPort);
      /* Serial.println("(serial) Semaphore serial port released."); */
    }

    // TODO: Task Schedule
    const TickType_t X_DELAY = TASK_PERIOD / portTICK_PERIOD_MS;
    vTaskDelay(X_DELAY); // one tick delay (15ms)
  }
}

[feilipu]

Without looking in detail, using Serial.println() is an Arduino C++ trap. Expect to need over 512 bytes of stack to instantiate that class of functions, IIRC, and 128 bytes is nowhere near sufficient. Check other past issues here for more details.

Perhaps test and report if you could, please. Then we can look in more detail.

There's a low level print function available as an option, IIRC.

[ubaldot]

Oh boy! That worked but it was nearly impossible to detect! I'll look into past issues.

[ubaldot]

I looked in the past issued using println but I haven't found so much - if not that it requires lot of memory.
Regarding the low level function, so you mean Serial.write()?

[feilipu]

Best to check the Arduino Serial Class to be sure, but anyway the general suggestions given here by Adafruit apply. But remember the standard stack is replaced by individual Task stacks that are size limited, rather than being all the free memory growing down to the end of the heap.