Why are MSPs in STM32 HAL defined as callback functions?

Question

Please see my edit:

I asked this question stackoverflow and no one answered. In STM32CubeMX MSP stands for MCU Support Package and of all here is what it basically about:

MSPs are user callback functions to perform system level initializations such as (Clock, GPIOs, DMA, interrupts).

Now I'm looking at such a function used as:

HAL_TIM_MspPostInit(&htim2);

And when I open declaration it is found under stm32f3xx_hal_msp.c as:

void HAL_TIM_MspPostInit(TIM_HandleTypeDef* htim)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(htim->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspPostInit 0 */

  /* USER CODE END TIM2_MspPostInit 0 */

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**TIM2 GPIO Configuration
    PA0     ------> TIM2_CH1
    */
    GPIO_InitStruct.Pin = GPIO_PIN_0;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN TIM2_MspPostInit 1 */

  /* USER CODE END TIM2_MspPostInit 1 */
  }

Now in C callback function is a function which its pointer is passed to another function. Here selected answer is an example.

My question is: What makes MSPs callback functions? They get structs passed as arguments not functions. And where are the callbacks in MSPs? I could not see the footprint of a callback function there. An example would help.

EDIT:

I still dont get it. Here is what CubeMX generates in main.c:

static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 65535;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 5000;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.BreakFilter = 0;
  sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
  sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
  sBreakDeadTimeConfig.Break2Filter = 0;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */
  HAL_TIM_MspPostInit(&htim1);

}

Look at the last line above!:

It is: HAL_TIM_MspPostInit(&htim1);

This is obviously a function call from main.c to stm32f3xx_hal_msp.c library.

But almost all of the answers claims the following:

it is a callback from HAL to user code.

But to me it is a function call from the user code to HAL. Where am I wrong?

Answer 1

You have a misconception what a callback means. It just means a function that is called back from e.g. some library code, whether or not you provide the library with info what to call or not.

Maybe you are just used to the mechanism that when you do some kind of thing that requires a callback, you have been able to provide the pointer to callback function yourself. An example of this is the C sort() function which requires you to provide a callback function which can compare the two elements to be able to sort them.

But sometimes you can't provide a custom callback and you have to have a function with a specific name for the callback. It still is exactly the same callback mechanism, it does not change it in any way whether the callback can be set or if it is fixed.

Answer 2

Callback functions is a well-defined term meaning "function defined by my application but called by someone else". Someone else being a library or an OS.

Take for example the pthreads library where you upon creation hand the library a function pointer to your custom function, which is then called not by your application code but the underlying library/OS. The function definition resides in your code but the function call does not. Another example is the bsearch/qsort functions in the C standard lib taking a callback comparison function as parameter.

Callbacks are very similar to interrupt service routines (ISR) with the only distinction that an ISR is called by hardware, but a callback is called by some software library, like a driver or HAL.

HAL_TIM_MspPostInit(&htim2); is an explicit function call, so if this is the only way this function is called, it is not a callback function. Callback functions almost certainly involve a function pointer interface, similar to this:

void some_timer_init (void (*callback)(void), int interval);

Assume this is a HAL for some timer hardware peripheral. You want this lib to call a function toggling a LED every 100ms, so you come up with a function like:

void toggle_led (void)
{
  THE_LED ^= MASK;
}

In case the some_timer_init implements a timer ISR internally, it can then register your toggle_led function as a callback, to get called by the ISR every 100ms. You would register it by calling some_timer_init(toggle_led, 100);.

Basically every single sensible hardware timer peripheral HAL uses callbacks, so understanding them is crucial for any professional microcontroller programming project.

Answer 3

"Callback" is not exactly what you think it is. Well, it kinda is, but not exactly. It's a poor name for the concept that confuses many people. It means "call at the back" (still confusing) or "function called after some other function" (disputed; your definition isn't wrong either). If you set function2() to be called at the end of function1(), then function2() is a callback function (and it is passed as an argument to function1()). Whenever function1() did its job, callback function function2() is called.

There is some fuzziness on the precise definition (as usual; depends on context of the discussion), such as the wikipedia article or top 2 stackoverflow answers to this question that I find good.

---

What makes the function you provided a callback one stands in its name - "postInit". It's called at the end of some initialization function. Simple as that.