Platformio create libopencm3 + FreeRTOS project

PlatformIO: libopencm3 + FreeRTOS

The following steps are based on common Bluepill STM32F103C8T6, Also applicable to other libopencm3 Supported by MCU model

Scheme 1 : Copy only the files you need

1. stay PlatformIO in , Board choice Bluepill F103C8, Framework choice libopencm3, Create project
2. In the project lib Create a new directory FreeRTOS
3. Unzip the latest FreeRTOS
   1. Copy FreeRTOS/Source/ Under the table of contents , except portable All other files and directories except directory , to lib/FreeRTOS Next
   2. Copy FreeRTOS/Source/portable/GCC/ARM_CM3 All files in the directory (port.c, portmacro.h), to lib/FreeRTOS Next
   3. Copy FreeRTOS/Source/portable/Common All files in the directory (mpu_wrappers.c), to lib/FreeRTOS Next
   4. Copy FreeRTOS/Source/portable/MemMang Under the table of contents heap_4.c, to lib/FreeRTOS Next
4. Copy FreeRTOSConfig.h, to lib/FreeRTOS/include Next
5. To write src/main.c

After completion, the directory structure should be

├── include
│   └── README
├── lib
│   ├── FreeRTOS
│   │   ├── croutine.c
│   │   ├── event_groups.c
│   │   ├── heap_4.c
│   │   ├── include
│   │   │   ├── atomic.h
│   │   │   ├── croutine.h
│   │   │   ├── deprecated_definitions.h
│   │   │   ├── event_groups.h
│   │   │   ├── FreeRTOSConfig.h
│   │   │   ├── FreeRTOS.h
│   │   │   ├── list.h
│   │   │   ├── message_buffer.h
│   │   │   ├── mpu_prototypes.h
│   │   │   ├── mpu_wrappers.h
│   │   │   ├── portable.h
│   │   │   ├── projdefs.h
│   │   │   ├── queue.h
│   │   │   ├── semphr.h
│   │   │   ├── stack_macros.h
│   │   │   ├── StackMacros.h
│   │   │   ├── stdint.readme
│   │   │   ├── stream_buffer.h
│   │   │   ├── task.h
│   │   │   └── timers.h
│   │   ├── list.c
│   │   ├── mpu_wrappers.c
│   │   ├── port.c
│   │   ├── portmacro.h
│   │   ├── queue.c
│   │   ├── stream_buffer.c
│   │   ├── tasks.c
│   │   └── timers.c
│   └── README
├── platformio.ini
├── README.md
├── src
│   └── main.c
└── test
    └── README

Option two : complete FreeRTOS, Use library.json

1. stay PlatformIO in , Board choice Bluepill F103C8, Framework choice libopencm3, Create project
2. In the project lib Create a new directory FreeRTOS
3. Unzip the latest FreeRTOS
4. Copy FreeRTOS/Source/ All files in the directory to lib/FreeRTOS Next
5. Copy FreeRTOS/Source/portable/GCC/ARM_CM3 Under the table of contents portmacro.h to lib/FreeRTOS Next , because library.json Multiple... Are not supported yet include route
6. Copy FreeRTOSConfig.h, to lib/FreeRTOS Next
7. lib/FreeRTOS Add below library.json
8. To write src/main.c

library.json The contents are as follows , Include only what you need c file

{
    "name": "FreeRTOS",
    "version": "10.4.6",
    "build": {
        "srcFilter": [
            "+<*.c>",
            "+<portable/GCC/ARM_CM3/port.c>",
            "+<portable/MemMang/heap_4.c>"
        ]
    }
}

If it's multi-core MCU, Need to include again mpu_wrappers.c, about F103C8 Not really

"+<portable/Common/mpu_wrappers.c>",

After completion, the directory structure is

├── include
│   └── README
├── lib
│   ├── FreeRTOS
│   │   ├── croutine.c
│   │   ├── event_groups.c
│   │   ├── FreeRTOSConfig.h
│   │   ├── include
│   │   ├── library.json
│   │   ├── list.c
│   │   ├── miniprintf.c
│   │   ├── miniprintf.h
│   │   ├── portable
│   │   ├── portmacro.h
│   │   ├── queue.c
│   │   ├── stream_buffer.c
│   │   ├── tasks.c
│   │   └── timers.c
│   └── README
├── platformio.ini
├── README.md
├── src
│   └── main.c
└── test
    └── README

Sample code

Use Queue Of UART Send and receive

/* Task based UART demo, using queued communication.
 *
 *    TX:    A9  ====> RX of TTL serial
 *    RX:    A10 <==== TX of TTL serial (not used)
 */
#include <FreeRTOS.h>
#include <task.h>
#include <queue.h>

#include <libopencm3/stm32/rcc.h>
#include <libopencm3/stm32/gpio.h>
#include <libopencm3/stm32/usart.h>

static QueueHandle_t uart_txq;        // TX queue for UART

/*********************************************************************
 * Configure and initialize USART1:
 *********************************************************************/
static void
uart_setup(void) {

    rcc_periph_clock_enable(RCC_GPIOA);
    rcc_periph_clock_enable(RCC_USART1);

    // UART TX on PA9 (GPIO_USART1_TX)
    gpio_set_mode(GPIOA,
        GPIO_MODE_OUTPUT_50_MHZ,
        GPIO_CNF_OUTPUT_ALTFN_PUSHPULL,
        GPIO_USART1_TX);

    usart_set_baudrate(USART1,115200);
    usart_set_databits(USART1,8);
    usart_set_stopbits(USART1,USART_STOPBITS_1);
    usart_set_mode(USART1,USART_MODE_TX);
    usart_set_parity(USART1,USART_PARITY_NONE);
    usart_set_flow_control(USART1,USART_FLOWCONTROL_NONE);
    usart_enable(USART1);

    // Create a queue for data to transmit from UART
    uart_txq = xQueueCreate(256,sizeof(char));
}

/*********************************************************************
 * USART Task: 
 *********************************************************************/
static void
uart_task(void *args __attribute__((unused))) {
    char ch;

    for (;;) {
        // Receive char to be TX
        if ( xQueueReceive(uart_txq,&ch,500) == pdPASS ) {
            // if not tx data buffer empty
            while ( !usart_get_flag(USART1,USART_SR_TXE) )
                taskYIELD();    // Yield until ready
            usart_send(USART1,ch);
        }
        // Toggle LED to show signs of life
        gpio_toggle(GPIOB,GPIO12);
        gpio_toggle(GPIOC,GPIO13);
    }
}

/*********************************************************************
 * Queue a string of characters to be TX
 *********************************************************************/
static void
uart_puts(const char *s) {
    
    for ( ; *s; ++s ) {
        // blocks when queue is full
        xQueueSend(uart_txq,s,portMAX_DELAY); 
    }
}

/*********************************************************************
 * Demo Task:
 *    Simply queues up two line messages to be TX, one second
 *    apart.
 *********************************************************************/
static void
demo_task(void *args __attribute__((unused))) {

    for (;;) {
        uart_puts("Now this is a message..\n\r");
        uart_puts(" sent via FreeRTOS queues.\n\n\r");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

/*********************************************************************
 * Main program & scheduler:
 *********************************************************************/
int
main(void) {

    rcc_clock_setup_in_hse_8mhz_out_72mhz();    // CPU clock is 72 MHz

    // GPIO PB12,PC13:
    rcc_periph_clock_enable(RCC_GPIOB);
    rcc_periph_clock_enable(RCC_GPIOC);
    gpio_set_mode(
        GPIOC,
        GPIO_MODE_OUTPUT_2_MHZ,
        GPIO_CNF_OUTPUT_PUSHPULL,
        GPIO13);
    gpio_set_mode(
        GPIOB,
        GPIO_MODE_OUTPUT_2_MHZ,
        GPIO_CNF_OUTPUT_PUSHPULL,
        GPIO12);
	// Turn LED off
    gpio_set(GPIOB, GPIO12);
    gpio_set(GPIOC, GPIO13);

    uart_setup();

    xTaskCreate(uart_task,"UART",100,NULL,configMAX_PRIORITIES-1,NULL);
    xTaskCreate(demo_task,"DEMO",100,NULL,configMAX_PRIORITIES-1,NULL);

    vTaskStartScheduler();
    for (;;);
    return 0;
}