在队列 FreeRTOS 中传递变量

Question

On the STM32F103 I measure the voltage and display the result on the LCD. The result is displayed, the code is as follows:

HAL_ADCEx_InjectedStart(&hadc1);
HAL_ADC_PollForConversion(&hadc1,100);
u0= 180 - (180*(3 - ((float)HAL_ADCEx_InjectedGetValue(&hadc1,ADC_INJECTED_RANK_1))*3/4096));      
sprintf(str,"%.1fV",u0);
LCD_String(str);
HAL_ADCEx_InjectedStop(&hadc1);

I wanted to separate the operations into tasks, that is, we measure in the StartADC task and pass it through the queue to the StartLCDTask task, which displays the result on the display. But instead of the measured value, the display shows 0V. Where did I go wrong?

/* Definitions for UARTQueue*/
osMessageQueueId_t UARTQueueHandle 
/* creation of UARTQueue*/
UARTQueueHandle = osMessageQueueNew (8, sizeof(uint8_t), &UARTQueue_attributes);

typedef struct {
   char Buf;
} QUEUE_t;

void StartADC(void *argument)
{
   char u0;
  for(;;)
  {
   HAL_ADCEx_InjectedStart(&hadc1);
   HAL_ADC_PollForConversion(&hadc1,100);
   u0= 180 - (180*(3 - ((float)HAL_ADCEx_InjectedGetValue(&hadc1,ADC_INJECTED_RANK_1))*3/4096));      
   osMessageQueuePut(UARTQueueHandle, &u0, 0, osWaitForever);
   HAL_ADCEx_InjectedStop(&hadc1);
   osDelay(200);
  }
}

void StartLCDTask(void *argument)
{
   QUEUE_t msg;
   char str[9];
  for(;;)
  {
   osMessageQueueGet(UARTQueueHandle, &msg, 0, osWaitForever);
   sprintf(str,"%.0fV", (double)msg.Buf);
   LCD_SetPos(0,0);
   LCD_String(str);
  }
}

Answer 1

In your first example, you do:

sprintf(str,"%.1fV",u0);

This implies u0 is float . If it's not, then this is UB (undefined behavior)

But, in your second example, u0 is char u0; You are truncating a floating point value to a char . The fractional part will be lost.

Then, you enqueue it and send it.

And, you're "cheating" a bit:

1. You're sending a char but receiving a QUEUE_t .
2. The queue is initialized with a msg_size of sizeof(uint8_t) instead of sizeof(QUEUE_t)

This "happens" to work but it's sloppy. It's not very extensible. It would break if the QUEUE_t struct was extended and needed multiple values to be sent. We'll need to fix that below.

The recipient StartLCDTask does:

sprintf(str, "%.0fV", (double) msg.Buf);

The two sprintf are not equivalent.

---

Now that you have two tasks you have the choice of which task/function does the calculation/conversion of the raw ADC value (which is a uint32_t ). In either case, we'll need to change QUEUE_t to handle the value.

Here is a version that enqueues the raw value and has the display task do the conversion.

/* Definitions for UARTQueue*/
osMessageQueueId_t UARTQueueHandle;

typedef struct {
    uint32_t adcraw;
} QUEUE_t;

/* creation of UARTQueue*/
void
init_queue(void)
{
    UARTQueueHandle = osMessageQueueNew(8, sizeof(QUEUE_t),
        &UARTQueue_attributes);
}

void
StartADC(void *argument)
{
    QUEUE_t msg;

    for (;;) {
        HAL_ADCEx_InjectedStart(&hadc1);
        HAL_ADC_PollForConversion(&hadc1, 100);

        msg.adcraw = HAL_ADCEx_InjectedGetValue(&hadc1, ADC_INJECTED_RANK_1);

        osMessageQueuePut(UARTQueueHandle, &msg, 0, osWaitForever);

        HAL_ADCEx_InjectedStop(&hadc1);

        osDelay(200);
    }
}

void
StartLCDTask(void *argument)
{
    QUEUE_t msg;
    float_t u0;
    char str[20];

    for (;;) {
        osMessageQueueGet(UARTQueueHandle, &msg, 0, osWaitForever);

        u0 = msg.adcraw;
        u0 = 180 - (180 * (3 - u0 * 3 / 4096));

        sprintf(str, "%.0fV", u0);

        LCD_SetPos(0, 0);
        LCD_String(str);
    }
}

---

UPDATE:

Although I noted this before, I didn't realize the possible impact.

In the single task code, the format is:

"%.1fV"

But, this got changed for the multiple task code:

"%.0fV"

I suspect that this is a typo. I think the format should be the same in both cases.