integrated FreeRTOS for STM32F

cmake/freeRTOSUtils.cmake

@@ -0,0 +1,38 @@
+function(freertos_get_source_files list_out)
+    set(list_local "")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/croutine.c")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/event_groups.c")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/list.c")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/stream_buffer.c")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/tasks.c")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/timers.c")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/queue.c")
+    set(${list_out} ${list_local} PARENT_SCOPE)
+endfunction()
+function(freertos_get_header_files list_out)
+    set(list_local "")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/FreeRTOSConfig.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/atomic.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/croutine.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/deprecated_definitions.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/event_groups.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/FreeRTOS.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/list.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/message_buffer.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/mpu_prototypes.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/mpu_syscall_numbers.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/mpu_wrappers.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/newlib-freertos.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/picolibc-freertos.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/portable.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/projdefs.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/queue.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/semphr.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/stack_macros.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/StackMacros.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/stream_buffer.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/task.h")
+    list(APPEND list_local "${CMAKE_CURRENT_SOURCE_DIR}/include/timers.h")
+    set(${list_out} ${list_local} PARENT_SCOPE )
+endfunction()
+

tests/CMakeLists.txt

@@ -165,3 +165,26 @@ memory_test_check(enough_memory)
 if(${enough_memory} STREQUAL "true")
     add_subdirectory(file_system)
 endif()
+# led_freertos_test
+if(${TOOLCHAIN_ID} STREQUAL "gcc_arm_none_eabi"  AND ${MCU_NAME} MATCHES "^STM32F(.+)$")
+    add_subdirectory(led_freertos_test)
+endif()
+
+#producer_consumer
+if(${TOOLCHAIN_ID} STREQUAL "gcc_arm_none_eabi"  AND ${MCU_NAME} MATCHES "^STM32F(.+)$")
+    add_subdirectory(producer_consumer) 
+endif()
+
+#signalling
+if(${TOOLCHAIN_ID} STREQUAL "gcc_arm_none_eabi"  AND ${MCU_NAME} MATCHES "^STM32F(.+)$")
+    add_subdirectory(signalling) 
+endif()
+
+#blinking_diodes
+if(${TOOLCHAIN_ID} STREQUAL "gcc_arm_none_eabi"  AND ${MCU_NAME} MATCHES "^STM32F(.+)$")
+    add_subdirectory(blinking_diodes) 
+endif()
+#task_notifications
+if(${TOOLCHAIN_ID} STREQUAL "gcc_arm_none_eabi"  AND ${MCU_NAME} MATCHES "^STM32F(.+)$")
+    add_subdirectory(task_notifications)
+endif()

tests/blinking_diodes/CMakeLists.txt

@@ -0,0 +1,32 @@
+add_executable( blinking_diodes
+    main.c
+)
+
+############################ blinking_diodes GENERATED CODE START ###########################
+find_package(MikroSDK.Driver.GPIO.Port REQUIRED)
+target_link_libraries(blinking_diodes PUBLIC MikroSDK.Driver.GPIO.Port)
+find_package(MikroSDK.Driver.GPIO.Out REQUIRED)
+target_link_libraries( blinking_diodes PUBLIC MikroSDK.Driver.GPIO.Out)
+find_package(MikroSDK.Driver.GPIO.In REQUIRED)
+target_link_libraries( blinking_diodes PUBLIC MikroSDK.Driver.GPIO.In)
+find_package(MikroSDK.Driver REQUIRED)
+target_link_libraries( blinking_diodes PUBLIC MikroSDK.Driver)
+find_package(MikroSDK.Board REQUIRED)
+target_link_libraries( blinking_diodes PUBLIC MikroSDK.Board)
+find_package(MikroC.Core REQUIRED)
+target_link_libraries( blinking_diodes PUBLIC MikroC.Core)
+############################ blinking_diodes GENERATED CODE END ###########################
+target_link_libraries( blinking_diodes PUBLIC
+    MikroC.Core
+    MikroSDK.Board
+    MikroSDK.Driver
+    MikroSDK.Driver.GPIO.In
+    MikroSDK.Driver.GPIO.Port
+    MikroSDK.Driver.GPIO.Out
+    MikroSDK.FreeRTOS
+)
+target_include_directories( blinking_diodes PUBLIC
+    ${PROJECT_SOURCE_DIR}/../thirdparty/freeRTOS/include
+	${PROJECT_SOURCE_DIR}/
+) 
+target_sources( blinking_diodes PRIVATE ./systick.h)

tests/blinking_diodes/main.c

@@ -0,0 +1,57 @@
+#include "board.h"
+#include "drv_digital_out.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "portmacro.h"
+#include "semphr.h"
+#include "systick.h"
+#include <sys/time.h>
+#include "drv_port.h"
+
+#define NUMBER_OF_PINS 4
+
+static digital_out_t pinA;
+static digital_out_t pinB;
+static digital_out_t pinC;
+static digital_out_t pinD;
+static digital_out_t pins[NUMBER_OF_PINS];
+static SemaphoreHandle_t semaphores[NUMBER_OF_PINS];
+
+static void foo(void* param)
+{
+    while(1){
+        xSemaphoreTake(semaphores[((int)param)], portMAX_DELAY);
+        digital_out_toggle(&pins[((int)param)]);
+        vTaskDelay(100);
+        xSemaphoreGive(semaphores[(((int)param)+1)%NUMBER_OF_PINS]);
+    }
+}
+
+int main(){
+    #ifdef PREINIT_SUPPORTED
+    preinit();
+    #endif
+    __asm volatile ("cpsie i");
+    digital_out_init(&pinA, PD0);
+    digital_out_init(&pinB, PD1);
+    digital_out_init(&pinC, PD2);
+    digital_out_init(&pinD, PD3);
+    pins[0]=pinA;
+    pins[1]=pinB;
+    pins[2]=pinC;
+    pins[3]=pinD;
+    for(int i=0; i<NUMBER_OF_PINS; i++){
+        semaphores[i]=xSemaphoreCreateBinary();
+    }
+    xSemaphoreGive(semaphores[0]);
+
+    for(int i=0; i<NUMBER_OF_PINS; i++){
+        if(xTaskCreate(foo, '0'+i, 128, i, 4, NULL)==pdPASS){
+
+        }else {
+            while(1);
+        }
+    }
+    vTaskStartScheduler();
+    while(1);
+}

tests/blinking_diodes/systick.h

@@ -0,0 +1,116 @@
+#include <mcu.h>
+
+#ifndef SysTick_IRQn
+    #define SysTick_IRQn -1
+#endif
+
+// CMSIS Core macros.
+#define SCS_BASE (0xE000E000UL)         /*!< System Control Space Base Address */
+
+#define SCB_BASE (SCS_BASE + 0x0D00UL)  /*!< System Control Block Base Address */
+#define SCB ((SCB_Type *)SCB_BASE)      /*!< SCB configuration struct */
+
+#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */
+#define NVIC ((NVIC_Type *)NVIC_BASE)   /*!< NVIC configuration struct */
+
+#define SysTick_BASE (SCS_BASE + 0x0010UL)     /*!< SysTick Base Address */
+#define SysTick ((SysTick_Type *)SysTick_BASE) /*!< SysTick configuration struct */
+
+// SysTick settings.
+#define TICK_FREQ_10HZ 100U
+#define TICK_FREQ_100HZ 10U
+#define TICK_FREQ_1KHZ 1U
+#define TICK_FREQ_DEFAULT TICK_FREQ_1KHZ
+#define GET_TICK_NUMBER_PER_CLOCK ((FOSC_KHZ_VALUE*1000UL) / (1000U / TICK_FREQ_DEFAULT))
+
+// Systick API prototypes.
+static inline uint32_t sysTickConfig(uint32_t ticks) __attribute__((always_inline));
+static inline void sysTickInit(uint8_t priority) __attribute__((always_inline));
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct {
+    volatile uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+    volatile uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+    volatile uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+    volatile uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+    volatile uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+    volatile uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+    volatile uint8_t  SHP[12U];               /*!< Offset: 0x018 (R/W)  System Handlers Priority Registers (4-7, 8-11, 12-15) */
+    volatile uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+    volatile uint32_t CFSR;                   /*!< Offset: 0x028 (R/W)  Configurable Fault Status Register */
+    volatile uint32_t HFSR;                   /*!< Offset: 0x02C (R/W)  HardFault Status Register */
+    volatile uint32_t DFSR;                   /*!< Offset: 0x030 (R/W)  Debug Fault Status Register */
+    volatile uint32_t MMFAR;                  /*!< Offset: 0x034 (R/W)  MemManage Fault Address Register */
+    volatile uint32_t BFAR;                   /*!< Offset: 0x038 (R/W)  BusFault Address Register */
+    volatile uint32_t AFSR;                   /*!< Offset: 0x03C (R/W)  Auxiliary Fault Status Register */
+    volatile uint32_t PFR[2U];                /*!< Offset: 0x040 (R/ )  Processor Feature Register */
+    volatile uint32_t DFR;                    /*!< Offset: 0x048 (R/ )  Debug Feature Register */
+    volatile uint32_t ADR;                    /*!< Offset: 0x04C (R/ )  Auxiliary Feature Register */
+    volatile uint32_t MMFR[4U];               /*!< Offset: 0x050 (R/ )  Memory Model Feature Register */
+    volatile uint32_t ISAR[5U];               /*!< Offset: 0x060 (R/ )  Instruction Set Attributes Register */
+             uint32_t RESERVED0[5U];
+    volatile uint32_t CPACR;                  /*!< Offset: 0x088 (R/W)  Coprocessor Access Control Register */
+} SCB_Type;
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct {
+  volatile uint32_t ISER[8U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+           uint32_t RESERVED0[24U];
+  volatile uint32_t ICER[8U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+           uint32_t RESERVED1[24U];
+  volatile uint32_t ISPR[8U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+           uint32_t RESERVED2[24U];
+  volatile uint32_t ICPR[8U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+           uint32_t RESERVED3[24U];
+  volatile uint32_t IABR[8U];               /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+           uint32_t RESERVED4[56U];
+  volatile uint8_t  IP[240U];               /*!< Offset: 0x300 (R/W)  Interrupt Priority Register (8Bit wide) */
+           uint32_t RESERVED5[644U];
+  volatile uint32_t STIR;                   /*!< Offset: 0xE00 ( /W)  Software Trigger Interrupt Register */
+} NVIC_Type;
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct {
+    volatile uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+    volatile uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+    volatile uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+    volatile uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+__attribute__((always_inline)) static uint32_t getEncodedPriorityGrouping(uint8_t preemptPriority, uint8_t subPriority) {
+    uint32_t prioritygroup = ((uint32_t)((SCB->AIRCR & (7UL << 8U)) >> 8U));
+    uint32_t priorityGroupTmp = (prioritygroup & (uint32_t)0x07UL); /* only values 0..7 are used */
+    uint32_t preemptPriorityBits = ((7UL - priorityGroupTmp) > (uint32_t)(4U)) ? (uint32_t)(4U) : (uint32_t)(7UL - priorityGroupTmp);
+    uint32_t subPriorityBits = ((priorityGroupTmp + (uint32_t)(4U)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((priorityGroupTmp - 7UL) + (uint32_t)(4U));
+
+    return (
+                ((preemptPriority & (uint32_t)((1UL << (preemptPriorityBits)) - 1UL)) << subPriorityBits) |
+                ((subPriority     & (uint32_t)((1UL << (subPriorityBits    )) - 1UL)))
+            );
+}
+
+static inline uint32_t sysTickConfig(uint32_t ticks) {
+    if ((ticks - 1UL) > 0xFFFFFFUL)  // Reload value impossible.
+        return (1UL);                                                   
+
+    // Set reload register.
+    SysTick->LOAD = (uint32_t)(ticks - 1UL);   
+    // Set priority level MAX.
+    SCB->SHP[(((uint32_t)SysTick_IRQn) & 0xFUL)-4UL] = (uint8_t)((15 << (8U - 4U)) & (uint32_t)0xFFUL);
+    // Load the SysTick Counter Value.
+    SysTick->VAL = 0UL;                                             
+    // Enable SysTick IRQ and SysTick Timer.
+    SysTick->CTRL = 0x7U;  
+
+    return (0UL);
+}
+
+static inline void sysTickInit(uint8_t priority) {
+    SCB->SHP[(((uint32_t)SysTick_IRQn) & 0xFUL)-4UL] = (uint8_t)(((uint32_t)getEncodedPriorityGrouping(priority, 0) << (8U - 4U)) & (uint32_t)0xFFUL);
+}

tests/led_freertos_test/CMakeLists.txt

@@ -0,0 +1,16 @@
+add_executable( led_freertos_test
+    main.c
+)
+
+target_link_libraries( led_freertos_test PUBLIC
+    MikroC.Core
+    MikroSDK.Driver.GPIO.Out
+    MikroSDK.Board
+    MikroSDK.FreeRTOS
+)
+target_include_directories(led_freertos_test PUBLIC
+    ${PROJECT_SOURCE_DIR}/../thirdparty/freeRTOS/include
+	${PROJECT_SOURCE_DIR}/
+) 
+ target_sources(led_freertos_test PRIVATE ./systick.h)
+

tests/led_freertos_test/main.c

@@ -0,0 +1,44 @@
+#include "board.h"
+#include "drv_digital_out.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "systick.h"
+#include <sys/time.h>
+
+static digital_out_t pinC;
+static digital_out_t pinD;
+
+static void foo(void* param);
+static void foo2(void* param);
+static void foo(void* param)
+{
+    while(1){
+        digital_out_toggle(&pinC);
+        vTaskDelay(100);
+    }
+}
+static void foo2(void* param)
+{
+    while(1){
+        digital_out_toggle(&pinD);
+        vTaskDelay(200);
+    }
+}
+
+
+int main(){
+    #ifdef PREINIT_SUPPORTED
+    preinit();
+    #endif
+    __asm volatile ("cpsie i");
+    digital_out_init(&pinC, PC8);
+    digital_out_init(&pinD, PC9);
+    TaskHandle_t ledBlinking;
+    if(xTaskCreate(foo, "task", 128, NULL, 4, NULL)==pdPASS){
+        if(xTaskCreate(foo2, "task", 128, NULL, 4, NULL)==pdPASS){ 
+
+            vTaskStartScheduler();
+        }
+    }
+    while(1);
+}