foxBMS  1.2.0
The foxBMS Battery Management System API Documentation
algorithm.c
Go to the documentation of this file.
1 /**
2  *
3  * @copyright © 2010 - 2021, Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V.
4  * All rights reserved.
5  *
6  * SPDX-License-Identifier: BSD-3-Clause
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright notice, this
12  * list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright notice,
15  * this list of conditions and the following disclaimer in the documentation
16  * and/or other materials provided with the distribution.
17  *
18  * 3. Neither the name of the copyright holder nor the names of its
19  * contributors may be used to endorse or promote products derived from
20  * this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * We kindly request you to use one or more of the following phrases to refer to
34  * foxBMS in your hardware, software, documentation or advertising materials:
35  *
36  * - ″This product uses parts of foxBMS®″
37  * - ″This product includes parts of foxBMS®″
38  * - ″This product is derived from foxBMS®″
39  *
40  */
41 
42 /**
43  * @file algorithm.c
44  * @author foxBMS Team
45  * @date 2017-12-18 (date of creation)
46  * @updated 2020-06-30 (date of last update)
47  * @ingroup ALGORITHMS
48  * @prefix ALGO
49  *
50  * @brief Main module to handle the execution of algorithms
51  *
52  *
53  */
54 
55 /*========== Includes =======================================================*/
56 #include "algorithm.h"
57 
58 #include "os.h"
59 
60 /*========== Macros and Definitions =========================================*/
61 
62 /*========== Static Constant and Variable Definitions =======================*/
63 /**
64  * This is a signal that skips initialization of #ALGO_Initialization()
65  * until it has been requested.
66  */
67 static bool algo_initializationRequested = false;
68 
69 /*========== Extern Constant and Variable Definitions =======================*/
70 
71 /*========== Static Function Prototypes =====================================*/
72 /**
73  * @brief initializes local variables and module internals needed to use the
74  * algorithm module
75  */
76 static void ALGO_Initialization(void);
77 
78 /*========== Static Function Implementations ================================*/
79 static void ALGO_Initialization(void) {
80  /* iterate over all algorithms */
81  for (uint16_t i = 0u; i < algo_length; i++) {
82  /* check if the cycle time is valid */
83  FAS_ASSERT((algo_algorithms[i].cycleTime_ms % ALGO_TICK_MS) == 0u);
84 
85  /* check only uninitialized algorithms */
86  if (ALGO_UNINITIALIZED == algo_algorithms[i].state) {
87  /* directly make ready when init function is a null pointer otherwise run init */
88  if (NULL_PTR == algo_algorithms[i].fpInitialization) {
90  } else {
92  FAS_ASSERT((STD_OK == result) || (STD_NOT_OK == result));
93  if (STD_OK == result) {
95  } else {
97  }
98  }
99  }
100  }
101 }
102 
103 /*========== Extern Function Implementations ================================*/
104 
105 extern void ALGO_UnlockInitialization(void) {
109 }
110 
111 extern void ALGO_MainFunction(void) {
113  const bool initializationRequested = algo_initializationRequested;
115  if (true == initializationRequested) {
120  }
121 
122  static uint32_t counter_ticks = 0u;
123 
124  for (uint16_t i = 0u; i < algo_length; i++) {
125  const bool runAlgorithmAsap = (algo_algorithms[i].cycleTime_ms == 0u);
126  const bool runAlgorithmCycleElapsed =
127  ((algo_algorithms[i].cycleTime_ms != 0u) && ((counter_ticks % algo_algorithms[i].cycleTime_ms) == 0u));
128  if ((runAlgorithmAsap != false) || (runAlgorithmCycleElapsed != false)) {
129  /* Cycle time elapsed -> call function */
130  if (ALGO_READY == algo_algorithms[i].state) {
131  /* Set state to running -> reset to READY before leaving algo function */
135  ALGO_MarkAsDone(i);
136  }
137  }
138  }
139 
140  counter_ticks += ALGO_TICK_MS;
141 }
142 
143 extern void ALGO_MonitorExecutionTime(void) {
144  const uint32_t timestamp = OS_GetTickCount();
145 
146  for (uint16_t i = 0u; i < algo_length; i++) {
147  if ((algo_algorithms[i].startTime != 0u) && (ALGO_RUNNING == algo_algorithms[i].state) &&
148  ((algo_algorithms[i].startTime + algo_algorithms[i].maxCalculationDuration_ms) < timestamp)) {
149  /* Block task from further execution because of runtime violation, but task will finish its execution */
151 
152  /* TODO: Add diag call to notify error in algorithm module */
153  }
154  }
155 }
156 
157 /*========== Externalized Static Function Implementations (Unit Test) =======*/
158 #ifdef UNITY_UNIT_TEST
159 extern void TEST_ALGO_ResetInitializationRequest() {
161 }
162 #endif /* UNITY_UNIT_TEST */
void ALGO_UnlockInitialization(void)
Calling this function sets a signal that lets ALGO_Initialization() know that the initialization has ...
Definition: algorithm.c:105
static void ALGO_Initialization(void)
initializes local variables and module internals needed to use the algorithm module
Definition: algorithm.c:79
void ALGO_MainFunction(void)
handles the call of different algorithm functions when cycle time has expired
Definition: algorithm.c:111
void ALGO_MonitorExecutionTime(void)
monitors the calculation duration of the different algorithms
Definition: algorithm.c:143
static bool algo_initializationRequested
Definition: algorithm.c:67
Headers for the driver for the storage in the EEPROM memory.
const uint16_t algo_length
Definition: algorithm_cfg.c:70
ALGO_TASKS_s algo_algorithms[]
Definition: algorithm_cfg.c:66
void ALGO_MarkAsDone(uint32_t algorithmIndex)
Mark the current algorithm as done (will reset to ALGO_READY if possible)
Definition: algorithm_cfg.c:78
@ ALGO_UNINITIALIZED
Definition: algorithm_cfg.h:81
@ ALGO_RUNNING
Definition: algorithm_cfg.h:83
@ ALGO_FAILED_INIT
Definition: algorithm_cfg.h:86
@ ALGO_READY
Definition: algorithm_cfg.h:82
@ ALGO_BLOCKED
Definition: algorithm_cfg.h:85
#define FAS_ASSERT(x)
Assertion macro that asserts that x is true.
Definition: fassert.h:237
@ STD_NOT_OK
Definition: fstd_types.h:73
@ STD_OK
Definition: fstd_types.h:72
#define NULL_PTR
Null pointer.
Definition: fstd_types.h:66
enum STD_RETURN_TYPE STD_RETURN_TYPE_e
#define ALGO_TICK_MS
Definition: algorithm_cfg.h:66
void OS_ExitTaskCritical(void)
Exit Critical interface function for use in FreeRTOS-Tasks and FreeRTOS-ISR.
Definition: os.c:178
void OS_EnterTaskCritical(void)
Enter Critical interface function for use in FreeRTOS-Tasks and FreeRTOS-ISR.
Definition: os.c:174
uint32_t OS_GetTickCount(void)
Returns OS based system tick value.
Definition: os.c:182
Implementation of the tasks used by the system, headers.
uint32_t cycleTime_ms
Definition: algorithm_cfg.h:92
ALGO_INITIALIZATION_FUNCTION_f * fpInitialization
Definition: algorithm_cfg.h:95
ALGO_COMPUTATION_FUNCTION_f * fpAlgorithm
Definition: algorithm_cfg.h:97
ALGO_STATE_e state
Definition: algorithm_cfg.h:91
uint32_t startTime
Definition: algorithm_cfg.h:94