/* ************************************************************************************************************************ * uC/OS-III * The Real-Time Kernel * * (c) Copyright 2009-2011; Micrium, Inc.; Weston, FL * All rights reserved. Protected by international copyright laws. * * OS CONFIGURATION (APPLICATION SPECIFICS) * * File : OS_CFG_APP.C * By : JJL * Version : V3.02.00 * * LICENSING TERMS: * --------------- * uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or * for peaceful research. If you plan or intend to use uC/OS-III in a commercial application/ * product then, you need to contact Micrium to properly license uC/OS-III for its use in your * application/product. We provide ALL the source code for your convenience and to help you * experience uC/OS-III. The fact that the source is provided does NOT mean that you can use * it commercially without paying a licensing fee. * * Knowledge of the source code may NOT be used to develop a similar product. * * Please help us continue to provide the embedded community with the finest software available. * Your honesty is greatly appreciated. * * You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036. ************************************************************************************************************************ * Note(s) : DO NOT CHANGE THIS FILE! ************************************************************************************************************************ */ #include #include #ifdef VSC_INCLUDE_SOURCE_FILE_NAMES const CPU_CHAR *os_cfg_app__c = "$Id: $"; #endif #define OS_CFG_IDLE_TASK_STK_LIMIT ((OS_CFG_IDLE_TASK_STK_SIZE * OS_CFG_TASK_STK_LIMIT_PCT_EMPTY) / 100u) #define OS_CFG_INT_Q_TASK_STK_LIMIT ((OS_CFG_INT_Q_TASK_STK_SIZE * OS_CFG_TASK_STK_LIMIT_PCT_EMPTY) / 100u) #define OS_CFG_STAT_TASK_STK_LIMIT ((OS_CFG_STAT_TASK_STK_SIZE * OS_CFG_TASK_STK_LIMIT_PCT_EMPTY) / 100u) #define OS_CFG_TICK_TASK_STK_LIMIT ((OS_CFG_TICK_TASK_STK_SIZE * OS_CFG_TASK_STK_LIMIT_PCT_EMPTY) / 100u) #define OS_CFG_TMR_TASK_STK_LIMIT ((OS_CFG_TMR_TASK_STK_SIZE * OS_CFG_TASK_STK_LIMIT_PCT_EMPTY) / 100u) /* ************************************************************************************************************************ * DATA STORAGE ************************************************************************************************************************ */ CPU_STK OSCfg_IdleTaskStk [OS_CFG_IDLE_TASK_STK_SIZE]; #if (OS_CFG_ISR_POST_DEFERRED_EN > 0u) OS_INT_Q OSCfg_IntQ [OS_CFG_INT_Q_SIZE]; CPU_STK OSCfg_IntQTaskStk [OS_CFG_INT_Q_TASK_STK_SIZE]; #endif #if (OS_CFG_ISR_STK_SIZE > 0u) CPU_STK OSCfg_ISRStk [OS_CFG_ISR_STK_SIZE]; #endif #if (OS_MSG_EN > 0u) OS_MSG OSCfg_MsgPool [OS_CFG_MSG_POOL_SIZE]; #endif #if (OS_CFG_STAT_TASK_EN > 0u) CPU_STK OSCfg_StatTaskStk [OS_CFG_STAT_TASK_STK_SIZE]; #endif CPU_STK OSCfg_TickTaskStk [OS_CFG_TICK_TASK_STK_SIZE]; OS_TICK_SPOKE OSCfg_TickWheel [OS_CFG_TICK_WHEEL_SIZE]; #if (OS_CFG_TMR_EN > 0u) CPU_STK OSCfg_TmrTaskStk [OS_CFG_TMR_TASK_STK_SIZE]; OS_TMR_SPOKE OSCfg_TmrWheel [OS_CFG_TMR_WHEEL_SIZE]; #endif /*$PAGE*/ /* ************************************************************************************************************************ * CONSTANTS ************************************************************************************************************************ */ CPU_STK * const OSCfg_IdleTaskStkBasePtr = (CPU_STK *)&OSCfg_IdleTaskStk[0]; CPU_STK_SIZE const OSCfg_IdleTaskStkLimit = (CPU_STK_SIZE)OS_CFG_IDLE_TASK_STK_LIMIT; CPU_STK_SIZE const OSCfg_IdleTaskStkSize = (CPU_STK_SIZE)OS_CFG_IDLE_TASK_STK_SIZE; CPU_INT32U const OSCfg_IdleTaskStkSizeRAM = (CPU_INT32U )sizeof(OSCfg_IdleTaskStk); #if (OS_CFG_ISR_POST_DEFERRED_EN > 0u) OS_INT_Q * const OSCfg_IntQBasePtr = (OS_INT_Q *)&OSCfg_IntQ[0]; OS_OBJ_QTY const OSCfg_IntQSize = (OS_OBJ_QTY )OS_CFG_INT_Q_SIZE; CPU_INT32U const OSCfg_IntQSizeRAM = (CPU_INT32U )sizeof(OSCfg_IntQ); CPU_STK * const OSCfg_IntQTaskStkBasePtr = (CPU_STK *)&OSCfg_IntQTaskStk[0]; CPU_STK_SIZE const OSCfg_IntQTaskStkLimit = (CPU_STK_SIZE)OS_CFG_INT_Q_TASK_STK_LIMIT; CPU_STK_SIZE const OSCfg_IntQTaskStkSize = (CPU_STK_SIZE)OS_CFG_INT_Q_TASK_STK_SIZE; CPU_INT32U const OSCfg_IntQTaskStkSizeRAM = (CPU_INT32U )sizeof(OSCfg_IntQTaskStk); #else OS_INT_Q * const OSCfg_IntQBasePtr = (OS_INT_Q *)0; OS_OBJ_QTY const OSCfg_IntQSize = (OS_OBJ_QTY )0; CPU_INT32U const OSCfg_IntQSizeRAM = (CPU_INT32U )0; CPU_STK * const OSCfg_IntQTaskStkBasePtr = (CPU_STK *)0; CPU_STK_SIZE const OSCfg_IntQTaskStkLimit = (CPU_STK_SIZE)0; CPU_STK_SIZE const OSCfg_IntQTaskStkSize = (CPU_STK_SIZE)0; CPU_INT32U const OSCfg_IntQTaskStkSizeRAM = (CPU_INT32U )0; #endif #if (OS_CFG_ISR_STK_SIZE > 0u) CPU_STK * const OSCfg_ISRStkBasePtr = (CPU_STK *)&OSCfg_ISRStk[0]; CPU_STK_SIZE const OSCfg_ISRStkSize = (CPU_STK_SIZE)OS_CFG_ISR_STK_SIZE; CPU_INT32U const OSCfg_ISRStkSizeRAM = (CPU_INT32U )sizeof(OSCfg_ISRStk); #else CPU_STK * const OSCfg_ISRStkBasePtr = (CPU_STK *)0; CPU_STK_SIZE const OSCfg_ISRStkSize = (CPU_STK_SIZE)0; CPU_INT32U const OSCfg_ISRStkSizeRAM = (CPU_INT32U )0; #endif #if (OS_MSG_EN > 0u) OS_MSG_SIZE const OSCfg_MsgPoolSize = (OS_MSG_SIZE)OS_CFG_MSG_POOL_SIZE; CPU_INT32U const OSCfg_MsgPoolSizeRAM = (CPU_INT32U )sizeof(OSCfg_MsgPool); OS_MSG * const OSCfg_MsgPoolBasePtr = (OS_MSG *)&OSCfg_MsgPool[0]; #else OS_MSG_SIZE const OSCfg_MsgPoolSize = (OS_MSG_SIZE)0; CPU_INT32U const OSCfg_MsgPoolSizeRAM = (CPU_INT32U )0; OS_MSG * const OSCfg_MsgPoolBasePtr = (OS_MSG *)0; #endif #if (OS_CFG_STAT_TASK_EN > 0u) OS_PRIO const OSCfg_StatTaskPrio = (OS_PRIO )OS_CFG_STAT_TASK_PRIO; OS_RATE_HZ const OSCfg_StatTaskRate_Hz = (OS_RATE_HZ )OS_CFG_STAT_TASK_RATE_HZ; CPU_STK * const OSCfg_StatTaskStkBasePtr = (CPU_STK *)&OSCfg_StatTaskStk[0]; CPU_STK_SIZE const OSCfg_StatTaskStkLimit = (CPU_STK_SIZE)OS_CFG_STAT_TASK_STK_LIMIT; CPU_STK_SIZE const OSCfg_StatTaskStkSize = (CPU_STK_SIZE)OS_CFG_STAT_TASK_STK_SIZE; CPU_INT32U const OSCfg_StatTaskStkSizeRAM = (CPU_INT32U )sizeof(OSCfg_StatTaskStk); #else OS_PRIO const OSCfg_StatTaskPrio = (OS_PRIO )0; OS_RATE_HZ const OSCfg_StatTaskRate_Hz = (OS_RATE_HZ )0; CPU_STK * const OSCfg_StatTaskStkBasePtr = (CPU_STK *)0; CPU_STK_SIZE const OSCfg_StatTaskStkLimit = (CPU_STK_SIZE)0; CPU_STK_SIZE const OSCfg_StatTaskStkSize = (CPU_STK_SIZE)0; CPU_INT32U const OSCfg_StatTaskStkSizeRAM = (CPU_INT32U )0; #endif CPU_STK_SIZE const OSCfg_StkSizeMin = (CPU_STK_SIZE)OS_CFG_STK_SIZE_MIN; OS_RATE_HZ const OSCfg_TickRate_Hz = (OS_RATE_HZ )OS_CFG_TICK_RATE_HZ; OS_PRIO const OSCfg_TickTaskPrio = (OS_PRIO )OS_CFG_TICK_TASK_PRIO; CPU_STK * const OSCfg_TickTaskStkBasePtr = (CPU_STK *)&OSCfg_TickTaskStk[0]; CPU_STK_SIZE const OSCfg_TickTaskStkLimit = (CPU_STK_SIZE)OS_CFG_TICK_TASK_STK_LIMIT; CPU_STK_SIZE const OSCfg_TickTaskStkSize = (CPU_STK_SIZE)OS_CFG_TICK_TASK_STK_SIZE; CPU_INT32U const OSCfg_TickTaskStkSizeRAM = (CPU_INT32U )sizeof(OSCfg_TickTaskStk); OS_OBJ_QTY const OSCfg_TickWheelSize = (OS_OBJ_QTY )OS_CFG_TICK_WHEEL_SIZE; CPU_INT32U const OSCfg_TickWheelSizeRAM = (CPU_INT32U )sizeof(OSCfg_TickWheel); #if (OS_CFG_TMR_EN > 0u) OS_PRIO const OSCfg_TmrTaskPrio = (OS_PRIO )OS_CFG_TMR_TASK_PRIO; OS_RATE_HZ const OSCfg_TmrTaskRate_Hz = (OS_RATE_HZ )OS_CFG_TMR_TASK_RATE_HZ; CPU_STK * const OSCfg_TmrTaskStkBasePtr = (CPU_STK *)&OSCfg_TmrTaskStk[0]; CPU_STK_SIZE const OSCfg_TmrTaskStkLimit = (CPU_STK_SIZE)OS_CFG_TMR_TASK_STK_LIMIT; CPU_STK_SIZE const OSCfg_TmrTaskStkSize = (CPU_STK_SIZE)OS_CFG_TMR_TASK_STK_SIZE; CPU_INT32U const OSCfg_TmrTaskStkSizeRAM = (CPU_INT32U )sizeof(OSCfg_TmrTaskStk); OS_OBJ_QTY const OSCfg_TmrWheelSize = (OS_OBJ_QTY )OS_CFG_TMR_WHEEL_SIZE; CPU_INT32U const OSCfg_TmrWheelSizeRAM = (CPU_INT32U )sizeof(OSCfg_TmrWheel); #else OS_PRIO const OSCfg_TmrTaskPrio = (OS_PRIO )0; OS_RATE_HZ const OSCfg_TmrTaskRate_Hz = (OS_RATE_HZ )0; CPU_STK * const OSCfg_TmrTaskStkBasePtr = (CPU_STK *)0; CPU_STK_SIZE const OSCfg_TmrTaskStkLimit = (CPU_STK_SIZE)0; CPU_STK_SIZE const OSCfg_TmrTaskStkSize = (CPU_STK_SIZE)0; CPU_INT32U const OSCfg_TmrTaskStkSizeRAM = (CPU_INT32U )0; OS_OBJ_QTY const OSCfg_TmrWheelSize = (OS_OBJ_QTY )0; CPU_INT32U const OSCfg_TmrWheelSizeRAM = (CPU_INT32U )0; #endif /*$PAGE*/ /* ************************************************************************************************************************ * TOTAL SIZE OF APPLICATION CONFIGURATION ************************************************************************************************************************ */ CPU_INT32U const OSCfg_DataSizeRAM = sizeof(OSCfg_IdleTaskStk) #if (OS_CFG_ISR_POST_DEFERRED_EN > 0u) + sizeof(OSCfg_IntQ) + sizeof(OSCfg_IntQTaskStk) #endif #if (OS_MSG_EN > 0u) + sizeof(OSCfg_MsgPool) #endif #if (OS_CFG_STAT_TASK_EN > 0u) + sizeof(OSCfg_StatTaskStk) #endif #if (OS_CFG_TMR_EN > 0u) + sizeof(OSCfg_TmrTaskStk) + sizeof(OSCfg_TmrWheel) #endif #if (OS_CFG_ISR_STK_SIZE > 0u) + sizeof(OSCfg_ISRStk) #endif + sizeof(OSCfg_TickTaskStk) + sizeof(OSCfg_TickWheel); /*$PAGE*/ /* ************************************************************************************************************************ * OS CONFIGURATION INITIALIZATION * * Description: This function is used to make sure that debug variables that are unused in the application are not * optimized away. This function might not be necessary for all compilers. In this case, you should simply * DELETE the code in this function while still leaving the declaration of the function itself. * * Arguments : none * * Returns : none * * Note(s) : (1) This code doesn't do anything, it simply prevents the compiler from optimizing out the 'const' * variables which are declared in this file. * (2) You may decide to 'compile out' the code (by using #if 0/#endif) INSIDE the function if your compiler * DOES NOT optimize out the 'const' variables above. ************************************************************************************************************************ */ void OSCfg_Init (void) { void const *p_temp; p_temp = (void const *)&OSCfg_DataSizeRAM; p_temp = (void const *)&OSCfg_IdleTaskStkBasePtr; p_temp = (void const *)&OSCfg_IdleTaskStkLimit; p_temp = (void const *)&OSCfg_IdleTaskStkSize; p_temp = (void const *)&OSCfg_IdleTaskStkSizeRAM; #if (OS_CFG_ISR_POST_DEFERRED_EN > 0u) p_temp = (void const *)&OSCfg_IntQBasePtr; p_temp = (void const *)&OSCfg_IntQSize; p_temp = (void const *)&OSCfg_IntQSizeRAM; p_temp = (void const *)&OSCfg_IntQTaskStkBasePtr; p_temp = (void const *)&OSCfg_IntQTaskStkLimit; p_temp = (void const *)&OSCfg_IntQTaskStkSize; p_temp = (void const *)&OSCfg_IntQTaskStkSizeRAM; #endif p_temp = (void const *)&OSCfg_ISRStkBasePtr; p_temp = (void const *)&OSCfg_ISRStkSize; p_temp = (void const *)&OSCfg_ISRStkSizeRAM; #if (OS_MSG_EN > 0u) p_temp = (void const *)&OSCfg_MsgPoolSize; p_temp = (void const *)&OSCfg_MsgPoolSizeRAM; p_temp = (void const *)&OSCfg_MsgPoolBasePtr; #endif #if (OS_CFG_STAT_TASK_EN > 0u) p_temp = (void const *)&OSCfg_StatTaskPrio; p_temp = (void const *)&OSCfg_StatTaskRate_Hz; p_temp = (void const *)&OSCfg_StatTaskStkBasePtr; p_temp = (void const *)&OSCfg_StatTaskStkLimit; p_temp = (void const *)&OSCfg_StatTaskStkSize; p_temp = (void const *)&OSCfg_StatTaskStkSizeRAM; #endif p_temp = (void const *)&OSCfg_StkSizeMin; p_temp = (void const *)&OSCfg_TickRate_Hz; p_temp = (void const *)&OSCfg_TickTaskPrio; p_temp = (void const *)&OSCfg_TickTaskStkBasePtr; p_temp = (void const *)&OSCfg_TickTaskStkLimit; p_temp = (void const *)&OSCfg_TickTaskStkSize; p_temp = (void const *)&OSCfg_TickTaskStkSizeRAM; p_temp = (void const *)&OSCfg_TickWheelSize; p_temp = (void const *)&OSCfg_TickWheelSizeRAM; #if (OS_CFG_TMR_EN > 0u) p_temp = (void const *)&OSCfg_TmrTaskPrio; p_temp = (void const *)&OSCfg_TmrTaskRate_Hz; p_temp = (void const *)&OSCfg_TmrTaskStkBasePtr; p_temp = (void const *)&OSCfg_TmrTaskStkLimit; p_temp = (void const *)&OSCfg_TmrTaskStkSize; p_temp = (void const *)&OSCfg_TmrTaskStkSizeRAM; p_temp = (void const *)&OSCfg_TmrWheelSize; p_temp = (void const *)&OSCfg_TmrWheelSizeRAM; #endif p_temp = p_temp; }