{getToc} $title={Índice}
Filas (ou queues, em inglês) são a forma primária de comunicação entre duas tasks do FreeRTOS [1]. Elas podem ser usadas para enviar mensagens tanto entre tasks, quanto entre interrupções e tasks. Na grande maioria dos casos, elas são usadas como buffers FIFO (first in, first out), ou seja, o primeiro item a entrar na fila é o primeiro a sair, apesar de também existirem outras opções.
O presente artigo considera que a pessoa já tenha uma base de FreeRTOS. Caso seja iniciante, é recomendado que veja os dois artigos sobre FreeRTOS disponíveis aqui [2][3].
Para criar a fila, é preciso usar a função xQueueCreate. Ela recebe 2 argumentos, sendo o primeiro o número de itens que a fila suporta, e o segundo o tamanho da estrutura dos itens que serão adicionados na fila, e retorna um handle para a fila criada (ou um ponteiro nulo, em caso de erro). Sendo assim, para se criar uma fila que suporta até 10 números inteiros, pode-se utilizá-la da seguinte forma:
```C
// Handle para a fila
QueueHandle_t myqueue = NULL;
// Alocação de memória para fila
myqueue = xQueueCreate(10, sizeof(int));
```
Para inserir um item na fila, pode ser utilizada a função xQueueSend. Ela recebe 3 parâmetros, o handle da fila que se deseja adicionar o valor, um ponteiro que aponte para o item que se deseja adicionar, e o tempo em ticks que será aguardado, caso a fila esteja cheia. Se o valor desse terceiro parâmetro for 0, a função retornará imediatamente, e caso a fila estiver cheia, nada será adicionado. Um exemplo de uso pode ser visto a seguir:
```C
int val = 0;
// Adiciona o valor da variável val à fila "myqueue"
xQueueSend(myqueue, &val, (TickType_t)0);
```
Para remover os valores da fila, pode-se utilizar a função xQueueReceive, que possui 3 parâmetros. O primeiro é o handle da fila de onde se deseja retirar os itens. Depois, o endereço do local que receberá uma cópia do valor a ser recebido e por último o tempo de espera para receber um item na fila. Se a intenção for travar a task até que algo seja recebido, pode-se estabelecer o tempo de espera como portMAX_DELAY. A função retorna pdTRUE caso consiga ler o item recebido com sucesso, e pdFALSE caso contrário.
O código a seguir insere 3 valores em uma fila que suporta até 10 valores inteiros, e depois lê um a um retirando-os da fila a partir da task “main_task”.
```C
/**
* @file main.c
* @author Matheus
* @brief Exemplo de fila do freertos
*/
#include <stdio.h>
#include <inttypes.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_chip_info.h"
#include "esp_flash.h"
#include "esp_system.h"
#include "esp_log.h"
#include "freertos/queue.h"
#include "freertos/portmacro.h"
static QueueHandle_t myqueue = NULL;
/**
* @brief Task para retirar os elementos da fila
*
* @param pvParameters
*/
void main_task(void *pvParameters)
{
int next_num;
while(myqueue != NULL) {
if(xQueueReceive(myqueue, &next_num, portMAX_DELAY) == pdTRUE)
{
ESP_LOGI("QUEUE", "Número tirado da fila: %d\n", next_num );
}
vTaskDelay(pdMS_TO_TICKS(1000));
}
vTaskDelete(NULL);
}
void app_main(void)
{
myqueue = xQueueCreate(10, sizeof(int));
int val = 0;
// Adiciona valor 0
xQueueSend(myqueue, &val, (TickType_t)0);
val++;
// Adiciona valor 1
xQueueSend(myqueue, &val, (TickType_t)0);
val++;
// Adiciona valor 2
xQueueSend(myqueue, &val, (TickType_t)0);
xTaskCreate(main_task, "main_task", 4096, NULL, 1, NULL);
while(1) {
vTaskDelay(portMAX_DELAY);
}
}
```
O resultado que deve ser printado na tela via IDF monitor é o semelhante ao seguinte:
```bash
...
I (261) app_start: Starting scheduler on CPU0
I (265) main_task: Started on CPU0
I (265) main_task: Calling app_main()
I (265) QUEUE: Número tirado da fila: 0
I (1275) QUEUE: Número tirado da fila: 1
I (2275) QUEUE: Número tirado da fila: 2
```