os.c

Go to the documentation of this file.

/**
 *
 * @copyright © 2010 - 2021, Fraunhofer-Gesellschaft zur Foerderung der
 *  angewandten Forschung e.V. All rights reserved.
 *
 * BSD 3-Clause License
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 1.  Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of the copyright holder nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * We kindly request you to use one or more of the following phrases to refer
 * to foxBMS in your hardware, software, documentation or advertising
 * materials:
 *
 * ″This product uses parts of foxBMS®″
 *
 * ″This product includes parts of foxBMS®″
 *
 * ″This product is derived from foxBMS®″
 *
 */
 
/**
 * @file    os.c
 * @author  foxBMS Team
 * @date    2019-08-27 (date of creation)
 * @updated 2020-01-21 (date of last update)
 * @ingroup OS
 * @prefix  OS
 *
 * @brief   Implementation of the tasks used by the system
 *
 */
 
/*========== Includes =======================================================*/
#include "os.h"
 
#include "ftask.h"
 
/*========== Macros and Definitions =========================================*/
 
/** stack size of the idle task */
#define OS_IDLE_TASK_SIZE configMINIMAL_STACK_SIZE
 
/*========== Static Constant and Variable Definitions =======================*/
 
/*========== Extern Constant and Variable Definitions =======================*/
/** boot state of the OS */
volatile OS_BOOT_STATE_e os_boot = OS_OFF;
/** system timer variable */
volatile OS_TIMER_s os_timer = {0, 0, 0, 0, 0, 0, 0};
/** timestamp of the scheduler start */
uint32_t os_schedulerStartTime = 0;
 
/** Buffer for the Idle Task's structure */
static StaticTask_t os_idleTaskTcbBuffer;
 
/** @brief Stack for the Idle task */
static StackType_t os_idleStack[OS_IDLE_TASK_SIZE];
 
#if (configUSE_TIMERS > 0) && (configSUPPORT_STATIC_ALLOCATION == 1)
/** Buffer for the Timer Task's structure */
static StaticTask_t os_timerTaskTcbBuffer;
#endif /* configUSE_TIMERS */
 
#if (configUSE_TIMERS > 0) && (configSUPPORT_STATIC_ALLOCATION == 1)
/** Stack for the Timer Task */
static StackType_t os_timerStack[configTIMER_TASK_STACK_DEPTH];
#endif /* configUSE_TIMERS */
 
/*========== Static Function Prototypes =====================================*/
 
/*========== Static Function Implementations ================================*/
 
/*========== Extern Function Implementations ================================*/
 
void OS_StartScheduler(void) {
    vTaskStartScheduler();
}
 
void OS_InitializeTasks(void) {
    /* operating system configuration (Queues, Mutexes, Events, Tasks */
    os_boot = OS_CREATE_QUEUES;
    FTSK_CreateQueues();
    os_boot = OS_CREATE_MUTEX;
    FTSK_CreateMutexes();
    os_boot = OS_CREATE_EVENT;
    FTSK_CreateEvents();
    os_boot = OS_CREATE_TASKS;
    FTSK_CreateTasks();
    os_boot = OS_INIT_PRE_OS;
}
 
void vApplicationGetIdleTaskMemory(
    StaticTask_t **ppxIdleTaskTCBBuffer,
    StackType_t **ppxIdleTaskStackBuffer,
    uint32_t *pulIdleTaskStackSize) {
    *ppxIdleTaskTCBBuffer   = &os_idleTaskTcbBuffer;
    *ppxIdleTaskStackBuffer = &os_idleStack[0];
    *pulIdleTaskStackSize   = OS_IDLE_TASK_SIZE;
}
 
#if (configUSE_TIMERS > 0) && (configSUPPORT_STATIC_ALLOCATION == 1)
void vApplicationGetTimerTaskMemory(
    StaticTask_t **ppxTimerTaskTCBBuffer,
    StackType_t **ppxTimerTaskStackBuffer,
    uint32_t *pulTimerTaskStackSize) {
    *ppxTimerTaskTCBBuffer   = &os_timerTaskTcbBuffer;
    *ppxTimerTaskStackBuffer = &os_timerStack[0];
    *pulTimerTaskStackSize   = configTIMER_TASK_STACK_DEPTH;
}
#endif /* configUSE_TIMERS */
 
void vApplicationIdleHook(void) {
    FTSK_UserCodeIdle();
}
 
void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName) {
    FAS_ASSERT(FAS_TRAP);
}
 
void OS_TriggerTimer(volatile OS_TIMER_s *timer) {
    if (++timer->timer_1ms > 9) {
        /* 10ms */
        timer->timer_1ms = 0;
 
        if (++timer->timer_10ms > 9) {
            /* 100ms */
            timer->timer_10ms = 0;
 
            if (++timer->timer_100ms > 9) {
                /* 1s */
                timer->timer_100ms = 0;
 
                if (++timer->timer_sec > 59) {
                    /* 1min */
                    timer->timer_sec = 0;
 
                    if (++timer->timer_min > 59) {
                        /* 1h */
                        timer->timer_min = 0;
 
                        if (++timer->timer_h > 23) {
                            /* 1d */
                            timer->timer_h = 0;
                            ++timer->timer_d;
                        }
                    }
                }
            }
        }
    }
}
 
void OS_EnterTaskCritical(void) {
    taskENTER_CRITICAL();
}
 
void OS_ExitTaskCritical(void) {
    taskEXIT_CRITICAL();
}
 
uint32_t OS_GetTickCount(void) {
    return xTaskGetTickCount(); /*TMS570 does not support nested interrupts*/
}
 
void OS_DelayTask(uint32_t delay_ms) {
#if INCLUDE_vTaskDelay
    TickType_t ticks = delay_ms / portTICK_PERIOD_MS;
 
    vTaskDelay(ticks ? ticks : 1); /* Minimum delay = 1 tick */
#else
#error "Can't use OS_taskDelay."
#endif
}
 
void OS_DelayTaskUntil(uint32_t *pPreviousWakeTime, uint32_t milliseconds) {
#if INCLUDE_vTaskDelayUntil
    TickType_t ticks = (milliseconds / portTICK_PERIOD_MS);
    vTaskDelayUntil((TickType_t *)pPreviousWakeTime, ticks ? ticks : 1);
 
#else
#error "Can't use OS_taskDelayUntil."
#endif
}
 
void OS_SystemTickHandler(void) {
#if (INCLUDE_xTaskGetSchedulerState == 1)
    /* Only increment operating systick timer if scheduler started */
    if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
        xTaskIncrementTick();
    }
#else
    xTaskIncrementTick();
#endif /* INCLUDE_xTaskGetSchedulerState */
}
 
/*========== Externalized Static Function Implementations (Unit Test) =======*/