foxBMS  1.5.0
The foxBMS Battery Management System API Documentation
ltc_6813-1.c
Go to the documentation of this file.
1 /**
2  *
3  * @copyright © 2010 - 2023, 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 ltc_6813-1.c
44  * @author foxBMS Team
45  * @date 2019-09-01 (date of creation)
46  * @updated 2023-02-03 (date of last update)
47  * @version v1.5.0
48  * @ingroup DRIVERS
49  * @prefix LTC
50  *
51  * @brief Driver for the LTC analog front-end.
52  *
53  */
54 
55 /*========== Includes =======================================================*/
56 /* clang-format off */
57 #include "ltc_6813-1_cfg.h"
58 #include "ltc.h"
59 /* clang-format on */
60 
61 #include "HL_spi.h"
62 #include "HL_system.h"
63 
64 #include "afe_plausibility.h"
65 #include "database.h"
66 #include "diag.h"
67 #include "io.h"
68 #include "ltc_pec.h"
69 #include "os.h"
70 #include "pex.h"
71 
72 #include <stdbool.h>
73 #include <stdint.h>
74 
75 /*========== Macros and Definitions =========================================*/
76 
77 /**
78  * TI port expander register addresses
79  * @{
80  */
81 #define LTC_PORT_EXPANDER_TI_INPUT_REG_ADR (0x00u)
82 #define LTC_PORT_EXPANDER_TI_OUTPUT_REG_ADR (0x01u)
83 #define LTC_PORT_EXPANDER_TI_CONFIG_REG_ADR (0x03u)
84 /**@}*/
85 
86 /**
87  * LTC COMM definitions
88  * @{
89  */
90 #define LTC_ICOM_START (0x60u)
91 #define LTC_ICOM_STOP (0x10u)
92 #define LTC_ICOM_BLANK (0x00u)
93 #define LTC_ICOM_NO_TRANSMIT (0x70u)
94 #define LTC_FCOM_MASTER_ACK (0x00u)
95 #define LTC_FCOM_MASTER_NACK (0x08u)
96 #define LTC_FCOM_MASTER_NACK_STOP (0x09u)
97 /**@}*/
98 
99 /** maximum number of supported cells */
100 #define LTC_MAX_SUPPORTED_CELLS (12u)
101 
102 /*========== Static Constant and Variable Definitions =======================*/
103 /**
104  * PEC buffer for RX and TX
105  * @{
106  */
107 /* AXIVION Disable Style MisraC2012-1.2: The Pec buffer must be put in the shared RAM section for performance reasons */
108 #pragma SET_DATA_SECTION(".sharedRAM")
109 uint16_t ltc_RxPecBuffer[LTC_N_BYTES_FOR_DATA_TRANSMISSION] = {0};
110 uint16_t ltc_TxPecBuffer[LTC_N_BYTES_FOR_DATA_TRANSMISSION] = {0};
111 #pragma SET_DATA_SECTION()
112 /* AXIVION Enable Style MisraC2012-1.2: only Pec buffer needed to be in the shared RAM section */
113 /**@}*/
114 
115 /** index of used cells */
116 static uint16_t ltc_used_cells_index[BS_NR_OF_STRINGS] = {0};
117 /** local copies of database tables */
118 /**@{*/
119 static DATA_BLOCK_CELL_VOLTAGE_s ltc_cellVoltage = {.header.uniqueId = DATA_BLOCK_ID_CELL_VOLTAGE_BASE};
120 static DATA_BLOCK_CELL_TEMPERATURE_s ltc_celltemperature = {.header.uniqueId = DATA_BLOCK_ID_CELL_TEMPERATURE_BASE};
121 static DATA_BLOCK_BALANCING_FEEDBACK_s ltc_balancing_feedback = {
122  .header.uniqueId = DATA_BLOCK_ID_BALANCING_FEEDBACK_BASE};
123 static DATA_BLOCK_BALANCING_CONTROL_s ltc_balancing_control = {.header.uniqueId = DATA_BLOCK_ID_BALANCING_CONTROL};
124 static DATA_BLOCK_SLAVE_CONTROL_s ltc_slave_control = {.header.uniqueId = DATA_BLOCK_ID_SLAVE_CONTROL};
125 static DATA_BLOCK_ALL_GPIO_VOLTAGES_s ltc_allgpiovoltage = {.header.uniqueId = DATA_BLOCK_ID_ALL_GPIO_VOLTAGES_BASE};
126 static DATA_BLOCK_OPEN_WIRE_s ltc_openWire = {.header.uniqueId = DATA_BLOCK_ID_OPEN_WIRE_BASE};
127 /**@}*/
128 /** stores information on the detected open wires locally */
129 static LTC_OPENWIRE_DETECTION_s ltc_openWireDetection = {0};
130 static LTC_ERRORTABLE_s ltc_errorTable = {0}; /*!< init in LTC_ResetErrorTable-function */
131 
132 /** local definition of plausible cell voltage values for the LTC6813 (and similar) */
133 static const AFE_PLAUSIBILITY_VALUES_s ltc_plausibleCellVoltages681x = {
134  .maximumPlausibleVoltage_mV = 5000,
135  .minimumPlausibleVoltage_mV = 0,
136 };
137 
138 /*========== Extern Constant and Variable Definitions =======================*/
139 
140 LTC_STATE_s ltc_stateBase = {
141  .timer = 0,
142  .statereq = {.request = LTC_STATE_NO_REQUEST, .string = 0xFFu},
143  .state = LTC_STATEMACH_UNINITIALIZED,
144  .substate = 0,
145  .laststate = LTC_STATEMACH_UNINITIALIZED,
146  .lastsubstate = 0,
147  .adcModereq = LTC_ADCMODE_FAST_DCP0,
148  .adcMode = LTC_ADCMODE_FAST_DCP0,
149  .adcMeasChreq = LTC_ADCMEAS_UNDEFINED,
150  .adcMeasCh = LTC_ADCMEAS_UNDEFINED,
151  .numberOfMeasuredMux = 32,
152  .triggerentry = 0,
153  .ErrRetryCounter = 0,
154  .ErrRequestCounter = 0,
155  .VoltageSampleTime = 0,
156  .muxSampleTime = 0,
157  .commandDataTransferTime = 3,
158  .commandTransferTime = 3,
159  .gpioClocksTransferTime = 3,
160  .muxmeas_seqptr = {NULL_PTR},
161  .muxmeas_seqendptr = {NULL_PTR},
162  .muxmeas_nr_end = {0},
163  .first_measurement_made = false,
164  .ltc_muxcycle_finished = STD_NOT_OK,
165  .check_spi_flag = STD_NOT_OK,
166  .balance_control_done = STD_NOT_OK,
167  .transmit_ongoing = false,
168  .dummyByte_ongoing = STD_NOT_OK,
169  .spiDiagErrorEntry = DIAG_ID_AFE_SPI,
170  .pecDiagErrorEntry = DIAG_ID_AFE_COM_INTEGRITY,
171  .muxDiagErrorEntry = DIAG_ID_AFE_MUX,
172  .voltMeasDiagErrorEntry = DIAG_ID_AFE_CELL_VOLTAGE_MEAS_ERROR,
173  .tempMeasDiagErrorEntry = DIAG_ID_AFE_CELL_TEMPERATURE_MEAS_ERROR,
174  .ltcData.pSpiInterface = spi_ltcInterface,
175  .ltcData.txBuffer = ltc_TxPecBuffer,
176  .ltcData.rxBuffer = ltc_RxPecBuffer,
177  .ltcData.frameLength = LTC_N_BYTES_FOR_DATA_TRANSMISSION,
178  .ltcData.cellVoltage = &ltc_cellVoltage,
179  .ltcData.cellTemperature = &ltc_celltemperature,
180  .ltcData.balancingFeedback = &ltc_balancing_feedback,
181  .ltcData.balancingControl = &ltc_balancing_control,
182  .ltcData.slaveControl = &ltc_slave_control,
183  .ltcData.openWireDetection = &ltc_openWireDetection,
184  .ltcData.errorTable = &ltc_errorTable,
185  .ltcData.allGpioVoltages = &ltc_allgpiovoltage,
186  .ltcData.openWire = &ltc_openWire,
187  .ltcData.usedCellIndex = ltc_used_cells_index,
188  .currentString = 0u,
189  .requestedString = 0u,
190 };
191 
192 static uint16_t ltc_cmdWRCFG[4] = {0x00, 0x01, 0x3D, 0x6E};
193 static uint16_t ltc_cmdWRCFG2[4] = {0x00, 0x24, 0xB1, 0x9E};
194 static uint16_t ltc_cmdRDCFG[4] = {0x00, 0x02, 0x2B, 0x0A};
195 
196 static uint16_t ltc_cmdRDCVA[4] = {0x00, 0x04, 0x07, 0xC2};
197 static uint16_t ltc_cmdRDCVB[4] = {0x00, 0x06, 0x9A, 0x94};
198 static uint16_t ltc_cmdRDCVC[4] = {0x00, 0x08, 0x5E, 0x52};
199 static uint16_t ltc_cmdRDCVD[4] = {0x00, 0x0A, 0xC3, 0x04};
200 static uint16_t ltc_cmdRDCVE[4] = {0x00, 0x09, 0xD5, 0x60};
201 static uint16_t ltc_cmdRDCVF[4] = {0x00, 0x0B, 0x48, 0x36};
202 static uint16_t ltc_cmdWRCOMM[4] = {0x07, 0x21, 0x24, 0xB2};
203 static uint16_t ltc_cmdSTCOMM[4] = {0x07, 0x23, 0xB9, 0xE4};
204 static uint16_t ltc_cmdRDCOMM[4] = {0x07, 0x22, 0x32, 0xD6};
205 static uint16_t ltc_cmdRDAUXA[4] = {0x00, 0x0C, 0xEF, 0xCC};
206 static uint16_t ltc_cmdRDAUXB[4] = {0x00, 0x0E, 0x72, 0x9A};
207 static uint16_t ltc_cmdRDAUXC[4] = {0x00, 0x0D, 0x64, 0xFE};
208 static uint16_t ltc_cmdRDAUXD[4] = {0x00, 0x0F, 0xF9, 0xA8};
209 
210 /* static uint16_t ltc_cmdMUTE[4] = {0x00, 0x28, 0xE8, 0x0E}; !< MUTE discharging via S pins */
211 /* static uint16_t ltc_cmdUNMUTE[4] = {0x00, 0x29, 0x63, 0x3C}; !< UN-MUTE discharging via S pins */
212 
213 /* LTC I2C commands */
214 /* static uint16_t ltc_I2CcmdDummy[6] = {0x7F, 0xF9, 0x7F, 0xF9, 0x7F, 0xF9}; !< dummy command (no transmit) */
215 
216 static uint16_t ltc_I2CcmdTempSens0[6] = {
217  0x69,
218  0x08,
219  0x00,
220  0x09,
221  0x7F,
222  0xF9}; /*!< sets the internal data pointer of the temperature sensor (address 0x48) to 0x00 */
223 static uint16_t ltc_I2CcmdTempSens1[6] =
224  {0x69, 0x18, 0x0F, 0xF0, 0x0F, 0xF9}; /*!< reads two data bytes from the temperature sensor */
225 
226 static uint16_t ltc_I2CcmdPortExpander1[6] =
227  {0x64, 0x18, 0x0F, 0xF9, 0x7F, 0xF9}; /*!< reads one data byte from the port expander */
228 
229 /* Cells */
230 static uint16_t ltc_cmdADCV_normal_DCP0[4] =
231  {0x03, 0x60, 0xF4, 0x6C}; /*!< All cells, normal mode, discharge not permitted (DCP=0) */
232 static uint16_t ltc_cmdADCV_normal_DCP1[4] =
233  {0x03, 0x70, 0xAF, 0x42}; /*!< All cells, normal mode, discharge permitted (DCP=1) */
234 static uint16_t ltc_cmdADCV_filtered_DCP0[4] =
235  {0x03, 0xE0, 0xB0, 0x4A}; /*!< All cells, filtered mode, discharge not permitted (DCP=0) */
236 static uint16_t ltc_cmdADCV_filtered_DCP1[4] =
237  {0x03, 0xF0, 0xEB, 0x64}; /*!< All cells, filtered mode, discharge permitted (DCP=1) */
238 static uint16_t ltc_cmdADCV_fast_DCP0[4] =
239  {0x02, 0xE0, 0x38, 0x06}; /*!< All cells, fast mode, discharge not permitted (DCP=0) */
240 static uint16_t ltc_cmdADCV_fast_DCP1[4] =
241  {0x02, 0xF0, 0x63, 0x28}; /*!< All cells, fast mode, discharge permitted (DCP=1) */
242 static uint16_t ltc_cmdADCV_fast_DCP0_twocells[4] =
243  {0x02, 0xE1, 0xB3, 0x34}; /*!< Two cells (1 and 7), fast mode, discharge not permitted (DCP=0) */
244 
245 /* GPIOs */
246 static uint16_t ltc_cmdADAX_normal_GPIO1[4] = {0x05, 0x61, 0x58, 0x92}; /*!< Single channel, GPIO 1, normal mode */
247 static uint16_t ltc_cmdADAX_filtered_GPIO1[4] = {0x05, 0xE1, 0x1C, 0xB4}; /*!< Single channel, GPIO 1, filtered mode */
248 static uint16_t ltc_cmdADAX_fast_GPIO1[4] = {0x04, 0xE1, 0x94, 0xF8}; /*!< Single channel, GPIO 1, fast mode */
249 static uint16_t ltc_cmdADAX_normal_GPIO2[4] = {0x05, 0x62, 0x4E, 0xF6}; /*!< Single channel, GPIO 2, normal mode */
250 static uint16_t ltc_cmdADAX_filtered_GPIO2[4] = {0x05, 0xE2, 0x0A, 0xD0}; /*!< Single channel, GPIO 2, filtered mode */
251 static uint16_t ltc_cmdADAX_fast_GPIO2[4] = {0x04, 0xE2, 0x82, 0x9C}; /*!< Single channel, GPIO 2, fast mode */
252 static uint16_t ltc_cmdADAX_normal_GPIO3[4] = {0x05, 0x63, 0xC5, 0xC4}; /*!< Single channel, GPIO 3, normal mode */
253 static uint16_t ltc_cmdADAX_filtered_GPIO3[4] = {0x05, 0xE3, 0x81, 0xE2}; /*!< Single channel, GPIO 3, filtered mode */
254 static uint16_t ltc_cmdADAX_fast_GPIO3[4] = {0x04, 0xE3, 0x09, 0xAE}; /*!< Single channel, GPIO 3, fast mode */
255 /* static uint16_t ltc_cmdADAX_normal_GPIO4[4] = {0x05, 0x64, 0x62, 0x3E}; !< Single channel, GPIO 4, normal mode */
256 /* static uint16_t ltc_cmdADAX_filtered_GPIO4[4] = {0x05, 0xE4, 0x26, 0x18}; !< Single channel, GPIO 4, filtered mode */
257 /* static uint16_t ltc_cmdADAX_fast_GPIO4[4] = {0x04, 0xE4, 0xAE, 0x54}; !< Single channel, GPIO 4, fast mode */
258 /* static uint16_t ltc_cmdADAX_normal_GPIO5[4] = {0x05, 0x65, 0xE9, 0x0C}; !< Single channel, GPIO 5, normal mode */
259 /* static uint16_t ltc_cmdADAX_filtered_GPIO5[4] = {0x05, 0xE5, 0xAD, 0x2A}; !< Single channel, GPIO 5, filtered mode */
260 /* static uint16_t ltc_cmdADAX_fast_GPIO5[4] = {0x04, 0xE5, 0x25, 0x66}; !< Single channel, GPIO 5, fast mode */
261 static uint16_t ltc_cmdADAX_normal_ALLGPIOS[4] = {0x05, 0x60, 0xD3, 0xA0}; /*!< All channels, normal mode */
262 static uint16_t ltc_cmdADAX_filtered_ALLGPIOS[4] =
263  {0x05, 0xE0, 0x97, 0x86}; /*!< All channels, filtered mode */
264 static uint16_t ltc_cmdADAX_fast_ALLGPIOS[4] = {0x04, 0xE0, 0x1F, 0xCA}; /*!< All channels, fast mode */
265 
266 /* Open-wire */
267 static uint16_t ltc_BC_cmdADOW_PUP_normal_DCP0[4] = {
268  0x03,
269  0x68,
270  0x1C,
271  0x62}; /*!< Broadcast, Pull-up current, All cells, normal mode, discharge not permitted (DCP=0) */
272 static uint16_t ltc_BC_cmdADOW_PDOWN_normal_DCP0[4] = {
273  0x03,
274  0x28,
275  0xFB,
276  0xE8}; /*!< Broadcast, Pull-down current, All cells, normal mode, discharge not permitted (DCP=0) */
277 static uint16_t ltc_BC_cmdADOW_PUP_filtered_DCP0[4] = {
278  0x03,
279  0xE8,
280  0x58,
281  0x44}; /*!< Broadcast, Pull-up current, All cells, filtered mode, discharge not permitted (DCP=0) */
282 static uint16_t ltc_BC_cmdADOW_PDOWN_filtered_DCP0[4] = {
283  0x03,
284  0xA8,
285  0xBF,
286  0xCE}; /*!< Broadcast, Pull-down current, All cells, filtered mode, discharge not permitted (DCP=0) */
287 
288 /*========== Static Function Prototypes =====================================*/
289 static void LTC_SetFirstMeasurementCycleFinished(LTC_STATE_s *ltc_state);
290 static void LTC_InitializeDatabase(LTC_STATE_s *ltc_state);
291 static void LTC_SaveBalancingFeedback(LTC_STATE_s *ltc_state, uint16_t *DataBufferSPI_RX, uint8_t stringNumber);
292 static void LTC_GetBalancingControlValues(LTC_STATE_s *ltc_state);
293 static void LTC_SaveLastStates(LTC_STATE_s *ltc_state);
294 static void LTC_StateTransition(LTC_STATE_s *ltc_state, LTC_STATEMACH_e state, uint8_t substate, uint16_t timer_ms);
295 static void LTC_CondBasedStateTransition(
296  LTC_STATE_s *ltc_state,
297  STD_RETURN_TYPE_e retVal,
298  DIAG_ID_e diagCode,
299  LTC_STATEMACH_e state_ok,
300  uint8_t substate_ok,
301  uint16_t timer_ms_ok,
302  LTC_STATEMACH_e state_nok,
303  uint8_t substate_nok,
304  uint16_t timer_ms_nok);
305 
306 static STD_RETURN_TYPE_e LTC_BalanceControl(
307  LTC_STATE_s *ltc_state,
308  SPI_INTERFACE_CONFIG_s *pSpiInterface,
309  uint16_t *pTxBuff,
310  uint16_t *pRxBuff,
311  uint32_t frameLength,
312  uint8_t registerSet,
313  uint8_t stringNumber);
314 
315 static void LTC_ResetErrorTable(LTC_STATE_s *ltc_state);
316 static STD_RETURN_TYPE_e LTC_Init(
317  SPI_INTERFACE_CONFIG_s *pSpiInterface,
318  uint16_t *pTxBuff,
319  uint16_t *pRxBuff,
320  uint32_t frameLength);
321 
322 static STD_RETURN_TYPE_e LTC_StartVoltageMeasurement(
323  SPI_INTERFACE_CONFIG_s *pSpiInterface,
324  LTC_ADCMODE_e adcMode,
325  LTC_ADCMEAS_CHAN_e adcMeasCh);
326 static STD_RETURN_TYPE_e LTC_StartGpioMeasurement(
327  SPI_INTERFACE_CONFIG_s *pSpiInterface,
328  LTC_ADCMODE_e adcMode,
329  LTC_ADCMEAS_CHAN_e adcMeasCh);
330 static STD_RETURN_TYPE_e LTC_StartOpenWireMeasurement(
331  SPI_INTERFACE_CONFIG_s *pSpiInterface,
332  LTC_ADCMODE_e adcMode,
333  uint8_t PUP);
334 
335 static uint16_t LTC_GetMeasurementTimeCycle(LTC_ADCMODE_e adcMode, LTC_ADCMEAS_CHAN_e adcMeasCh);
336 static void LTC_SaveRxToVoltageBuffer(
337  LTC_STATE_s *ltc_state,
338  uint16_t *pRxBuff,
339  uint8_t registerSet,
340  uint8_t stringNumber);
341 static void LTC_SaveRxToGpioBuffer(
342  LTC_STATE_s *ltc_state,
343  uint16_t *pRxBuff,
344  uint8_t registerSet,
345  uint8_t stringNumber);
346 
347 static STD_RETURN_TYPE_e LTC_CheckPec(
348  LTC_STATE_s *ltc_state,
349  uint16_t *DataBufferSPI_RX_with_PEC,
350  uint8_t stringNumber);
351 static STD_RETURN_TYPE_e LTC_ReadRegister(
352  uint16_t *Command,
353  SPI_INTERFACE_CONFIG_s *pSpiInterface,
354  uint16_t *pTxBuff,
355  uint16_t *pRxBuff,
356  uint32_t frameLength);
357 static STD_RETURN_TYPE_e LTC_WriteRegister(
358  uint16_t *Command,
359  SPI_INTERFACE_CONFIG_s *pSpiInterface,
360  uint16_t *pTxBuff,
361  uint16_t *pRxBuff,
362  uint32_t frameLength);
363 static void LTC_SetMuxChCommand(uint16_t *pTxBuff, uint8_t mux, uint8_t channel);
364 static STD_RETURN_TYPE_e LTC_SendEepromReadCommand(
365  LTC_STATE_s *ltc_state,
366  SPI_INTERFACE_CONFIG_s *pSpiInterface,
367  uint16_t *pTxBuff,
368  uint16_t *pRxBuff,
369  uint32_t frameLength,
370  uint8_t step);
371 static void LTC_SetEepromReadCommand(LTC_STATE_s *ltc_state, uint16_t *pTxBuff, uint8_t step);
372 static void LTC_EepromSaveReadValue(LTC_STATE_s *ltc_state, uint16_t *pRxBuff);
373 static STD_RETURN_TYPE_e LTC_SendEepromWriteCommand(
374  LTC_STATE_s *ltc_state,
375  SPI_INTERFACE_CONFIG_s *pSpiInterface,
376  uint16_t *pTxBuff,
377  uint16_t *pRxBuff,
378  uint32_t frameLength,
379  uint8_t step);
380 static void LTC_SetEepromWriteCommand(LTC_STATE_s *ltc_state, uint16_t *pTxBuff, uint8_t step);
381 static STD_RETURN_TYPE_e LTC_SetMuxChannel(
382  SPI_INTERFACE_CONFIG_s *pSpiInterface,
383  uint16_t *pTxBuff,
384  uint16_t *pRxBuff,
385  uint32_t frameLength,
386  uint8_t mux,
387  uint8_t channel);
388 static STD_RETURN_TYPE_e LTC_SetPortExpander(
389  LTC_STATE_s *ltc_state,
390  SPI_INTERFACE_CONFIG_s *pSpiInterface,
391  uint16_t *pTxBuff,
392  uint16_t *pRxBuff,
393  uint32_t frameLength);
394 static void LTC_PortExpanderSaveValues(LTC_STATE_s *ltc_state, uint16_t *pRxBuff);
395 static void LTC_TempSensSaveTemp(LTC_STATE_s *ltc_state, uint16_t *pRxBuff);
396 static STD_RETURN_TYPE_e LTC_SetPortExpanderDirectionTi(
397  LTC_STATE_s *ltc_state,
398  SPI_INTERFACE_CONFIG_s *pSpiInterface,
399  uint16_t *pTxBuff,
400  uint16_t *pRxBuff,
401  uint32_t frameLength,
402  LTC_PORT_EXPANDER_TI_DIRECTION_e direction);
403 static STD_RETURN_TYPE_e LTC_SetPortExpanderOutputTi(
404  LTC_STATE_s *ltc_state,
405  SPI_INTERFACE_CONFIG_s *pSpiInterface,
406  uint16_t *pTxBuff,
407  uint16_t *pRxBuff,
408  uint32_t frameLength);
409 static STD_RETURN_TYPE_e LTC_GetPortExpanderInputTi(
410  LTC_STATE_s *ltc_state,
411  SPI_INTERFACE_CONFIG_s *pSpiInterface,
412  uint16_t *pTxBuff,
413  uint16_t *pRxBuff,
414  uint32_t frameLength,
415  uint8_t step);
416 static void LTC_PortExpanderSaveValuesTi(LTC_STATE_s *ltc_state, uint16_t *pTxBuff);
417 
418 static STD_RETURN_TYPE_e LTC_I2cClock(SPI_INTERFACE_CONFIG_s *pSpiInterface);
419 static STD_RETURN_TYPE_e LTC_SendI2cCommand(
420  SPI_INTERFACE_CONFIG_s *pSpiInterface,
421  uint16_t *pTxBuff,
422  uint16_t *pRxBuff,
423  uint32_t frameLength,
424  uint16_t *cmd_data);
425 
426 static STD_RETURN_TYPE_e LTC_I2cCheckAck(LTC_STATE_s *ltc_state, uint16_t *pRxBuff, uint8_t mux, uint8_t stringNumber);
427 
428 static void LTC_SaveMuxMeasurement(
429  LTC_STATE_s *ltc_state,
430  uint16_t *pRxBuff,
431  LTC_MUX_CH_CFG_s *muxseqptr,
432  uint8_t stringNumber);
433 
434 static uint32_t LTC_GetSpiClock(SPI_INTERFACE_CONFIG_s *pSpiInterface);
435 static void LTC_SetTransferTimes(LTC_STATE_s *ltc_state);
436 
437 static LTC_RETURN_TYPE_e LTC_CheckStateRequest(LTC_STATE_s *ltc_state, LTC_REQUEST_s statereq);
438 
439 /*========== Static Function Implementations ================================*/
440 /**
441  * @brief in the database, initializes the fields related to the LTC drivers.
442  *
443  * This function loops through all the LTC-related data fields in the database
444  * and sets them to 0. It should be called in the initialization or re-initialization
445  * routine of the LTC driver.
446  *
447  * @param ltc_state: state of the ltc state machine
448  *
449  */
450 static void LTC_InitializeDatabase(LTC_STATE_s *ltc_state) {
451  for (uint8_t s = 0u; s < BS_NR_OF_STRINGS; s++) {
452  ltc_state->ltcData.cellVoltage->state = 0;
453  for (uint16_t i = 0; i < BS_NR_OF_CELL_BLOCKS_PER_STRING; i++) {
454  ltc_state->ltcData.cellVoltage->cellVoltage_mV[s][i] = 0;
455  ltc_state->ltcData.openWireDetection->openWirePup[s][i] = 0;
456  ltc_state->ltcData.openWireDetection->openWirePdown[s][i] = 0;
457  ltc_state->ltcData.openWireDetection->openWireDelta[s][i] = 0;
458  }
459 
460  ltc_state->ltcData.cellTemperature->state = 0;
461  for (uint16_t i = 0; i < BS_NR_OF_TEMP_SENSORS_PER_STRING; i++) {
462  ltc_state->ltcData.cellTemperature->cellTemperature_ddegC[s][i] = 0;
463  }
464 
465  ltc_state->ltcData.balancingFeedback->state = 0;
466  for (uint16_t i = 0; i < BS_NR_OF_CELL_BLOCKS_PER_STRING; i++) {
467  ltc_state->ltcData.balancingControl->balancingState[s][i] = 0;
468  }
469  ltc_state->ltcData.balancingControl->nrBalancedCells[s] = 0u;
470  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
471  ltc_state->ltcData.balancingFeedback->value[s][i] = 0;
472  }
473 
474  ltc_state->ltcData.slaveControl->state = 0;
475  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
476  ltc_state->ltcData.slaveControl->ioValueIn[i] = 0;
477  ltc_state->ltcData.slaveControl->ioValueOut[i] = 0;
478  ltc_state->ltcData.slaveControl->externalTemperatureSensor[i] = 0;
479  ltc_state->ltcData.slaveControl->eepromValueRead[i] = 0;
480  ltc_state->ltcData.slaveControl->eepromValueWrite[i] = 0;
481  }
482  ltc_state->ltcData.slaveControl->eepromReadAddressLastUsed = 0xFFFFFFFF;
483  ltc_state->ltcData.slaveControl->eepromReadAddressToUse = 0xFFFFFFFF;
484  ltc_state->ltcData.slaveControl->eepromWriteAddressLastUsed = 0xFFFFFFFF;
485  ltc_state->ltcData.slaveControl->eepromWriteAddressToUse = 0xFFFFFFFF;
486 
487  ltc_state->ltcData.allGpioVoltages->state = 0;
488  for (uint16_t i = 0; i < (BS_NR_OF_MODULES_PER_STRING * BS_NR_OF_GPIOS_PER_MODULE); i++) {
489  ltc_state->ltcData.allGpioVoltages->gpioVoltages_mV[s][i] = 0;
490  }
491 
492  for (uint16_t i = 0; i < (BS_NR_OF_MODULES_PER_STRING * (BS_NR_OF_CELL_BLOCKS_PER_MODULE + 1)); i++) {
493  ltc_state->ltcData.openWire->openWire[s][i] = 0;
494  }
495  ltc_state->ltcData.openWire->state = 0;
496  }
497 
498  DATA_WRITE_DATA(
499  ltc_state->ltcData.cellVoltage,
500  ltc_state->ltcData.cellTemperature,
501  ltc_state->ltcData.balancingFeedback,
502  ltc_state->ltcData.openWire);
503  DATA_WRITE_DATA(ltc_state->ltcData.balancingControl, ltc_state->ltcData.slaveControl);
504 }
505 
506 /**
507  * @brief Saves the last state and the last substate
508  *
509  * @param ltc_state: state of the ltc state machine
510  */
511 static void LTC_SaveLastStates(LTC_STATE_s *ltc_state) {
512  ltc_state->laststate = ltc_state->state;
513  ltc_state->lastsubstate = ltc_state->substate;
514 }
515 
516 /**
517  * @brief function for setting LTC_Trigger state transitions
518  *
519  * @param ltc_state: state of the ltc state machine
520  * @param state: state to transition into
521  * @param substate: substate to transition into
522  * @param timer_ms: transition into state, substate after timer elapsed
523  */
524 static void LTC_StateTransition(LTC_STATE_s *ltc_state, LTC_STATEMACH_e state, uint8_t substate, uint16_t timer_ms) {
525  ltc_state->state = state;
526  ltc_state->substate = substate;
527  ltc_state->timer = timer_ms;
528 }
529 
530 /**
531  * @brief condition-based state transition depending on retVal
532  *
533  * If retVal is #STD_OK, after timer_ms_ok is elapsed the LTC statemachine will
534  * transition into state_ok and substate_ok, otherwise after timer_ms_nok the
535  * statemachine will transition to state_nok and substate_nok. Depending on
536  * value of retVal the corresponding diagnosis entry will be called.
537  *
538  * @param ltc_state state of the ltc state machine
539  * @param retVal condition to determine if state machine will transition
540  * into ok or nok states
541  * @param diagCode symbolic IDs for diagnosis entry, called with
542  * #DIAG_EVENT_OK if retVal is #STD_OK, #DIAG_EVENT_NOT_OK
543  * otherwise
544  * @param state_ok state to transition into if retVal is #STD_OK
545  * @param substate_ok substate to transition into if retVal is #STD_OK
546  * @param timer_ms_ok transition into state_ok, substate_ok after timer_ms_ok
547  * elapsed
548  * @param state_nok state to transition into if retVal is #STD_NOT_OK
549  * @param substate_nok substate to transition into if retVal is #STD_NOT_OK
550  * @param timer_ms_nok transition into state_nok, substate_nok after
551  * timer_ms_nok elapsed
552  */
553 static void LTC_CondBasedStateTransition(
554  LTC_STATE_s *ltc_state,
555  STD_RETURN_TYPE_e retVal,
556  DIAG_ID_e diagCode,
557  LTC_STATEMACH_e state_ok,
558  uint8_t substate_ok,
559  uint16_t timer_ms_ok,
560  LTC_STATEMACH_e state_nok,
561  uint8_t substate_nok,
562  uint16_t timer_ms_nok) {
563  if ((retVal != STD_OK)) {
564  DIAG_Handler(diagCode, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
565  LTC_StateTransition(ltc_state, state_nok, substate_nok, timer_ms_nok);
566  } else {
567  DIAG_Handler(diagCode, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
568  LTC_StateTransition(ltc_state, state_ok, substate_ok, timer_ms_ok);
569  }
570 }
571 
572 extern void LTC_SaveVoltages(LTC_STATE_s *ltc_state, uint8_t stringNumber) {
573  /* Pointer validity check */
574  FAS_ASSERT(ltc_state != NULL_PTR);
575  FAS_ASSERT(stringNumber < BS_NR_OF_STRINGS);
576 
577  /* Iterate over all cell to:
578  *
579  * 1. Check open-wires and set respective cell measurements to invalid
580  * 2. Perform minimum/maximum measurement value plausibility check
581  * 3. Calculate string values
582  */
583  STD_RETURN_TYPE_e cellVoltageMeasurementValid = STD_OK;
584  int32_t stringVoltage_mV = 0;
585  uint16_t numberValidMeasurements = 0;
586  for (uint8_t m = 0u; m < BS_NR_OF_MODULES_PER_STRING; m++) {
587  for (uint8_t c = 0u; c < BS_NR_OF_CELL_BLOCKS_PER_MODULE; c++) {
588  /* ------- 1. Check open-wires -----------------
589  * Is cell N input not open wire &&
590  * Is cell N+1 input not open wire &&
591  * Is cell voltage valid because of previous PEC error
592  * If so, everything okay, else set cell voltage measurement to invalid.
593  */
594  if ((ltc_state->ltcData.openWire
595  ->openWire[stringNumber][(m * (BS_NR_OF_CELL_BLOCKS_PER_MODULE + 1u)) + c] == 0u) &&
596  (ltc_state->ltcData.openWire
597  ->openWire[stringNumber][(m * (BS_NR_OF_CELL_BLOCKS_PER_MODULE + 1u)) + c + 1u] == 0u) &&
598  ((ltc_state->ltcData.cellVoltage->invalidCellVoltage[stringNumber][m] & (0x01u << c)) == 0u)) {
599  /* Cell voltage is valid -> perform minimum/maximum plausibility check */
600 
601  /* ------- 2. Perform minimum/maximum measurement range check ---------- */
602  if (STD_OK == AFE_PlausibilityCheckVoltageMeasurementRange(
603  ltc_state->ltcData.cellVoltage
604  ->cellVoltage_mV[stringNumber][(m * BS_NR_OF_CELL_BLOCKS_PER_MODULE) + c],
605  ltc_plausibleCellVoltages681x)) {
606  /* Cell voltage is valid -> calculate string voltage */
607  /* -------- 3. Calculate string values ------------- */
608  stringVoltage_mV += ltc_state->ltcData.cellVoltage
609  ->cellVoltage_mV[stringNumber][(m * BS_NR_OF_CELL_BLOCKS_PER_MODULE) + c];
610  numberValidMeasurements++;
611  } else {
612  /* Invalidate cell voltage measurement */
613  ltc_state->ltcData.cellVoltage->invalidCellVoltage[stringNumber][m] |= (0x01u << c);
614  cellVoltageMeasurementValid = STD_NOT_OK;
615  }
616  } else {
617  /* Set cell voltage measurement value invalid, if not already invalid because of PEC Error */
618  ltc_state->ltcData.cellVoltage->invalidCellVoltage[stringNumber][m] |= (0x01u << c);
619  cellVoltageMeasurementValid = STD_NOT_OK;
620  }
621  }
622  }
623  DIAG_CheckEvent(cellVoltageMeasurementValid, ltc_state->voltMeasDiagErrorEntry, DIAG_STRING, stringNumber);
624  ltc_state->ltcData.cellVoltage->packVoltage_mV[stringNumber] = stringVoltage_mV;
625  ltc_state->ltcData.cellVoltage->nrValidCellVoltages[stringNumber] = numberValidMeasurements;
626 
627  /* Increment state variable each time new values are written into database */
628  ltc_state->ltcData.cellVoltage->state++;
629 
630  DATA_WRITE_DATA(ltc_state->ltcData.cellVoltage);
631 }
632 
633 /*========== Extern Function Implementations ================================*/
634 extern void LTC_SaveTemperatures(LTC_STATE_s *ltc_state, uint8_t stringNumber) {
635  FAS_ASSERT(ltc_state != NULL_PTR);
636  STD_RETURN_TYPE_e cellTemperatureMeasurementValid = STD_OK;
637  uint16_t numberValidMeasurements = 0;
638 
639  for (uint8_t m = 0u; m < BS_NR_OF_MODULES_PER_STRING; m++) {
640  for (uint8_t c = 0u; c < BS_NR_OF_TEMP_SENSORS_PER_MODULE; c++) {
641  /* ------- 1. Check valid flag -----------------
642  * Is cell temperature valid because of previous PEC error
643  * If so, everything okay, else set cell temperature measurement to invalid.
644  */
645  if ((ltc_state->ltcData.cellTemperature->invalidCellTemperature[stringNumber][m] & (0x01u << c)) == 0u) {
646  /* Cell temperature is valid -> perform minimum/maximum plausibility check */
647 
648  /* ------- 2. Perform minimum/maximum measurement range check ---------- */
649  if (STD_OK ==
650  AFE_PlausibilityCheckTempMinMax(
651  ltc_state->ltcData.cellTemperature
652  ->cellTemperature_ddegC[stringNumber][(m * BS_NR_OF_TEMP_SENSORS_PER_MODULE) + c])) {
653  numberValidMeasurements++;
654  } else {
655  /* Invalidate cell temperature measurement */
656  ltc_state->ltcData.cellTemperature->invalidCellTemperature[stringNumber][m] |= (0x01u << c);
657  cellTemperatureMeasurementValid = STD_NOT_OK;
658  }
659  } else {
660  /* Already invalid because of PEC Error */
661  cellTemperatureMeasurementValid = STD_NOT_OK;
662  }
663  }
664  }
665  DIAG_CheckEvent(cellTemperatureMeasurementValid, ltc_state->tempMeasDiagErrorEntry, DIAG_STRING, stringNumber);
666 
667  ltc_state->ltcData.cellTemperature->nrValidTemperatures[stringNumber] = numberValidMeasurements;
668 
669  ltc_state->ltcData.cellTemperature->state++;
670  DATA_WRITE_DATA(ltc_state->ltcData.cellTemperature);
671 }
672 
673 extern void LTC_SaveAllGpioMeasurement(LTC_STATE_s *ltc_state) {
674  FAS_ASSERT(ltc_state != NULL_PTR);
675  ltc_state->ltcData.allGpioVoltages->state++;
676  DATA_WRITE_DATA(ltc_state->ltcData.allGpioVoltages);
677 }
678 
679 /**
680  * @brief stores the measured balancing feedback values in the database.
681  *
682  * This function stores the global balancing feedback value measured on GPIO3 of the LTC into the database
683  *
684  * @param ltc_state state of the ltc state machine
685  * @param DataBufferSPI_RX receive buffer of the SPI interface
686  * @param stringNumber string addressed
687  *
688  */
689 static void LTC_SaveBalancingFeedback(LTC_STATE_s *ltc_state, uint16_t *DataBufferSPI_RX, uint8_t stringNumber) {
690  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
691  const uint16_t val_i = DataBufferSPI_RX[8u + (1u * i * 8u)] |
692  (DataBufferSPI_RX[8u + (1u * i * 8u) + 1u] << 8u); /* raw value, GPIO3 */
693 
694  ltc_state->ltcData.balancingFeedback->value[stringNumber][i] = val_i;
695  }
696 
697  ltc_state->ltcData.balancingFeedback->state++;
698  DATA_WRITE_DATA(ltc_state->ltcData.balancingFeedback);
699 }
700 
701 /**
702  * @brief gets the balancing orders from the database.
703  *
704  * This function gets the balancing control from the database. Balancing control
705  * is set by the BMS. The LTC driver only executes the balancing orders.
706  *
707  * @param ltc_state: state of the ltc state machine
708  *
709  */
710 static void LTC_GetBalancingControlValues(LTC_STATE_s *ltc_state) {
711  DATA_READ_DATA(ltc_state->ltcData.balancingControl);
712 }
713 
714 /**
715  * @brief re-entrance check of LTC state machine trigger function
716  *
717  * This function is not re-entrant and should only be called time- or event-triggered.
718  * It increments the triggerentry counter from the state variable ltc_state.
719  * It should never be called by two different processes, so if it is the case, triggerentry
720  * should never be higher than 0 when this function is called.
721  *
722  * @param ltc_state: state of the ltc state machine
723  *
724  * @return retval 0 if no further instance of the function is active, 0xff else
725  *
726  */
727 uint8_t LTC_CheckReEntrance(LTC_STATE_s *ltc_state) {
728  FAS_ASSERT(ltc_state != NULL_PTR);
729  uint8_t retval = 0;
730 
731  OS_EnterTaskCritical();
732  if (!ltc_state->triggerentry) {
733  ltc_state->triggerentry++;
734  } else {
735  retval = 0xFF; /* multiple calls of function */
736  }
737  OS_ExitTaskCritical();
738 
739  return (retval);
740 }
741 
742 extern LTC_REQUEST_s LTC_GetStateRequest(LTC_STATE_s *ltc_state) {
743  FAS_ASSERT(ltc_state != NULL_PTR);
744  LTC_REQUEST_s retval = {.request = LTC_STATE_NO_REQUEST, .string = 0x0u};
745 
746  OS_EnterTaskCritical();
747  retval.request = ltc_state->statereq.request;
748  retval.string = ltc_state->statereq.string;
749  OS_ExitTaskCritical();
750 
751  return (retval);
752 }
753 
754 extern LTC_STATEMACH_e LTC_GetState(LTC_STATE_s *ltc_state) {
755  FAS_ASSERT(ltc_state != NULL_PTR);
756  return ltc_state->state;
757 }
758 
759 /**
760  * @brief transfers the current state request to the state machine.
761  *
762  * This function takes the current state request from ltc_state and transfers it to the state machine.
763  * It resets the value from ltc_state to LTC_STATE_NO_REQUEST
764  *
765  * @param ltc_state: state of the ltc state machine
766  * @param pBusIDptr bus ID, main or backup (deprecated)
767  * @param pAdcModeptr LTC ADCmeasurement mode (fast, normal or filtered)
768  * @param pAdcMeasChptr number of channels measured for GPIOS (one at a time for multiplexers or all five GPIOs)
769  *
770  * @return retVal current state request, taken from LTC_STATE_REQUEST_e
771  *
772  */
773 LTC_REQUEST_s LTC_TransferStateRequest(
774  LTC_STATE_s *ltc_state,
775  uint8_t *pBusIDptr,
776  LTC_ADCMODE_e *pAdcModeptr,
777  LTC_ADCMEAS_CHAN_e *pAdcMeasChptr) {
778  FAS_ASSERT(ltc_state != NULL_PTR);
779  FAS_ASSERT(pBusIDptr != NULL_PTR);
780  FAS_ASSERT(pAdcModeptr != NULL_PTR);
781  FAS_ASSERT(pAdcMeasChptr != NULL_PTR);
782  LTC_REQUEST_s retval = {.request = LTC_STATE_NO_REQUEST, .string = 0x0u};
783 
784  OS_EnterTaskCritical();
785  retval.request = ltc_state->statereq.request;
786  retval.string = ltc_state->statereq.string;
787  ltc_state->requestedString = ltc_state->statereq.string;
788  *pAdcModeptr = ltc_state->adcModereq;
789  *pAdcMeasChptr = ltc_state->adcMeasChreq;
790  ltc_state->statereq.request = LTC_STATE_NO_REQUEST;
791  ltc_state->statereq.string = 0x0u;
792  OS_ExitTaskCritical();
793 
794  return (retval);
795 }
796 
797 LTC_RETURN_TYPE_e LTC_SetStateRequest(LTC_STATE_s *ltc_state, LTC_REQUEST_s statereq) {
798  FAS_ASSERT(ltc_state != NULL_PTR);
799  LTC_RETURN_TYPE_e retVal = LTC_ERROR;
800 
801  OS_EnterTaskCritical();
802  retVal = LTC_CheckStateRequest(ltc_state, statereq);
803 
804  if ((retVal == LTC_OK) || (retVal == LTC_BUSY_OK) || (retVal == LTC_OK_FROM_ERROR)) {
805  ltc_state->statereq = statereq;
806  }
807  OS_ExitTaskCritical();
808 
809  return (retVal);
810 }
811 
812 void LTC_Trigger(LTC_STATE_s *ltc_state) {
813  FAS_ASSERT(ltc_state != NULL_PTR);
814  STD_RETURN_TYPE_e retVal = STD_OK;
815  LTC_REQUEST_s statereq = {.request = LTC_STATE_NO_REQUEST, .string = 0x0u};
816  uint8_t tmpbusID = 0;
817  LTC_ADCMODE_e tmpadcMode = LTC_ADCMODE_UNDEFINED;
818  LTC_ADCMEAS_CHAN_e tmpadcMeasCh = LTC_ADCMEAS_UNDEFINED;
819  STD_RETURN_TYPE_e continueFunction = STD_OK;
820 
821  FAS_ASSERT(ltc_state != NULL_PTR);
822 
823  /* Check re-entrance of function */
824  if (LTC_CheckReEntrance(ltc_state) > 0u) {
825  continueFunction = STD_NOT_OK;
826  }
827 
828  if (ltc_state->check_spi_flag == STD_NOT_OK) {
829  if (ltc_state->timer > 0u) {
830  if ((--ltc_state->timer) > 0u) {
831  ltc_state->triggerentry--;
832  continueFunction = STD_NOT_OK; /* handle state machine only if timer has elapsed */
833  }
834  }
835  } else {
836  if (AFE_IsTransmitOngoing(ltc_state) == true) {
837  if (ltc_state->timer > 0u) {
838  if ((--ltc_state->timer) > 0u) {
839  ltc_state->triggerentry--;
840  continueFunction = STD_NOT_OK; /* handle state machine only if timer has elapsed */
841  }
842  }
843  }
844  }
845 
846  if (continueFunction == STD_OK) {
847  switch (ltc_state->state) {
848  /****************************UNINITIALIZED***********************************/
849  case LTC_STATEMACH_UNINITIALIZED:
850  /* waiting for Initialization Request */
851  statereq = LTC_TransferStateRequest(ltc_state, &tmpbusID, &tmpadcMode, &tmpadcMeasCh);
852  if (statereq.request == LTC_STATE_INIT_REQUEST) {
853  LTC_SaveLastStates(ltc_state);
854  LTC_InitializeDatabase(ltc_state);
855  LTC_ResetErrorTable(ltc_state);
856  LTC_StateTransition(
857  ltc_state, LTC_STATEMACH_INITIALIZATION, LTC_INIT_STRING, LTC_STATEMACH_SHORTTIME);
858  ltc_state->adcMode = tmpadcMode;
859  ltc_state->adcMeasCh = tmpadcMeasCh;
860  } else if (statereq.request == LTC_STATE_NO_REQUEST) {
861  /* no actual request pending */
862  } else {
863  ltc_state->ErrRequestCounter++; /* illegal request pending */
864  }
865  break;
866 
867  /****************************INITIALIZATION**********************************/
868  case LTC_STATEMACH_INITIALIZATION:
869 
870  LTC_SetTransferTimes(ltc_state);
871 
872  if (ltc_state->substate == LTC_INIT_STRING) {
873  LTC_SaveLastStates(ltc_state);
874  ltc_state->currentString = 0u;
875 
876  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface;
877  ltc_state->spiNumberInterfaces = BS_NR_OF_STRINGS;
878  ltc_state->spiSeqEndPtr = ltc_state->ltcData.pSpiInterface + BS_NR_OF_STRINGS;
879  LTC_StateTransition(
880  ltc_state, LTC_STATEMACH_INITIALIZATION, LTC_ENTRY_INITIALIZATION, LTC_STATEMACH_SHORTTIME);
881  } else if (ltc_state->substate == LTC_ENTRY_INITIALIZATION) {
882  LTC_SaveLastStates(ltc_state);
883 
884  ltc_state->muxmeas_seqptr[ltc_state->currentString] = ltc_mux_seq.seqptr;
885  ltc_state->muxmeas_nr_end[ltc_state->currentString] = ltc_mux_seq.nr_of_steps;
886  ltc_state->muxmeas_seqendptr[ltc_state->currentString] =
887  ((LTC_MUX_CH_CFG_s *)ltc_mux_seq.seqptr) + ltc_mux_seq.nr_of_steps; /* last sequence + 1 */
888 
889  retVal =
890  LTC_TRANSMIT_WAKE_UP(ltc_state->spiSeqPtr); /* Send dummy byte to wake up the daisy chain */
891  LTC_CondBasedStateTransition(
892  ltc_state,
893  retVal,
894  ltc_state->spiDiagErrorEntry,
895  LTC_STATEMACH_INITIALIZATION,
896  LTC_RE_ENTRY_INITIALIZATION,
897  LTC_STATEMACH_DAISY_CHAIN_FIRST_INITIALIZATION_TIME,
898  LTC_STATEMACH_INITIALIZATION,
899  LTC_ENTRY_INITIALIZATION,
900  LTC_STATEMACH_SHORTTIME);
901  } else if (ltc_state->substate == LTC_RE_ENTRY_INITIALIZATION) {
902  LTC_SaveLastStates(ltc_state);
903  retVal = LTC_TRANSMIT_WAKE_UP(
904  ltc_state->spiSeqPtr); /* Send dummy byte again to wake up the daisy chain */
905  LTC_CondBasedStateTransition(
906  ltc_state,
907  retVal,
908  ltc_state->spiDiagErrorEntry,
909  LTC_STATEMACH_INITIALIZATION,
910  LTC_START_INIT_INITIALIZATION,
911  LTC_STATEMACH_DAISY_CHAIN_SECOND_INITIALIZATION_TIME,
912  LTC_STATEMACH_INITIALIZATION,
913  LTC_RE_ENTRY_INITIALIZATION,
914  LTC_STATEMACH_SHORTTIME);
915  } else if (ltc_state->substate == LTC_START_INIT_INITIALIZATION) {
916  LTC_SaveLastStates(ltc_state);
917  ltc_state->check_spi_flag = STD_OK;
918  AFE_SetTransmitOngoing(ltc_state);
919  retVal = LTC_Init(
920  ltc_state->spiSeqPtr,
921  ltc_state->ltcData.txBuffer,
922  ltc_state->ltcData.rxBuffer,
923  ltc_state->ltcData.frameLength); /* Initialize main LTC loop */
924  ltc_state->lastsubstate = ltc_state->substate;
925  DIAG_CheckEvent(retVal, ltc_state->spiDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
926  LTC_StateTransition(
927  ltc_state,
928  LTC_STATEMACH_INITIALIZATION,
929  LTC_CHECK_INITIALIZATION,
930  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT);
931  } else if (ltc_state->substate == LTC_CHECK_INITIALIZATION) {
932  /* Read values written in config register, currently unused */
933  LTC_SaveLastStates(ltc_state);
934  AFE_SetTransmitOngoing(ltc_state);
935  retVal = LTC_ReadRegister(
936  ltc_cmdRDCFG,
937  ltc_state->spiSeqPtr,
938  ltc_state->ltcData.txBuffer,
939  ltc_state->ltcData.rxBuffer,
940  ltc_state->ltcData.frameLength); /* Read config register */
941  LTC_StateTransition(
942  ltc_state,
943  LTC_STATEMACH_INITIALIZATION,
944  LTC_EXIT_INITIALIZATION,
945  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT);
946  } else if (ltc_state->substate == LTC_EXIT_INITIALIZATION) {
947  LTC_SaveLastStates(ltc_state);
948  ++ltc_state->spiSeqPtr;
949  ++ltc_state->currentString;
950  if (ltc_state->spiSeqPtr >= ltc_state->spiSeqEndPtr) {
951  LTC_StateTransition(
952  ltc_state, LTC_STATEMACH_INITIALIZED, LTC_ENTRY_INITIALIZATION, LTC_STATEMACH_SHORTTIME);
953  } else {
954  LTC_StateTransition(
955  ltc_state, LTC_STATEMACH_INITIALIZATION, LTC_ENTRY_INITIALIZATION, LTC_STATEMACH_SHORTTIME);
956  }
957  }
958  break;
959 
960  /****************************INITIALIZED*************************************/
961  case LTC_STATEMACH_INITIALIZED:
962  LTC_SaveLastStates(ltc_state);
963  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
964  break;
965 
966  /****************************START MEASUREMENT*******************************/
967  case LTC_STATEMACH_STARTMEAS:
968 
969  ltc_state->adcMode = LTC_VOLTAGE_MEASUREMENT_MODE;
970  ltc_state->adcMeasCh = LTC_ADCMEAS_ALLCHANNEL_CELLS;
971 
972  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface;
973  ltc_state->spiNumberInterfaces = BS_NR_OF_STRINGS;
974  ltc_state->spiSeqEndPtr = ltc_state->ltcData.pSpiInterface + BS_NR_OF_STRINGS;
975  ltc_state->currentString = 0u;
976 
977  ltc_state->check_spi_flag = STD_NOT_OK;
978  retVal = LTC_StartVoltageMeasurement(ltc_state->spiSeqPtr, ltc_state->adcMode, ltc_state->adcMeasCh);
979 
980  LTC_CondBasedStateTransition(
981  ltc_state,
982  retVal,
983  ltc_state->spiDiagErrorEntry,
984  LTC_STATEMACH_READVOLTAGE,
985  LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE,
986  (ltc_state->commandTransferTime +
987  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, ltc_state->adcMeasCh)),
988  LTC_STATEMACH_READVOLTAGE,
989  LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE,
990  LTC_STATEMACH_SHORTTIME);
991 
992  break;
993 
994  /****************************START MEASUREMENT CONTINUE*******************************/
995  /* Do not reset SPI interface pointer */
996  case LTC_STATEMACH_STARTMEAS_CONTINUE:
997 
998  ltc_state->adcMode = LTC_VOLTAGE_MEASUREMENT_MODE;
999  ltc_state->adcMeasCh = LTC_ADCMEAS_ALLCHANNEL_CELLS;
1000 
1001  ltc_state->check_spi_flag = STD_NOT_OK;
1002  retVal = LTC_StartVoltageMeasurement(ltc_state->spiSeqPtr, ltc_state->adcMode, ltc_state->adcMeasCh);
1003 
1004  LTC_CondBasedStateTransition(
1005  ltc_state,
1006  retVal,
1007  ltc_state->spiDiagErrorEntry,
1008  LTC_STATEMACH_READVOLTAGE,
1009  LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE,
1010  (ltc_state->commandTransferTime +
1011  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, ltc_state->adcMeasCh)),
1012  LTC_STATEMACH_READVOLTAGE,
1013  LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE,
1014  LTC_STATEMACH_SHORTTIME);
1015 
1016  break;
1017 
1018  /****************************READ VOLTAGE************************************/
1019  case LTC_STATEMACH_READVOLTAGE:
1020 
1021  if (ltc_state->substate == LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE) {
1022  ltc_state->check_spi_flag = STD_OK;
1023  AFE_SetTransmitOngoing(ltc_state);
1024  retVal = LTC_ReadRegister(
1025  ltc_cmdRDCVA,
1026  ltc_state->spiSeqPtr,
1027  ltc_state->ltcData.txBuffer,
1028  ltc_state->ltcData.rxBuffer,
1029  ltc_state->ltcData.frameLength);
1030  LTC_CondBasedStateTransition(
1031  ltc_state,
1032  retVal,
1033  ltc_state->spiDiagErrorEntry,
1034  LTC_STATEMACH_READVOLTAGE,
1035  LTC_READ_VOLTAGE_REGISTER_B_RDCVB_READVOLTAGE,
1036  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1037  LTC_STATEMACH_READVOLTAGE,
1038  LTC_READ_VOLTAGE_REGISTER_B_RDCVB_READVOLTAGE,
1039  LTC_STATEMACH_SHORTTIME);
1040  break;
1041  } else if (ltc_state->substate == LTC_READ_VOLTAGE_REGISTER_B_RDCVB_READVOLTAGE) {
1042  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1043  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1044  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 0, ltc_state->currentString);
1045 
1046  AFE_SetTransmitOngoing(ltc_state);
1047  retVal = LTC_ReadRegister(
1048  ltc_cmdRDCVB,
1049  ltc_state->spiSeqPtr,
1050  ltc_state->ltcData.txBuffer,
1051  ltc_state->ltcData.rxBuffer,
1052  ltc_state->ltcData.frameLength);
1053  LTC_CondBasedStateTransition(
1054  ltc_state,
1055  retVal,
1056  ltc_state->spiDiagErrorEntry,
1057  LTC_STATEMACH_READVOLTAGE,
1058  LTC_READ_VOLTAGE_REGISTER_C_RDCVC_READVOLTAGE,
1059  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1060  LTC_STATEMACH_READVOLTAGE,
1061  LTC_READ_VOLTAGE_REGISTER_C_RDCVC_READVOLTAGE,
1062  LTC_STATEMACH_SHORTTIME);
1063  break;
1064  } else if (ltc_state->substate == LTC_READ_VOLTAGE_REGISTER_C_RDCVC_READVOLTAGE) {
1065  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1066  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1067  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 1, ltc_state->currentString);
1068 
1069  AFE_SetTransmitOngoing(ltc_state);
1070  retVal = LTC_ReadRegister(
1071  ltc_cmdRDCVC,
1072  ltc_state->spiSeqPtr,
1073  ltc_state->ltcData.txBuffer,
1074  ltc_state->ltcData.rxBuffer,
1075  ltc_state->ltcData.frameLength);
1076  LTC_CondBasedStateTransition(
1077  ltc_state,
1078  retVal,
1079  ltc_state->spiDiagErrorEntry,
1080  LTC_STATEMACH_READVOLTAGE,
1081  LTC_READ_VOLTAGE_REGISTER_D_RDCVD_READVOLTAGE,
1082  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1083  LTC_STATEMACH_READVOLTAGE,
1084  LTC_READ_VOLTAGE_REGISTER_D_RDCVD_READVOLTAGE,
1085  LTC_STATEMACH_SHORTTIME);
1086  break;
1087  } else if (ltc_state->substate == LTC_READ_VOLTAGE_REGISTER_D_RDCVD_READVOLTAGE) {
1088  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1089  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1090  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 2, ltc_state->currentString);
1091 
1092  AFE_SetTransmitOngoing(ltc_state);
1093  retVal = LTC_ReadRegister(
1094  ltc_cmdRDCVD,
1095  ltc_state->spiSeqPtr,
1096  ltc_state->ltcData.txBuffer,
1097  ltc_state->ltcData.rxBuffer,
1098  ltc_state->ltcData.frameLength);
1099  if (LTC_6813_MAX_SUPPORTED_CELLS > 12u) {
1100  LTC_CondBasedStateTransition(
1101  ltc_state,
1102  retVal,
1103  ltc_state->spiDiagErrorEntry,
1104  LTC_STATEMACH_READVOLTAGE,
1105  LTC_READ_VOLTAGE_REGISTER_E_RDCVE_READVOLTAGE,
1106  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1107  LTC_STATEMACH_READVOLTAGE,
1108  LTC_READ_VOLTAGE_REGISTER_E_RDCVE_READVOLTAGE,
1109  LTC_STATEMACH_SHORTTIME);
1110  } else {
1111  LTC_CondBasedStateTransition(
1112  ltc_state,
1113  retVal,
1114  ltc_state->spiDiagErrorEntry,
1115  LTC_STATEMACH_READVOLTAGE,
1116  LTC_EXIT_READVOLTAGE,
1117  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1118  LTC_STATEMACH_READVOLTAGE,
1119  LTC_EXIT_READVOLTAGE,
1120  LTC_STATEMACH_SHORTTIME);
1121  }
1122  break;
1123  } else if (ltc_state->substate == LTC_READ_VOLTAGE_REGISTER_E_RDCVE_READVOLTAGE) {
1124  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1125  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1126  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 3, ltc_state->currentString);
1127 
1128  AFE_SetTransmitOngoing(ltc_state);
1129  retVal = LTC_ReadRegister(
1130  ltc_cmdRDCVE,
1131  ltc_state->spiSeqPtr,
1132  ltc_state->ltcData.txBuffer,
1133  ltc_state->ltcData.rxBuffer,
1134  ltc_state->ltcData.frameLength);
1135  if (LTC_6813_MAX_SUPPORTED_CELLS > 15u) {
1136  LTC_CondBasedStateTransition(
1137  ltc_state,
1138  retVal,
1139  ltc_state->spiDiagErrorEntry,
1140  LTC_STATEMACH_READVOLTAGE,
1141  LTC_READ_VOLTAGE_REGISTER_F_RDCVF_READVOLTAGE,
1142  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1143  LTC_STATEMACH_READVOLTAGE,
1144  LTC_READ_VOLTAGE_REGISTER_F_RDCVF_READVOLTAGE,
1145  LTC_STATEMACH_SHORTTIME);
1146  } else {
1147  LTC_CondBasedStateTransition(
1148  ltc_state,
1149  retVal,
1150  ltc_state->spiDiagErrorEntry,
1151  LTC_STATEMACH_READVOLTAGE,
1152  LTC_EXIT_READVOLTAGE,
1153  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1154  LTC_STATEMACH_READVOLTAGE,
1155  LTC_EXIT_READVOLTAGE,
1156  LTC_STATEMACH_SHORTTIME);
1157  }
1158  break;
1159  } else if (ltc_state->substate == LTC_READ_VOLTAGE_REGISTER_F_RDCVF_READVOLTAGE) {
1160  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1161  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1162  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 4, ltc_state->currentString);
1163 
1164  AFE_SetTransmitOngoing(ltc_state);
1165  retVal = LTC_ReadRegister(
1166  ltc_cmdRDCVF,
1167  ltc_state->spiSeqPtr,
1168  ltc_state->ltcData.txBuffer,
1169  ltc_state->ltcData.rxBuffer,
1170  ltc_state->ltcData.frameLength);
1171  LTC_CondBasedStateTransition(
1172  ltc_state,
1173  retVal,
1174  ltc_state->spiDiagErrorEntry,
1175  LTC_STATEMACH_READVOLTAGE,
1176  LTC_EXIT_READVOLTAGE,
1177  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1178  LTC_STATEMACH_READVOLTAGE,
1179  LTC_EXIT_READVOLTAGE,
1180  LTC_STATEMACH_SHORTTIME);
1181  break;
1182  } else if (ltc_state->substate == LTC_EXIT_READVOLTAGE) {
1183  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1184  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1185  if (LTC_6813_MAX_SUPPORTED_CELLS == 12u) {
1186  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 3, ltc_state->currentString);
1187  } else if (LTC_6813_MAX_SUPPORTED_CELLS == 15u) {
1188  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 4, ltc_state->currentString);
1189  } else if (LTC_6813_MAX_SUPPORTED_CELLS == 18u) {
1190  LTC_SaveRxToVoltageBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 5, ltc_state->currentString);
1191  }
1192 
1193  /* Switch to different state if read voltage state is reused
1194  * e.g. open-wire check... */
1195  if (ltc_state->reusageMeasurementMode == LTC_NOT_REUSED) {
1196  LTC_SaveVoltages(ltc_state, ltc_state->currentString);
1197  LTC_StateTransition(
1198  ltc_state,
1199  LTC_STATEMACH_MUXMEASUREMENT,
1200  LTC_STATEMACH_MUXCONFIGURATION_INIT,
1201  LTC_STATEMACH_SHORTTIME);
1202  } else if (ltc_state->reusageMeasurementMode == LTC_REUSE_READVOLT_FOR_ADOW_PUP) {
1203  LTC_StateTransition(
1204  ltc_state,
1205  LTC_STATEMACH_OPENWIRE_CHECK,
1206  LTC_READ_VOLTAGES_PULLUP_OPENWIRE_CHECK,
1207  LTC_STATEMACH_SHORTTIME);
1208  } else if (ltc_state->reusageMeasurementMode == LTC_REUSE_READVOLT_FOR_ADOW_PDOWN) {
1209  LTC_StateTransition(
1210  ltc_state,
1211  LTC_STATEMACH_OPENWIRE_CHECK,
1212  LTC_READ_VOLTAGES_PULLDOWN_OPENWIRE_CHECK,
1213  LTC_STATEMACH_SHORTTIME);
1214  }
1215  ltc_state->check_spi_flag = STD_NOT_OK;
1216  }
1217  break;
1218 
1219  /****************************MULTIPLEXED MEASUREMENT CONFIGURATION***********/
1220  case LTC_STATEMACH_MUXMEASUREMENT:
1221 
1222  ltc_state->adcMode = LTC_VOLTAGE_MEASUREMENT_MODE;
1223  ltc_state->adcMeasCh = LTC_ADCMEAS_SINGLECHANNEL_GPIO1;
1224 
1225  if (ltc_state->substate == LTC_STATEMACH_MUXCONFIGURATION_INIT) {
1226  ltc_state->adcMode = LTC_GPIO_MEASUREMENT_MODE;
1227  ltc_state->adcMeasCh = LTC_ADCMEAS_SINGLECHANNEL_GPIO1;
1228 
1229  if (ltc_state->muxmeas_seqptr[ltc_state->currentString] >=
1230  ltc_state->muxmeas_seqendptr[ltc_state->currentString]) {
1231  /* last step of sequence reached (or no sequence configured) */
1232 
1233  ltc_state->muxmeas_seqptr[ltc_state->currentString] = ltc_mux_seq.seqptr;
1234  ltc_state->muxmeas_nr_end[ltc_state->currentString] = ltc_mux_seq.nr_of_steps;
1235  ltc_state->muxmeas_seqendptr[ltc_state->currentString] =
1236  ((LTC_MUX_CH_CFG_s *)ltc_mux_seq.seqptr) + ltc_mux_seq.nr_of_steps; /* last sequence + 1 */
1237 
1238  LTC_SaveTemperatures(ltc_state, ltc_state->currentString);
1239  }
1240 
1241  ltc_state->check_spi_flag = STD_OK;
1242  AFE_SetTransmitOngoing(ltc_state);
1243  retVal = LTC_SetMuxChannel(
1244  ltc_state->spiSeqPtr,
1245  ltc_state->ltcData.txBuffer,
1246  ltc_state->ltcData.rxBuffer,
1247  ltc_state->ltcData.frameLength,
1248  ltc_state->muxmeas_seqptr[ltc_state->currentString]->muxID, /* mux */
1249  ltc_state->muxmeas_seqptr[ltc_state->currentString]->muxCh /* channel */);
1250  if (retVal != STD_OK) {
1251  DIAG_Handler(
1252  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1253  ++ltc_state->muxmeas_seqptr[ltc_state->currentString];
1254  LTC_StateTransition(
1255  ltc_state,
1256  LTC_STATEMACH_MUXMEASUREMENT,
1257  LTC_STATEMACH_MUXCONFIGURATION_INIT,
1258  LTC_STATEMACH_SHORTTIME);
1259  } else {
1260  DIAG_Handler(
1261  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1262  LTC_StateTransition(
1263  ltc_state,
1264  LTC_STATEMACH_MUXMEASUREMENT,
1265  LTC_SEND_CLOCK_STCOMM_MUXMEASUREMENT_CONFIG,
1266  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT));
1267  }
1268  break;
1269  } else if (ltc_state->substate == LTC_SEND_CLOCK_STCOMM_MUXMEASUREMENT_CONFIG) {
1270  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1271  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1272  DIAG_Handler(
1273  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1274  } else {
1275  DIAG_Handler(
1276  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1277  }
1278 
1279  AFE_SetTransmitOngoing(ltc_state);
1280  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
1281  if (LTC_GOTO_MUX_CHECK == true) {
1282  LTC_CondBasedStateTransition(
1283  ltc_state,
1284  retVal,
1285  ltc_state->spiDiagErrorEntry,
1286  LTC_STATEMACH_MUXMEASUREMENT,
1287  LTC_READ_I2C_TRANSMISSION_RESULT_RDCOMM_MUXMEASUREMENT_CONFIG,
1288  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
1289  LTC_STATEMACH_MUXMEASUREMENT,
1290  LTC_READ_I2C_TRANSMISSION_RESULT_RDCOMM_MUXMEASUREMENT_CONFIG,
1291  LTC_STATEMACH_SHORTTIME);
1292  ;
1293  } else {
1294  LTC_CondBasedStateTransition(
1295  ltc_state,
1296  retVal,
1297  ltc_state->spiDiagErrorEntry,
1298  LTC_STATEMACH_MUXMEASUREMENT,
1299  LTC_STATEMACH_MUXMEASUREMENT,
1300  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
1301  LTC_STATEMACH_MUXMEASUREMENT,
1302  LTC_STATEMACH_MUXMEASUREMENT,
1303  LTC_STATEMACH_SHORTTIME);
1304  }
1305  break;
1306  } else if (ltc_state->substate == LTC_READ_I2C_TRANSMISSION_RESULT_RDCOMM_MUXMEASUREMENT_CONFIG) {
1307  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1308  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1309  DIAG_Handler(
1310  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1311  } else {
1312  DIAG_Handler(
1313  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1314  }
1315 
1316  AFE_SetTransmitOngoing(ltc_state);
1317  retVal = LTC_ReadRegister(
1318  ltc_cmdRDCOMM,
1319  ltc_state->spiSeqPtr,
1320  ltc_state->ltcData.txBuffer,
1321  ltc_state->ltcData.rxBuffer,
1322  ltc_state->ltcData.frameLength);
1323  LTC_CondBasedStateTransition(
1324  ltc_state,
1325  retVal,
1326  ltc_state->spiDiagErrorEntry,
1327  LTC_STATEMACH_MUXMEASUREMENT,
1328  LTC_READ_I2C_TRANSMISSION_CHECK_MUXMEASUREMENT_CONFIG,
1329  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
1330  LTC_STATEMACH_MUXMEASUREMENT,
1331  LTC_READ_I2C_TRANSMISSION_CHECK_MUXMEASUREMENT_CONFIG,
1332  LTC_STATEMACH_SHORTTIME);
1333  break;
1334  } else if (ltc_state->substate == LTC_READ_I2C_TRANSMISSION_CHECK_MUXMEASUREMENT_CONFIG) {
1335  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1336  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1337  DIAG_Handler(
1338  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1339  } else {
1340  DIAG_Handler(
1341  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1342  }
1343 
1344  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1345  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1346 
1347  /* if CRC OK: check multiplexer answer on i2C bus */
1348  retVal = LTC_I2cCheckAck(
1349  ltc_state,
1350  ltc_state->ltcData.rxBuffer,
1351  ltc_state->muxmeas_seqptr[ltc_state->currentString]->muxID,
1352  ltc_state->currentString);
1353  DIAG_CheckEvent(retVal, ltc_state->muxDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1354  LTC_StateTransition(
1355  ltc_state, LTC_STATEMACH_MUXMEASUREMENT, LTC_STATEMACH_MUXMEASUREMENT, LTC_STATEMACH_SHORTTIME);
1356  break;
1357  } else if (ltc_state->substate == LTC_STATEMACH_MUXMEASUREMENT) {
1358  if (ltc_state->muxmeas_seqptr[ltc_state->currentString]->muxCh == 0xFF) {
1359  /* actual multiplexer is switched off, so do not make a measurement and follow up with next step (mux configuration) */
1360  ++ltc_state
1361  ->muxmeas_seqptr[ltc_state->currentString]; /* go further with next step of sequence
1362  ltc_state.numberOfMeasuredMux not decremented, this does not count as a measurement */
1363  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1364  break;
1365  } else {
1366  if (LTC_GOTO_MUX_CHECK == false) {
1367  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1368  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1369  DIAG_Handler(
1370  ltc_state->spiDiagErrorEntry,
1371  DIAG_EVENT_NOT_OK,
1372  DIAG_STRING,
1373  ltc_state->currentString);
1374  } else {
1375  DIAG_Handler(
1376  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1377  }
1378  }
1379 
1380  ltc_state->check_spi_flag = STD_NOT_OK;
1381  /* user multiplexer type -> connected to GPIO2! */
1382  if ((ltc_state->muxmeas_seqptr[ltc_state->currentString]->muxID == 1) ||
1383  (ltc_state->muxmeas_seqptr[ltc_state->currentString]->muxID == 2)) {
1384  retVal = LTC_StartGpioMeasurement(
1385  ltc_state->spiSeqPtr, ltc_state->adcMode, LTC_ADCMEAS_SINGLECHANNEL_GPIO2);
1386  } else {
1387  retVal = LTC_StartGpioMeasurement(
1388  ltc_state->spiSeqPtr, ltc_state->adcMode, LTC_ADCMEAS_SINGLECHANNEL_GPIO1);
1389  }
1390  }
1391  LTC_CondBasedStateTransition(
1392  ltc_state,
1393  retVal,
1394  ltc_state->spiDiagErrorEntry,
1395  LTC_STATEMACH_MUXMEASUREMENT,
1396  LTC_STATEMACH_READMUXMEASUREMENT,
1397  (ltc_state->commandTransferTime +
1398  LTC_GetMeasurementTimeCycle(
1399  ltc_state->adcMode, LTC_ADCMEAS_SINGLECHANNEL_GPIO2)), /* wait, ADAX-Command */
1400  LTC_STATEMACH_MUXMEASUREMENT,
1401  LTC_STATEMACH_READMUXMEASUREMENT,
1402  LTC_STATEMACH_SHORTTIME);
1403  break;
1404  } else if (ltc_state->substate == LTC_STATEMACH_READMUXMEASUREMENT) {
1405  ltc_state->check_spi_flag = STD_OK;
1406 
1407  AFE_SetTransmitOngoing(ltc_state);
1408  retVal = LTC_ReadRegister(
1409  ltc_cmdRDAUXA,
1410  ltc_state->spiSeqPtr,
1411  ltc_state->ltcData.txBuffer,
1412  ltc_state->ltcData.rxBuffer,
1413  ltc_state->ltcData.frameLength);
1414  LTC_CondBasedStateTransition(
1415  ltc_state,
1416  retVal,
1417  ltc_state->spiDiagErrorEntry,
1418  LTC_STATEMACH_MUXMEASUREMENT,
1419  LTC_STATEMACH_STOREMUXMEASUREMENT,
1420  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
1421  LTC_STATEMACH_MUXMEASUREMENT,
1422  LTC_STATEMACH_STOREMUXMEASUREMENT,
1423  LTC_STATEMACH_SHORTTIME);
1424  break;
1425  } else if (ltc_state->substate == LTC_STATEMACH_STOREMUXMEASUREMENT) {
1426  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1427  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1428  DIAG_Handler(
1429  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1430  } else {
1431  DIAG_Handler(
1432  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1433  }
1434 
1435  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1436  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1437  LTC_SaveMuxMeasurement(
1438  ltc_state,
1439  ltc_state->ltcData.rxBuffer,
1440  ltc_state->muxmeas_seqptr[ltc_state->currentString],
1441  ltc_state->currentString);
1442 
1443  ++ltc_state->muxmeas_seqptr[ltc_state->currentString];
1444 
1445  LTC_StateTransition(
1446  ltc_state, LTC_STATEMACH_MEASCYCLE_FINISHED, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1447  break;
1448  }
1449 
1450  break;
1451 
1452  /****************************END OF MEASUREMENT CYCLE************************/
1453  case LTC_STATEMACH_MEASCYCLE_FINISHED:
1454 
1455  if (ltc_state->balance_control_done == STD_OK) {
1456  if (LTC_IsFirstMeasurementCycleFinished(ltc_state) == false) {
1457  LTC_SetFirstMeasurementCycleFinished(ltc_state);
1458  }
1459  statereq = LTC_TransferStateRequest(ltc_state, &tmpbusID, &tmpadcMode, &tmpadcMeasCh);
1460  if (statereq.request == LTC_STATE_USER_IO_WRITE_REQUEST) {
1461  LTC_StateTransition(
1462  ltc_state,
1463  LTC_STATEMACH_USER_IO_CONTROL,
1464  LTC_USER_IO_SET_OUTPUT_REGISTER,
1465  LTC_STATEMACH_SHORTTIME);
1466  ltc_state->balance_control_done = STD_NOT_OK;
1467  } else if (statereq.request == LTC_STATE_USER_IO_READ_REQUEST) {
1468  LTC_StateTransition(
1469  ltc_state,
1470  LTC_STATEMACH_USER_IO_FEEDBACK,
1471  LTC_USER_IO_READ_INPUT_REGISTER,
1472  LTC_STATEMACH_SHORTTIME);
1473  ltc_state->balance_control_done = STD_NOT_OK;
1474  } else if (statereq.request == LTC_STATE_USER_IO_WRITE_REQUEST_TI) {
1475  LTC_StateTransition(
1476  ltc_state,
1477  LTC_STATEMACH_USER_IO_CONTROL_TI,
1478  LTC_USER_IO_SET_DIRECTION_REGISTER_TI,
1479  LTC_STATEMACH_SHORTTIME);
1480  ltc_state->balance_control_done = STD_NOT_OK;
1481  } else if (statereq.request == LTC_STATE_USER_IO_READ_REQUEST_TI) {
1482  LTC_StateTransition(
1483  ltc_state,
1484  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
1485  LTC_USER_IO_SET_DIRECTION_REGISTER_TI,
1486  LTC_STATEMACH_SHORTTIME);
1487  ltc_state->balance_control_done = STD_NOT_OK;
1488  } else if (statereq.request == LTC_STATE_EEPROM_READ_REQUEST) {
1489  LTC_StateTransition(
1490  ltc_state, LTC_STATEMACH_EEPROM_READ, LTC_EEPROM_READ_DATA1, LTC_STATEMACH_SHORTTIME);
1491  } else if (statereq.request == LTC_STATE_EEPROM_WRITE_REQUEST) {
1492  LTC_StateTransition(
1493  ltc_state, LTC_STATEMACH_EEPROM_WRITE, LTC_EEPROM_WRITE_DATA1, LTC_STATEMACH_SHORTTIME);
1494  ltc_state->balance_control_done = STD_NOT_OK;
1495  } else if (statereq.request == LTC_STATE_TEMP_SENS_READ_REQUEST) {
1496  LTC_StateTransition(
1497  ltc_state, LTC_STATEMACH_TEMP_SENS_READ, LTC_TEMP_SENS_SEND_DATA1, LTC_STATEMACH_SHORTTIME);
1498  ltc_state->balance_control_done = STD_NOT_OK;
1499  } else if (statereq.request == LTC_STATEMACH_BALANCEFEEDBACK_REQUEST) {
1500  LTC_StateTransition(
1501  ltc_state, LTC_STATEMACH_BALANCEFEEDBACK, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1502  ltc_state->balance_control_done = STD_NOT_OK;
1503  } else if (statereq.request == LTC_STATE_OPENWIRE_CHECK_REQUEST) {
1504  LTC_StateTransition(
1505  ltc_state,
1506  LTC_STATEMACH_OPENWIRE_CHECK,
1507  LTC_REQUEST_PULLUP_CURRENT_OPENWIRE_CHECK,
1508  LTC_STATEMACH_SHORTTIME);
1509  /* Send ADOW command with PUP two times */
1510  ltc_state->resendCommandCounter = LTC_NMBR_REQ_ADOW_COMMANDS;
1511  ltc_state->balance_control_done = STD_NOT_OK;
1512  } else {
1513  LTC_StateTransition(
1514  ltc_state,
1515  LTC_STATEMACH_BALANCECONTROL,
1516  LTC_CONFIG_BALANCECONTROL,
1517  LTC_STATEMACH_SHORTTIME);
1518  ltc_state->balance_control_done = STD_NOT_OK;
1519  }
1520  } else {
1521  LTC_StateTransition(
1522  ltc_state, LTC_STATEMACH_BALANCECONTROL, LTC_CONFIG_BALANCECONTROL, LTC_STATEMACH_SHORTTIME);
1523  }
1524 
1525  break;
1526 
1527  /****************************BALANCE CONTROL*********************************/
1528  case LTC_STATEMACH_BALANCECONTROL:
1529 
1530  if (ltc_state->substate == LTC_CONFIG_BALANCECONTROL) {
1531  ltc_state->check_spi_flag = STD_OK;
1532  AFE_SetTransmitOngoing(ltc_state);
1533  retVal = LTC_BalanceControl(
1534  ltc_state,
1535  ltc_state->spiSeqPtr,
1536  ltc_state->ltcData.txBuffer,
1537  ltc_state->ltcData.rxBuffer,
1538  ltc_state->ltcData.frameLength,
1539  0u,
1540  ltc_state->currentString);
1541  LTC_CondBasedStateTransition(
1542  ltc_state,
1543  retVal,
1544  ltc_state->spiDiagErrorEntry,
1545  LTC_STATEMACH_BALANCECONTROL,
1546  LTC_CONFIG2_BALANCECONTROL,
1547  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1548  LTC_STATEMACH_BALANCECONTROL,
1549  LTC_CONFIG2_BALANCECONTROL,
1550  LTC_STATEMACH_SHORTTIME);
1551  break;
1552  } else if (ltc_state->substate == LTC_CONFIG2_BALANCECONTROL) {
1553  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1554  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1555  DIAG_Handler(
1556  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1557  } else {
1558  DIAG_Handler(
1559  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1560  }
1561 
1562  if (BS_NR_OF_CELL_BLOCKS_PER_MODULE > 12) {
1563  AFE_SetTransmitOngoing(ltc_state);
1564  retVal = LTC_BalanceControl(
1565  ltc_state,
1566  ltc_state->spiSeqPtr,
1567  ltc_state->ltcData.txBuffer,
1568  ltc_state->ltcData.rxBuffer,
1569  ltc_state->ltcData.frameLength,
1570  1u,
1571  ltc_state->currentString);
1572  LTC_CondBasedStateTransition(
1573  ltc_state,
1574  retVal,
1575  ltc_state->spiDiagErrorEntry,
1576  LTC_STATEMACH_BALANCECONTROL,
1577  LTC_CONFIG2_BALANCECONTROL_END,
1578  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
1579  LTC_STATEMACH_BALANCECONTROL,
1580  LTC_CONFIG2_BALANCECONTROL_END,
1581  LTC_STATEMACH_SHORTTIME);
1582  } else {
1583  /* 12 cells, balancing control finished */
1584  ltc_state->check_spi_flag = STD_NOT_OK;
1585  ++ltc_state->spiSeqPtr;
1586  ++ltc_state->currentString;
1587  if (ltc_state->spiSeqPtr >= ltc_state->spiSeqEndPtr) {
1588  ltc_state->balance_control_done = STD_OK;
1589  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1590  } else {
1591  LTC_StateTransition(
1592  ltc_state, LTC_STATEMACH_STARTMEAS_CONTINUE, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1593  }
1594  }
1595 
1596  break;
1597  } else if (ltc_state->substate == LTC_CONFIG2_BALANCECONTROL_END) {
1598  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1599  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1600  DIAG_Handler(
1601  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1602  } else {
1603  DIAG_Handler(
1604  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1605  }
1606  /* More than 12 cells, balancing control finished */
1607  ltc_state->check_spi_flag = STD_NOT_OK;
1608  ++ltc_state->spiSeqPtr;
1609  ++ltc_state->currentString;
1610  if (ltc_state->spiSeqPtr >= ltc_state->spiSeqEndPtr) {
1611  ltc_state->balance_control_done = STD_OK;
1612  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1613  } else {
1614  LTC_StateTransition(
1615  ltc_state, LTC_STATEMACH_STARTMEAS_CONTINUE, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1616  }
1617 
1618  break;
1619  }
1620  break;
1621 
1622  /****************************START MEASUREMENT*******************************/
1623  case LTC_STATEMACH_ALLGPIOMEASUREMENT:
1624 
1625  ltc_state->adcMode = LTC_GPIO_MEASUREMENT_MODE;
1626  ltc_state->adcMeasCh = LTC_ADCMEAS_ALLCHANNEL_GPIOS;
1627 
1628  ltc_state->check_spi_flag = STD_NOT_OK;
1629  retVal = LTC_StartGpioMeasurement(ltc_state->spiSeqPtr, ltc_state->adcMode, ltc_state->adcMeasCh);
1630  LTC_CondBasedStateTransition(
1631  ltc_state,
1632  retVal,
1633  ltc_state->spiDiagErrorEntry,
1634  LTC_STATEMACH_READALLGPIO,
1635  LTC_READ_AUXILIARY_REGISTER_A_RDAUXA,
1636  (ltc_state->commandTransferTime +
1637  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, ltc_state->adcMeasCh)),
1638  LTC_STATEMACH_ALLGPIOMEASUREMENT,
1639  LTC_ENTRY,
1640  LTC_STATEMACH_SHORTTIME); /* TODO: @koffel here same state is kept if error occurs */
1641  break;
1642 
1643  /****************************READ ALL GPIO VOLTAGE************************************/
1644  case LTC_STATEMACH_READALLGPIO:
1645 
1646  if (ltc_state->substate == LTC_READ_AUXILIARY_REGISTER_A_RDAUXA) {
1647  ltc_state->check_spi_flag = STD_OK;
1648  AFE_SetTransmitOngoing(ltc_state);
1649  retVal = LTC_ReadRegister(
1650  ltc_cmdRDAUXA,
1651  ltc_state->spiSeqPtr,
1652  ltc_state->ltcData.txBuffer,
1653  ltc_state->ltcData.rxBuffer,
1654  ltc_state->ltcData.frameLength);
1655  LTC_CondBasedStateTransition(
1656  ltc_state,
1657  retVal,
1658  ltc_state->spiDiagErrorEntry,
1659  LTC_STATEMACH_READALLGPIO,
1660  LTC_READ_AUXILIARY_REGISTER_B_RDAUXB,
1661  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1662  LTC_STATEMACH_READALLGPIO,
1663  LTC_READ_AUXILIARY_REGISTER_B_RDAUXB,
1664  LTC_STATEMACH_SHORTTIME);
1665  break;
1666  } else if (ltc_state->substate == LTC_READ_AUXILIARY_REGISTER_B_RDAUXB) {
1667  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1668  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1669  LTC_SaveRxToGpioBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 0, ltc_state->currentString);
1670 
1671  AFE_SetTransmitOngoing(ltc_state);
1672  retVal = LTC_ReadRegister(
1673  ltc_cmdRDAUXB,
1674  ltc_state->spiSeqPtr,
1675  ltc_state->ltcData.txBuffer,
1676  ltc_state->ltcData.rxBuffer,
1677  ltc_state->ltcData.frameLength);
1678 
1679  if (LTC_6813_MAX_SUPPORTED_CELLS > 12u) {
1680  LTC_CondBasedStateTransition(
1681  ltc_state,
1682  retVal,
1683  ltc_state->spiDiagErrorEntry,
1684  LTC_STATEMACH_READALLGPIO,
1685  LTC_READ_AUXILIARY_REGISTER_C_RDAUXC,
1686  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1687  LTC_STATEMACH_READALLGPIO,
1688  LTC_READ_AUXILIARY_REGISTER_C_RDAUXC,
1689  LTC_STATEMACH_SHORTTIME);
1690  } else {
1691  LTC_CondBasedStateTransition(
1692  ltc_state,
1693  retVal,
1694  ltc_state->spiDiagErrorEntry,
1695  LTC_STATEMACH_READALLGPIO,
1696  LTC_EXIT_READAUXILIARY_ALLGPIOS,
1697  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1698  LTC_STATEMACH_READALLGPIO,
1699  LTC_EXIT_READAUXILIARY_ALLGPIOS,
1700  LTC_STATEMACH_SHORTTIME);
1701  }
1702  break;
1703  } else if (ltc_state->substate == LTC_READ_AUXILIARY_REGISTER_C_RDAUXC) {
1704  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1705  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1706  LTC_SaveRxToGpioBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 1, ltc_state->currentString);
1707 
1708  AFE_SetTransmitOngoing(ltc_state);
1709  retVal = LTC_ReadRegister(
1710  ltc_cmdRDAUXC,
1711  ltc_state->spiSeqPtr,
1712  ltc_state->ltcData.txBuffer,
1713  ltc_state->ltcData.rxBuffer,
1714  ltc_state->ltcData.frameLength);
1715  LTC_CondBasedStateTransition(
1716  ltc_state,
1717  retVal,
1718  ltc_state->spiDiagErrorEntry,
1719  LTC_STATEMACH_READALLGPIO,
1720  LTC_READ_AUXILIARY_REGISTER_D_RDAUXD,
1721  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1722  LTC_STATEMACH_READALLGPIO,
1723  LTC_READ_AUXILIARY_REGISTER_D_RDAUXD,
1724  LTC_STATEMACH_SHORTTIME);
1725  break;
1726  } else if (ltc_state->substate == LTC_READ_AUXILIARY_REGISTER_D_RDAUXD) {
1727  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1728  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1729  LTC_SaveRxToGpioBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 2, ltc_state->currentString);
1730 
1731  AFE_SetTransmitOngoing(ltc_state);
1732  retVal = LTC_ReadRegister(
1733  ltc_cmdRDAUXD,
1734  ltc_state->spiSeqPtr,
1735  ltc_state->ltcData.txBuffer,
1736  ltc_state->ltcData.rxBuffer,
1737  ltc_state->ltcData.frameLength);
1738  LTC_CondBasedStateTransition(
1739  ltc_state,
1740  retVal,
1741  ltc_state->spiDiagErrorEntry,
1742  LTC_STATEMACH_READALLGPIO,
1743  LTC_EXIT_READAUXILIARY_ALLGPIOS,
1744  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
1745  LTC_STATEMACH_READALLGPIO,
1746  LTC_EXIT_READAUXILIARY_ALLGPIOS,
1747  LTC_STATEMACH_SHORTTIME);
1748  break;
1749  } else if (ltc_state->substate == LTC_EXIT_READAUXILIARY_ALLGPIOS) {
1750  retVal = LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1751  DIAG_CheckEvent(retVal, ltc_state->pecDiagErrorEntry, DIAG_STRING, ltc_state->currentString);
1752 
1753  if (LTC_6813_MAX_SUPPORTED_CELLS == 12u) {
1754  LTC_SaveRxToGpioBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 1, ltc_state->currentString);
1755  } else if (LTC_6813_MAX_SUPPORTED_CELLS > 12u) {
1756  LTC_SaveRxToGpioBuffer(ltc_state, ltc_state->ltcData.rxBuffer, 3, ltc_state->currentString);
1757  }
1758 
1759  LTC_SaveAllGpioMeasurement(ltc_state);
1760 
1761  LTC_StateTransition(
1762  ltc_state, LTC_STATEMACH_MEASCYCLE_FINISHED, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1763  }
1764 
1765  break;
1766 
1767  /****************************BALANCE FEEDBACK*********************************/
1768  case LTC_STATEMACH_BALANCEFEEDBACK:
1769 
1770  ltc_state->adcMode = LTC_GPIO_MEASUREMENT_MODE;
1771  ltc_state->adcMeasCh = LTC_ADCMEAS_SINGLECHANNEL_GPIO3;
1772 
1773  if (ltc_state->substate == LTC_ENTRY) {
1774  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
1775  ltc_state->adcMode = LTC_ADCMODE_NORMAL_DCP0;
1776  ltc_state->adcMeasCh = LTC_ADCMEAS_SINGLECHANNEL_GPIO3;
1777 
1778  ltc_state->check_spi_flag = STD_NOT_OK;
1779  retVal = LTC_StartGpioMeasurement(ltc_state->spiSeqPtr, ltc_state->adcMode, ltc_state->adcMeasCh);
1780  LTC_CondBasedStateTransition(
1781  ltc_state,
1782  retVal,
1783  ltc_state->spiDiagErrorEntry,
1784  LTC_STATEMACH_BALANCEFEEDBACK,
1785  LTC_READ_FEEDBACK_BALANCECONTROL,
1786  (ltc_state->commandDataTransferTime +
1787  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, ltc_state->adcMeasCh)),
1788  LTC_STATEMACH_BALANCEFEEDBACK,
1789  LTC_READ_FEEDBACK_BALANCECONTROL,
1790  LTC_STATEMACH_SHORTTIME);
1791  break;
1792  } else if (ltc_state->substate == LTC_READ_FEEDBACK_BALANCECONTROL) {
1793  ltc_state->check_spi_flag = STD_OK;
1794  AFE_SetTransmitOngoing(ltc_state);
1795  retVal = LTC_ReadRegister(
1796  ltc_cmdRDAUXA,
1797  ltc_state->spiSeqPtr,
1798  ltc_state->ltcData.txBuffer,
1799  ltc_state->ltcData.rxBuffer,
1800  ltc_state->ltcData.frameLength); /* read AUXA register */
1801  LTC_CondBasedStateTransition(
1802  ltc_state,
1803  retVal,
1804  ltc_state->spiDiagErrorEntry,
1805  LTC_STATEMACH_BALANCEFEEDBACK,
1806  LTC_SAVE_FEEDBACK_BALANCECONTROL,
1807  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
1808  LTC_STATEMACH_BALANCEFEEDBACK,
1809  LTC_SAVE_FEEDBACK_BALANCECONTROL,
1810  LTC_STATEMACH_SHORTTIME);
1811  } else if (ltc_state->substate == LTC_SAVE_FEEDBACK_BALANCECONTROL) {
1812  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1813  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1814  DIAG_Handler(
1815  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1816  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1817  break;
1818  } else {
1819  DIAG_Handler(
1820  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1821  }
1822 
1823  if (LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString) != STD_OK) {
1824  DIAG_Handler(
1825  ltc_state->pecDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1826  } else {
1827  DIAG_Handler(
1828  ltc_state->pecDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1829  LTC_SaveBalancingFeedback(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString);
1830  }
1831  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1832  break;
1833  }
1834  break;
1835 
1836  /****************************BOARD TEMPERATURE SENSOR*********************************/
1837  case LTC_STATEMACH_TEMP_SENS_READ:
1838 
1839  if (ltc_state->substate == LTC_TEMP_SENS_SEND_DATA1) {
1840  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
1841  ltc_state->check_spi_flag = STD_OK;
1842  AFE_SetTransmitOngoing(ltc_state);
1843  retVal = LTC_SendI2cCommand(
1844  ltc_state->spiSeqPtr,
1845  ltc_state->ltcData.txBuffer,
1846  ltc_state->ltcData.rxBuffer,
1847  ltc_state->ltcData.frameLength,
1848  ltc_I2CcmdTempSens0);
1849 
1850  if (retVal != STD_OK) {
1851  DIAG_Handler(
1852  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1853  ++ltc_state->muxmeas_seqptr[ltc_state->requestedString];
1854  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1855  } else {
1856  DIAG_Handler(
1857  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1858  LTC_StateTransition(
1859  ltc_state,
1860  LTC_STATEMACH_TEMP_SENS_READ,
1861  LTC_TEMP_SENS_SEND_CLOCK_STCOMM1,
1862  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT);
1863  }
1864 
1865  break;
1866  } else if (ltc_state->substate == LTC_TEMP_SENS_SEND_CLOCK_STCOMM1) {
1867  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1868  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1869  DIAG_Handler(
1870  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1871  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1872  break;
1873  } else {
1874  DIAG_Handler(
1875  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1876  }
1877 
1878  AFE_SetTransmitOngoing(ltc_state);
1879  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
1880  LTC_CondBasedStateTransition(
1881  ltc_state,
1882  retVal,
1883  ltc_state->spiDiagErrorEntry,
1884  LTC_STATEMACH_TEMP_SENS_READ,
1885  LTC_TEMP_SENS_READ_DATA1,
1886  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
1887  LTC_STATEMACH_TEMP_SENS_READ,
1888  LTC_TEMP_SENS_READ_DATA1,
1889  LTC_STATEMACH_SHORTTIME);
1890  break;
1891  } else if (ltc_state->substate == LTC_TEMP_SENS_READ_DATA1) {
1892  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1893  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1894  DIAG_Handler(
1895  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1896  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1897  break;
1898  } else {
1899  DIAG_Handler(
1900  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1901  }
1902 
1903  AFE_SetTransmitOngoing(ltc_state);
1904  retVal = LTC_SendI2cCommand(
1905  ltc_state->spiSeqPtr,
1906  ltc_state->ltcData.txBuffer,
1907  ltc_state->ltcData.rxBuffer,
1908  ltc_state->ltcData.frameLength,
1909  ltc_I2CcmdTempSens1);
1910 
1911  if (retVal != STD_OK) {
1912  DIAG_Handler(
1913  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1914  ++ltc_state->muxmeas_seqptr[ltc_state->requestedString];
1915  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1916  } else {
1917  DIAG_Handler(
1918  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1919  LTC_StateTransition(
1920  ltc_state,
1921  LTC_STATEMACH_TEMP_SENS_READ,
1922  LTC_TEMP_SENS_SEND_CLOCK_STCOMM2,
1923  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT));
1924  }
1925 
1926  break;
1927  } else if (ltc_state->substate == LTC_TEMP_SENS_SEND_CLOCK_STCOMM2) {
1928  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1929  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1930  DIAG_Handler(
1931  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1932  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1933  break;
1934  } else {
1935  DIAG_Handler(
1936  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1937  }
1938 
1939  AFE_SetTransmitOngoing(ltc_state);
1940  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
1941  LTC_CondBasedStateTransition(
1942  ltc_state,
1943  retVal,
1944  ltc_state->spiDiagErrorEntry,
1945  LTC_STATEMACH_TEMP_SENS_READ,
1946  LTC_TEMP_SENS_READ_I2C_TRANSMISSION_RESULT_RDCOMM,
1947  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
1948  LTC_STATEMACH_TEMP_SENS_READ,
1949  LTC_TEMP_SENS_READ_I2C_TRANSMISSION_RESULT_RDCOMM,
1950  LTC_STATEMACH_SHORTTIME);
1951  break;
1952  } else if (ltc_state->substate == LTC_TEMP_SENS_READ_I2C_TRANSMISSION_RESULT_RDCOMM) {
1953  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1954  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1955  DIAG_Handler(
1956  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1957  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1958  break;
1959  } else {
1960  DIAG_Handler(
1961  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1962  }
1963 
1964  AFE_SetTransmitOngoing(ltc_state);
1965  retVal = LTC_ReadRegister(
1966  ltc_cmdRDCOMM,
1967  ltc_state->spiSeqPtr,
1968  ltc_state->ltcData.txBuffer,
1969  ltc_state->ltcData.rxBuffer,
1970  ltc_state->ltcData.frameLength);
1971  LTC_CondBasedStateTransition(
1972  ltc_state,
1973  retVal,
1974  ltc_state->spiDiagErrorEntry,
1975  LTC_STATEMACH_TEMP_SENS_READ,
1976  LTC_TEMP_SENS_SAVE_TEMP,
1977  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
1978  LTC_STATEMACH_TEMP_SENS_READ,
1979  LTC_TEMP_SENS_SAVE_TEMP,
1980  LTC_STATEMACH_SHORTTIME);
1981  break;
1982  } else if (ltc_state->substate == LTC_TEMP_SENS_SAVE_TEMP) {
1983  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
1984  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
1985  DIAG_Handler(
1986  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1987  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
1988  break;
1989  } else {
1990  DIAG_Handler(
1991  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
1992  }
1993 
1994  if (LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString) != STD_OK) {
1995  DIAG_Handler(
1996  ltc_state->pecDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
1997  } else {
1998  DIAG_Handler(
1999  ltc_state->pecDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2000  LTC_TempSensSaveTemp(ltc_state, ltc_state->ltcData.rxBuffer);
2001  }
2002 
2003  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2004  break;
2005  }
2006  break;
2007 
2008  /****************************WRITE TO PORT EXPANDER IO***********/
2009  case LTC_STATEMACH_USER_IO_CONTROL:
2010 
2011  if (ltc_state->substate == LTC_USER_IO_SET_OUTPUT_REGISTER) {
2012  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2013  ltc_state->check_spi_flag = STD_OK;
2014  AFE_SetTransmitOngoing(ltc_state);
2015  retVal = LTC_SetPortExpander(
2016  ltc_state,
2017  ltc_state->spiSeqPtr,
2018  ltc_state->ltcData.txBuffer,
2019  ltc_state->ltcData.rxBuffer,
2020  ltc_state->ltcData.frameLength);
2021 
2022  if (retVal != STD_OK) {
2023  DIAG_Handler(
2024  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2025  ++ltc_state->muxmeas_seqptr[ltc_state->requestedString];
2026  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2027  } else {
2028  DIAG_Handler(
2029  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2030  LTC_StateTransition(
2031  ltc_state,
2032  LTC_STATEMACH_USER_IO_CONTROL,
2033  LTC_SEND_CLOCK_STCOMM_MUXMEASUREMENT_CONFIG,
2034  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT));
2035  }
2036  break;
2037  } else if (ltc_state->substate == LTC_SEND_CLOCK_STCOMM_MUXMEASUREMENT_CONFIG) {
2038  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2039  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2040  DIAG_Handler(
2041  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2042  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2043  break;
2044  } else {
2045  DIAG_Handler(
2046  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2047  }
2048 
2049  ltc_state->check_spi_flag = STD_NOT_OK;
2050  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2051  LTC_CondBasedStateTransition(
2052  ltc_state,
2053  retVal,
2054  ltc_state->spiDiagErrorEntry,
2055  LTC_STATEMACH_STARTMEAS,
2056  LTC_ENTRY,
2057  ltc_state->gpioClocksTransferTime,
2058  LTC_STATEMACH_STARTMEAS,
2059  LTC_ENTRY,
2060  LTC_STATEMACH_SHORTTIME);
2061  break;
2062  }
2063  break;
2064 
2065  /****************************READ FROM PORT EXPANDER IO***********/
2066  case LTC_STATEMACH_USER_IO_FEEDBACK:
2067 
2068  if (ltc_state->substate == LTC_USER_IO_READ_INPUT_REGISTER) {
2069  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2070  ltc_state->check_spi_flag = STD_OK;
2071  AFE_SetTransmitOngoing(ltc_state);
2072  retVal = LTC_SendI2cCommand(
2073  ltc_state->spiSeqPtr,
2074  ltc_state->ltcData.txBuffer,
2075  ltc_state->ltcData.rxBuffer,
2076  ltc_state->ltcData.frameLength,
2077  ltc_I2CcmdPortExpander1);
2078 
2079  if (retVal != STD_OK) {
2080  DIAG_Handler(
2081  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2082  ++ltc_state->muxmeas_seqptr[ltc_state->requestedString];
2083  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2084  } else {
2085  DIAG_Handler(
2086  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2087  LTC_StateTransition(
2088  ltc_state,
2089  LTC_STATEMACH_USER_IO_FEEDBACK,
2090  LTC_USER_IO_SEND_CLOCK_STCOMM,
2091  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT);
2092  }
2093 
2094  break;
2095  } else if (ltc_state->substate == LTC_USER_IO_SEND_CLOCK_STCOMM) {
2096  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2097  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2098  DIAG_Handler(
2099  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2100  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2101  break;
2102  } else {
2103  DIAG_Handler(
2104  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2105  }
2106 
2107  ltc_state->check_spi_flag = STD_NOT_OK;
2108  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2109  LTC_CondBasedStateTransition(
2110  ltc_state,
2111  retVal,
2112  ltc_state->spiDiagErrorEntry,
2113  LTC_STATEMACH_USER_IO_FEEDBACK,
2114  LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM,
2115  ltc_state->gpioClocksTransferTime,
2116  LTC_STATEMACH_USER_IO_FEEDBACK,
2117  LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM,
2118  LTC_STATEMACH_SHORTTIME);
2119  break;
2120  } else if (ltc_state->substate == LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM) {
2121  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2122  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2123  DIAG_Handler(
2124  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2125  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2126  break;
2127  } else {
2128  DIAG_Handler(
2129  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2130  }
2131 
2132  AFE_SetTransmitOngoing(ltc_state);
2133  retVal = LTC_ReadRegister(
2134  ltc_cmdRDCOMM,
2135  ltc_state->spiSeqPtr,
2136  ltc_state->ltcData.txBuffer,
2137  ltc_state->ltcData.rxBuffer,
2138  ltc_state->ltcData.frameLength);
2139  LTC_CondBasedStateTransition(
2140  ltc_state,
2141  retVal,
2142  ltc_state->spiDiagErrorEntry,
2143  LTC_STATEMACH_USER_IO_FEEDBACK,
2144  LTC_USER_IO_SAVE_DATA,
2145  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
2146  LTC_STATEMACH_USER_IO_FEEDBACK,
2147  LTC_USER_IO_SAVE_DATA,
2148  LTC_STATEMACH_SHORTTIME);
2149  break;
2150  } else if (ltc_state->substate == LTC_USER_IO_SAVE_DATA) {
2151  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2152  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2153  DIAG_Handler(
2154  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2155  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2156  break;
2157  } else {
2158  DIAG_Handler(
2159  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2160  }
2161 
2162  if (LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString) != STD_OK) {
2163  DIAG_Handler(
2164  ltc_state->pecDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2165  } else {
2166  DIAG_Handler(
2167  ltc_state->pecDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2168  LTC_PortExpanderSaveValues(ltc_state, ltc_state->ltcData.rxBuffer);
2169  }
2170 
2171  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2172  break;
2173  }
2174 
2175  break;
2176 
2177  /****************************WRITE TO TI PORT EXPANDER IO***********/
2178  case LTC_STATEMACH_USER_IO_CONTROL_TI:
2179 
2180  if (ltc_state->substate == LTC_USER_IO_SET_DIRECTION_REGISTER_TI) {
2181  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2182  ltc_state->check_spi_flag = STD_OK;
2183  AFE_SetTransmitOngoing(ltc_state);
2184  retVal = LTC_SetPortExpanderDirectionTi(
2185  ltc_state,
2186  ltc_state->spiSeqPtr,
2187  ltc_state->ltcData.txBuffer,
2188  ltc_state->ltcData.rxBuffer,
2189  ltc_state->ltcData.frameLength,
2190  LTC_PORT_EXPANDER_TI_OUTPUT);
2191  LTC_CondBasedStateTransition(
2192  ltc_state,
2193  retVal,
2194  ltc_state->spiDiagErrorEntry,
2195  LTC_STATEMACH_USER_IO_CONTROL_TI,
2196  LTC_USER_IO_SEND_CLOCK_STCOMM_TI,
2197  LTC_STATEMACH_SHORTTIME,
2198  LTC_STATEMACH_STARTMEAS,
2199  LTC_ENTRY,
2200  LTC_STATEMACH_SHORTTIME);
2201  break;
2202  } else if (ltc_state->substate == LTC_USER_IO_SEND_CLOCK_STCOMM_TI) {
2203  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2204  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2205  DIAG_Handler(
2206  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2207  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2208  break;
2209  } else {
2210  DIAG_Handler(
2211  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2212  }
2213 
2214  ltc_state->check_spi_flag = STD_NOT_OK;
2215  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2216  LTC_CondBasedStateTransition(
2217  ltc_state,
2218  retVal,
2219  ltc_state->spiDiagErrorEntry,
2220  LTC_STATEMACH_USER_IO_CONTROL_TI,
2221  LTC_USER_IO_SET_OUTPUT_REGISTER_TI,
2222  ltc_state->gpioClocksTransferTime,
2223  LTC_STATEMACH_STARTMEAS,
2224  LTC_ENTRY,
2225  LTC_STATEMACH_SHORTTIME);
2226  break;
2227  } else if (ltc_state->substate == LTC_USER_IO_SET_OUTPUT_REGISTER_TI) {
2228  ltc_state->check_spi_flag = STD_OK;
2229  AFE_SetTransmitOngoing(ltc_state);
2230  retVal = LTC_SetPortExpanderOutputTi(
2231  ltc_state,
2232  ltc_state->spiSeqPtr,
2233  ltc_state->ltcData.txBuffer,
2234  ltc_state->ltcData.rxBuffer,
2235  ltc_state->ltcData.frameLength);
2236  LTC_CondBasedStateTransition(
2237  ltc_state,
2238  retVal,
2239  ltc_state->spiDiagErrorEntry,
2240  LTC_STATEMACH_USER_IO_CONTROL_TI,
2241  LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_SECOND,
2242  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
2243  LTC_STATEMACH_STARTMEAS,
2244  LTC_ENTRY,
2245  LTC_STATEMACH_SHORTTIME);
2246  break;
2247  } else if (ltc_state->substate == LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_SECOND) {
2248  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2249  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2250  DIAG_Handler(
2251  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2252  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2253  break;
2254  } else {
2255  DIAG_Handler(
2256  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2257  }
2258 
2259  ltc_state->check_spi_flag = STD_NOT_OK;
2260  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2261  LTC_CondBasedStateTransition(
2262  ltc_state,
2263  retVal,
2264  ltc_state->spiDiagErrorEntry,
2265  LTC_STATEMACH_STARTMEAS,
2266  LTC_ENTRY,
2267  ltc_state->gpioClocksTransferTime,
2268  LTC_STATEMACH_STARTMEAS,
2269  LTC_ENTRY,
2270  LTC_STATEMACH_SHORTTIME);
2271  break;
2272  }
2273  break;
2274 
2275  /****************************READ TI PORT EXPANDER IO***********/
2276  case LTC_STATEMACH_USER_IO_FEEDBACK_TI:
2277 
2278  if (ltc_state->substate == LTC_USER_IO_SET_DIRECTION_REGISTER_TI) {
2279  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2280  ltc_state->check_spi_flag = STD_OK;
2281  AFE_SetTransmitOngoing(ltc_state);
2282  retVal = LTC_SetPortExpanderDirectionTi(
2283  ltc_state,
2284  ltc_state->spiSeqPtr,
2285  ltc_state->ltcData.txBuffer,
2286  ltc_state->ltcData.rxBuffer,
2287  ltc_state->ltcData.frameLength,
2288  LTC_PORT_EXPANDER_TI_INPUT);
2289  LTC_CondBasedStateTransition(
2290  ltc_state,
2291  retVal,
2292  ltc_state->spiDiagErrorEntry,
2293  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2294  LTC_USER_IO_SEND_CLOCK_STCOMM_TI,
2295  LTC_STATEMACH_SHORTTIME,
2296  LTC_STATEMACH_STARTMEAS,
2297  LTC_ENTRY,
2298  LTC_STATEMACH_SHORTTIME);
2299  break;
2300  } else if (ltc_state->substate == LTC_USER_IO_SEND_CLOCK_STCOMM_TI) {
2301  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2302  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2303  DIAG_Handler(
2304  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2305  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2306  break;
2307  } else {
2308  DIAG_Handler(
2309  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2310  }
2311 
2312  ltc_state->check_spi_flag = STD_NOT_OK;
2313  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2314  LTC_CondBasedStateTransition(
2315  ltc_state,
2316  retVal,
2317  ltc_state->spiDiagErrorEntry,
2318  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2319  LTC_USER_IO_READ_INPUT_REGISTER_TI_FIRST,
2320  ltc_state->gpioClocksTransferTime,
2321  LTC_STATEMACH_STARTMEAS,
2322  LTC_ENTRY,
2323  LTC_STATEMACH_SHORTTIME);
2324  break;
2325  } else if (ltc_state->substate == LTC_USER_IO_READ_INPUT_REGISTER_TI_FIRST) {
2326  ltc_state->check_spi_flag = STD_OK;
2327  AFE_SetTransmitOngoing(ltc_state);
2328  retVal = LTC_GetPortExpanderInputTi(
2329  ltc_state,
2330  ltc_state->spiSeqPtr,
2331  ltc_state->ltcData.txBuffer,
2332  ltc_state->ltcData.rxBuffer,
2333  ltc_state->ltcData.frameLength,
2334  0);
2335  LTC_CondBasedStateTransition(
2336  ltc_state,
2337  retVal,
2338  ltc_state->spiDiagErrorEntry,
2339  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2340  LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_SECOND,
2341  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
2342  LTC_STATEMACH_STARTMEAS,
2343  LTC_ENTRY,
2344  LTC_STATEMACH_SHORTTIME);
2345  break;
2346  } else if (ltc_state->substate == LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_SECOND) {
2347  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2348  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2349  DIAG_Handler(
2350  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2351  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2352  break;
2353  } else {
2354  DIAG_Handler(
2355  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2356  }
2357 
2358  ltc_state->check_spi_flag = STD_NOT_OK;
2359  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2360  LTC_CondBasedStateTransition(
2361  ltc_state,
2362  retVal,
2363  ltc_state->spiDiagErrorEntry,
2364  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2365  LTC_USER_IO_READ_INPUT_REGISTER_TI_SECOND,
2366  ltc_state->gpioClocksTransferTime,
2367  LTC_STATEMACH_STARTMEAS,
2368  LTC_ENTRY,
2369  LTC_STATEMACH_SHORTTIME);
2370  break;
2371  } else if (ltc_state->substate == LTC_USER_IO_READ_INPUT_REGISTER_TI_SECOND) {
2372  ltc_state->check_spi_flag = STD_OK;
2373  AFE_SetTransmitOngoing(ltc_state);
2374  retVal = LTC_GetPortExpanderInputTi(
2375  ltc_state,
2376  ltc_state->spiSeqPtr,
2377  ltc_state->ltcData.txBuffer,
2378  ltc_state->ltcData.rxBuffer,
2379  ltc_state->ltcData.frameLength,
2380  1);
2381  LTC_CondBasedStateTransition(
2382  ltc_state,
2383  retVal,
2384  ltc_state->spiDiagErrorEntry,
2385  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2386  LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_THIRD,
2387  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
2388  LTC_STATEMACH_STARTMEAS,
2389  LTC_ENTRY,
2390  LTC_STATEMACH_SHORTTIME);
2391  break;
2392  } else if (ltc_state->substate == LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_THIRD) {
2393  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2394  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2395  DIAG_Handler(
2396  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2397  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2398  break;
2399  } else {
2400  DIAG_Handler(
2401  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2402  }
2403 
2404  ltc_state->check_spi_flag = STD_NOT_OK;
2405  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2406  LTC_CondBasedStateTransition(
2407  ltc_state,
2408  retVal,
2409  ltc_state->spiDiagErrorEntry,
2410  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2411  LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_FOURTH,
2412  ltc_state->gpioClocksTransferTime,
2413  LTC_STATEMACH_STARTMEAS,
2414  LTC_ENTRY,
2415  LTC_STATEMACH_SHORTTIME);
2416  break;
2417  } else if (ltc_state->substate == LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_FOURTH) {
2418  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2419  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2420  DIAG_Handler(
2421  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2422  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2423  break;
2424  } else {
2425  DIAG_Handler(
2426  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2427  }
2428 
2429  AFE_SetTransmitOngoing(ltc_state);
2430  retVal = LTC_ReadRegister(
2431  ltc_cmdRDCOMM,
2432  ltc_state->spiSeqPtr,
2433  ltc_state->ltcData.txBuffer,
2434  ltc_state->ltcData.rxBuffer,
2435  ltc_state->ltcData.frameLength);
2436  LTC_CondBasedStateTransition(
2437  ltc_state,
2438  retVal,
2439  ltc_state->spiDiagErrorEntry,
2440  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2441  LTC_USER_IO_SAVE_DATA_TI,
2442  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT,
2443  LTC_STATEMACH_USER_IO_FEEDBACK_TI,
2444  LTC_USER_IO_SAVE_DATA_TI,
2445  LTC_STATEMACH_SHORTTIME);
2446  break;
2447  } else if (ltc_state->substate == LTC_USER_IO_SAVE_DATA_TI) {
2448  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2449  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2450  DIAG_Handler(
2451  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2452  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2453  break;
2454  } else {
2455  DIAG_Handler(
2456  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2457  }
2458 
2459  if (LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString) != STD_OK) {
2460  DIAG_Handler(
2461  ltc_state->pecDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2462  } else {
2463  DIAG_Handler(
2464  ltc_state->pecDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2465  LTC_PortExpanderSaveValuesTi(ltc_state, ltc_state->ltcData.txBuffer);
2466  }
2467 
2468  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2469  break;
2470  }
2471 
2472  break;
2473 
2474  /****************************EEPROM READ*********************************/
2475  case LTC_STATEMACH_EEPROM_READ:
2476 
2477  if (ltc_state->substate == LTC_EEPROM_READ_DATA1) {
2478  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2479  ltc_state->check_spi_flag = STD_OK;
2480  AFE_SetTransmitOngoing(ltc_state);
2481  retVal = LTC_SendEepromReadCommand(
2482  ltc_state,
2483  ltc_state->spiSeqPtr,
2484  ltc_state->ltcData.txBuffer,
2485  ltc_state->ltcData.rxBuffer,
2486  ltc_state->ltcData.frameLength,
2487  0);
2488 
2489  if (retVal != STD_OK) {
2490  DIAG_Handler(
2491  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2492  ++ltc_state->muxmeas_seqptr[ltc_state->requestedString];
2493  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2494  } else {
2495  DIAG_Handler(
2496  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2497  LTC_StateTransition(
2498  ltc_state,
2499  LTC_STATEMACH_EEPROM_READ,
2500  LTC_EEPROM_SEND_CLOCK_STCOMM1,
2501  ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT);
2502  }
2503 
2504  break;
2505  } else if (ltc_state->substate == LTC_EEPROM_SEND_CLOCK_STCOMM1) {
2506  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2507  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2508  DIAG_Handler(
2509  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2510  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2511  break;
2512  } else {
2513  DIAG_Handler(
2514  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2515  }
2516 
2517  AFE_SetTransmitOngoing(ltc_state);
2518  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2519  LTC_CondBasedStateTransition(
2520  ltc_state,
2521  retVal,
2522  ltc_state->spiDiagErrorEntry,
2523  LTC_STATEMACH_EEPROM_READ,
2524  LTC_EEPROM_READ_DATA2,
2525  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
2526  LTC_STATEMACH_EEPROM_READ,
2527  LTC_EEPROM_READ_DATA2,
2528  LTC_STATEMACH_SHORTTIME);
2529  break;
2530  } else if (ltc_state->substate == LTC_EEPROM_READ_DATA2) {
2531  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2532  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2533  DIAG_Handler(
2534  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2535  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2536  break;
2537  } else {
2538  DIAG_Handler(
2539  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2540  }
2541 
2542  AFE_SetTransmitOngoing(ltc_state);
2543  retVal = LTC_SendEepromReadCommand(
2544  ltc_state,
2545  ltc_state->spiSeqPtr,
2546  ltc_state->ltcData.txBuffer,
2547  ltc_state->ltcData.rxBuffer,
2548  ltc_state->ltcData.frameLength,
2549  1);
2550  LTC_CondBasedStateTransition(
2551  ltc_state,
2552  retVal,
2553  ltc_state->spiDiagErrorEntry,
2554  LTC_STATEMACH_EEPROM_READ,
2555  LTC_EEPROM_SEND_CLOCK_STCOMM2,
2556  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
2557  LTC_STATEMACH_EEPROM_READ,
2558  LTC_EEPROM_SEND_CLOCK_STCOMM2,
2559  LTC_STATEMACH_SHORTTIME);
2560  break;
2561  } else if (ltc_state->substate == LTC_EEPROM_SEND_CLOCK_STCOMM2) {
2562  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2563  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2564  DIAG_Handler(
2565  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2566  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2567  break;
2568  } else {
2569  DIAG_Handler(
2570  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2571  }
2572 
2573  AFE_SetTransmitOngoing(ltc_state);
2574  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2575  LTC_CondBasedStateTransition(
2576  ltc_state,
2577  retVal,
2578  ltc_state->spiDiagErrorEntry,
2579  LTC_STATEMACH_EEPROM_READ,
2580  LTC_EEPROM_READ_I2C_TRANSMISSION_RESULT_RDCOMM,
2581  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
2582  LTC_STATEMACH_EEPROM_READ,
2583  LTC_EEPROM_READ_I2C_TRANSMISSION_RESULT_RDCOMM,
2584  LTC_STATEMACH_SHORTTIME);
2585  break;
2586  } else if (ltc_state->substate == LTC_EEPROM_READ_I2C_TRANSMISSION_RESULT_RDCOMM) {
2587  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2588  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2589  DIAG_Handler(
2590  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2591  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2592  break;
2593  } else {
2594  DIAG_Handler(
2595  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2596  }
2597 
2598  AFE_SetTransmitOngoing(ltc_state);
2599  retVal = LTC_ReadRegister(
2600  ltc_cmdRDCOMM,
2601  ltc_state->spiSeqPtr,
2602  ltc_state->ltcData.txBuffer,
2603  ltc_state->ltcData.rxBuffer,
2604  ltc_state->ltcData.frameLength);
2605  LTC_CondBasedStateTransition(
2606  ltc_state,
2607  retVal,
2608  ltc_state->spiDiagErrorEntry,
2609  LTC_STATEMACH_EEPROM_READ,
2610  LTC_EEPROM_SAVE_READ,
2611  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
2612  LTC_STATEMACH_EEPROM_READ,
2613  LTC_EEPROM_SAVE_READ,
2614  LTC_STATEMACH_SHORTTIME);
2615  break;
2616  } else if (ltc_state->substate == LTC_EEPROM_SAVE_READ) {
2617  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2618  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2619  DIAG_Handler(
2620  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2621  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2622  break;
2623  } else {
2624  DIAG_Handler(
2625  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2626  }
2627 
2628  if (LTC_CheckPec(ltc_state, ltc_state->ltcData.rxBuffer, ltc_state->currentString) != STD_OK) {
2629  DIAG_Handler(
2630  ltc_state->pecDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2631  } else {
2632  DIAG_Handler(
2633  ltc_state->pecDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2634  LTC_EepromSaveReadValue(ltc_state, ltc_state->ltcData.rxBuffer);
2635  }
2636  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2637  break;
2638  }
2639 
2640  break;
2641 
2642  /****************************EEPROM READ*********************************/
2643  case LTC_STATEMACH_EEPROM_WRITE:
2644 
2645  if (ltc_state->substate == LTC_EEPROM_WRITE_DATA1) {
2646  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2647  ltc_state->check_spi_flag = STD_OK;
2648  AFE_SetTransmitOngoing(ltc_state);
2649  retVal = LTC_SendEepromWriteCommand(
2650  ltc_state,
2651  ltc_state->spiSeqPtr,
2652  ltc_state->ltcData.txBuffer,
2653  ltc_state->ltcData.rxBuffer,
2654  ltc_state->ltcData.frameLength,
2655  0);
2656 
2657  if (retVal != STD_OK) {
2658  DIAG_Handler(
2659  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2660  ++ltc_state->muxmeas_seqptr[ltc_state->requestedString];
2661  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2662  } else {
2663  DIAG_Handler(
2664  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2665  LTC_StateTransition(
2666  ltc_state,
2667  LTC_STATEMACH_EEPROM_WRITE,
2668  LTC_EEPROM_SEND_CLOCK_STCOMM3,
2669  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT));
2670  }
2671 
2672  break;
2673  } else if (ltc_state->substate == LTC_EEPROM_SEND_CLOCK_STCOMM3) {
2674  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2675  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2676  DIAG_Handler(
2677  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2678  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2679  break;
2680  } else {
2681  DIAG_Handler(
2682  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2683  }
2684 
2685  AFE_SetTransmitOngoing(ltc_state);
2686  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2687  LTC_CondBasedStateTransition(
2688  ltc_state,
2689  retVal,
2690  ltc_state->spiDiagErrorEntry,
2691  LTC_STATEMACH_EEPROM_WRITE,
2692  LTC_EEPROM_WRITE_DATA2,
2693  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
2694  LTC_STATEMACH_EEPROM_WRITE,
2695  LTC_EEPROM_WRITE_DATA2,
2696  LTC_STATEMACH_SHORTTIME);
2697  break;
2698  } else if (ltc_state->substate == LTC_EEPROM_WRITE_DATA2) {
2699  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2700  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2701  DIAG_Handler(
2702  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2703  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2704  break;
2705  } else {
2706  DIAG_Handler(
2707  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2708  }
2709 
2710  AFE_SetTransmitOngoing(ltc_state);
2711  retVal = LTC_SendEepromWriteCommand(
2712  ltc_state,
2713  ltc_state->spiSeqPtr,
2714  ltc_state->ltcData.txBuffer,
2715  ltc_state->ltcData.rxBuffer,
2716  ltc_state->ltcData.frameLength,
2717  1);
2718  LTC_CondBasedStateTransition(
2719  ltc_state,
2720  retVal,
2721  ltc_state->spiDiagErrorEntry,
2722  LTC_STATEMACH_EEPROM_WRITE,
2723  LTC_EEPROM_SEND_CLOCK_STCOMM4,
2724  (ltc_state->commandDataTransferTime + LTC_TRANSMISSION_TIMEOUT),
2725  LTC_STATEMACH_EEPROM_WRITE,
2726  LTC_EEPROM_SEND_CLOCK_STCOMM4,
2727  LTC_STATEMACH_SHORTTIME);
2728  break;
2729  } else if (ltc_state->substate == LTC_EEPROM_SEND_CLOCK_STCOMM4) {
2730  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2731  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2732  DIAG_Handler(
2733  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2734  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2735  break;
2736  } else {
2737  DIAG_Handler(
2738  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2739  }
2740 
2741  AFE_SetTransmitOngoing(ltc_state);
2742  retVal = LTC_I2cClock(ltc_state->spiSeqPtr);
2743  LTC_CondBasedStateTransition(
2744  ltc_state,
2745  retVal,
2746  ltc_state->spiDiagErrorEntry,
2747  LTC_STATEMACH_EEPROM_WRITE,
2748  LTC_EEPROM_FINISHED,
2749  (ltc_state->gpioClocksTransferTime + LTC_TRANSMISSION_TIMEOUT),
2750  LTC_STATEMACH_EEPROM_WRITE,
2751  LTC_EEPROM_FINISHED,
2752  LTC_STATEMACH_SHORTTIME);
2753  break;
2754  } else if (ltc_state->substate == LTC_EEPROM_FINISHED) {
2755  bool transmitOngoing = AFE_IsTransmitOngoing(ltc_state);
2756  if ((ltc_state->timer == 0) && (transmitOngoing == true)) {
2757  DIAG_Handler(
2758  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2759  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2760  break;
2761  } else {
2762  DIAG_Handler(
2763  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2764  }
2765  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2766  break;
2767  }
2768 
2769  break;
2770 
2771  /**************************OPEN-WIRE CHECK*******************************/
2772  case LTC_STATEMACH_OPENWIRE_CHECK:
2773  ltc_state->spiSeqPtr = ltc_state->ltcData.pSpiInterface + ltc_state->requestedString;
2774  /* This is necessary because the state machine will go through read voltage measurement registers */
2775  ltc_state->currentString = ltc_state->requestedString;
2776  if (ltc_state->substate == LTC_REQUEST_PULLUP_CURRENT_OPENWIRE_CHECK) {
2777  /* Run ADOW command with PUP = 1 */
2778  ltc_state->adcMode = LTC_OW_MEASUREMENT_MODE;
2779  ltc_state->check_spi_flag = STD_NOT_OK;
2780 
2781  retVal = LTC_StartOpenWireMeasurement(ltc_state->spiSeqPtr, ltc_state->adcMode, 1);
2782  if (retVal == STD_OK) {
2783  DIAG_Handler(
2784  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2785  LTC_StateTransition(
2786  ltc_state,
2787  LTC_STATEMACH_OPENWIRE_CHECK,
2788  LTC_REQUEST_PULLUP_CURRENT_OPENWIRE_CHECK,
2789  (ltc_state->commandDataTransferTime +
2790  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, LTC_ADCMEAS_ALLCHANNEL_CELLS)));
2791  ltc_state->resendCommandCounter--;
2792 
2793  /* Check how many retries are left */
2794  if (ltc_state->resendCommandCounter == 0) {
2795  /* Switch to read voltage state to read cell voltages */
2796  LTC_StateTransition(
2797  ltc_state,
2798  LTC_STATEMACH_READVOLTAGE,
2799  LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE,
2800  (ltc_state->commandDataTransferTime +
2801  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, LTC_ADCMEAS_ALLCHANNEL_CELLS)));
2802  /* Reuse read voltage register */
2803  ltc_state->reusageMeasurementMode = LTC_REUSE_READVOLT_FOR_ADOW_PUP;
2804  }
2805  } else {
2806  DIAG_Handler(
2807  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2808  LTC_StateTransition(
2809  ltc_state, LTC_STATEMACH_STARTMEAS_CONTINUE, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2810  }
2811  } else if (ltc_state->substate == LTC_READ_VOLTAGES_PULLUP_OPENWIRE_CHECK) {
2812  /* Previous state: Read voltage -> information stored in voltage buffer */
2813  ltc_state->reusageMeasurementMode = LTC_NOT_REUSED;
2814 
2815  /* Copy data from voltage struct into open-wire struct */
2816  for (uint16_t i = 0u; i < BS_NR_OF_CELL_BLOCKS_PER_STRING; i++) {
2817  ltc_state->ltcData.openWireDetection->openWirePup[ltc_state->requestedString][i] =
2818  ltc_state->ltcData.cellVoltage->cellVoltage_mV[ltc_state->requestedString][i];
2819  }
2820 
2821  /* Set number of ADOW retries - send ADOW command with pull-down two times */
2822  ltc_state->resendCommandCounter = LTC_NMBR_REQ_ADOW_COMMANDS;
2823  LTC_StateTransition(
2824  ltc_state,
2825  LTC_STATEMACH_OPENWIRE_CHECK,
2826  LTC_REQUEST_PULLDOWN_CURRENT_OPENWIRE_CHECK,
2827  LTC_STATEMACH_SHORTTIME);
2828  } else if (ltc_state->substate == LTC_REQUEST_PULLDOWN_CURRENT_OPENWIRE_CHECK) {
2829  /* Run ADOW command with PUP = 0 */
2830  ltc_state->adcMode = LTC_OW_MEASUREMENT_MODE;
2831  ltc_state->check_spi_flag = STD_NOT_OK;
2832 
2833  retVal = LTC_StartOpenWireMeasurement(ltc_state->spiSeqPtr, ltc_state->adcMode, 0);
2834  if (retVal == STD_OK) {
2835  DIAG_Handler(
2836  ltc_state->spiDiagErrorEntry, DIAG_EVENT_OK, DIAG_STRING, ltc_state->currentString);
2837  LTC_StateTransition(
2838  ltc_state,
2839  LTC_STATEMACH_OPENWIRE_CHECK,
2840  LTC_REQUEST_PULLDOWN_CURRENT_OPENWIRE_CHECK,
2841  (ltc_state->commandDataTransferTime +
2842  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, LTC_ADCMEAS_ALLCHANNEL_CELLS)));
2843  ltc_state->resendCommandCounter--;
2844 
2845  /* Check how many retries are left */
2846  if (ltc_state->resendCommandCounter == 0) {
2847  /* Switch to read voltage state to read cell voltages */
2848  LTC_StateTransition(
2849  ltc_state,
2850  LTC_STATEMACH_READVOLTAGE,
2851  LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE,
2852  (ltc_state->commandDataTransferTime +
2853  LTC_GetMeasurementTimeCycle(ltc_state->adcMode, LTC_ADCMEAS_ALLCHANNEL_CELLS)));
2854  /* Reuse read voltage register */
2855  ltc_state->reusageMeasurementMode = LTC_REUSE_READVOLT_FOR_ADOW_PDOWN;
2856  }
2857  } else {
2858  DIAG_Handler(
2859  ltc_state->spiDiagErrorEntry, DIAG_EVENT_NOT_OK, DIAG_STRING, ltc_state->currentString);
2860  LTC_StateTransition(
2861  ltc_state, LTC_STATEMACH_STARTMEAS_CONTINUE, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2862  }
2863  } else if (ltc_state->substate == LTC_READ_VOLTAGES_PULLDOWN_OPENWIRE_CHECK) {
2864  /* Previous state: Read voltage -> information stored in voltage buffer */
2865  ltc_state->reusageMeasurementMode = LTC_NOT_REUSED;
2866 
2867  /* Copy data from voltage struct into open-wire struct */
2868  for (uint16_t i = 0u; i < BS_NR_OF_CELL_BLOCKS_PER_STRING; i++) {
2869  ltc_state->ltcData.openWireDetection->openWirePdown[ltc_state->requestedString][i] =
2870  ltc_state->ltcData.cellVoltage->cellVoltage_mV[ltc_state->requestedString][i];
2871  }
2872  LTC_StateTransition(
2873  ltc_state, LTC_STATEMACH_OPENWIRE_CHECK, LTC_PERFORM_OPENWIRE_CHECK, LTC_STATEMACH_SHORTTIME);
2874  } else if (ltc_state->substate == LTC_PERFORM_OPENWIRE_CHECK) {
2875  /* Perform actual open-wire check */
2876  for (uint8_t m = 0; m < BS_NR_OF_MODULES_PER_STRING; m++) {
2877  /* Open-wire at C0: cell_pup(0) == 0 */
2878  if (ltc_state->ltcData.openWireDetection
2879  ->openWirePup[ltc_state->requestedString][0 + (m * BS_NR_OF_CELL_BLOCKS_PER_MODULE)] ==
2880  0u) {
2881  ltc_state->ltcData.openWire->openWire[ltc_state->requestedString]
2882  [0 + (m * (BS_NR_OF_CELL_BLOCKS_PER_MODULE))] = 1u;
2883  }
2884  /* Open-wire at Cmax: cell_pdown(BS_NR_OF_CELL_BLOCKS_PER_MODULE-1) == 0 */
2885  if (ltc_state->ltcData.openWireDetection->openWirePdown[ltc_state->requestedString][(
2886  (BS_NR_OF_CELL_BLOCKS_PER_MODULE - 1) + (m * BS_NR_OF_CELL_BLOCKS_PER_MODULE))] == 0u) {
2887  ltc_state->ltcData.openWire
2888  ->openWire[ltc_state->requestedString]
2889  [BS_NR_OF_CELL_BLOCKS_PER_MODULE + (m * BS_NR_OF_CELL_BLOCKS_PER_MODULE)] =
2890  1u;
2891  }
2892  }
2893 
2894  /* Take difference between pull-up and pull-down measurement */
2895  for (uint16_t i = 1u; i < BS_NR_OF_CELL_BLOCKS_PER_STRING; i++) {
2896  ltc_state->ltcData.openWireDetection->openWireDelta[ltc_state->requestedString][i] =
2897  ltc_state->ltcData.openWireDetection->openWirePup[ltc_state->requestedString][i] -
2898  ltc_state->ltcData.openWireDetection->openWirePdown[ltc_state->requestedString][i];
2899  }
2900 
2901  /* Open-wire at C(N): delta cell(n+1) < -400mV */
2902  for (uint8_t m = 0u; m < BS_NR_OF_MODULES_PER_STRING; m++) {
2903  for (uint8_t c = 1u; c < (BS_NR_OF_CELL_BLOCKS_PER_MODULE - 1); c++) {
2904  if (ltc_state->ltcData.openWireDetection
2905  ->openWireDelta[ltc_state->requestedString]
2906  [c + (m * BS_NR_OF_CELL_BLOCKS_PER_MODULE)] < LTC_ADOW_THRESHOLD) {
2907  ltc_state->ltcData.openWire->openWire[ltc_state->requestedString]
2908  [c + (m * BS_NR_OF_CELL_BLOCKS_PER_MODULE)] = 1;
2909  }
2910  }
2911  }
2912 
2913  /* Write database entry */
2914  DATA_WRITE_DATA(ltc_state->ltcData.openWire);
2915  /* Start new measurement cycle */
2916  LTC_StateTransition(ltc_state, LTC_STATEMACH_STARTMEAS, LTC_ENTRY, LTC_STATEMACH_SHORTTIME);
2917  }
2918  break;
2919 
2920  /****************************DEFAULT**************************/
2921  default:
2922  /* invalid state */
2923  FAS_ASSERT(FAS_TRAP);
2924  break;
2925  }
2926 
2927  ltc_state->triggerentry--; /* reentrance counter */
2928  } /* continueFunction */
2929 }
2930 
2931 /**
2932  * @brief saves the multiplexer values read from the LTC daisy-chain.
2933  *
2934  * After a voltage measurement was initiated on GPIO 1 to read the currently
2935  * selected multiplexer voltage, the results is read via SPI from the
2936  * daisy-chain.
2937  * This function is called to store the result from the transmission in a
2938  * buffer.
2939  *
2940  * @param ltc_state state of the ltc state machine
2941  * @param pRxBuff receive buffer
2942  * @param muxseqptr pointer to the multiplexer sequence, which
2943  * configures the currently selected multiplexer ID and
2944  * channel
2945  * @param stringNumber string addressed
2946  */
2947 static void LTC_SaveMuxMeasurement(
2948  LTC_STATE_s *ltc_state,
2949  uint16_t *pRxBuff,
2950  LTC_MUX_CH_CFG_s *muxseqptr,
2951  uint8_t stringNumber) {
2952  FAS_ASSERT(ltc_state != NULL_PTR);
2953  FAS_ASSERT(pRxBuff != NULL_PTR);
2954  FAS_ASSERT(muxseqptr != NULL_PTR);
2955  uint16_t val_ui = 0;
2956  int16_t temperature_ddegC = 0;
2957  uint8_t sensor_idx = 0;
2958  uint8_t ch_idx = 0;
2959  uint16_t buffer_LSB = 0;
2960  uint16_t buffer_MSB = 0;
2961 
2962  /* pointer to measurement Sequence of Mux- and Channel-Configurations (1,0xFF)...(3,0xFF),(0,1),...(0,7)) */
2963  /* Channel 0xFF means that the multiplexer is deactivated, therefore no measurement will be made and saved*/
2964  if (muxseqptr->muxCh != 0xFF) {
2965  /* user multiplexer type -> connected to GPIO2! */
2966  if ((muxseqptr->muxID == 1) || (muxseqptr->muxID == 2)) {
2967  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
2968  if (muxseqptr->muxID == 1) {
2969  ch_idx = 0 + muxseqptr->muxCh; /* channel index 0..7 */
2970  } else {
2971  ch_idx = 8 + muxseqptr->muxCh; /* channel index 8..15 */
2972  }
2973 
2974  if (ch_idx < (2u * 8u)) {
2975  val_ui = *((uint16_t *)(&pRxBuff[6u + (1u * i * 8u)])); /* raw values, all mux on all LTCs */
2976  /* ltc_user_mux.value[i*8*2+ch_idx] = (uint16_t)(((float_t)(val_ui))*100e-6f*1000.0f); */ /* Unit -> in V -> in mV */
2977  }
2978  }
2979  } else {
2980  /* temperature multiplexer type -> connected to GPIO1! */
2981  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
2982  buffer_MSB = pRxBuff[4u + (i * 8u) + 1u];
2983  buffer_LSB = pRxBuff[4u + (i * 8u)];
2984  val_ui = buffer_LSB | (buffer_MSB << 8);
2985  /* val_ui = *((uint16_t *)(&pRxBuff[4+i*8])); */
2986  /* GPIO voltage in 100uV -> * 0.1 ---- conversion to mV */
2987  temperature_ddegC = LTC_ConvertMuxVoltagesToTemperatures(val_ui / 10u); /* unit: deci &deg;C */
2988  sensor_idx = ltc_muxsensortemperatur_cfg[muxseqptr->muxCh];
2989  /* wrong configuration! */
2990  if (sensor_idx >= BS_NR_OF_TEMP_SENSORS_PER_MODULE) {
2991  FAS_ASSERT(FAS_TRAP);
2992  }
2993  /* Set bitmask for valid flags */
2994 
2995  /* Check LTC PEC error */
2996  if (ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] == true) {
2997  /* Reset invalid flag */
2998  ltc_state->ltcData.cellTemperature->invalidCellTemperature[stringNumber][i] =
2999  ltc_state->ltcData.cellTemperature->invalidCellTemperature[stringNumber][i] &
3000  (~(1u << sensor_idx));
3001 
3002  ltc_state->ltcData.cellTemperature
3003  ->cellTemperature_ddegC[stringNumber][(i * (BS_NR_OF_TEMP_SENSORS_PER_MODULE)) + sensor_idx] =
3004  temperature_ddegC;
3005  } else {
3006  /* Set invalid flag */
3007  ltc_state->ltcData.cellTemperature->invalidCellTemperature[stringNumber][i] |= (1u << sensor_idx);
3008  }
3009  }
3010  }
3011  }
3012 }
3013 
3014 /**
3015  * @brief saves the voltage values read from the LTC daisy-chain.
3016  *
3017  * After a voltage measurement was initiated to measure the voltages of the cells,
3018  * the result is read via SPI from the daisy-chain.
3019  * There are 6 register to read _(A,B,C,D,E,F) to get all cell voltages.
3020  * Only one register can be read at a time.
3021  * This function is called to store the result from the transmission in a buffer.
3022  *
3023  * @param ltc_state state of the ltc state machine
3024  * @param pRxBuff receive buffer
3025  * @param registerSet voltage register that was read (voltage register A,B,C,D,E or F)
3026  * @param stringNumber string addressed
3027  *
3028  */
3029 static void LTC_SaveRxToVoltageBuffer(
3030  LTC_STATE_s *ltc_state,
3031  uint16_t *pRxBuff,
3032  uint8_t registerSet,
3033  uint8_t stringNumber) {
3034  FAS_ASSERT(ltc_state != NULL_PTR);
3035  FAS_ASSERT(pRxBuff != NULL_PTR);
3036  uint16_t cellOffset = 0;
3037  uint16_t voltage_index = 0;
3038  uint16_t val_ui = 0;
3039  uint16_t voltage = 0;
3040  uint32_t bitmask = 0;
3041  uint16_t buffer_LSB = 0;
3042  uint16_t buffer_MSB = 0;
3043  bool continueFunction = true;
3044 
3045  if (registerSet == 0u) {
3046  /* RDCVA command -> voltage register group A */
3047  cellOffset = 0;
3048  } else if (registerSet == 1u) {
3049  /* RDCVB command -> voltage register group B */
3050  cellOffset = 3;
3051  } else if (registerSet == 2u) {
3052  /* RDCVC command -> voltage register group C */
3053  cellOffset = 6;
3054  } else if (registerSet == 3u) {
3055  /* RDCVD command -> voltage register group D */
3056  cellOffset = 9;
3057  } else if (registerSet == 4u) {
3058  /* RDCVD command -> voltage register group E (only for 15 and 18 cell version) */
3059  cellOffset = 12;
3060  } else if (registerSet == 5u) {
3061  /* RDCVD command -> voltage register group F (only for 18 cell version) */
3062  cellOffset = 15;
3063  } else {
3064  continueFunction = false;
3065  }
3066 
3067  if (continueFunction == true) {
3068  /* Calculate bitmask for valid flags */
3069  bitmask |= 0x07u << cellOffset; /* 0x07: three voltages in each register */
3070 
3071  /* reinitialize index counter at begin of cycle */
3072  if (cellOffset == 0u) {
3073  (ltc_state->ltcData.usedCellIndex[stringNumber]) = 0;
3074  }
3075 
3076  /* Retrieve data without command and CRC*/
3077  for (uint16_t m = 0u; m < LTC_N_LTC; m++) {
3078  uint16_t incrementations = 0u;
3079 
3080  /* parse all three voltages (3 * 2bytes) contained in one register */
3081  for (uint8_t c = 0u; c < 3u; c++) {
3082  /* index considering maximum number of cells */
3083  voltage_index = c + cellOffset;
3084 
3085  if (ltc_voltage_input_used[voltage_index] == 1u) {
3086  buffer_MSB = pRxBuff[4u + (2u * c) + (m * 8u) + 1u];
3087  buffer_LSB = pRxBuff[4u + (2u * c) + (m * 8u)];
3088  val_ui = buffer_LSB | (buffer_MSB << 8u);
3089  /* val_ui = *((uint16_t *)(&pRxBuff[4+2*j+i*8])); */
3090  voltage = ((val_ui)) * 100e-6f * 1000.0f; /* Unit V -> in mV */
3091 
3092  /* Check PEC for every LTC in the daisy-chain */
3093  if (ltc_state->ltcData.errorTable->PEC_valid[stringNumber][m] == true) {
3094  ltc_state->ltcData.cellVoltage
3095  ->cellVoltage_mV[stringNumber]
3096  [(ltc_state->ltcData.usedCellIndex[stringNumber]) +
3097  (m * BS_NR_OF_CELL_BLOCKS_PER_MODULE)] = voltage;
3098  bitmask = ~bitmask; /* negate bitmask to only validate flags of this voltage register */
3099  ltc_state->ltcData.cellVoltage
3100  ->invalidCellVoltage[stringNumber][(m / LTC_NUMBER_OF_LTC_PER_MODULE)] &= bitmask;
3101  } else {
3102  /* PEC_valid == false: Invalidate only flags of this voltage register */
3103  ltc_state->ltcData.cellVoltage
3104  ->invalidCellVoltage[stringNumber][(m / LTC_NUMBER_OF_LTC_PER_MODULE)] |= bitmask;
3105  }
3106 
3107  (ltc_state->ltcData.usedCellIndex[stringNumber])++;
3108  incrementations++;
3109 
3110  if ((ltc_state->ltcData.usedCellIndex[stringNumber]) > BS_NR_OF_CELL_BLOCKS_PER_MODULE) {
3111  break;
3112  }
3113  }
3114  }
3115 
3116  /* Restore start value for next module in the daisy-chain. Only
3117  * decrement used cell index if current module is not the last
3118  * module in the daisy-chain. */
3119  if ((m + 1u) < LTC_N_LTC) {
3120  (ltc_state->ltcData.usedCellIndex[stringNumber]) -= incrementations;
3121  }
3122  }
3123  }
3124 }
3125 
3126 /**
3127  * @brief saves the GPIO voltage values read from the LTC daisy-chain.
3128  *
3129  * After a voltage measurement was initiated to measure the voltages on all GPIOs,
3130  * the result is read via SPI from the daisy-chain. In order to read the result of all GPIO measurements,
3131  * it is necessary to read auxiliary register A and B.
3132  * Only one register can be read at a time.
3133  * This function is called to store the result from the transmission in a buffer.
3134  *
3135  * @param ltc_state state of the ltc state machine
3136  * @param pRxBuff receive buffer
3137  * @param registerSet voltage register that was read (auxiliary register A, B, C or D)
3138  * @param stringNumber string addressed
3139  *
3140  */
3141 static void LTC_SaveRxToGpioBuffer(
3142  LTC_STATE_s *ltc_state,
3143  uint16_t *pRxBuff,
3144  uint8_t registerSet,
3145  uint8_t stringNumber) {
3146  FAS_ASSERT(ltc_state != NULL_PTR);
3147  FAS_ASSERT(pRxBuff != NULL_PTR);
3148  uint8_t i_offset = 0;
3149  uint32_t bitmask = 0;
3150  uint16_t buffer_LSB = 0;
3151  uint16_t buffer_MSB = 0;
3152 
3153  if (registerSet == 0u) {
3154  /* RDAUXA command -> GPIO register group A */
3155  i_offset = 0;
3156  bitmask = 0x07u << i_offset; /* 0x07: three temperatures in this register */
3157  /* Retrieve data without command and CRC*/
3158  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
3159  /* Check if PEC is valid */
3160  if (ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] == true) {
3161  bitmask = ~bitmask; /* negate bitmask to only validate flags of this voltage register */
3162  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] &= bitmask;
3163  /* values received in 100uV -> divide by 10 to convert to mV */
3164  buffer_MSB = pRxBuff[4u + (i * 8u) + 1u];
3165  buffer_LSB = pRxBuff[4u + (i * 8u)];
3166  ltc_state->ltcData.allGpioVoltages
3167  ->gpioVoltages_mV[stringNumber][0u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3168  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3169  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][0 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[4+i*8]))/10; */
3170  buffer_MSB = pRxBuff[6u + (i * 8u) + 1u];
3171  buffer_LSB = pRxBuff[6u + (i * 8u)];
3172  ltc_state->ltcData.allGpioVoltages
3173  ->gpioVoltages_mV[stringNumber][1u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3174  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3175  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][1 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[6+i*8]))/10; */
3176  buffer_MSB = pRxBuff[8u + (i * 8u) + 1u];
3177  buffer_LSB = pRxBuff[8u + (i * 8u)];
3178  ltc_state->ltcData.allGpioVoltages
3179  ->gpioVoltages_mV[stringNumber][2u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3180  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3181  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][2 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[8+i*8]))/10; */
3182  } else {
3183  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] |= bitmask;
3184  }
3185  }
3186  } else if (registerSet == 1u) {
3187  /* RDAUXB command -> GPIO register group B */
3188  i_offset = 3;
3189  bitmask = 0x03u << i_offset; /* 0x03: two temperatures in this register */
3190  /* Retrieve data without command and CRC*/
3191  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
3192  /* Check if PEC is valid */
3193  if (ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] == true) {
3194  bitmask = ~bitmask; /* negate bitmask to only validate flags of this voltage register */
3195  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] &= bitmask;
3196  /* values received in 100uV -> divide by 10 to convert to mV */
3197  buffer_MSB = pRxBuff[4u + (i * 8u) + 1u];
3198  buffer_LSB = pRxBuff[4u + (i * 8u)];
3199  ltc_state->ltcData.allGpioVoltages
3200  ->gpioVoltages_mV[stringNumber][0u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3201  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3202  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][0 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[4+i*8]))/10; */
3203  buffer_MSB = pRxBuff[6u + (i * 8u) + 1u];
3204  buffer_LSB = pRxBuff[6u + (i * 8u)];
3205  ltc_state->ltcData.allGpioVoltages
3206  ->gpioVoltages_mV[stringNumber][1u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3207  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3208  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][1 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[6+i*8]))/10; */
3209  } else {
3210  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] |= bitmask;
3211  }
3212  }
3213  } else if (registerSet == 2u) {
3214  /* RDAUXC command -> GPIO register group C, for 18 cell version */
3215  i_offset = 5;
3216  bitmask = 0x07u << i_offset; /* 0x07: three temperatures in this register */
3217  /* Retrieve data without command and CRC*/
3218  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
3219  /* Check if PEC is valid */
3220  if (ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] == true) {
3221  bitmask = ~bitmask; /* negate bitmask to only validate flags of this voltage register */
3222  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] &= bitmask;
3223  /* values received in 100uV -> divide by 10 to convert to mV */
3224  buffer_MSB = pRxBuff[4u + (i * 8u) + 1u];
3225  buffer_LSB = pRxBuff[4u + (i * 8u)];
3226  ltc_state->ltcData.allGpioVoltages
3227  ->gpioVoltages_mV[stringNumber][0u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3228  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3229  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][0 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[4+i*8]))/10; */
3230  buffer_MSB = pRxBuff[6u + (i * 8u) + 1u];
3231  buffer_LSB = pRxBuff[6u + (i * 8u)];
3232  ltc_state->ltcData.allGpioVoltages
3233  ->gpioVoltages_mV[stringNumber][1u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3234  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3235  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][1 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[6+i*8]))/10; */
3236  buffer_MSB = pRxBuff[8u + (i * 8u) + 1u];
3237  buffer_LSB = pRxBuff[8u + (i * 8u)];
3238  ltc_state->ltcData.allGpioVoltages
3239  ->gpioVoltages_mV[stringNumber][2u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3240  ((buffer_LSB | (buffer_MSB << 8u))) / 10u;
3241  /* ltc_state->ltcData.allGpioVoltages->gpiovoltage[stringNumber][2 + i_offset + BS_NR_OF_GPIOS_PER_MODULE*i]= *((uint16_t *)(&pRxBuff[8+i*8]))/10; */
3242  } else {
3243  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] |= bitmask;
3244  }
3245  }
3246  } else if (registerSet == 3u) {
3247  /* RDAUXD command -> GPIO register group D, for 18 cell version */
3248  i_offset = 8;
3249  bitmask = 0x01u << i_offset; /* 0x01: one temperature in this register */
3250  /* Retrieve data without command and CRC*/
3251  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
3252  /* Check if PEC is valid */
3253  if (ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] == true) {
3254  bitmask = ~bitmask; /* negate bitmask to only validate flags of this voltage register */
3255  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] &= bitmask;
3256  /* values received in 100uV -> divide by 10 to convert to mV */
3257  ltc_state->ltcData.allGpioVoltages
3258  ->gpioVoltages_mV[stringNumber][0u + i_offset + (BS_NR_OF_GPIOS_PER_MODULE * i)] =
3259  *((uint16_t *)(&pRxBuff[4u + (i * 8u)])) / 10u;
3260  } else {
3261  ltc_state->ltcData.allGpioVoltages->invalidGpioVoltages[stringNumber][i] |= bitmask;
3262  }
3263  }
3264  } else {
3265  ; /* Nothing to do */
3266  }
3267 }
3268 
3269 /**
3270  * @brief checks if the multiplexers acknowledged transmission.
3271  *
3272  * The RDCOMM command can be used to read the answer of the multiplexers to a
3273  * I2C transmission.
3274  * This function determines if the communication with the multiplexers was
3275  * successful or not.
3276  * The array error table is updated to locate the multiplexers that did not
3277  * acknowledge transmission.
3278  *
3279  * @param ltc_state state of the ltc state machine
3280  * @param pRxBuff receive buffer
3281  * @param mux multiplexer to be addressed (multiplexer ID)
3282  * @param stringNumber string addressed
3283  *
3284  * @return STD_OK if there was no error, STD_NOT_OK if there was errors
3285  */
3286 static STD_RETURN_TYPE_e LTC_I2cCheckAck(LTC_STATE_s *ltc_state, uint16_t *pRxBuff, uint8_t mux, uint8_t stringNumber) {
3287  FAS_ASSERT(ltc_state != NULL_PTR);
3288  FAS_ASSERT(pRxBuff != NULL_PTR);
3289  STD_RETURN_TYPE_e muxError = STD_OK;
3290 
3291  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
3292  if ((pRxBuff[4u + 1u + (LTC_NUMBER_OF_LTC_PER_MODULE * i * 8u)] & 0x0Fu) != 0x07u) { /* ACK = 0xX7 */
3293  if (LTC_DISCARD_MUX_CHECK == false) {
3294  if (mux == 0u) {
3295  ltc_state->ltcData.errorTable->mux0[stringNumber][i] = 1;
3296  }
3297  if (mux == 1u) {
3298  ltc_state->ltcData.errorTable->mux1[stringNumber][i] = 1;
3299  }
3300  if (mux == 2u) {
3301  ltc_state->ltcData.errorTable->mux2[stringNumber][i] = 1;
3302  }
3303  if (mux == 3u) {
3304  ltc_state->ltcData.errorTable->mux3[stringNumber][i] = 1;
3305  }
3306  }
3307  muxError = STD_NOT_OK;
3308  } else {
3309  if (mux == 0u) {
3310  ltc_state->ltcData.errorTable->mux0[stringNumber][i] = 0;
3311  }
3312  if (mux == 1u) {
3313  ltc_state->ltcData.errorTable->mux1[stringNumber][i] = 0;
3314  }
3315  if (mux == 2u) {
3316  ltc_state->ltcData.errorTable->mux2[stringNumber][i] = 0;
3317  }
3318  if (mux == 3u) {
3319  ltc_state->ltcData.errorTable->mux3[stringNumber][i] = 0;
3320  }
3321  }
3322  }
3323 
3324  if (LTC_DISCARD_MUX_CHECK == true) {
3325  muxError = STD_OK;
3326  }
3327  return muxError;
3328 }
3329 
3330 /**
3331  * @brief initialize the daisy-chain.
3332  *
3333  * To initialize the LTC6804 daisy-chain, a dummy byte (0x00) is sent.
3334  *
3335  * @param pSpiInterface pointer to SPI configuration
3336  * @param pTxBuff transmit buffer
3337  * @param pRxBuff receive buffer
3338  * @param frameLength number of words to transmit
3339  *
3340  * @return retVal #STD_OK if dummy byte was sent correctly by SPI, #STD_NOT_OK otherwise
3341  *
3342  */
3343 static STD_RETURN_TYPE_e LTC_Init(
3344  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3345  uint16_t *pTxBuff,
3346  uint16_t *pRxBuff,
3347  uint32_t frameLength) {
3348  FAS_ASSERT(pSpiInterface != NULL_PTR);
3349  FAS_ASSERT(pTxBuff != NULL_PTR);
3350  FAS_ASSERT(pRxBuff != NULL_PTR);
3351  STD_RETURN_TYPE_e retVal = STD_NOT_OK;
3352 
3353  uint8_t PEC_Check[LTC_DATA_SIZE_IN_BYTES];
3354  uint16_t PEC_result = 0;
3355 
3356  /* now construct the message to be sent: it contains the wanted data, PLUS the needed PECs */
3357  pTxBuff[0] = ltc_cmdWRCFG[0];
3358  pTxBuff[1] = ltc_cmdWRCFG[1];
3359  pTxBuff[2] = ltc_cmdWRCFG[2];
3360  pTxBuff[3] = ltc_cmdWRCFG[3];
3361 
3362  /* set REFON bit to 1 */
3363  /* data for the configuration */
3364  for (uint16_t i = 0u; i < LTC_N_LTC; i++) {
3365  /* FC = disable all pull-downs, REFON = 1, DTEN = 0, ADCOPT = 0 */
3366  pTxBuff[4u + (i * 8u)] = 0xFC;
3367  pTxBuff[5u + (i * 8u)] = 0x00;
3368  pTxBuff[6u + (i * 8u)] = 0x00;
3369  pTxBuff[7u + (i * 8u)] = 0x00;
3370  pTxBuff[8u + (i * 8u)] = 0x00;
3371  pTxBuff[9u + (i * 8u)] = 0x00;
3372 
3373  PEC_Check[0] = pTxBuff[4u + (i * 8u)];
3374  PEC_Check[1] = pTxBuff[5u + (i * 8u)];
3375  PEC_Check[2] = pTxBuff[6u + (i * 8u)];
3376  PEC_Check[3] = pTxBuff[7u + (i * 8u)];
3377  PEC_Check[4] = pTxBuff[8u + (i * 8u)];
3378  PEC_Check[5] = pTxBuff[9u + (i * 8u)];
3379 
3380  PEC_result = LTC_CalculatePec15(LTC_DATA_SIZE_IN_BYTES, PEC_Check);
3381  pTxBuff[10u + (i * 8u)] = (PEC_result >> 8u) & 0xFFu;
3382  pTxBuff[11u + (i * 8u)] = PEC_result & 0xFFu;
3383  } /* end for */
3384 
3385  retVal = LTC_TRANSMIT_RECEIVE_DATA(pSpiInterface, pTxBuff, pRxBuff, frameLength);
3386 
3387  return retVal;
3388 }
3389 
3390 /**
3391  * @brief sets the balancing according to the control values read in the database.
3392  *
3393  * To set balancing for the cells, the corresponding bits have to be written in the configuration register.
3394  * The LTC driver only executes the balancing orders written by the BMS in the database.
3395  *
3396  * @param ltc_state state of the ltc state machine
3397  * @param pSpiInterface pointer to SPI configuration
3398  * @param pTxBuff transmit buffer
3399  * @param pRxBuff receive buffer
3400  * @param frameLength number of words to transmit
3401  * @param registerSet register Set, 0: cells 1 to 12 (WRCFG), 1: cells 13 to 15/18 (WRCFG2)
3402  * @param stringNumber string addressed
3403  *
3404  * @return STD_OK if dummy byte was sent correctly by SPI, STD_NOT_OK otherwise
3405  *
3406  */
3407 static STD_RETURN_TYPE_e LTC_BalanceControl(
3408  LTC_STATE_s *ltc_state,
3409  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3410  uint16_t *pTxBuff,
3411  uint16_t *pRxBuff,
3412  uint32_t frameLength,
3413  uint8_t registerSet,
3414  uint8_t stringNumber) {
3415  FAS_ASSERT(ltc_state != NULL_PTR);
3416  FAS_ASSERT(pSpiInterface != NULL_PTR);
3417  FAS_ASSERT(pTxBuff != NULL_PTR);
3418  FAS_ASSERT(pRxBuff != NULL_PTR);
3419  STD_RETURN_TYPE_e retVal = STD_OK;
3420 
3421  uint8_t PEC_Check[LTC_DATA_SIZE_IN_BYTES];
3422  uint16_t PEC_result = 0;
3423 
3424  LTC_GetBalancingControlValues(ltc_state);
3425 
3426  if (registerSet == 0u) { /* cells 1 to 12, WRCFG */
3427  pTxBuff[0] = ltc_cmdWRCFG[0];
3428  pTxBuff[1] = ltc_cmdWRCFG[1];
3429  pTxBuff[2] = ltc_cmdWRCFG[2];
3430  pTxBuff[3] = ltc_cmdWRCFG[3];
3431  for (uint16_t j = 0; j < BS_NR_OF_MODULES_PER_STRING; j++) {
3432  /* The daisy-chain works like a shift register, so the order has to be reversed:
3433  when addressing e.g. the first module in the daisy-chain, the data will be sent last on the SPI bus and
3434  when addressing e.g. the last module in the daisy-chain, the data will be sent first on the SPI bus */
3435  const uint16_t reverseModuleNumber = BS_NR_OF_MODULES_PER_STRING - j - 1u;
3436 
3437  /* FC = disable all pull-downs, REFON = 1 (reference always on), DTEN off, ADCOPT = 0 */
3438  pTxBuff[4u + (reverseModuleNumber * 8u)] = 0xFC;
3439  pTxBuff[5u + (reverseModuleNumber * 8u)] = 0x00;
3440  pTxBuff[6u + (reverseModuleNumber * 8u)] = 0x00;
3441  pTxBuff[7u + (reverseModuleNumber * 8u)] = 0x00;
3442  pTxBuff[8u + (reverseModuleNumber * 8u)] = 0x00;
3443  pTxBuff[9u + (reverseModuleNumber * 8u)] = 0x00;
3444 
3445  if (ltc_state->ltcData.balancingControl
3446  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 0u] == 1u) {
3447  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x01u;
3448  }
3449  if (ltc_state->ltcData.balancingControl
3450  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 1u] == 1u) {
3451  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x02u;
3452  }
3453  if (ltc_state->ltcData.balancingControl
3454  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 2u] == 1u) {
3455  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x04u;
3456  }
3457  if (ltc_state->ltcData.balancingControl
3458  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 3u] == 1u) {
3459  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x08u;
3460  }
3461  if (ltc_state->ltcData.balancingControl
3462  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 4u] == 1u) {
3463  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x10u;
3464  }
3465  if (ltc_state->ltcData.balancingControl
3466  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 5u] == 1u) {
3467  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x20u;
3468  }
3469  if (ltc_state->ltcData.balancingControl
3470  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 6u] == 1u) {
3471  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x40u;
3472  }
3473  if (ltc_state->ltcData.balancingControl
3474  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 7u] == 1u) {
3475  pTxBuff[8u + (reverseModuleNumber * 8u)] |= 0x80u;
3476  }
3477  if (ltc_state->ltcData.balancingControl
3478  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 8u] == 1u) {
3479  pTxBuff[9u + (reverseModuleNumber * 8u)] |= 0x01u;
3480  }
3481  if (ltc_state->ltcData.balancingControl
3482  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 9u] == 1u) {
3483  pTxBuff[9u + (reverseModuleNumber * 8u)] |= 0x02u;
3484  }
3485  if (ltc_state->ltcData.balancingControl
3486  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 10u] == 1u) {
3487  pTxBuff[9u + (reverseModuleNumber * 8u)] |= 0x04u;
3488  }
3489  if (ltc_state->ltcData.balancingControl
3490  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 11u] == 1u) {
3491  pTxBuff[9u + (reverseModuleNumber * 8u)] |= 0x08u;
3492  }
3493 
3494  PEC_Check[0] = pTxBuff[4u + (reverseModuleNumber * 8u)];
3495  PEC_Check[1] = pTxBuff[5u + (reverseModuleNumber * 8u)];
3496  PEC_Check[2] = pTxBuff[6u + (reverseModuleNumber * 8u)];
3497  PEC_Check[3] = pTxBuff[7u + (reverseModuleNumber * 8u)];
3498  PEC_Check[4] = pTxBuff[8u + (reverseModuleNumber * 8u)];
3499  PEC_Check[5] = pTxBuff[9u + (reverseModuleNumber * 8u)];
3500 
3501  PEC_result = LTC_CalculatePec15(LTC_DATA_SIZE_IN_BYTES, PEC_Check);
3502  pTxBuff[10u + (reverseModuleNumber * 8u)] = (PEC_result >> 8u) & 0xFFu;
3503  pTxBuff[11u + (reverseModuleNumber * 8u)] = PEC_result & 0xFFu;
3504  }
3505  retVal = LTC_TRANSMIT_RECEIVE_DATA(pSpiInterface, pTxBuff, pRxBuff, frameLength);
3506  } else if (registerSet == 1u) { /* cells 13 to 15/18 WRCFG2 */
3507  pTxBuff[0] = ltc_cmdWRCFG2[0];
3508  pTxBuff[1] = ltc_cmdWRCFG2[1];
3509  pTxBuff[2] = ltc_cmdWRCFG2[2];
3510  pTxBuff[3] = ltc_cmdWRCFG2[3];
3511  for (uint16_t j = 0; j < BS_NR_OF_MODULES_PER_STRING; j++) {
3512  /* The daisy-chain works like a shift register, so the order has to be reversed:
3513  when addressing e.g. the first module in the daisy-chain, the data will be sent last on the SPI bus and
3514  when addressing e.g. the last module in the daisy-chain, the data will be sent first on the SPI bus */
3515  const uint16_t reverseModuleNumber = BS_NR_OF_MODULES_PER_STRING - j - 1u;
3516 
3517  /* 0x0F = disable pull-downs on GPIO6-9 */
3518  pTxBuff[4u + (reverseModuleNumber * 8u)] = 0x0F;
3519  pTxBuff[5u + (reverseModuleNumber * 8u)] = 0x00;
3520  pTxBuff[6u + (reverseModuleNumber * 8u)] = 0x00;
3521  pTxBuff[7u + (reverseModuleNumber * 8u)] = 0x00;
3522  pTxBuff[8u + (reverseModuleNumber * 8u)] = 0x00;
3523  pTxBuff[9u + (reverseModuleNumber * 8u)] = 0x00;
3524 
3525  if (ltc_state->ltcData.balancingControl
3526  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 12u] == 1u) {
3527  pTxBuff[4u + (reverseModuleNumber * 8u)] |= 0x10u;
3528  }
3529  if (ltc_state->ltcData.balancingControl
3530  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 13u] == 1u) {
3531  pTxBuff[4u + (reverseModuleNumber * 8u)] |= 0x20u;
3532  }
3533  if (ltc_state->ltcData.balancingControl
3534  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 14u] == 1u) {
3535  pTxBuff[4u + (reverseModuleNumber * 8u)] |= 0x40u;
3536  }
3537  if (BS_NR_OF_CELL_BLOCKS_PER_MODULE > 15u) {
3538  if (ltc_state->ltcData.balancingControl
3539  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 15u] == 1u) {
3540  pTxBuff[4u + (reverseModuleNumber * 8u)] |= 0x80u;
3541  }
3542  if (ltc_state->ltcData.balancingControl
3543  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 16u] == 1u) {
3544  pTxBuff[5u + (reverseModuleNumber * 8u)] |= 0x01u;
3545  }
3546  if (ltc_state->ltcData.balancingControl
3547  ->balancingState[stringNumber][(j * (BS_NR_OF_CELL_BLOCKS_PER_MODULE)) + 17u] == 1u) {
3548  pTxBuff[5u + (reverseModuleNumber * 8u)] |= 0x02u;
3549  }
3550  }
3551 
3552  PEC_Check[0] = pTxBuff[4u + (reverseModuleNumber * 8u)];
3553  PEC_Check[1] = pTxBuff[5u + (reverseModuleNumber * 8u)];
3554  PEC_Check[2] = pTxBuff[6u + (reverseModuleNumber * 8u)];
3555  PEC_Check[3] = pTxBuff[7u + (reverseModuleNumber * 8u)];
3556  PEC_Check[4] = pTxBuff[8u + (reverseModuleNumber * 8u)];
3557  PEC_Check[5] = pTxBuff[9u + (reverseModuleNumber * 8u)];
3558 
3559  PEC_result = LTC_CalculatePec15(LTC_DATA_SIZE_IN_BYTES, PEC_Check);
3560  pTxBuff[10u + (reverseModuleNumber * 8u)] = (PEC_result >> 8u) & 0xFFu;
3561  pTxBuff[11u + (reverseModuleNumber * 8u)] = PEC_result & 0xFFu;
3562  }
3563  retVal = LTC_TRANSMIT_RECEIVE_DATA(pSpiInterface, pTxBuff, pRxBuff, frameLength);
3564  } else {
3565  retVal = STD_NOT_OK;
3566  }
3567  return retVal;
3568 }
3569 
3570 /**
3571  * @brief resets the error table.
3572  *
3573  * This function should be called during initialization or before starting a new measurement cycle
3574  *
3575  * @param ltc_state: state of the ltc state machine
3576  *
3577  */
3578 static void LTC_ResetErrorTable(LTC_STATE_s *ltc_state) {
3579  FAS_ASSERT(ltc_state != NULL_PTR);
3580  for (uint8_t s = 0u; s < BS_NR_OF_STRINGS; s++) {
3581  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
3582  ltc_state->ltcData.errorTable->PEC_valid[s][i] = false;
3583  ltc_state->ltcData.errorTable->mux0[s][i] = 0;
3584  ltc_state->ltcData.errorTable->mux1[s][i] = 0;
3585  ltc_state->ltcData.errorTable->mux2[s][i] = 0;
3586  ltc_state->ltcData.errorTable->mux3[s][i] = 0;
3587  }
3588  }
3589 }
3590 
3591 /**
3592  * @brief brief missing
3593  * @details Gets the measurement time needed by the LTC analog front-end,
3594  * depending on the measurement mode and the number of channels.
3595  * For all cell voltages or all 5 GPIOS, the measurement time is the
3596  * same.
3597  * For 2 cell voltages or 1 GPIO, the measurement time is the same.
3598  * As a consequence, this function is used for cell voltage and for
3599  * GPIO measurement.
3600  * @param adcMode LTC ADCmeasurement mode (fast, normal or filtered)
3601  * @param adcMeasCh number of channels measured for GPIOS (one at a time
3602  * for multiplexers or all five GPIOs) or number of cell
3603  * voltage measured (2 cells or all cells)
3604  * @return measurement time in ms
3605  */
3606 static uint16_t LTC_GetMeasurementTimeCycle(LTC_ADCMODE_e adcMode, LTC_ADCMEAS_CHAN_e adcMeasCh) {
3607  uint16_t retVal = LTC_ADCMEAS_UNDEFINED; /* default */
3608 
3609  if (adcMeasCh == LTC_ADCMEAS_ALLCHANNEL_CELLS) {
3610  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3611  retVal = LTC_STATEMACH_MEAS_ALL_CELLS_FAST_TCYCLE;
3612  } else if ((adcMode == LTC_ADCMODE_NORMAL_DCP0) || (adcMode == LTC_ADCMODE_NORMAL_DCP1)) {
3613  retVal = LTC_STATEMACH_MEAS_ALL_CELLS_NORMAL_TCYCLE;
3614  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3615  retVal = LTC_STATEMACH_MEAS_ALL_CELLS_FILTERED_TCYCLE;
3616  }
3617  } else if (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_TWOCELLS) {
3618  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3619  retVal = LTC_STATEMACH_MEAS_TWO_CELLS_FAST_TCYCLE;
3620  } else if ((adcMode == LTC_ADCMODE_NORMAL_DCP0) || (adcMode == LTC_ADCMODE_NORMAL_DCP1)) {
3621  retVal = LTC_STATEMACH_MEAS_TWO_CELLS_NORMAL_TCYCLE;
3622  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3623  retVal = LTC_STATEMACH_MEAS_TWO_CELLS_FILTERED_TCYCLE;
3624  }
3625  } else if (adcMeasCh == LTC_ADCMEAS_ALLCHANNEL_GPIOS) {
3626  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3627  retVal = LTC_STATEMACH_MEAS_ALL_GPIOS_FAST_TCYCLE;
3628  } else if ((adcMode == LTC_ADCMODE_NORMAL_DCP0) || (adcMode == LTC_ADCMODE_NORMAL_DCP1)) {
3629  retVal = LTC_STATEMACH_MEAS_ALL_GPIOS_NORMAL_TCYCLE;
3630  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3631  retVal = LTC_STATEMACH_MEAS_ALL_GPIOS_FILTERED_TCYCLE;
3632  }
3633  } else if (
3634  (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO1) || (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO2) ||
3635  (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO3) || (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO4) ||
3636  (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO5)) {
3637  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3638  retVal = LTC_STATEMACH_MEAS_SINGLE_GPIO_FAST_TCYCLE;
3639  } else if ((adcMode == LTC_ADCMODE_NORMAL_DCP0) || (adcMode == LTC_ADCMODE_NORMAL_DCP1)) {
3640  retVal = LTC_STATEMACH_MEAS_SINGLE_GPIO_NORMAL_TCYCLE;
3641  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3642  retVal = LTC_STATEMACH_MEAS_SINGLE_GPIO_FILTERED_TCYCLE;
3643  }
3644  } else {
3645  retVal = LTC_ADCMEAS_UNDEFINED;
3646  }
3647 
3648  return retVal;
3649 }
3650 
3651 /**
3652  * @brief tells the LTC daisy-chain to start measuring the voltage on all cells.
3653  *
3654  * This function sends an instruction to the daisy-chain via SPI, in order to start voltage measurement for all cells.
3655  *
3656  * @param pSpiInterface pointer to SPI configuration
3657  * @param adcMode LTC ADCmeasurement mode (fast, normal or filtered)
3658  * @param adcMeasCh number of cell voltage measured (2 cells or all cells)
3659  *
3660  * @return retVal #STD_OK if dummy byte was sent correctly by SPI, #STD_NOT_OK otherwise
3661  *
3662  */
3663 static STD_RETURN_TYPE_e LTC_StartVoltageMeasurement(
3664  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3665  LTC_ADCMODE_e adcMode,
3666  LTC_ADCMEAS_CHAN_e adcMeasCh) {
3667  FAS_ASSERT(pSpiInterface != NULL_PTR);
3668  STD_RETURN_TYPE_e retVal = STD_OK;
3669 
3670  if (adcMeasCh == LTC_ADCMEAS_ALLCHANNEL_CELLS) {
3671  if (adcMode == LTC_ADCMODE_FAST_DCP0) {
3672  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_fast_DCP0);
3673  } else if (adcMode == LTC_ADCMODE_NORMAL_DCP0) {
3674  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_normal_DCP0);
3675  } else if (adcMode == LTC_ADCMODE_FILTERED_DCP0) {
3676  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_filtered_DCP0);
3677  } else if (adcMode == LTC_ADCMODE_FAST_DCP1) {
3678  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_fast_DCP1);
3679  } else if (adcMode == LTC_ADCMODE_NORMAL_DCP1) {
3680  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_normal_DCP1);
3681  } else if (adcMode == LTC_ADCMODE_FILTERED_DCP1) {
3682  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_filtered_DCP1);
3683  } else {
3684  retVal = STD_NOT_OK;
3685  }
3686  } else if (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_TWOCELLS) {
3687  if (adcMode == LTC_ADCMODE_FAST_DCP0) {
3688  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADCV_fast_DCP0_twocells);
3689  } else {
3690  retVal = STD_NOT_OK;
3691  }
3692  } else {
3693  retVal = STD_NOT_OK;
3694  }
3695  return retVal;
3696 }
3697 
3698 /**
3699  * @brief tells LTC daisy-chain to start measuring the voltage on GPIOS.
3700  * @details This function sends an instruction to the daisy-chain via SPI to
3701  * start the measurement.
3702  *
3703  * @param pSpiInterface pointer to SPI configuration
3704  * @param adcMode LTC ADCmeasurement mode (fast, normal or filtered)
3705  * @param adcMeasCh number of channels measured for GPIOS (one at a
3706  * time, typically when multiplexers are used, or all
3707  * five GPIOs)
3708  *
3709  * @return #STD_OK if dummy byte was sent correctly by SPI, #STD_NOT_OK
3710  * otherwise
3711  */
3712 static STD_RETURN_TYPE_e LTC_StartGpioMeasurement(
3713  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3714  LTC_ADCMODE_e adcMode,
3715  LTC_ADCMEAS_CHAN_e adcMeasCh) {
3716  FAS_ASSERT(pSpiInterface != NULL_PTR);
3717  STD_RETURN_TYPE_e retVal;
3718 
3719  if (adcMeasCh == LTC_ADCMEAS_ALLCHANNEL_GPIOS) {
3720  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3721  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_fast_ALLGPIOS);
3722  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3723  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_filtered_ALLGPIOS);
3724  } else {
3725  /*if (adcMode == LTC_ADCMODE_NORMAL_DCP0 || adcMode == LTC_ADCMODE_NORMAL_DCP1)*/
3726  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_normal_ALLGPIOS);
3727  }
3728  } else if (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO1) {
3729  /* Single Channel */
3730  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3731  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_fast_GPIO1);
3732  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3733  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_filtered_GPIO1);
3734  } else {
3735  /*if (adcMode == LTC_ADCMODE_NORMAL_DCP0 || adcMode == LTC_ADCMODE_NORMAL_DCP1)*/
3736 
3737  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_normal_GPIO1);
3738  }
3739  } else if (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO2) {
3740  /* Single Channel */
3741  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3742  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_fast_GPIO2);
3743  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3744  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_filtered_GPIO2);
3745  } else {
3746  /*if (adcMode == LTC_ADCMODE_NORMAL_DCP0 || adcMode == LTC_ADCMODE_NORMAL_DCP1)*/
3747 
3748  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_normal_GPIO2);
3749  }
3750  } else if (adcMeasCh == LTC_ADCMEAS_SINGLECHANNEL_GPIO3) {
3751  /* Single Channel */
3752  if ((adcMode == LTC_ADCMODE_FAST_DCP0) || (adcMode == LTC_ADCMODE_FAST_DCP1)) {
3753  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_fast_GPIO3);
3754  } else if ((adcMode == LTC_ADCMODE_FILTERED_DCP0) || (adcMode == LTC_ADCMODE_FILTERED_DCP1)) {
3755  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_filtered_GPIO3);
3756  } else {
3757  /*if (adcMode == LTC_ADCMODE_NORMAL_DCP0 || adcMode == LTC_ADCMODE_NORMAL_DCP1)*/
3758 
3759  retVal = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_cmdADAX_normal_GPIO3);
3760  }
3761  } else {
3762  retVal = STD_NOT_OK;
3763  }
3764 
3765  return retVal;
3766 }
3767 
3768 /**
3769  * @brief tells LTC daisy-chain to start measuring the voltage on GPIOS.
3770  *
3771  * This function sends an instruction to the daisy-chain via SPI to start the measurement.
3772  *
3773  * @param pSpiInterface pointer to SPI configuration
3774  * @param adcMode LTC ADCmeasurement mode (fast, normal or filtered)
3775  * @param PUP pull-up bit for pull-up or pull-down current (0: pull-down, 1: pull-up)
3776  *
3777  * @return retVal #STD_OK if command was sent correctly by SPI, #STD_NOT_OK otherwise
3778  *
3779  */
3780 static STD_RETURN_TYPE_e LTC_StartOpenWireMeasurement(
3781  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3782  LTC_ADCMODE_e adcMode,
3783  uint8_t PUP) {
3784  FAS_ASSERT(pSpiInterface != NULL_PTR);
3785  STD_RETURN_TYPE_e retval = STD_NOT_OK;
3786  if (PUP == 0u) {
3787  /* pull-down current */
3788  if (adcMode == LTC_ADCMODE_NORMAL_DCP0) {
3789  retval = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_BC_cmdADOW_PDOWN_normal_DCP0);
3790  } else if (adcMode == LTC_ADCMODE_FILTERED_DCP0) {
3791  retval = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_BC_cmdADOW_PDOWN_filtered_DCP0);
3792  } else {
3793  retval = STD_NOT_OK;
3794  }
3795  } else if (PUP == 1u) {
3796  /* pull-up current */
3797  if (adcMode == LTC_ADCMODE_NORMAL_DCP0) {
3798  retval = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_BC_cmdADOW_PUP_normal_DCP0);
3799  } else if (adcMode == LTC_ADCMODE_FILTERED_DCP0) {
3800  retval = LTC_TRANSMIT_COMMAND(pSpiInterface, ltc_BC_cmdADOW_PUP_filtered_DCP0);
3801  } else {
3802  retval = STD_NOT_OK;
3803  }
3804  }
3805  return retval;
3806 }
3807 
3808 /**
3809  * @brief checks if the data received from the daisy-chain is not corrupt.
3810  *
3811  * This function computes the PEC (CRC) from the data received by the daisy-chain.
3812  * It compares it with the PEC sent by the LTCs.
3813  * If there are errors, the array LTC_ErrorTable is updated to locate the LTCs in daisy-chain
3814  * that transmitted corrupt data.
3815  *
3816  * @param ltc_state state of the ltc state machine
3817  * @param DataBufferSPI_RX_with_PEC data obtained from the SPI transmission
3818  * @param stringNumber string addressed
3819  *
3820  * @return retVal STD_OK if PEC check is OK, STD_NOT_OK otherwise
3821  *
3822  */
3823 static STD_RETURN_TYPE_e LTC_CheckPec(
3824  LTC_STATE_s *ltc_state,
3825  uint16_t *DataBufferSPI_RX_with_PEC,
3826  uint8_t stringNumber) {
3827  FAS_ASSERT(ltc_state != NULL_PTR);
3828  FAS_ASSERT(DataBufferSPI_RX_with_PEC != NULL_PTR);
3829  STD_RETURN_TYPE_e retVal = STD_OK;
3830  uint8_t PEC_TX[2];
3831  uint16_t PEC_result = 0;
3832  uint8_t PEC_Check[LTC_DATA_SIZE_IN_BYTES] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
3833 
3834  /* check all PECs and put data without command and PEC in DataBufferSPI_RX (easier to use) */
3835  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
3836  PEC_Check[0] = DataBufferSPI_RX_with_PEC[4u + (i * 8u)];
3837  PEC_Check[1] = DataBufferSPI_RX_with_PEC[5u + (i * 8u)];
3838  PEC_Check[2] = DataBufferSPI_RX_with_PEC[6u + (i * 8u)];
3839  PEC_Check[3] = DataBufferSPI_RX_with_PEC[7u + (i * 8u)];
3840  PEC_Check[4] = DataBufferSPI_RX_with_PEC[8u + (i * 8u)];
3841  PEC_Check[5] = DataBufferSPI_RX_with_PEC[9u + (i * 8u)];
3842 
3843  PEC_result = LTC_CalculatePec15(LTC_DATA_SIZE_IN_BYTES, PEC_Check);
3844  PEC_TX[0] = (uint8_t)((PEC_result >> 8u) & 0xFFu);
3845  PEC_TX[1] = (uint8_t)(PEC_result & 0xFFu);
3846 
3847  /* if calculated PEC not equal to received PEC */
3848  if ((PEC_TX[0] != DataBufferSPI_RX_with_PEC[10u + (i * 8u)]) ||
3849  (PEC_TX[1] != DataBufferSPI_RX_with_PEC[11u + (i * 8u)])) {
3850  /* update error table of the corresponding LTC only if PEC check is activated */
3851  if (LTC_DISCARD_PEC == false) {
3852  ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] = false;
3853  retVal = STD_NOT_OK;
3854  } else {
3855  ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] = true;
3856  }
3857  } else {
3858  /* update error table of the corresponding LTC */
3859  ltc_state->ltcData.errorTable->PEC_valid[stringNumber][i] = true;
3860  }
3861  }
3862  return retVal;
3863 }
3864 
3865 /**
3866  * @brief send command to the LTC daisy-chain and receives data from the LTC
3867  * daisy-chain.
3868  * @details This is the core function to receive data from the LTC6813-1
3869  * daisy-chain.
3870  * A 2 byte command is sent with the corresponding PEC.
3871  * *Example*: read configuration register (RDCFG).
3872  * Only command has to be set, the function calculates the PEC
3873  * automatically.
3874  * - The data sent is:
3875  * - 2 bytes (COMMAND) 2 bytes (PEC)
3876  * - The data received is:
3877  * - 6 bytes (LTC1) 2 bytes (PEC) +
3878  * - 6 bytes (LTC2) 2 bytes (PEC) +
3879  * - 6 bytes (LTC3) 2 bytes (PEC) +
3880  * - ... +
3881  * - 6 bytes (LTC{LTC_N_LTC}) 2 bytes (PEC)
3882  *
3883  * The function does not check the PECs. This has to be done
3884  * elsewhere.
3885  *
3886  * @param Command command sent to the daisy-chain
3887  * @param pSpiInterface pointer to SPI configuration
3888  * @param pTxBuff transmit buffer
3889  * @param pRxBuff receive buffer
3890  * @param frameLength number of words to transmit
3891  *
3892  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
3893  */
3894 static STD_RETURN_TYPE_e LTC_ReadRegister(
3895  uint16_t *Command,
3896  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3897  uint16_t *pTxBuff,
3898  uint16_t *pRxBuff,
3899  uint32_t frameLength) {
3900  FAS_ASSERT(Command != NULL_PTR);
3901  FAS_ASSERT(pSpiInterface != NULL_PTR);
3902  FAS_ASSERT(pTxBuff != NULL_PTR);
3903  FAS_ASSERT(pRxBuff != NULL_PTR);
3904  STD_RETURN_TYPE_e retVal = STD_NOT_OK;
3905 
3906  /* DataBufferSPI_RX_with_PEC contains the data to receive.
3907  The transmission function checks the PECs.
3908  It constructs DataBufferSPI_RX, which contains the received data without PEC (easier to use). */
3909 
3910  for (uint16_t i = 0; i < LTC_N_BYTES_FOR_DATA_TRANSMISSION; i++) {
3911  pTxBuff[i] = 0x00;
3912  }
3913 
3914  pTxBuff[0] = Command[0];
3915  pTxBuff[1] = Command[1];
3916  pTxBuff[2] = Command[2];
3917  pTxBuff[3] = Command[3];
3918 
3919  retVal = LTC_TRANSMIT_RECEIVE_DATA(pSpiInterface, pTxBuff, pRxBuff, frameLength);
3920 
3921  return retVal;
3922 }
3923 
3924 /**
3925  * @brief sends command and data to the LTC daisy-chain.
3926  * @details This is the core function to transmit data to the LTC6813-1
3927  * daisy-chain.
3928  * The data sent is:
3929  * - COMMAND +
3930  * - 6 bytes (LTC1) +
3931  * - 6 bytes (LTC2) +
3932  * - 6 bytes (LTC3) +
3933  * - ... +
3934  * - 6 bytes (LTC{LTC_N_LTC})
3935  *
3936  * A 2 byte command is sent with the corresponding PEC.
3937  * *Example*: write configuration register (WRCFG).
3938  * The command has to be set and then the function calculates the PEC
3939  * automatically.
3940  * The function calculates the needed PEC to send the data to the
3941  * daisy-chain.
3942  * The sent data has the format:
3943  * - 2 byte-COMMAND (2 bytes PEC) +
3944  * - 6 bytes (LTC1) (2 bytes PEC) +
3945  * - 6 bytes (LTC2) (2 bytes PEC) +
3946  * - 6 bytes (LTC3) (2 bytes PEC) +
3947  * - ... +
3948  * - 6 bytes (LTC{LTC_N_LTC}) (2 bytes PEC)
3949  *
3950  * The function returns 0. The only way to check if the transmission
3951  * was successful is to read the results of the write operation.
3952  * (example: read configuration register after writing to it)
3953  *
3954  * @param Command command sent to the daisy-chain
3955  * @param pSpiInterface pointer to SPI configuration
3956  * @param pTxBuff transmit buffer
3957  * @param pRxBuff receive buffer
3958  * @param frameLength number of words to transmit
3959  *
3960  * @return STD_OK if SPI transmission is OK, STD_NOT_OK otherwise
3961  */
3962 static STD_RETURN_TYPE_e LTC_WriteRegister(
3963  uint16_t *Command,
3964  SPI_INTERFACE_CONFIG_s *pSpiInterface,
3965  uint16_t *pTxBuff,
3966  uint16_t *pRxBuff,
3967  uint32_t frameLength) {
3968  FAS_ASSERT(Command != NULL_PTR);
3969  FAS_ASSERT(pSpiInterface != NULL_PTR);
3970  FAS_ASSERT(pTxBuff != NULL_PTR);
3971  FAS_ASSERT(pRxBuff != NULL_PTR);
3972  STD_RETURN_TYPE_e retVal = STD_NOT_OK;
3973 
3974  uint16_t PEC_result = 0;
3975  uint8_t PEC_Check[LTC_DATA_SIZE_IN_BYTES] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
3976 
3977  pTxBuff[0] = Command[0];
3978  pTxBuff[1] = Command[1];
3979  pTxBuff[2] = Command[2];
3980  pTxBuff[3] = Command[3];
3981 
3982  /* Calculate PEC of all data (1 PEC value for 6 bytes) */
3983  for (uint16_t i = 0u; i < LTC_N_LTC; i++) {
3984  PEC_Check[0] = pTxBuff[4u + (i * 8u)];
3985  PEC_Check[1] = pTxBuff[5u + (i * 8u)];
3986  PEC_Check[2] = pTxBuff[6u + (i * 8u)];
3987  PEC_Check[3] = pTxBuff[7u + (i * 8u)];
3988  PEC_Check[4] = pTxBuff[8u + (i * 8u)];
3989  PEC_Check[5] = pTxBuff[9u + (i * 8u)];
3990 
3991  PEC_result = LTC_CalculatePec15(LTC_DATA_SIZE_IN_BYTES, PEC_Check);
3992  pTxBuff[10u + (i * 8u)] = (PEC_result >> 8u) & 0xFFu;
3993  pTxBuff[11u + (i * 8u)] = PEC_result & 0xFFu;
3994  }
3995 
3996  retVal = LTC_TRANSMIT_RECEIVE_DATA(pSpiInterface, pTxBuff, pRxBuff, frameLength);
3997 
3998  return retVal;
3999 }
4000 
4001 /**
4002  * @brief configures the data that will be sent to the LTC daisy-chain to configure multiplexer channels.
4003  *
4004  * This function does not sent the data to the multiplexer daisy-chain. This is done
4005  * by the function LTC_SetMuxChannel(), which calls LTC_SetMuxChCommand()..
4006  *
4007  * @param pTxBuff transmit buffer
4008  * @param mux multiplexer ID to be configured (0,1,2 or 3)
4009  * @param channel multiplexer channel to be configured (0 to 7)
4010  *
4011  */
4012 static void LTC_SetMuxChCommand(uint16_t *pTxBuff, uint8_t mux, uint8_t channel) {
4013  FAS_ASSERT(pTxBuff != NULL_PTR);
4014  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4015 #if SLAVE_BOARD_VERSION == 2u
4016 
4017  /* using ADG728 */
4018  uint8_t address = 0x98u | ((mux % 4u) << 1u);
4019  uint8_t data = 1u << (channel % 8u);
4020  if (channel == 0xFFu) { /* no channel selected, output of multiplexer is high impedance */
4021  data = 0x00;
4022  }
4023 
4024 #else
4025 
4026  /* using LTC1380 */
4027  uint8_t address = 0x90u | ((mux % 4u) << 1u);
4028  uint8_t data = 0x08u | (channel % 8u);
4029  if (channel == 0xFFu) { /* no channel selected, output of multiplexer is high impedance */
4030  data = 0x00;
4031  }
4032 
4033 #endif
4034 
4035  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | ((address >> 4u) & 0x0Fu); /* 0x6 : LTC6804: ICOM START from Master */
4036  pTxBuff[5u + (i * 8u)] = LTC_FCOM_MASTER_NACK | ((address << 4u) & 0xF0u);
4037  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | ((data >> 4u) & 0x0Fu);
4038  pTxBuff[7u + (i * 8u)] = LTC_FCOM_MASTER_NACK_STOP | ((data << 4u) & 0xF0u);
4039  pTxBuff[8u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT; /* 0x1 : ICOM-STOP */
4040  pTxBuff[9u + (i * 8u)] = 0x00; /* 0x0 : dummy (Dn) */
4041  /* 9: MASTER NACK + STOP (FCOM) */
4042  }
4043 }
4044 
4045 /**
4046  * @brief sends data to the LTC daisy-chain to read EEPROM on slaves.
4047  *
4048  * @param ltc_state state of the ltc state machine
4049  * @param pSpiInterface pointer to SPI configuration
4050  * @param pTxBuff transmit buffer
4051  * @param pRxBuff receive buffer
4052  * @param frameLength number of words to transmit
4053  * @param step first or second stage of read process (0 or 1)
4054  *
4055  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4056  */
4057 static STD_RETURN_TYPE_e LTC_SendEepromReadCommand(
4058  LTC_STATE_s *ltc_state,
4059  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4060  uint16_t *pTxBuff,
4061  uint16_t *pRxBuff,
4062  uint32_t frameLength,
4063  uint8_t step) {
4064  FAS_ASSERT(ltc_state != NULL_PTR);
4065  FAS_ASSERT(pSpiInterface != NULL_PTR);
4066  FAS_ASSERT(pTxBuff != NULL_PTR);
4067  FAS_ASSERT(pRxBuff != NULL_PTR);
4068  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4069 
4070  /* send WRCOMM to send I2C message to choose channel */
4071  LTC_SetEepromReadCommand(ltc_state, pTxBuff, step);
4072  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4073 
4074  return statusSPI;
4075 }
4076 
4077 /**
4078  * @brief configures the data that will be sent to the LTC daisy-chain to read EEPROM on slaves.
4079  *
4080  * @param ltc_state state of the ltc state machine
4081  * @param pTxBuff transmit buffer
4082  * @param step first or second stage of read process (0 or 1)
4083  *
4084  */
4085 static void LTC_SetEepromReadCommand(LTC_STATE_s *ltc_state, uint16_t *pTxBuff, uint8_t step) {
4086  FAS_ASSERT(ltc_state != NULL_PTR);
4087  FAS_ASSERT(pTxBuff != NULL_PTR);
4088  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4089 
4090  uint32_t address = ltc_state->ltcData.slaveControl->eepromReadAddressToUse;
4091 
4092  address &= 0x3FFFFu;
4093  const uint8_t address0 = address >> 16u;
4094  const uint8_t address1 = (address & 0xFFFFu) >> 8u;
4095  const uint8_t address2 = address & 0xFFu;
4096 
4097  if (step == 0u) {
4098  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4099  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | (0x0Au); /* 0x6 : LTC6804: ICOM START from Master */
4100  pTxBuff[5u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (((address0 & 0x03u) << 5u) | 0x00u);
4101  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | (address1 >> 4u);
4102  pTxBuff[7u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (address1 << 4u);
4103  pTxBuff[8u + (i * 8u)] = LTC_ICOM_BLANK | (address2 >> 4u);
4104  pTxBuff[9u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (address2 << 4u);
4105  }
4106  } else { /* step == 1 */
4107  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4108  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | (0x0Au); /* 0x6 : LTC6804: ICOM START from Master */
4109  pTxBuff[5u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (((address0 & 0x03u) << 5u) | 0x10u);
4110  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | 0x0Fu;
4111  pTxBuff[7u + (i * 8u)] = LTC_FCOM_MASTER_NACK_STOP | 0xF0u;
4112  pTxBuff[8u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT | 0x00u;
4113  pTxBuff[9u + (i * 8u)] = LTC_FCOM_MASTER_NACK_STOP | 0x00u;
4114  }
4115  }
4116 }
4117 
4118 /**
4119  * @brief saves the read values of the external EEPROMs read from the LTC daisy-chain.
4120  *
4121  * @param ltc_state state of the ltc state machine
4122  * @param pRxBuff receive buffer
4123  *
4124  */
4125 static void LTC_EepromSaveReadValue(LTC_STATE_s *ltc_state, uint16_t *pRxBuff) {
4126  FAS_ASSERT(ltc_state != NULL_PTR);
4127  FAS_ASSERT(pRxBuff != NULL_PTR);
4128  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4129 
4130  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4131  ltc_state->ltcData.slaveControl->eepromValueRead[i] = (pRxBuff[6u + (i * 8u)] << 4u) |
4132  ((pRxBuff[7u + (i * 8u)] >> 4u));
4133  }
4134 
4135  ltc_state->ltcData.slaveControl->eepromReadAddressLastUsed =
4136  ltc_state->ltcData.slaveControl->eepromReadAddressToUse;
4137  ltc_state->ltcData.slaveControl->eepromReadAddressToUse = 0xFFFFFFFF;
4138 
4139  DATA_WRITE_DATA(ltc_state->ltcData.slaveControl);
4140 }
4141 
4142 /**
4143  * @brief sends data to the LTC daisy-chain to write EEPROM on slaves.
4144  *
4145  * @param ltc_state state of the ltc state machine
4146  * @param pSpiInterface pointer to SPI configuration
4147  * @param pTxBuff transmit buffer
4148  * @param pRxBuff receive buffer
4149  * @param frameLength number of words to transmit
4150  * @param step first or second stage of read process (0 or 1)
4151  *
4152  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4153  */
4154 static STD_RETURN_TYPE_e LTC_SendEepromWriteCommand(
4155  LTC_STATE_s *ltc_state,
4156  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4157  uint16_t *pTxBuff,
4158  uint16_t *pRxBuff,
4159  uint32_t frameLength,
4160  uint8_t step) {
4161  FAS_ASSERT(ltc_state != NULL_PTR);
4162  FAS_ASSERT(pSpiInterface != NULL_PTR);
4163  FAS_ASSERT(pTxBuff != NULL_PTR);
4164  FAS_ASSERT(pRxBuff != NULL_PTR);
4165  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4166 
4167  /* send WRCOMM to send I2C message to write EEPROM */
4168  LTC_SetEepromWriteCommand(ltc_state, pTxBuff, step);
4169  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4170 
4171  return statusSPI;
4172 }
4173 
4174 /**
4175  * @brief configures the data that will be sent to the LTC daisy-chain to write EEPROM on slaves.
4176  *
4177  * @param ltc_state state of the ltc state machine
4178  * @param pTxBuff transmit buffer
4179  * @param step first or second stage of read process (0 or 1)
4180  *
4181  */
4182 static void LTC_SetEepromWriteCommand(LTC_STATE_s *ltc_state, uint16_t *pTxBuff, uint8_t step) {
4183  FAS_ASSERT(ltc_state != NULL_PTR);
4184  FAS_ASSERT(pTxBuff != NULL_PTR);
4185  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4186 
4187  uint32_t address = ltc_state->ltcData.slaveControl->eepromWriteAddressToUse;
4188 
4189  address &= 0x3FFFFu;
4190  const uint8_t address0 = address >> 16u;
4191  const uint8_t address1 = (address & 0xFFFFu) >> 8u;
4192  const uint8_t address2 = address & 0xFFu;
4193 
4194  if (step == 0u) {
4195  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4196  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | (0x0Au); /* 0x6 : LTC6804: ICOM START from Master */
4197  pTxBuff[5u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (((address0 & 0x03u) << 5u) | 0x00u);
4198  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | (address1 >> 4u);
4199  pTxBuff[7u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (address1 << 4u);
4200  pTxBuff[8u + (i * 8u)] = LTC_ICOM_BLANK | (address2 >> 4u);
4201  pTxBuff[9u + (i * 8u)] = LTC_FCOM_MASTER_NACK | (address2 << 4u);
4202  }
4203  } else { /* step == 1 */
4204  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4205  const uint8_t data = ltc_state->ltcData.slaveControl->eepromValueWrite[i];
4206 
4207  pTxBuff[4u + (i * 8u)] = LTC_ICOM_BLANK | (data >> 4u); /* 0x6 : LTC6804: ICOM START from Master */
4208  pTxBuff[5u + (i * 8u)] = LTC_FCOM_MASTER_NACK_STOP | (data << 4u);
4209  pTxBuff[6u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT | 0x00u;
4210  pTxBuff[7u + (i * 8u)] = LTC_FCOM_MASTER_NACK_STOP | 0x00u;
4211  pTxBuff[8u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT | 0x00u;
4212  pTxBuff[9u + (i * 8u)] = LTC_FCOM_MASTER_NACK_STOP | 0x00u;
4213  }
4214 
4215  ltc_state->ltcData.slaveControl->eepromWriteAddressLastUsed =
4216  ltc_state->ltcData.slaveControl->eepromWriteAddressToUse;
4217  ltc_state->ltcData.slaveControl->eepromWriteAddressToUse = 0xFFFFFFFF;
4218 
4219  DATA_WRITE_DATA(ltc_state->ltcData.slaveControl);
4220  }
4221 }
4222 
4223 /**
4224  * @brief sends data to the LTC daisy-chain to configure multiplexer channels.
4225  *
4226  * This function calls the function LTC_SetMuxChCommand() to set the data.
4227  *
4228  * @param pSpiInterface pointer to SPI configuration
4229  * @param pTxBuff transmit buffer
4230  * @param pRxBuff receive buffer
4231  * @param frameLength number of words to transmit
4232  * @param mux multiplexer ID to be configured (0,1,2 or 3)
4233  * @param channel multiplexer channel to be configured (0 to 7)
4234  *
4235  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4236  */
4237 static STD_RETURN_TYPE_e LTC_SetMuxChannel(
4238  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4239  uint16_t *pTxBuff,
4240  uint16_t *pRxBuff,
4241  uint32_t frameLength,
4242  uint8_t mux,
4243  uint8_t channel) {
4244  FAS_ASSERT(pSpiInterface != NULL_PTR);
4245  FAS_ASSERT(pTxBuff != NULL_PTR);
4246  FAS_ASSERT(pRxBuff != NULL_PTR);
4247 
4248  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4249 
4250  /* send WRCOMM to send I2C message to choose channel */
4251  LTC_SetMuxChCommand(pTxBuff, mux, channel);
4252  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4253 
4254  return statusSPI;
4255 }
4256 
4257 /**
4258  * @brief sends data to the LTC daisy-chain to communicate via I2C
4259  *
4260  * This function initiates an I2C signal sent by the LTC6804 on the slave boards
4261  *
4262  * @param pSpiInterface pointer to SPI configuration
4263  * @param pTxBuff transmit buffer
4264  * @param pRxBuff receive buffer
4265  * @param frameLength number of words to transmit
4266  * @param cmd_data command data to be sent
4267  *
4268  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4269  */
4270 static STD_RETURN_TYPE_e LTC_SendI2cCommand(
4271  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4272  uint16_t *pTxBuff,
4273  uint16_t *pRxBuff,
4274  uint32_t frameLength,
4275  uint16_t *cmd_data) {
4276  FAS_ASSERT(pSpiInterface != NULL_PTR);
4277  FAS_ASSERT(pTxBuff != NULL_PTR);
4278  FAS_ASSERT(pRxBuff != NULL_PTR);
4279  FAS_ASSERT(cmd_data != NULL_PTR);
4280  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4281 
4282  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
4283  pTxBuff[4u + (i * 6u)] = cmd_data[0];
4284  pTxBuff[5u + (i * 6u)] = cmd_data[1];
4285 
4286  pTxBuff[6u + (i * 6u)] = cmd_data[2];
4287  pTxBuff[7u + (i * 6u)] = cmd_data[3];
4288 
4289  pTxBuff[8u + (i * 6u)] = cmd_data[4];
4290  pTxBuff[9u + (i * 6u)] = cmd_data[5];
4291  }
4292 
4293  /* send WRCOMM to send I2C message */
4294  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4295 
4296  return statusSPI;
4297 }
4298 
4299 /**
4300  * @brief saves the temperature value of the external temperature sensors read from the LTC daisy-chain.
4301  *
4302  * This function saves the temperature value received from the external temperature sensors
4303  *
4304  * @param ltc_state state of the ltc state machine
4305  * @param pRxBuff receive buffer
4306  *
4307  */
4308 static void LTC_TempSensSaveTemp(LTC_STATE_s *ltc_state, uint16_t *pRxBuff) {
4309  FAS_ASSERT(ltc_state != NULL_PTR);
4310  FAS_ASSERT(pRxBuff != NULL_PTR);
4311  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4312 
4313  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4314  uint8_t temp_tmp[2];
4315  temp_tmp[0] = (pRxBuff[6u + (i * 8u)] << 4u) | ((pRxBuff[7u + (i * 8u)] >> 4u));
4316  temp_tmp[1] = (pRxBuff[8u + (i * 8u)] << 4u) | ((pRxBuff[9u + (i * 8u)] >> 4u));
4317  uint16_t val_i = (temp_tmp[0] << 8u) | (temp_tmp[1]);
4318  val_i = val_i >> 8u;
4319  ltc_state->ltcData.slaveControl->externalTemperatureSensor[i] = val_i;
4320  }
4321 
4322  DATA_WRITE_DATA(ltc_state->ltcData.slaveControl);
4323 }
4324 
4325 /**
4326  * @brief sends data to the LTC daisy-chain to control the user port expander
4327  *
4328  * This function sends a control byte to the register of the user port expander
4329  *
4330  * @param ltc_state state of the ltc state machine
4331  * @param pSpiInterface pointer to SPI configuration
4332  * @param pTxBuff transmit buffer
4333  * @param pRxBuff receive buffer
4334  * @param frameLength number of words to transmit
4335  *
4336  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4337  */
4338 static STD_RETURN_TYPE_e LTC_SetPortExpander(
4339  LTC_STATE_s *ltc_state,
4340  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4341  uint16_t *pTxBuff,
4342  uint16_t *pRxBuff,
4343  uint32_t frameLength) {
4344  FAS_ASSERT(ltc_state != NULL_PTR);
4345  FAS_ASSERT(pSpiInterface != NULL_PTR);
4346  FAS_ASSERT(pTxBuff != NULL_PTR);
4347  FAS_ASSERT(pRxBuff != NULL_PTR);
4348 
4349  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4350 
4351  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4352 
4353  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
4354  const uint8_t output_data = ltc_state->ltcData.slaveControl->ioValueOut[BS_NR_OF_MODULES_PER_STRING - 1 - i];
4355 
4356  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START |
4357  0x04u; /* 6: ICOM0 start condition, 4: upper nibble of PCA8574 address */
4358  pTxBuff[5u + (i * 8u)] =
4359  0u | LTC_FCOM_MASTER_NACK; /* 0: lower nibble of PCA8574 address + R/W bit, 8: FCOM0 master NACK */
4360 
4361  pTxBuff[6u + (i * 8u)] =
4362  LTC_ICOM_BLANK |
4363  (output_data >> 4u); /* 0: ICOM1 blank, x: upper nibble of PCA8574 data register (0 == pin low) */
4364  pTxBuff[7u + (i * 8u)] =
4365  (uint8_t)(output_data << 4u) |
4366  LTC_FCOM_MASTER_NACK_STOP; /* x: lower nibble of PCA8574 data register, 9: FCOM1 master NACK + STOP */
4367 
4368  pTxBuff[8u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT; /* 7: no transmission, F: dummy data */
4369  pTxBuff[9u + (i * 8u)] = 0; /* F: dummy data, 9: FCOM2 master NACK + STOP */
4370  }
4371 
4372  /* send WRCOMM to send I2C message */
4373  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4374 
4375  return statusSPI;
4376 }
4377 
4378 /**
4379  * @brief saves the received values of the external port expander read from the LTC daisy-chain.
4380  *
4381  * This function saves the received data byte from the external port expander
4382  *
4383  * @param ltc_state state of the ltc state machine
4384  * @param pRxBuff receive buffer
4385  *
4386  */
4387 static void LTC_PortExpanderSaveValues(LTC_STATE_s *ltc_state, uint16_t *pRxBuff) {
4388  FAS_ASSERT(ltc_state != NULL_PTR);
4389  FAS_ASSERT(pRxBuff != NULL_PTR);
4390  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4391 
4392  /* extract data */
4393  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4394  const uint8_t val_i = (pRxBuff[6u + (i * 8u)] << 4u) | ((pRxBuff[7u + (i * 8u)] >> 4u));
4395  ltc_state->ltcData.slaveControl->ioValueIn[i] = val_i;
4396  }
4397 
4398  DATA_WRITE_DATA(ltc_state->ltcData.slaveControl);
4399 }
4400 
4401 /**
4402  * @brief sends data to the LTC daisy-chain to control the user port expander from TI
4403  *
4404  * This function sends a control byte to the register of the user port expander from TI
4405  *
4406  * @param ltc_state state of the ltc state machine
4407  * @param pSpiInterface pointer to SPI configuration
4408  * @param pTxBuff transmit buffer
4409  * @param pRxBuff receive buffer
4410  * @param frameLength number of words to transmit
4411  * @param direction use port expander pin as input or output
4412  *
4413  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4414  */
4415 static STD_RETURN_TYPE_e LTC_SetPortExpanderDirectionTi(
4416  LTC_STATE_s *ltc_state,
4417  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4418  uint16_t *pTxBuff,
4419  uint16_t *pRxBuff,
4420  uint32_t frameLength,
4421  LTC_PORT_EXPANDER_TI_DIRECTION_e direction) {
4422  FAS_ASSERT(ltc_state != NULL_PTR);
4423  FAS_ASSERT(pSpiInterface != NULL_PTR);
4424  FAS_ASSERT(pTxBuff != NULL_PTR);
4425  FAS_ASSERT(pRxBuff != NULL_PTR);
4426  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4427 
4428  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4429 
4430  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
4431  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | 0x4u; /*upper nibble of TCA6408A address */
4432  pTxBuff[5u + (i * 8u)] = (uint8_t)((LTC_PORTEXPANDER_ADR_TI << 1u) << 4u) |
4433  LTC_FCOM_MASTER_NACK; /* 0: lower nibble of TCA6408A address + R/W bit */
4434 
4435  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | (LTC_PORT_EXPANDER_TI_CONFIG_REG_ADR >>
4436  4u); /* upper nibble of TCA6408A configuration register address */
4437  pTxBuff[7u + (i * 8u)] = (uint8_t)(LTC_PORT_EXPANDER_TI_CONFIG_REG_ADR << 4u) |
4438  LTC_FCOM_MASTER_NACK; /* lower nibble of TCA6408A configuration register address */
4439 
4440  pTxBuff[8u + (i * 8u)] = LTC_ICOM_BLANK |
4441  (direction >> 4u); /* upper nibble of TCA6408A configuration register data */
4442  pTxBuff[9u + (i * 8u)] = (uint8_t)(direction << 4u) |
4443  LTC_FCOM_MASTER_NACK_STOP; /* lower nibble of TCA6408A configuration register data */
4444  }
4445 
4446  /* send WRCOMM to send I2C message */
4447  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4448 
4449  return statusSPI;
4450 }
4451 
4452 /**
4453  * @brief sends data to the LTC daisy-chain to control the user port expander from TI
4454  *
4455  * This function sends a control byte to the register of the user port expander from TI
4456  *
4457  * @param ltc_state state of the ltc state machine
4458  * @param pSpiInterface pointer to SPI configuration
4459  * @param pTxBuff transmit buffer
4460  * @param pRxBuff receive buffer
4461  * @param frameLength number of words to transmit
4462  *
4463  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4464  */
4465 static STD_RETURN_TYPE_e LTC_SetPortExpanderOutputTi(
4466  LTC_STATE_s *ltc_state,
4467  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4468  uint16_t *pTxBuff,
4469  uint16_t *pRxBuff,
4470  uint32_t frameLength) {
4471  FAS_ASSERT(ltc_state != NULL_PTR);
4472  FAS_ASSERT(pSpiInterface != NULL_PTR);
4473  FAS_ASSERT(pTxBuff != NULL_PTR);
4474  FAS_ASSERT(pRxBuff != NULL_PTR);
4475  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4476 
4477  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4478 
4479  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
4480  const uint8_t output_data = ltc_state->ltcData.slaveControl->ioValueOut[BS_NR_OF_MODULES_PER_STRING - 1 - i];
4481 
4482  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | 0x4u; /* upper nibble of TCA6408A address */
4483  pTxBuff[5u + (i * 8u)] = (uint8_t)((LTC_PORTEXPANDER_ADR_TI << 1u) << 4u) |
4484  LTC_FCOM_MASTER_NACK; /* 0: lower nibble of TCA6408A address + R/W bit */
4485 
4486  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | (LTC_PORT_EXPANDER_TI_OUTPUT_REG_ADR >>
4487  4u); /* upper nibble of TCA6408A output register address */
4488  pTxBuff[7u + (i * 8u)] = (uint8_t)(LTC_PORT_EXPANDER_TI_OUTPUT_REG_ADR << 4u) |
4489  LTC_FCOM_MASTER_NACK; /* lower nibble of TCA6408A output register address */
4490 
4491  pTxBuff[8u + (i * 8u)] = LTC_ICOM_BLANK | (output_data >> 4u); /* upper nibble of TCA6408A output register */
4492  pTxBuff[9u + (i * 8u)] = (uint8_t)(output_data << 4u) |
4493  LTC_FCOM_MASTER_NACK_STOP; /* lower nibble of TCA6408A output register */
4494  }
4495 
4496  /* send WRCOMM to send I2C message */
4497  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4498 
4499  return statusSPI;
4500 }
4501 
4502 /**
4503  * @brief sends data to the LTC daisy-chain to control the user port expander from TI
4504  *
4505  * @details This function sends a control byte to the register of the user port expander from TI
4506  *
4507  * @param ltc_state state of the ltc state machine
4508  * @param pSpiInterface pointer to SPI configuration
4509  * @param pTxBuff transmit buffer
4510  * @param pRxBuff receive buffer
4511  * @param frameLength number of words to transmit
4512  * @param step first or second stage of read process (0 or 1)
4513  *
4514  * @return #STD_OK if SPI transmission is OK, #STD_NOT_OK otherwise
4515  */
4516 static STD_RETURN_TYPE_e LTC_GetPortExpanderInputTi(
4517  LTC_STATE_s *ltc_state,
4518  SPI_INTERFACE_CONFIG_s *pSpiInterface,
4519  uint16_t *pTxBuff,
4520  uint16_t *pRxBuff,
4521  uint32_t frameLength,
4522  uint8_t step) {
4523  FAS_ASSERT(ltc_state != NULL_PTR);
4524  FAS_ASSERT(pSpiInterface != NULL_PTR);
4525  FAS_ASSERT(pTxBuff != NULL_PTR);
4526  FAS_ASSERT(pRxBuff != NULL_PTR);
4527  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4528 
4529  if (step == 0u) {
4530  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
4531  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | 0x4u; /* upper nibble of TCA6408A address */
4532  pTxBuff[5u + (i * 8u)] = (uint8_t)((LTC_PORTEXPANDER_ADR_TI << 1u) << 4u) |
4533  LTC_FCOM_MASTER_NACK; /* lower nibble of TCA6408A address + R/W bit */
4534 
4535  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | (LTC_PORT_EXPANDER_TI_INPUT_REG_ADR >>
4536  4u); /* upper nibble of TCA6408A input register address */
4537  pTxBuff[7u + (i * 8u)] = (uint8_t)(LTC_PORT_EXPANDER_TI_INPUT_REG_ADR << 4u) |
4538  LTC_FCOM_MASTER_NACK; /* x: lower nibble of TCA6408A input register address */
4539 
4540  pTxBuff[8u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT; /* no transmission */
4541  pTxBuff[9u + (i * 8u)] = 0; /* dummy data */
4542  }
4543  } else {
4544  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4545 
4546  for (uint16_t i = 0; i < BS_NR_OF_MODULES_PER_STRING; i++) {
4547  pTxBuff[4u + (i * 8u)] = LTC_ICOM_START | 0x4u; /* upper nibble of TCA6408A address */
4548  pTxBuff[5u + (i * 8u)] = (uint8_t)(((LTC_PORTEXPANDER_ADR_TI << 1u) | 1u) << 4u) |
4549  LTC_FCOM_MASTER_NACK; /* lower nibble of TCA6408A address + R/W bit */
4550 
4551  pTxBuff[6u + (i * 8u)] = LTC_ICOM_BLANK | 0x0Fu; /* upper nibble slave data, master pulls bus high */
4552  pTxBuff[7u + (i * 8u)] = LTC_FCOM_MASTER_NACK | 0xF0u; /* lower nibble slave data, master pulls bus high */
4553 
4554  pTxBuff[8u + (i * 8u)] = LTC_ICOM_NO_TRANSMIT; /* no transmission */
4555  pTxBuff[9u + (i * 8u)] = 0; /* dummy data */
4556  }
4557  }
4558 
4559  /* send WRCOMM to send I2C message */
4560  statusSPI = LTC_WriteRegister(ltc_cmdWRCOMM, pSpiInterface, pTxBuff, pRxBuff, frameLength);
4561 
4562  return statusSPI;
4563 }
4564 
4565 /**
4566  * @brief saves the received values of the external port expander from TI read from the LTC daisy-chain.
4567  * @details This function saves the received data byte from the external port expander from TI
4568  * @param ltc_state state of the ltc state machine
4569  * @param pTxBuff transmit buffer
4570  */
4571 static void LTC_PortExpanderSaveValuesTi(LTC_STATE_s *ltc_state, uint16_t *pTxBuff) {
4572  FAS_ASSERT(ltc_state != NULL_PTR);
4573  FAS_ASSERT(pTxBuff != NULL_PTR);
4574  DATA_READ_DATA(ltc_state->ltcData.slaveControl);
4575 
4576  /* extract data */
4577  for (uint16_t i = 0; i < LTC_N_LTC; i++) {
4578  const uint8_t val_i = (pTxBuff[6u + (i * 8u)] << 4u) | ((pTxBuff[7u + (i * 8u)] >> 4u));
4579  ltc_state->ltcData.slaveControl->ioValueIn[i] = val_i;
4580  }
4581 
4582  DATA_WRITE_DATA(ltc_state->ltcData.slaveControl);
4583 }
4584 
4585 /**
4586  * @brief sends 72 clock pulses to the LTC daisy-chain.
4587  *
4588  * This function is used for the communication with the multiplexers via I2C on the GPIOs.
4589  * It send the command STCOMM to the LTC daisy-chain.
4590  *
4591  * @param pSpiInterface pointer to SPI configuration
4592  *
4593  * @return statusSPI #STD_OK if clock pulses were sent correctly by SPI, #STD_NOT_OK otherwise
4594  *
4595  */
4596 static STD_RETURN_TYPE_e LTC_I2cClock(SPI_INTERFACE_CONFIG_s *pSpiInterface) {
4597  FAS_ASSERT(pSpiInterface != NULL_PTR);
4598  STD_RETURN_TYPE_e statusSPI = STD_NOT_OK;
4599  uint16_t ltc_TXBufferClock[4u + 9u];
4600 
4601  for (uint16_t i = 0; i < (4u + 9u); i++) {
4602  ltc_TXBufferClock[i] = 0xFF;
4603  }
4604 
4605  ltc_TXBufferClock[0] = ltc_cmdSTCOMM[0];
4606  ltc_TXBufferClock[1] = ltc_cmdSTCOMM[1];
4607  ltc_TXBufferClock[2] = ltc_cmdSTCOMM[2];
4608  ltc_TXBufferClock[3] = ltc_cmdSTCOMM[3];
4609 
4610  statusSPI = LTC_TRANSMIT_I2C_COMMAND(pSpiInterface, ltc_TXBufferClock);
4611 
4612  return statusSPI;
4613 }
4614 
4615 /**
4616  * @brief gets the frequency of the SPI clock.
4617  *
4618  * This function reads the configuration from the SPI handle directly.
4619  *
4620  * @param pSpiInterface pointer to SPI configuration
4621  *
4622  * @return frequency of the SPI clock
4623  */
4624 static uint32_t LTC_GetSpiClock(SPI_INTERFACE_CONFIG_s *pSpiInterface) {
4625  FAS_ASSERT(pSpiInterface != NULL_PTR);
4626  uint32_t SPI_Clock = 0;
4627  uint32_t prescaler = 0;
4628 
4629  /* if (LTC_SPI_INSTANCE == SPI2 || LTC_SPI_INSTANCE == SPI3) { */
4630  /* SPI2 and SPI3 are connected to APB1 (PCLK1) */
4631  /* The prescaler setup bits LTC_SPI_PRESCALER corresponds to the bits 5:3 in the SPI_CR1 register */
4632  /* Reference manual p.909 */
4633  /* The shift by 3 puts the bits 5:3 to the first position */
4634  /* Division are made by powers of 2 which corresponds to shifting to the right */
4635  /* Then 0 corresponds to divide by 2, 1 corresponds to divide by 4... so 1 has to be added to the value of the configuration bits */
4636 
4637  /* SPI_Clock = HAL_RCC_GetPCLK1Freq()>>((LTC_SPI_PRESCALER>>3)+1);
4638  } */
4639 
4640  /* if (LTC_SPI_INSTANCE == SPI1 || LTC_SPI_INSTANCE == SPI4 || LTC_SPI_INSTANCE == SPI5 || LTC_SPI_INSTANCE == SPI6) { */
4641  /* SPI1, SPI4, SPI5 and SPI6 are connected to APB2 (PCLK2) */
4642  /* The prescaler setup bits LTC_SPI_PRESCALER corresponds to the bits 5:3 in the SPI_CR1 register */
4643  /* Reference manual p.909 */
4644  /* The shift by 3 puts the bits 5:3 to the first position */
4645  /* Division are made by powers of 2 which corresponds to shifting to the right */
4646  /* Then 0 corresponds to divide by 2, 1 corresponds to divide by 4... so 1 has to be added to the value of the configuration bits */
4647 
4648  /* SPI_Clock = HAL_RCC_GetPCLK2Freq()>>((LTC_SPI_PRESCALER>>3)+1);
4649  } */
4650 
4651  /* Get SPI prescaler */
4652  prescaler = ((pSpiInterface->pNode->FMT0) >> 8u) & 0xFFu;
4653  SPI_Clock = (uint32_t)(AVCLK1_FREQ * 1000000u) / (prescaler + 1u);
4654 
4655  return SPI_Clock;
4656 }
4657 
4658 /**
4659  * @brief sets the transfer time needed to receive/send data with the LTC daisy-chain.
4660  *
4661  * This function gets the clock frequency and uses the number of LTCs in the daisy-chain.
4662  *
4663  * @param ltc_state: state of the ltc state machine
4664  *
4665  */
4666 static void LTC_SetTransferTimes(LTC_STATE_s *ltc_state) {
4667  FAS_ASSERT(ltc_state != NULL_PTR);
4668  uint32_t transferTime_us = 0;
4669  uint32_t SPI_Clock = 0;
4670 
4671  SPI_Clock = LTC_GetSpiClock(ltc_state->ltcData.pSpiInterface);
4672 
4673  /* Transmission of a command and data */
4674  /* Multiplication by 1000*1000 to get us */
4675  transferTime_us = (8u * 1000u * 1000u) / (SPI_Clock);
4676  transferTime_us *= LTC_N_BYTES_FOR_DATA_TRANSMISSION;
4677  transferTime_us = transferTime_us + LTC_SPI_WAKEUP_WAIT_TIME_US;
4678  ltc_state->commandDataTransferTime = (transferTime_us / 1000u) + 1u;
4679 
4680  /* Transmission of a command */
4681  /* Multiplication by 1000*1000 to get us */
4682  transferTime_us = ((4u) * 8u * 1000u * 1000u) / (SPI_Clock);
4683  transferTime_us = transferTime_us + LTC_SPI_WAKEUP_WAIT_TIME_US;
4684  ltc_state->commandTransferTime = (transferTime_us / 1000u) + 1u;
4685 
4686  /* Transmission of a command + 9 clocks */
4687  /* Multiplication by 1000*1000 to get us */
4688  transferTime_us = ((4u + 9u) * 8u * 1000u * 1000u) / (SPI_Clock);
4689  transferTime_us = transferTime_us + LTC_SPI_WAKEUP_WAIT_TIME_US;
4690  ltc_state->gpioClocksTransferTime = (transferTime_us / 1000u) + 1u;
4691 }
4692 
4693 /**
4694  * @brief checks the state requests that are made.
4695  *
4696  * This function checks the validity of the state requests.
4697  * The results of the checked is returned immediately.
4698  *
4699  * @param ltc_state: state of the ltc state machine
4700  * @param statereq state request to be checked
4701  *
4702  * @return result of the state request that was made, taken from LTC_RETURN_TYPE_e
4703  */
4704 static LTC_RETURN_TYPE_e LTC_CheckStateRequest(LTC_STATE_s *ltc_state, LTC_REQUEST_s statereq) {
4705  FAS_ASSERT(ltc_state != NULL_PTR);
4706  LTC_RETURN_TYPE_e retVal = LTC_OK;
4707  if (statereq.string >= BS_NR_OF_STRINGS) {
4708  retVal = LTC_ILLEGAL_REQUEST;
4709  } else if (ltc_state->statereq.request == LTC_STATE_NO_REQUEST) {
4710  /* init only allowed from the uninitialized state */
4711  if (statereq.request == LTC_STATE_INIT_REQUEST) {
4712  if (ltc_state->state == LTC_STATEMACH_UNINITIALIZED) {
4713  retVal = LTC_OK;
4714  } else {
4715  retVal = LTC_ALREADY_INITIALIZED;
4716  }
4717  } else {
4718  retVal = LTC_OK;
4719  }
4720  } else {
4721  retVal = LTC_REQUEST_PENDING;
4722  }
4723 
4724  return retVal;
4725 }
4726 
4727 extern bool LTC_IsFirstMeasurementCycleFinished(LTC_STATE_s *ltc_state) {
4728  FAS_ASSERT(ltc_state != NULL_PTR);
4729  bool retval = false;
4730 
4731  OS_EnterTaskCritical();
4732  retval = ltc_state->first_measurement_made;
4733  OS_ExitTaskCritical();
4734 
4735  return (retval);
4736 }
4737 
4738 /**
4739  * @brief sets the measurement initialization status.
4740  */
4741 static void LTC_SetFirstMeasurementCycleFinished(LTC_STATE_s *ltc_state) {
4742  OS_EnterTaskCritical();
4743  ltc_state->first_measurement_made = true;
4744  OS_ExitTaskCritical();
4745 }
4746 
4747 extern void LTC_InitializeMonitoringPin(void) {
4748  /* Set 3rd PE pins to enable daisy chains */
4749  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN10);
4750  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN11);
4751  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN12);
4752  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN13);
4753  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN14);
4754  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN15);
4755  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN16);
4756  PEX_SetPinDirectionOutput(PEX_PORT_EXPANDER3, PEX_PIN17);
4757  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN10);
4758  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN11);
4759  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN12);
4760  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN13);
4761  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN14);
4762  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN15);
4763  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN16);
4764  PEX_SetPin(PEX_PORT_EXPANDER3, PEX_PIN17);
4765 }
4766 
4767 /*========== Externalized Static Function Implementations (Unit Test) =======*/
4768 #ifdef UNITY_UNIT_TEST
4769 uint8_t TEST_LTC_CheckReEntrance(LTC_STATE_s *ltc_state) {
4770  return LTC_CheckReEntrance(ltc_state);
4771 }
4772 
4773 extern void TEST_LTC_SetFirstMeasurementCycleFinished(LTC_STATE_s *ltc_state) {
4774  LTC_SetFirstMeasurementCycleFinished(ltc_state);
4775 }
4776 
4777 /** this define is used for creating the declaration of a function for variable extraction */
4778 #define TEST_LTC_DEFINE_GET(VARIABLE) \
4779  extern void TEST_LTC_Get_##VARIABLE(uint8_t data[4]) { \
4780  for (uint8_t i = 0u; i < 4u; i++) { \
4781  data[i] = (uint8_t)(VARIABLE)[i]; \
4782  } \
4783  }
4784 TEST_LTC_DEFINE_GET(ltc_cmdWRCFG);
4785 TEST_LTC_DEFINE_GET(ltc_cmdWRCFG2);
4786 TEST_LTC_DEFINE_GET(ltc_cmdRDCFG);
4787 TEST_LTC_DEFINE_GET(ltc_cmdRDCVA);
4788 TEST_LTC_DEFINE_GET(ltc_cmdRDCVB);
4789 TEST_LTC_DEFINE_GET(ltc_cmdRDCVC);
4790 TEST_LTC_DEFINE_GET(ltc_cmdRDCVD);
4791 TEST_LTC_DEFINE_GET(ltc_cmdRDCVE);
4792 TEST_LTC_DEFINE_GET(ltc_cmdRDCVF);
4793 TEST_LTC_DEFINE_GET(ltc_cmdWRCOMM);
4794 TEST_LTC_DEFINE_GET(ltc_cmdSTCOMM);
4795 TEST_LTC_DEFINE_GET(ltc_cmdRDCOMM);
4796 TEST_LTC_DEFINE_GET(ltc_cmdRDAUXA);
4797 TEST_LTC_DEFINE_GET(ltc_cmdRDAUXB);
4798 TEST_LTC_DEFINE_GET(ltc_cmdRDAUXC);
4799 TEST_LTC_DEFINE_GET(ltc_cmdRDAUXD);
4800 TEST_LTC_DEFINE_GET(ltc_cmdADCV_normal_DCP0);
4801 TEST_LTC_DEFINE_GET(ltc_cmdADCV_normal_DCP1);
4802 TEST_LTC_DEFINE_GET(ltc_cmdADCV_filtered_DCP0);
4803 TEST_LTC_DEFINE_GET(ltc_cmdADCV_filtered_DCP1);
4804 TEST_LTC_DEFINE_GET(ltc_cmdADCV_fast_DCP0);
4805 TEST_LTC_DEFINE_GET(ltc_cmdADCV_fast_DCP1);
4806 TEST_LTC_DEFINE_GET(ltc_cmdADCV_fast_DCP0_twocells);
4807 TEST_LTC_DEFINE_GET(ltc_cmdADAX_normal_GPIO1);
4808 TEST_LTC_DEFINE_GET(ltc_cmdADAX_filtered_GPIO1);
4809 TEST_LTC_DEFINE_GET(ltc_cmdADAX_fast_GPIO1);
4810 TEST_LTC_DEFINE_GET(ltc_cmdADAX_normal_GPIO2);
4811 TEST_LTC_DEFINE_GET(ltc_cmdADAX_filtered_GPIO2);
4812 TEST_LTC_DEFINE_GET(ltc_cmdADAX_fast_GPIO2);
4813 TEST_LTC_DEFINE_GET(ltc_cmdADAX_normal_GPIO3);
4814 TEST_LTC_DEFINE_GET(ltc_cmdADAX_filtered_GPIO3);
4815 TEST_LTC_DEFINE_GET(ltc_cmdADAX_fast_GPIO3);
4816 TEST_LTC_DEFINE_GET(ltc_cmdADAX_normal_ALLGPIOS);
4817 TEST_LTC_DEFINE_GET(ltc_cmdADAX_filtered_ALLGPIOS);
4818 TEST_LTC_DEFINE_GET(ltc_cmdADAX_fast_ALLGPIOS);
4819 TEST_LTC_DEFINE_GET(ltc_BC_cmdADOW_PUP_normal_DCP0);
4820 TEST_LTC_DEFINE_GET(ltc_BC_cmdADOW_PDOWN_normal_DCP0);
4821 TEST_LTC_DEFINE_GET(ltc_BC_cmdADOW_PUP_filtered_DCP0);
4822 TEST_LTC_DEFINE_GET(ltc_BC_cmdADOW_PDOWN_filtered_DCP0);
4823 #endif
AFE_PlausibilityCheckTempMinMax
STD_RETURN_TYPE_e AFE_PlausibilityCheckTempMinMax(const int16_t celltemperature_ddegC)
Cell temperature plausibility check.
Definition: afe_plausibility.c:89
AFE_PlausibilityCheckVoltageMeasurementRange
STD_RETURN_TYPE_e AFE_PlausibilityCheckVoltageMeasurementRange(const int16_t cellVoltage_mV, const AFE_PLAUSIBILITY_VALUES_s plausibleValues)
Cell voltage measurement range plausibility check.
Definition: afe_plausibility.c:73
afe_plausibility.h
plausibility checks for cell voltage and cell temperatures
BS_NR_OF_CELL_BLOCKS_PER_MODULE
#define BS_NR_OF_CELL_BLOCKS_PER_MODULE
number of cells per module
Definition: battery_system_cfg.h:122
BS_NR_OF_STRINGS
#define BS_NR_OF_STRINGS
Number of parallel strings in the battery pack.
Definition: battery_system_cfg.h:99
BS_NR_OF_TEMP_SENSORS_PER_MODULE
#define BS_NR_OF_TEMP_SENSORS_PER_MODULE
number of temperature sensors per battery module
Definition: battery_system_cfg.h:152
BS_NR_OF_GPIOS_PER_MODULE
#define BS_NR_OF_GPIOS_PER_MODULE
Defines the number of GPIOs.
Definition: battery_system_cfg.h:140
BS_NR_OF_CELL_BLOCKS_PER_STRING
#define BS_NR_OF_CELL_BLOCKS_PER_STRING
Definition: battery_system_cfg.h:159
BS_NR_OF_MODULES_PER_STRING
#define BS_NR_OF_MODULES_PER_STRING
number of modules in a string
Definition: battery_system_cfg.h:112
BS_NR_OF_TEMP_SENSORS_PER_STRING
#define BS_NR_OF_TEMP_SENSORS_PER_STRING
Definition: battery_system_cfg.h:161
database.h
Database module header.
DATA_READ_DATA
#define DATA_READ_DATA(...)
Definition: database.h:86
DATA_WRITE_DATA
#define DATA_WRITE_DATA(...)
Definition: database.h:96
DATA_BLOCK_ID_BALANCING_CONTROL
@ DATA_BLOCK_ID_BALANCING_CONTROL
Definition: database_cfg.h:83
DATA_BLOCK_ID_CELL_TEMPERATURE_BASE
@ DATA_BLOCK_ID_CELL_TEMPERATURE_BASE
Definition: database_cfg.h:101
DATA_BLOCK_ID_OPEN_WIRE_BASE
@ DATA_BLOCK_ID_OPEN_WIRE_BASE
Definition: database_cfg.h:87
DATA_BLOCK_ID_SLAVE_CONTROL
@ DATA_BLOCK_ID_SLAVE_CONTROL
Definition: database_cfg.h:84
DATA_BLOCK_ID_CELL_VOLTAGE_BASE
@ DATA_BLOCK_ID_CELL_VOLTAGE_BASE
Definition: database_cfg.h:100
DATA_BLOCK_ID_ALL_GPIO_VOLTAGES_BASE
@ DATA_BLOCK_ID_ALL_GPIO_VOLTAGES_BASE
Definition: database_cfg.h:88
DATA_BLOCK_ID_BALANCING_FEEDBACK_BASE
@ DATA_BLOCK_ID_BALANCING_FEEDBACK_BASE
Definition: database_cfg.h:85
DIAG_CheckEvent
STD_RETURN_TYPE_e DIAG_CheckEvent(STD_RETURN_TYPE_e cond, DIAG_ID_e diagId, DIAG_IMPACT_LEVEL_e impact, uint32_t data)
DIAG_CheckEvent provides a simple interface to check an event for STD_OK.
Definition: diag.c:374
DIAG_Handler
DIAG_RETURNTYPE_e DIAG_Handler(DIAG_ID_e diagId, DIAG_EVENT_e event, DIAG_IMPACT_LEVEL_e impact, uint32_t data)
DIAG_Handler provides generic error handling, based on diagnosis group.
Definition: diag.c:246
diag.h
Diagnosis driver header.
DIAG_EVENT_NOT_OK
@ DIAG_EVENT_NOT_OK
Definition: diag_cfg.h:266
DIAG_EVENT_OK
@ DIAG_EVENT_OK
Definition: diag_cfg.h:265
DIAG_STRING
@ DIAG_STRING
Definition: diag_cfg.h:279
DIAG_ID_e
DIAG_ID_e
Definition: diag_cfg.h:176
DIAG_ID_AFE_MUX
@ DIAG_ID_AFE_MUX
Definition: diag_cfg.h:182
DIAG_ID_AFE_CELL_VOLTAGE_MEAS_ERROR
@ DIAG_ID_AFE_CELL_VOLTAGE_MEAS_ERROR
Definition: diag_cfg.h:190
DIAG_ID_AFE_CELL_TEMPERATURE_MEAS_ERROR
@ DIAG_ID_AFE_CELL_TEMPERATURE_MEAS_ERROR
Definition: diag_cfg.h:191
DIAG_ID_AFE_COM_INTEGRITY
@ DIAG_ID_AFE_COM_INTEGRITY
Definition: diag_cfg.h:181
DIAG_ID_AFE_SPI
@ DIAG_ID_AFE_SPI
Definition: diag_cfg.h:180
FAS_ASSERT
#define FAS_ASSERT(x)
Assertion macro that asserts that x is true.
Definition: fassert.h:254
FAS_TRAP
#define FAS_TRAP
Define that evaluates to essential boolean false thus tripping an assert.
Definition: fassert.h:129
STD_RETURN_TYPE_e
STD_RETURN_TYPE_e
Definition: fstd_types.h:82
STD_NOT_OK
@ STD_NOT_OK
Definition: fstd_types.h:84
STD_OK
@ STD_OK
Definition: fstd_types.h:83
NULL_PTR
#define NULL_PTR
Null pointer.
Definition: fstd_types.h:77
io.h
Header for the driver for the IO module.
ltc.h
Headers for the driver for the LTC analog front-end.
ltc_voltage_input_used
const uint8_t ltc_voltage_input_used[LTC_6806_MAX_SUPPORTED_CELLS]
Definition: ltc_6806_cfg.c:66
ltc_muxsensortemperatur_cfg
const uint8_t ltc_muxsensortemperatur_cfg[BS_NR_OF_TEMP_SENSORS_PER_MODULE]
Definition: ltc_6813-1_cfg.c:186
LTC_STATEMACH_DAISY_CHAIN_FIRST_INITIALIZATION_TIME
#define LTC_STATEMACH_DAISY_CHAIN_FIRST_INITIALIZATION_TIME
Definition: ltc_6806_cfg.h:188
LTC_TRANSMISSION_TIMEOUT
#define LTC_TRANSMISSION_TIMEOUT
Definition: ltc_6806_cfg.h:157
LTC_TRANSMIT_COMMAND
#define LTC_TRANSMIT_COMMAND(spi_ltcInterface, command)
Definition: ltc_6806_cfg.h:283
LTC_STATEMACH_SHORTTIME
#define LTC_STATEMACH_SHORTTIME
Definition: ltc_6806_cfg.h:182
LTC_DISCARD_PEC
#define LTC_DISCARD_PEC
Definition: ltc_6806_cfg.h:100
LTC_PORTEXPANDER_ADR_TI
#define LTC_PORTEXPANDER_ADR_TI
Definition: ltc_6806_cfg.h:97
LTC_NUMBER_OF_LTC_PER_MODULE
#define LTC_NUMBER_OF_LTC_PER_MODULE
Definition: ltc_6806_cfg.h:115
LTC_TRANSMIT_I2C_COMMAND
#define LTC_TRANSMIT_I2C_COMMAND(spi_ltcInterface, txbuf)
Definition: ltc_6806_cfg.h:280
LTC_VOLTAGE_MEASUREMENT_MODE
#define LTC_VOLTAGE_MEASUREMENT_MODE
Definition: ltc_6806_cfg.h:136
LTC_ADOW_THRESHOLD
#define LTC_ADOW_THRESHOLD
Definition: ltc_6806_cfg.h:128
LTC_ConvertMuxVoltagesToTemperatures
int16_t LTC_ConvertMuxVoltagesToTemperatures(uint16_t adcVoltage_mV)
converts a raw voltage from multiplexer to a temperature value in deci °C.
Definition: ltc_6813-1_cfg.c:232
LTC_SPI_WAKEUP_WAIT_TIME_US
#define LTC_SPI_WAKEUP_WAIT_TIME_US
Definition: ltc_6806_cfg.h:176
LTC_GPIO_MEASUREMENT_MODE
#define LTC_GPIO_MEASUREMENT_MODE
Definition: ltc_6806_cfg.h:144
LTC_TRANSMIT_WAKE_UP
#define LTC_TRANSMIT_WAKE_UP(spi_ltcInterface)
Definition: ltc_6806_cfg.h:279
LTC_NMBR_REQ_ADOW_COMMANDS
#define LTC_NMBR_REQ_ADOW_COMMANDS
Definition: ltc_6806_cfg.h:273
LTC_OW_MEASUREMENT_MODE
#define LTC_OW_MEASUREMENT_MODE
Definition: ltc_6806_cfg.h:151
LTC_TRANSMIT_RECEIVE_DATA
#define LTC_TRANSMIT_RECEIVE_DATA(spi_ltcInterface, txbuf, rxbuf, length)
Definition: ltc_6806_cfg.h:286
LTC_STATEMACH_DAISY_CHAIN_SECOND_INITIALIZATION_TIME
#define LTC_STATEMACH_DAISY_CHAIN_SECOND_INITIALIZATION_TIME
Definition: ltc_6806_cfg.h:193
LTC_PORT_EXPANDER_TI_OUTPUT_REG_ADR
#define LTC_PORT_EXPANDER_TI_OUTPUT_REG_ADR
Definition: ltc_6813-1.c:82
ltc_cmdADAX_fast_GPIO3
static uint16_t ltc_cmdADAX_fast_GPIO3[4]
Definition: ltc_6813-1.c:254
ltc_TxPecBuffer
uint16_t ltc_TxPecBuffer[LTC_N_BYTES_FOR_DATA_TRANSMISSION]
Definition: ltc_6813-1.c:110
ltc_cmdRDCVC
static uint16_t ltc_cmdRDCVC[4]
Definition: ltc_6813-1.c:198
LTC_StartVoltageMeasurement
static STD_RETURN_TYPE_e LTC_StartVoltageMeasurement(SPI_INTERFACE_CONFIG_s *pSpiInterface, LTC_ADCMODE_e adcMode, LTC_ADCMEAS_CHAN_e adcMeasCh)
tells the LTC daisy-chain to start measuring the voltage on all cells.
Definition: ltc_6813-1.c:3663
ltc_cmdRDAUXB
static uint16_t ltc_cmdRDAUXB[4]
Definition: ltc_6813-1.c:206
ltc_allgpiovoltage
static DATA_BLOCK_ALL_GPIO_VOLTAGES_s ltc_allgpiovoltage
Definition: ltc_6813-1.c:125
ltc_cmdRDCVA
static uint16_t ltc_cmdRDCVA[4]
Definition: ltc_6813-1.c:196
ltc_cmdWRCOMM
static uint16_t ltc_cmdWRCOMM[4]
Definition: ltc_6813-1.c:202
LTC_SendEepromWriteCommand
static STD_RETURN_TYPE_e LTC_SendEepromWriteCommand(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, uint8_t step)
sends data to the LTC daisy-chain to write EEPROM on slaves.
Definition: ltc_6813-1.c:4154
LTC_PORT_EXPANDER_TI_INPUT_REG_ADR
#define LTC_PORT_EXPANDER_TI_INPUT_REG_ADR
Definition: ltc_6813-1.c:81
ltc_openWire
static DATA_BLOCK_OPEN_WIRE_s ltc_openWire
Definition: ltc_6813-1.c:126
LTC_I2cCheckAck
static STD_RETURN_TYPE_e LTC_I2cCheckAck(LTC_STATE_s *ltc_state, uint16_t *pRxBuff, uint8_t mux, uint8_t stringNumber)
checks if the multiplexers acknowledged transmission.
Definition: ltc_6813-1.c:3286
ltc_cmdADAX_normal_GPIO1
static uint16_t ltc_cmdADAX_normal_GPIO1[4]
Definition: ltc_6813-1.c:246
LTC_SetEepromWriteCommand
static void LTC_SetEepromWriteCommand(LTC_STATE_s *ltc_state, uint16_t *pTxBuff, uint8_t step)
configures the data that will be sent to the LTC daisy-chain to write EEPROM on slaves.
Definition: ltc_6813-1.c:4182
LTC_StartOpenWireMeasurement
static STD_RETURN_TYPE_e LTC_StartOpenWireMeasurement(SPI_INTERFACE_CONFIG_s *pSpiInterface, LTC_ADCMODE_e adcMode, uint8_t PUP)
tells LTC daisy-chain to start measuring the voltage on GPIOS.
Definition: ltc_6813-1.c:3780
LTC_GetState
LTC_STATEMACH_e LTC_GetState(LTC_STATE_s *ltc_state)
gets the current state.
Definition: ltc_6813-1.c:754
LTC_ReadRegister
static STD_RETURN_TYPE_e LTC_ReadRegister(uint16_t *Command, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength)
send command to the LTC daisy-chain and receives data from the LTC daisy-chain.
Definition: ltc_6813-1.c:3894
LTC_IsFirstMeasurementCycleFinished
bool LTC_IsFirstMeasurementCycleFinished(LTC_STATE_s *ltc_state)
gets the measurement initialization status.
Definition: ltc_6813-1.c:4727
LTC_SetMuxChannel
static STD_RETURN_TYPE_e LTC_SetMuxChannel(SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, uint8_t mux, uint8_t channel)
sends data to the LTC daisy-chain to configure multiplexer channels.
Definition: ltc_6813-1.c:4237
ltc_cmdRDAUXA
static uint16_t ltc_cmdRDAUXA[4]
Definition: ltc_6813-1.c:205
ltc_cmdRDCVB
static uint16_t ltc_cmdRDCVB[4]
Definition: ltc_6813-1.c:197
LTC_EepromSaveReadValue
static void LTC_EepromSaveReadValue(LTC_STATE_s *ltc_state, uint16_t *pRxBuff)
saves the read values of the external EEPROMs read from the LTC daisy-chain.
Definition: ltc_6813-1.c:4125
LTC_SaveRxToGpioBuffer
static void LTC_SaveRxToGpioBuffer(LTC_STATE_s *ltc_state, uint16_t *pRxBuff, uint8_t registerSet, uint8_t stringNumber)
saves the GPIO voltage values read from the LTC daisy-chain.
Definition: ltc_6813-1.c:3141
LTC_StateTransition
static void LTC_StateTransition(LTC_STATE_s *ltc_state, LTC_STATEMACH_e state, uint8_t substate, uint16_t timer_ms)
function for setting LTC_Trigger state transitions
Definition: ltc_6813-1.c:524
ltc_cmdADCV_fast_DCP1
static uint16_t ltc_cmdADCV_fast_DCP1[4]
Definition: ltc_6813-1.c:240
ltc_cmdWRCFG2
static uint16_t ltc_cmdWRCFG2[4]
Definition: ltc_6813-1.c:193
LTC_SaveBalancingFeedback
static void LTC_SaveBalancingFeedback(LTC_STATE_s *ltc_state, uint16_t *DataBufferSPI_RX, uint8_t stringNumber)
stores the measured balancing feedback values in the database.
Definition: ltc_6813-1.c:689
LTC_SetFirstMeasurementCycleFinished
static void LTC_SetFirstMeasurementCycleFinished(LTC_STATE_s *ltc_state)
sets the measurement initialization status.
Definition: ltc_6813-1.c:4741
LTC_CheckStateRequest
static LTC_RETURN_TYPE_e LTC_CheckStateRequest(LTC_STATE_s *ltc_state, LTC_REQUEST_s statereq)
checks the state requests that are made.
Definition: ltc_6813-1.c:4704
LTC_StartGpioMeasurement
static STD_RETURN_TYPE_e LTC_StartGpioMeasurement(SPI_INTERFACE_CONFIG_s *pSpiInterface, LTC_ADCMODE_e adcMode, LTC_ADCMEAS_CHAN_e adcMeasCh)
tells LTC daisy-chain to start measuring the voltage on GPIOS.
Definition: ltc_6813-1.c:3712
LTC_SetStateRequest
LTC_RETURN_TYPE_e LTC_SetStateRequest(LTC_STATE_s *ltc_state, LTC_REQUEST_s statereq)
sets the current state request of the state variable ltc_state.
Definition: ltc_6813-1.c:797
LTC_ICOM_BLANK
#define LTC_ICOM_BLANK
Definition: ltc_6813-1.c:92
LTC_SetTransferTimes
static void LTC_SetTransferTimes(LTC_STATE_s *ltc_state)
sets the transfer time needed to receive/send data with the LTC daisy-chain.
Definition: ltc_6813-1.c:4666
ltc_cmdRDAUXC
static uint16_t ltc_cmdRDAUXC[4]
Definition: ltc_6813-1.c:207
LTC_GetSpiClock
static uint32_t LTC_GetSpiClock(SPI_INTERFACE_CONFIG_s *pSpiInterface)
gets the frequency of the SPI clock.
Definition: ltc_6813-1.c:4624
LTC_GetMeasurementTimeCycle
static uint16_t LTC_GetMeasurementTimeCycle(LTC_ADCMODE_e adcMode, LTC_ADCMEAS_CHAN_e adcMeasCh)
brief missing
Definition: ltc_6813-1.c:3606
ltc_cmdADAX_fast_GPIO2
static uint16_t ltc_cmdADAX_fast_GPIO2[4]
Definition: ltc_6813-1.c:251
ltc_cmdADAX_normal_ALLGPIOS
static uint16_t ltc_cmdADAX_normal_ALLGPIOS[4]
Definition: ltc_6813-1.c:261
ltc_cmdADAX_filtered_GPIO3
static uint16_t ltc_cmdADAX_filtered_GPIO3[4]
Definition: ltc_6813-1.c:253
ltc_cmdADAX_filtered_GPIO2
static uint16_t ltc_cmdADAX_filtered_GPIO2[4]
Definition: ltc_6813-1.c:250
LTC_CheckPec
static STD_RETURN_TYPE_e LTC_CheckPec(LTC_STATE_s *ltc_state, uint16_t *DataBufferSPI_RX_with_PEC, uint8_t stringNumber)
checks if the data received from the daisy-chain is not corrupt.
Definition: ltc_6813-1.c:3823
ltc_cmdRDCVD
static uint16_t ltc_cmdRDCVD[4]
Definition: ltc_6813-1.c:199
ltc_I2CcmdPortExpander1
static uint16_t ltc_I2CcmdPortExpander1[6]
Definition: ltc_6813-1.c:226
ltc_cmdRDCFG
static uint16_t ltc_cmdRDCFG[4]
Definition: ltc_6813-1.c:194
LTC_ICOM_NO_TRANSMIT
#define LTC_ICOM_NO_TRANSMIT
Definition: ltc_6813-1.c:93
LTC_SaveLastStates
static void LTC_SaveLastStates(LTC_STATE_s *ltc_state)
Saves the last state and the last substate.
Definition: ltc_6813-1.c:511
LTC_PortExpanderSaveValuesTi
static void LTC_PortExpanderSaveValuesTi(LTC_STATE_s *ltc_state, uint16_t *pTxBuff)
saves the received values of the external port expander from TI read from the LTC daisy-chain.
Definition: ltc_6813-1.c:4571
LTC_TransferStateRequest
LTC_REQUEST_s LTC_TransferStateRequest(LTC_STATE_s *ltc_state, uint8_t *pBusIDptr, LTC_ADCMODE_e *pAdcModeptr, LTC_ADCMEAS_CHAN_e *pAdcMeasChptr)
transfers the current state request to the state machine.
Definition: ltc_6813-1.c:773
LTC_SaveTemperatures
void LTC_SaveTemperatures(LTC_STATE_s *ltc_state, uint8_t stringNumber)
stores the measured temperatures and the measured multiplexer feedbacks in the database.
Definition: ltc_6813-1.c:634
LTC_PORT_EXPANDER_TI_CONFIG_REG_ADR
#define LTC_PORT_EXPANDER_TI_CONFIG_REG_ADR
Definition: ltc_6813-1.c:83
ltc_used_cells_index
static uint16_t ltc_used_cells_index[BS_NR_OF_STRINGS]
Definition: ltc_6813-1.c:116
LTC_PortExpanderSaveValues
static void LTC_PortExpanderSaveValues(LTC_STATE_s *ltc_state, uint16_t *pRxBuff)
saves the received values of the external port expander read from the LTC daisy-chain.
Definition: ltc_6813-1.c:4387
ltc_balancing_control
static DATA_BLOCK_BALANCING_CONTROL_s ltc_balancing_control
Definition: ltc_6813-1.c:123
LTC_SetPortExpanderDirectionTi
static STD_RETURN_TYPE_e LTC_SetPortExpanderDirectionTi(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, LTC_PORT_EXPANDER_TI_DIRECTION_e direction)
sends data to the LTC daisy-chain to control the user port expander from TI
Definition: ltc_6813-1.c:4415
LTC_GetPortExpanderInputTi
static STD_RETURN_TYPE_e LTC_GetPortExpanderInputTi(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, uint8_t step)
sends data to the LTC daisy-chain to control the user port expander from TI
Definition: ltc_6813-1.c:4516
LTC_FCOM_MASTER_NACK_STOP
#define LTC_FCOM_MASTER_NACK_STOP
Definition: ltc_6813-1.c:96
ltc_cmdADAX_fast_ALLGPIOS
static uint16_t ltc_cmdADAX_fast_ALLGPIOS[4]
Definition: ltc_6813-1.c:264
LTC_InitializeMonitoringPin
void LTC_InitializeMonitoringPin(void)
Sets the transceiver pins to enable LTC6820 IC.
Definition: ltc_6813-1.c:4747
ltc_cellVoltage
static DATA_BLOCK_CELL_VOLTAGE_s ltc_cellVoltage
Definition: ltc_6813-1.c:119
ltc_cmdADAX_normal_GPIO2
static uint16_t ltc_cmdADAX_normal_GPIO2[4]
Definition: ltc_6813-1.c:249
ltc_BC_cmdADOW_PDOWN_filtered_DCP0
static uint16_t ltc_BC_cmdADOW_PDOWN_filtered_DCP0[4]
Definition: ltc_6813-1.c:282
LTC_WriteRegister
static STD_RETURN_TYPE_e LTC_WriteRegister(uint16_t *Command, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength)
sends command and data to the LTC daisy-chain.
Definition: ltc_6813-1.c:3962
LTC_SetMuxChCommand
static void LTC_SetMuxChCommand(uint16_t *pTxBuff, uint8_t mux, uint8_t channel)
configures the data that will be sent to the LTC daisy-chain to configure multiplexer channels.
Definition: ltc_6813-1.c:4012
ltc_cmdADAX_filtered_ALLGPIOS
static uint16_t ltc_cmdADAX_filtered_ALLGPIOS[4]
Definition: ltc_6813-1.c:262
LTC_SaveRxToVoltageBuffer
static void LTC_SaveRxToVoltageBuffer(LTC_STATE_s *ltc_state, uint16_t *pRxBuff, uint8_t registerSet, uint8_t stringNumber)
saves the voltage values read from the LTC daisy-chain.
Definition: ltc_6813-1.c:3029
ltc_I2CcmdTempSens1
static uint16_t ltc_I2CcmdTempSens1[6]
Definition: ltc_6813-1.c:223
LTC_SetPortExpander
static STD_RETURN_TYPE_e LTC_SetPortExpander(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength)
sends data to the LTC daisy-chain to control the user port expander
Definition: ltc_6813-1.c:4338
LTC_I2cClock
static STD_RETURN_TYPE_e LTC_I2cClock(SPI_INTERFACE_CONFIG_s *pSpiInterface)
sends 72 clock pulses to the LTC daisy-chain.
Definition: ltc_6813-1.c:4596
ltc_cmdADCV_fast_DCP0
static uint16_t ltc_cmdADCV_fast_DCP0[4]
Definition: ltc_6813-1.c:238
LTC_BalanceControl
static STD_RETURN_TYPE_e LTC_BalanceControl(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, uint8_t registerSet, uint8_t stringNumber)
sets the balancing according to the control values read in the database.
Definition: ltc_6813-1.c:3407
LTC_GetStateRequest
LTC_REQUEST_s LTC_GetStateRequest(LTC_STATE_s *ltc_state)
gets the current state request.
Definition: ltc_6813-1.c:742
ltc_balancing_feedback
static DATA_BLOCK_BALANCING_FEEDBACK_s ltc_balancing_feedback
Definition: ltc_6813-1.c:121
LTC_SaveVoltages
void LTC_SaveVoltages(LTC_STATE_s *ltc_state, uint8_t stringNumber)
stores the measured voltages in the database.
Definition: ltc_6813-1.c:572
LTC_SetPortExpanderOutputTi
static STD_RETURN_TYPE_e LTC_SetPortExpanderOutputTi(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength)
sends data to the LTC daisy-chain to control the user port expander from TI
Definition: ltc_6813-1.c:4465
LTC_SendEepromReadCommand
static STD_RETURN_TYPE_e LTC_SendEepromReadCommand(LTC_STATE_s *ltc_state, SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, uint8_t step)
sends data to the LTC daisy-chain to read EEPROM on slaves.
Definition: ltc_6813-1.c:4057
ltc_plausibleCellVoltages681x
static const AFE_PLAUSIBILITY_VALUES_s ltc_plausibleCellVoltages681x
Definition: ltc_6813-1.c:133
LTC_Init
static STD_RETURN_TYPE_e LTC_Init(SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength)
initialize the daisy-chain.
Definition: ltc_6813-1.c:3343
ltc_cmdADCV_filtered_DCP0
static uint16_t ltc_cmdADCV_filtered_DCP0[4]
Definition: ltc_6813-1.c:234
LTC_ResetErrorTable
static void LTC_ResetErrorTable(LTC_STATE_s *ltc_state)
resets the error table.
Definition: ltc_6813-1.c:3578
LTC_SendI2cCommand
static STD_RETURN_TYPE_e LTC_SendI2cCommand(SPI_INTERFACE_CONFIG_s *pSpiInterface, uint16_t *pTxBuff, uint16_t *pRxBuff, uint32_t frameLength, uint16_t *cmd_data)
sends data to the LTC daisy-chain to communicate via I2C
Definition: ltc_6813-1.c:4270
ltc_stateBase
LTC_STATE_s ltc_stateBase
Definition: ltc_6813-1.c:140
ltc_cmdADAX_normal_GPIO3
static uint16_t ltc_cmdADAX_normal_GPIO3[4]
Definition: ltc_6813-1.c:252
LTC_GetBalancingControlValues
static void LTC_GetBalancingControlValues(LTC_STATE_s *ltc_state)
gets the balancing orders from the database.
Definition: ltc_6813-1.c:710
LTC_FCOM_MASTER_NACK
#define LTC_FCOM_MASTER_NACK
Definition: ltc_6813-1.c:95
ltc_cmdADCV_normal_DCP1
static uint16_t ltc_cmdADCV_normal_DCP1[4]
Definition: ltc_6813-1.c:232
ltc_cmdRDCVE
static uint16_t ltc_cmdRDCVE[4]
Definition: ltc_6813-1.c:200
ltc_cmdRDAUXD
static uint16_t ltc_cmdRDAUXD[4]
Definition: ltc_6813-1.c:208
ltc_cmdADCV_normal_DCP0
static uint16_t ltc_cmdADCV_normal_DCP0[4]
Definition: ltc_6813-1.c:230
LTC_SaveAllGpioMeasurement
void LTC_SaveAllGpioMeasurement(LTC_STATE_s *ltc_state)
stores the measured GPIOs in the database.
Definition: ltc_6813-1.c:673
ltc_BC_cmdADOW_PDOWN_normal_DCP0
static uint16_t ltc_BC_cmdADOW_PDOWN_normal_DCP0[4]
Definition: ltc_6813-1.c:272
ltc_cmdADCV_fast_DCP0_twocells
static uint16_t ltc_cmdADCV_fast_DCP0_twocells[4]
Definition: ltc_6813-1.c:242
ltc_errorTable
static LTC_ERRORTABLE_s ltc_errorTable
Definition: ltc_6813-1.c:130
LTC_Trigger
void LTC_Trigger(LTC_STATE_s *ltc_state)
trigger function for the LTC driver state machine.
Definition: ltc_6813-1.c:812
ltc_cmdRDCVF
static uint16_t ltc_cmdRDCVF[4]
Definition: ltc_6813-1.c:201
LTC_CheckReEntrance
uint8_t LTC_CheckReEntrance(LTC_STATE_s *ltc_state)
re-entrance check of LTC state machine trigger function
Definition: ltc_6813-1.c:727
LTC_ICOM_START
#define LTC_ICOM_START
Definition: ltc_6813-1.c:90
ltc_BC_cmdADOW_PUP_normal_DCP0
static uint16_t ltc_BC_cmdADOW_PUP_normal_DCP0[4]
Definition: ltc_6813-1.c:267
LTC_InitializeDatabase
static void LTC_InitializeDatabase(LTC_STATE_s *ltc_state)
in the database, initializes the fields related to the LTC drivers.
Definition: ltc_6813-1.c:450
ltc_cmdRDCOMM
static uint16_t ltc_cmdRDCOMM[4]
Definition: ltc_6813-1.c:204
ltc_RxPecBuffer
uint16_t ltc_RxPecBuffer[LTC_N_BYTES_FOR_DATA_TRANSMISSION]
Definition: ltc_6813-1.c:109
ltc_slave_control
static DATA_BLOCK_SLAVE_CONTROL_s ltc_slave_control
Definition: ltc_6813-1.c:124
ltc_I2CcmdTempSens0
static uint16_t ltc_I2CcmdTempSens0[6]
Definition: ltc_6813-1.c:216
LTC_TempSensSaveTemp
static void LTC_TempSensSaveTemp(LTC_STATE_s *ltc_state, uint16_t *pRxBuff)
saves the temperature value of the external temperature sensors read from the LTC daisy-chain.
Definition: ltc_6813-1.c:4308
ltc_openWireDetection
static LTC_OPENWIRE_DETECTION_s ltc_openWireDetection
Definition: ltc_6813-1.c:129
ltc_cmdSTCOMM
static uint16_t ltc_cmdSTCOMM[4]
Definition: ltc_6813-1.c:203
LTC_CondBasedStateTransition
static void LTC_CondBasedStateTransition(LTC_STATE_s *ltc_state, STD_RETURN_TYPE_e retVal, DIAG_ID_e diagCode, LTC_STATEMACH_e state_ok, uint8_t substate_ok, uint16_t timer_ms_ok, LTC_STATEMACH_e state_nok, uint8_t substate_nok, uint16_t timer_ms_nok)
condition-based state transition depending on retVal
Definition: ltc_6813-1.c:553
ltc_cmdADAX_filtered_GPIO1
static uint16_t ltc_cmdADAX_filtered_GPIO1[4]
Definition: ltc_6813-1.c:247
LTC_SaveMuxMeasurement
static void LTC_SaveMuxMeasurement(LTC_STATE_s *ltc_state, uint16_t *pRxBuff, LTC_MUX_CH_CFG_s *muxseqptr, uint8_t stringNumber)
saves the multiplexer values read from the LTC daisy-chain.
Definition: ltc_6813-1.c:2947
ltc_cmdWRCFG
static uint16_t ltc_cmdWRCFG[4]
Definition: ltc_6813-1.c:192
LTC_SetEepromReadCommand
static void LTC_SetEepromReadCommand(LTC_STATE_s *ltc_state, uint16_t *pTxBuff, uint8_t step)
configures the data that will be sent to the LTC daisy-chain to read EEPROM on slaves.
Definition: ltc_6813-1.c:4085
ltc_BC_cmdADOW_PUP_filtered_DCP0
static uint16_t ltc_BC_cmdADOW_PUP_filtered_DCP0[4]
Definition: ltc_6813-1.c:277
ltc_celltemperature
static DATA_BLOCK_CELL_TEMPERATURE_s ltc_celltemperature
Definition: ltc_6813-1.c:120
ltc_cmdADCV_filtered_DCP1
static uint16_t ltc_cmdADCV_filtered_DCP1[4]
Definition: ltc_6813-1.c:236
ltc_cmdADAX_fast_GPIO1
static uint16_t ltc_cmdADAX_fast_GPIO1[4]
Definition: ltc_6813-1.c:248
ltc_mux_seq
LTC_MUX_SEQUENCE_s ltc_mux_seq
Definition: ltc_6813-1_cfg.c:182
ltc_6813-1_cfg.h
Header for the configuration for the LTC 6804-1 6811-1, 6812-1, and 6813-1 monitoring IC.
LTC_STATEMACH_MEAS_SINGLE_GPIO_FAST_TCYCLE
#define LTC_STATEMACH_MEAS_SINGLE_GPIO_FAST_TCYCLE
Definition: ltc_6813-1_cfg.h:260
LTC_STATEMACH_MEAS_ALL_CELLS_FAST_TCYCLE
#define LTC_STATEMACH_MEAS_ALL_CELLS_FAST_TCYCLE
Definition: ltc_6813-1_cfg.h:202
LTC_DISCARD_MUX_CHECK
#define LTC_DISCARD_MUX_CHECK
Definition: ltc_6813-1_cfg.h:112
LTC_STATEMACH_MEAS_ALL_GPIOS_FILTERED_TCYCLE
#define LTC_STATEMACH_MEAS_ALL_GPIOS_FILTERED_TCYCLE
Definition: ltc_6813-1_cfg.h:254
LTC_STATEMACH_MEAS_ALL_CELLS_NORMAL_TCYCLE
#define LTC_STATEMACH_MEAS_ALL_CELLS_NORMAL_TCYCLE
Definition: ltc_6813-1_cfg.h:208
LTC_STATEMACH_MEAS_ALL_GPIOS_NORMAL_TCYCLE
#define LTC_STATEMACH_MEAS_ALL_GPIOS_NORMAL_TCYCLE
Definition: ltc_6813-1_cfg.h:248
LTC_STATEMACH_MEAS_SINGLE_GPIO_FILTERED_TCYCLE
#define LTC_STATEMACH_MEAS_SINGLE_GPIO_FILTERED_TCYCLE
Definition: ltc_6813-1_cfg.h:272
LTC_GOTO_MUX_CHECK
#define LTC_GOTO_MUX_CHECK
Definition: ltc_6813-1_cfg.h:109
LTC_STATEMACH_MEAS_TWO_CELLS_FILTERED_TCYCLE
#define LTC_STATEMACH_MEAS_TWO_CELLS_FILTERED_TCYCLE
Definition: ltc_6813-1_cfg.h:232
LTC_STATEMACH_MEAS_ALL_CELLS_FILTERED_TCYCLE
#define LTC_STATEMACH_MEAS_ALL_CELLS_FILTERED_TCYCLE
Definition: ltc_6813-1_cfg.h:214
LTC_STATEMACH_MEAS_ALL_GPIOS_FAST_TCYCLE
#define LTC_STATEMACH_MEAS_ALL_GPIOS_FAST_TCYCLE
Definition: ltc_6813-1_cfg.h:242
LTC_STATEMACH_MEAS_TWO_CELLS_NORMAL_TCYCLE
#define LTC_STATEMACH_MEAS_TWO_CELLS_NORMAL_TCYCLE
Definition: ltc_6813-1_cfg.h:226
LTC_STATEMACH_MEAS_TWO_CELLS_FAST_TCYCLE
#define LTC_STATEMACH_MEAS_TWO_CELLS_FAST_TCYCLE
Definition: ltc_6813-1_cfg.h:220
LTC_6813_MAX_SUPPORTED_CELLS
#define LTC_6813_MAX_SUPPORTED_CELLS
Defines the maximal number of supported cells per module.
Definition: ltc_6813-1_cfg.h:90
LTC_STATEMACH_MEAS_SINGLE_GPIO_NORMAL_TCYCLE
#define LTC_STATEMACH_MEAS_SINGLE_GPIO_NORMAL_TCYCLE
Definition: ltc_6813-1_cfg.h:266
AFE_IsTransmitOngoing
bool AFE_IsTransmitOngoing(LTC_STATE_s *pLtcState)
gets the SPI transmit status.
Definition: ltc_afe_dma.c:77
AFE_SetTransmitOngoing
void AFE_SetTransmitOngoing(LTC_STATE_s *pLtcState)
sets the SPI transmit status.
Definition: ltc_afe_dma.c:82
LTC_N_BYTES_FOR_DATA_TRANSMISSION
#define LTC_N_BYTES_FOR_DATA_TRANSMISSION
Definition: ltc_cfg.h:79
LTC_N_LTC
#define LTC_N_LTC
Definition: ltc_cfg.h:68
LTC_RE_ENTRY_INITIALIZATION
@ LTC_RE_ENTRY_INITIALIZATION
Definition: ltc_defs.h:181
LTC_ENTRY_INITIALIZATION
@ LTC_ENTRY_INITIALIZATION
Definition: ltc_defs.h:179
LTC_START_INIT_INITIALIZATION
@ LTC_START_INIT_INITIALIZATION
Definition: ltc_defs.h:180
LTC_EXIT_INITIALIZATION
@ LTC_EXIT_INITIALIZATION
Definition: ltc_defs.h:184
LTC_CHECK_INITIALIZATION
@ LTC_CHECK_INITIALIZATION
Definition: ltc_defs.h:183
LTC_INIT_STRING
@ LTC_INIT_STRING
Definition: ltc_defs.h:178
LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM
@ LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM
Definition: ltc_defs.h:290
LTC_USER_IO_SAVE_DATA
@ LTC_USER_IO_SAVE_DATA
Definition: ltc_defs.h:291
LTC_USER_IO_SEND_CLOCK_STCOMM
@ LTC_USER_IO_SEND_CLOCK_STCOMM
Definition: ltc_defs.h:289
LTC_USER_IO_READ_INPUT_REGISTER
@ LTC_USER_IO_READ_INPUT_REGISTER
Definition: ltc_defs.h:288
LTC_USER_IO_SET_OUTPUT_REGISTER
@ LTC_USER_IO_SET_OUTPUT_REGISTER
Definition: ltc_defs.h:287
LTC_STATE_EEPROM_READ_REQUEST
@ LTC_STATE_EEPROM_READ_REQUEST
Definition: ltc_defs.h:375
LTC_STATE_USER_IO_READ_REQUEST_TI
@ LTC_STATE_USER_IO_READ_REQUEST_TI
Definition: ltc_defs.h:374
LTC_STATE_INIT_REQUEST
@ LTC_STATE_INIT_REQUEST
Definition: ltc_defs.h:369
LTC_STATE_USER_IO_READ_REQUEST
@ LTC_STATE_USER_IO_READ_REQUEST
Definition: ltc_defs.h:371
LTC_STATE_EEPROM_WRITE_REQUEST
@ LTC_STATE_EEPROM_WRITE_REQUEST
Definition: ltc_defs.h:376
LTC_STATE_USER_IO_WRITE_REQUEST
@ LTC_STATE_USER_IO_WRITE_REQUEST
Definition: ltc_defs.h:370
LTC_STATE_USER_IO_WRITE_REQUEST_TI
@ LTC_STATE_USER_IO_WRITE_REQUEST_TI
Definition: ltc_defs.h:373
LTC_STATE_OPENWIRE_CHECK_REQUEST
@ LTC_STATE_OPENWIRE_CHECK_REQUEST
Definition: ltc_defs.h:391
LTC_STATE_TEMP_SENS_READ_REQUEST
@ LTC_STATE_TEMP_SENS_READ_REQUEST
Definition: ltc_defs.h:378
LTC_STATEMACH_BALANCEFEEDBACK_REQUEST
@ LTC_STATEMACH_BALANCEFEEDBACK_REQUEST
Definition: ltc_defs.h:389
LTC_STATE_NO_REQUEST
@ LTC_STATE_NO_REQUEST
Definition: ltc_defs.h:395
LTC_STATEMACH_e
LTC_STATEMACH_e
Definition: ltc_defs.h:122
LTC_STATEMACH_INITIALIZATION
@ LTC_STATEMACH_INITIALIZATION
Definition: ltc_defs.h:125
LTC_STATEMACH_USER_IO_FEEDBACK
@ LTC_STATEMACH_USER_IO_FEEDBACK
Definition: ltc_defs.h:140
LTC_STATEMACH_UNINITIALIZED
@ LTC_STATEMACH_UNINITIALIZED
Definition: ltc_defs.h:124
LTC_STATEMACH_MUXMEASUREMENT
@ LTC_STATEMACH_MUXMEASUREMENT
Definition: ltc_defs.h:132
LTC_STATEMACH_TEMP_SENS_READ
@ LTC_STATEMACH_TEMP_SENS_READ
Definition: ltc_defs.h:143
LTC_STATEMACH_BALANCECONTROL
@ LTC_STATEMACH_BALANCECONTROL
Definition: ltc_defs.h:134
LTC_STATEMACH_EEPROM_WRITE
@ LTC_STATEMACH_EEPROM_WRITE
Definition: ltc_defs.h:142
LTC_STATEMACH_EEPROM_READ
@ LTC_STATEMACH_EEPROM_READ
Definition: ltc_defs.h:141
LTC_STATEMACH_USER_IO_FEEDBACK_TI
@ LTC_STATEMACH_USER_IO_FEEDBACK_TI
Definition: ltc_defs.h:152
LTC_STATEMACH_STARTMEAS_CONTINUE
@ LTC_STATEMACH_STARTMEAS_CONTINUE
Definition: ltc_defs.h:153
LTC_STATEMACH_READALLGPIO
@ LTC_STATEMACH_READALLGPIO
Definition: ltc_defs.h:136
LTC_STATEMACH_OPENWIRE_CHECK
@ LTC_STATEMACH_OPENWIRE_CHECK
Definition: ltc_defs.h:145
LTC_STATEMACH_USER_IO_CONTROL_TI
@ LTC_STATEMACH_USER_IO_CONTROL_TI
Definition: ltc_defs.h:151
LTC_STATEMACH_USER_IO_CONTROL
@ LTC_STATEMACH_USER_IO_CONTROL
Definition: ltc_defs.h:139
LTC_STATEMACH_READVOLTAGE
@ LTC_STATEMACH_READVOLTAGE
Definition: ltc_defs.h:131
LTC_STATEMACH_BALANCEFEEDBACK
@ LTC_STATEMACH_BALANCEFEEDBACK
Definition: ltc_defs.h:144
LTC_STATEMACH_INITIALIZED
@ LTC_STATEMACH_INITIALIZED
Definition: ltc_defs.h:127
LTC_STATEMACH_STARTMEAS
@ LTC_STATEMACH_STARTMEAS
Definition: ltc_defs.h:130
LTC_STATEMACH_MEASCYCLE_FINISHED
@ LTC_STATEMACH_MEASCYCLE_FINISHED
Definition: ltc_defs.h:154
LTC_STATEMACH_ALLGPIOMEASUREMENT
@ LTC_STATEMACH_ALLGPIOMEASUREMENT
Definition: ltc_defs.h:135
LTC_STATEMACH_READMUXMEASUREMENT
@ LTC_STATEMACH_READMUXMEASUREMENT
Definition: ltc_defs.h:232
LTC_CONFIG_BALANCECONTROL
@ LTC_CONFIG_BALANCECONTROL
Definition: ltc_defs.h:222
LTC_SAVE_FEEDBACK_BALANCECONTROL
@ LTC_SAVE_FEEDBACK_BALANCECONTROL
Definition: ltc_defs.h:227
LTC_STATEMACH_MUXCONFIGURATION_INIT
@ LTC_STATEMACH_MUXCONFIGURATION_INIT
Definition: ltc_defs.h:230
LTC_CONFIG2_BALANCECONTROL_END
@ LTC_CONFIG2_BALANCECONTROL_END
Definition: ltc_defs.h:224
LTC_READ_FEEDBACK_BALANCECONTROL
@ LTC_READ_FEEDBACK_BALANCECONTROL
Definition: ltc_defs.h:226
LTC_CONFIG2_BALANCECONTROL
@ LTC_CONFIG2_BALANCECONTROL
Definition: ltc_defs.h:223
LTC_STATEMACH_STOREMUXMEASUREMENT
@ LTC_STATEMACH_STOREMUXMEASUREMENT
Definition: ltc_defs.h:233
LTC_DATA_SIZE_IN_BYTES
#define LTC_DATA_SIZE_IN_BYTES
Definition: ltc_defs.h:87
LTC_EEPROM_SEND_CLOCK_STCOMM4
@ LTC_EEPROM_SEND_CLOCK_STCOMM4
Definition: ltc_defs.h:320
LTC_EEPROM_SEND_CLOCK_STCOMM2
@ LTC_EEPROM_SEND_CLOCK_STCOMM2
Definition: ltc_defs.h:318
LTC_EEPROM_WRITE_DATA1
@ LTC_EEPROM_WRITE_DATA1
Definition: ltc_defs.h:315
LTC_EEPROM_READ_I2C_TRANSMISSION_RESULT_RDCOMM
@ LTC_EEPROM_READ_I2C_TRANSMISSION_RESULT_RDCOMM
Definition: ltc_defs.h:321
LTC_EEPROM_READ_DATA1
@ LTC_EEPROM_READ_DATA1
Definition: ltc_defs.h:313
LTC_EEPROM_SEND_CLOCK_STCOMM3
@ LTC_EEPROM_SEND_CLOCK_STCOMM3
Definition: ltc_defs.h:319
LTC_EEPROM_WRITE_DATA2
@ LTC_EEPROM_WRITE_DATA2
Definition: ltc_defs.h:316
LTC_EEPROM_READ_DATA2
@ LTC_EEPROM_READ_DATA2
Definition: ltc_defs.h:314
LTC_EEPROM_SEND_CLOCK_STCOMM1
@ LTC_EEPROM_SEND_CLOCK_STCOMM1
Definition: ltc_defs.h:317
LTC_EEPROM_SAVE_READ
@ LTC_EEPROM_SAVE_READ
Definition: ltc_defs.h:322
LTC_EEPROM_FINISHED
@ LTC_EEPROM_FINISHED
Definition: ltc_defs.h:323
LTC_REQUEST_PULLDOWN_CURRENT_OPENWIRE_CHECK
@ LTC_REQUEST_PULLDOWN_CURRENT_OPENWIRE_CHECK
Definition: ltc_defs.h:240
LTC_READ_VOLTAGES_PULLDOWN_OPENWIRE_CHECK
@ LTC_READ_VOLTAGES_PULLDOWN_OPENWIRE_CHECK
Definition: ltc_defs.h:241
LTC_READ_VOLTAGES_PULLUP_OPENWIRE_CHECK
@ LTC_READ_VOLTAGES_PULLUP_OPENWIRE_CHECK
Definition: ltc_defs.h:239
LTC_REQUEST_PULLUP_CURRENT_OPENWIRE_CHECK
@ LTC_REQUEST_PULLUP_CURRENT_OPENWIRE_CHECK
Definition: ltc_defs.h:238
LTC_PERFORM_OPENWIRE_CHECK
@ LTC_PERFORM_OPENWIRE_CHECK
Definition: ltc_defs.h:242
LTC_ADCMEAS_CHAN_e
LTC_ADCMEAS_CHAN_e
Definition: ltc_defs.h:108
LTC_ADCMEAS_SINGLECHANNEL_GPIO5
@ LTC_ADCMEAS_SINGLECHANNEL_GPIO5
Definition: ltc_defs.h:117
LTC_ADCMEAS_SINGLECHANNEL_GPIO2
@ LTC_ADCMEAS_SINGLECHANNEL_GPIO2
Definition: ltc_defs.h:114
LTC_ADCMEAS_UNDEFINED
@ LTC_ADCMEAS_UNDEFINED
Definition: ltc_defs.h:109
LTC_ADCMEAS_SINGLECHANNEL_GPIO4
@ LTC_ADCMEAS_SINGLECHANNEL_GPIO4
Definition: ltc_defs.h:116
LTC_ADCMEAS_SINGLECHANNEL_GPIO1
@ LTC_ADCMEAS_SINGLECHANNEL_GPIO1
Definition: ltc_defs.h:113
LTC_ADCMEAS_SINGLECHANNEL_GPIO3
@ LTC_ADCMEAS_SINGLECHANNEL_GPIO3
Definition: ltc_defs.h:115
LTC_ADCMEAS_SINGLECHANNEL_TWOCELLS
@ LTC_ADCMEAS_SINGLECHANNEL_TWOCELLS
Definition: ltc_defs.h:111
LTC_ADCMEAS_ALLCHANNEL_GPIOS
@ LTC_ADCMEAS_ALLCHANNEL_GPIOS
Definition: ltc_defs.h:112
LTC_ADCMEAS_ALLCHANNEL_CELLS
@ LTC_ADCMEAS_ALLCHANNEL_CELLS
Definition: ltc_defs.h:110
LTC_USER_IO_SET_OUTPUT_REGISTER_TI
@ LTC_USER_IO_SET_OUTPUT_REGISTER_TI
Definition: ltc_defs.h:298
LTC_USER_IO_SET_DIRECTION_REGISTER_TI
@ LTC_USER_IO_SET_DIRECTION_REGISTER_TI
Definition: ltc_defs.h:297
LTC_USER_IO_READ_INPUT_REGISTER_TI_FIRST
@ LTC_USER_IO_READ_INPUT_REGISTER_TI_FIRST
Definition: ltc_defs.h:299
LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_SECOND
@ LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_SECOND
Definition: ltc_defs.h:303
LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_THIRD
@ LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_THIRD
Definition: ltc_defs.h:304
LTC_USER_IO_SAVE_DATA_TI
@ LTC_USER_IO_SAVE_DATA_TI
Definition: ltc_defs.h:306
LTC_USER_IO_READ_INPUT_REGISTER_TI_SECOND
@ LTC_USER_IO_READ_INPUT_REGISTER_TI_SECOND
Definition: ltc_defs.h:300
LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_FOURTH
@ LTC_USER_IO_READ_I2C_TRANSMISSION_RESULT_RDCOMM_TI_FOURTH
Definition: ltc_defs.h:305
LTC_USER_IO_SEND_CLOCK_STCOMM_TI
@ LTC_USER_IO_SEND_CLOCK_STCOMM_TI
Definition: ltc_defs.h:301
LTC_PORT_EXPANDER_TI_DIRECTION_e
LTC_PORT_EXPANDER_TI_DIRECTION_e
Definition: ltc_defs.h:508
LTC_PORT_EXPANDER_TI_OUTPUT
@ LTC_PORT_EXPANDER_TI_OUTPUT
Definition: ltc_defs.h:509
LTC_PORT_EXPANDER_TI_INPUT
@ LTC_PORT_EXPANDER_TI_INPUT
Definition: ltc_defs.h:510
LTC_RETURN_TYPE_e
LTC_RETURN_TYPE_e
Definition: ltc_defs.h:401
LTC_BUSY_OK
@ LTC_BUSY_OK
Definition: ltc_defs.h:403
LTC_ILLEGAL_REQUEST
@ LTC_ILLEGAL_REQUEST
Definition: ltc_defs.h:405
LTC_ALREADY_INITIALIZED
@ LTC_ALREADY_INITIALIZED
Definition: ltc_defs.h:412
LTC_ERROR
@ LTC_ERROR
Definition: ltc_defs.h:411
LTC_OK_FROM_ERROR
@ LTC_OK_FROM_ERROR
Definition: ltc_defs.h:410
LTC_REQUEST_PENDING
@ LTC_REQUEST_PENDING
Definition: ltc_defs.h:404
LTC_OK
@ LTC_OK
Definition: ltc_defs.h:402
LTC_TEMP_SENS_READ_I2C_TRANSMISSION_RESULT_RDCOMM
@ LTC_TEMP_SENS_READ_I2C_TRANSMISSION_RESULT_RDCOMM
Definition: ltc_defs.h:333
LTC_TEMP_SENS_SEND_CLOCK_STCOMM1
@ LTC_TEMP_SENS_SEND_CLOCK_STCOMM1
Definition: ltc_defs.h:331
LTC_TEMP_SENS_SEND_CLOCK_STCOMM2
@ LTC_TEMP_SENS_SEND_CLOCK_STCOMM2
Definition: ltc_defs.h:332
LTC_TEMP_SENS_SAVE_TEMP
@ LTC_TEMP_SENS_SAVE_TEMP
Definition: ltc_defs.h:334
LTC_TEMP_SENS_SEND_DATA1
@ LTC_TEMP_SENS_SEND_DATA1
Definition: ltc_defs.h:328
LTC_TEMP_SENS_READ_DATA1
@ LTC_TEMP_SENS_READ_DATA1
Definition: ltc_defs.h:329
LTC_READ_I2C_TRANSMISSION_RESULT_RDCOMM_MUXMEASUREMENT_CONFIG
@ LTC_READ_I2C_TRANSMISSION_RESULT_RDCOMM_MUXMEASUREMENT_CONFIG
Definition: ltc_defs.h:345
LTC_READ_I2C_TRANSMISSION_CHECK_MUXMEASUREMENT_CONFIG
@ LTC_READ_I2C_TRANSMISSION_CHECK_MUXMEASUREMENT_CONFIG
Definition: ltc_defs.h:346
LTC_SEND_CLOCK_STCOMM_MUXMEASUREMENT_CONFIG
@ LTC_SEND_CLOCK_STCOMM_MUXMEASUREMENT_CONFIG
Definition: ltc_defs.h:342
LTC_READ_AUXILIARY_REGISTER_D_RDAUXD
@ LTC_READ_AUXILIARY_REGISTER_D_RDAUXD
Definition: ltc_defs.h:208
LTC_READ_VOLTAGE_REGISTER_F_RDCVF_READVOLTAGE
@ LTC_READ_VOLTAGE_REGISTER_F_RDCVF_READVOLTAGE
Definition: ltc_defs.h:200
LTC_READ_AUXILIARY_REGISTER_A_RDAUXA
@ LTC_READ_AUXILIARY_REGISTER_A_RDAUXA
Definition: ltc_defs.h:205
LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE
@ LTC_READ_VOLTAGE_REGISTER_A_RDCVA_READVOLTAGE
Definition: ltc_defs.h:195
LTC_READ_VOLTAGE_REGISTER_D_RDCVD_READVOLTAGE
@ LTC_READ_VOLTAGE_REGISTER_D_RDCVD_READVOLTAGE
Definition: ltc_defs.h:198
LTC_READ_AUXILIARY_REGISTER_C_RDAUXC
@ LTC_READ_AUXILIARY_REGISTER_C_RDAUXC
Definition: ltc_defs.h:207
LTC_EXIT_READAUXILIARY_ALLGPIOS
@ LTC_EXIT_READAUXILIARY_ALLGPIOS
Definition: ltc_defs.h:209
LTC_READ_AUXILIARY_REGISTER_B_RDAUXB
@ LTC_READ_AUXILIARY_REGISTER_B_RDAUXB
Definition: ltc_defs.h:206
LTC_READ_VOLTAGE_REGISTER_B_RDCVB_READVOLTAGE
@ LTC_READ_VOLTAGE_REGISTER_B_RDCVB_READVOLTAGE
Definition: ltc_defs.h:196
LTC_EXIT_READVOLTAGE
@ LTC_EXIT_READVOLTAGE
Definition: ltc_defs.h:204
LTC_READ_VOLTAGE_REGISTER_E_RDCVE_READVOLTAGE
@ LTC_READ_VOLTAGE_REGISTER_E_RDCVE_READVOLTAGE
Definition: ltc_defs.h:199
LTC_READ_VOLTAGE_REGISTER_C_RDCVC_READVOLTAGE
@ LTC_READ_VOLTAGE_REGISTER_C_RDCVC_READVOLTAGE
Definition: ltc_defs.h:197
LTC_REUSE_READVOLT_FOR_ADOW_PUP
@ LTC_REUSE_READVOLT_FOR_ADOW_PUP
Definition: ltc_defs.h:499
LTC_REUSE_READVOLT_FOR_ADOW_PDOWN
@ LTC_REUSE_READVOLT_FOR_ADOW_PDOWN
Definition: ltc_defs.h:500
LTC_NOT_REUSED
@ LTC_NOT_REUSED
Definition: ltc_defs.h:498
LTC_ADCMODE_e
LTC_ADCMODE_e
Definition: ltc_defs.h:97
LTC_ADCMODE_UNDEFINED
@ LTC_ADCMODE_UNDEFINED
Definition: ltc_defs.h:98
LTC_ADCMODE_FILTERED_DCP1
@ LTC_ADCMODE_FILTERED_DCP1
Definition: ltc_defs.h:104
LTC_ADCMODE_FAST_DCP1
@ LTC_ADCMODE_FAST_DCP1
Definition: ltc_defs.h:102
LTC_ADCMODE_NORMAL_DCP0
@ LTC_ADCMODE_NORMAL_DCP0
Definition: ltc_defs.h:100
LTC_ADCMODE_FILTERED_DCP0
@ LTC_ADCMODE_FILTERED_DCP0
Definition: ltc_defs.h:101
LTC_ADCMODE_NORMAL_DCP1
@ LTC_ADCMODE_NORMAL_DCP1
Definition: ltc_defs.h:103
LTC_ADCMODE_FAST_DCP0
@ LTC_ADCMODE_FAST_DCP0
Definition: ltc_defs.h:99
LTC_ENTRY
@ LTC_ENTRY
Definition: ltc_defs.h:165
os.h
Declaration of the OS wrapper interface.
OS_ExitTaskCritical
void OS_ExitTaskCritical(void)
Exit Critical interface function for use in FreeRTOS-Tasks and FreeRTOS-ISR.
Definition: os_freertos.c:138
OS_EnterTaskCritical
void OS_EnterTaskCritical(void)
Enter Critical interface function for use in FreeRTOS-Tasks and FreeRTOS-ISR.
Definition: os_freertos.c:134
PEX_SetPin
void PEX_SetPin(uint8_t portExpander, uint8_t pin)
sets pin to high.
Definition: pex.c:336
PEX_SetPinDirectionOutput
void PEX_SetPinDirectionOutput(uint8_t portExpander, uint8_t pin)
sets pin to input.
Definition: pex.c:409
pex.h
Header for the driver for the NXP PCA9539 port expander module.
PEX_PIN16
#define PEX_PIN16
Definition: pex_cfg.h:96
PEX_PIN13
#define PEX_PIN13
Definition: pex_cfg.h:93
PEX_PIN10
#define PEX_PIN10
Definition: pex_cfg.h:90
PEX_PORT_EXPANDER3
#define PEX_PORT_EXPANDER3
Definition: pex_cfg.h:77
PEX_PIN17
#define PEX_PIN17
Definition: pex_cfg.h:97
PEX_PIN12
#define PEX_PIN12
Definition: pex_cfg.h:92
PEX_PIN15
#define PEX_PIN15
Definition: pex_cfg.h:95
PEX_PIN11
#define PEX_PIN11
Definition: pex_cfg.h:91
PEX_PIN14
#define PEX_PIN14
Definition: pex_cfg.h:94
spi_ltcInterface
SPI_INTERFACE_CONFIG_s spi_ltcInterface[BS_NR_OF_STRINGS]
Definition: spi_cfg.c:171
AFE_PLAUSIBILITY_VALUES_s
struct definition for plausibility values of an AFE
Definition: afe_plausibility.h:72
AFE_PLAUSIBILITY_VALUES_s::maximumPlausibleVoltage_mV
const int16_t maximumPlausibleVoltage_mV
Definition: afe_plausibility.h:77
DATA_BLOCK_ALL_GPIO_VOLTAGES_s
Definition: database_cfg.h:314
DATA_BLOCK_ALL_GPIO_VOLTAGES_s::invalidGpioVoltages
uint16_t invalidGpioVoltages[BS_NR_OF_STRINGS][BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:324
DATA_BLOCK_ALL_GPIO_VOLTAGES_s::gpioVoltages_mV
int16_t gpioVoltages_mV[BS_NR_OF_STRINGS][BS_NR_OF_MODULES_PER_STRING *BS_NR_OF_GPIOS_PER_MODULE]
Definition: database_cfg.h:320
DATA_BLOCK_ALL_GPIO_VOLTAGES_s::state
uint8_t state
Definition: database_cfg.h:319
DATA_BLOCK_ALL_GPIO_VOLTAGES_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:318
DATA_BLOCK_BALANCING_CONTROL_s
Definition: database_cfg.h:246
DATA_BLOCK_BALANCING_CONTROL_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:250
DATA_BLOCK_BALANCING_CONTROL_s::balancingState
uint8_t balancingState[BS_NR_OF_STRINGS][BS_NR_OF_CELL_BLOCKS_PER_STRING]
Definition: database_cfg.h:255
DATA_BLOCK_BALANCING_CONTROL_s::nrBalancedCells
uint16_t nrBalancedCells[BS_NR_OF_STRINGS]
Definition: database_cfg.h:258
DATA_BLOCK_BALANCING_FEEDBACK_s
Definition: database_cfg.h:281
DATA_BLOCK_BALANCING_FEEDBACK_s::state
uint8_t state
Definition: database_cfg.h:286
DATA_BLOCK_BALANCING_FEEDBACK_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:285
DATA_BLOCK_BALANCING_FEEDBACK_s::value
uint16_t value[BS_NR_OF_STRINGS][BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:287
DATA_BLOCK_CELL_TEMPERATURE_s
Definition: database_cfg.h:145
DATA_BLOCK_CELL_TEMPERATURE_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:149
DATA_BLOCK_CELL_TEMPERATURE_s::cellTemperature_ddegC
int16_t cellTemperature_ddegC[BS_NR_OF_STRINGS][BS_NR_OF_TEMP_SENSORS_PER_STRING]
Definition: database_cfg.h:151
DATA_BLOCK_CELL_TEMPERATURE_s::nrValidTemperatures
uint16_t nrValidTemperatures[BS_NR_OF_STRINGS]
Definition: database_cfg.h:154
DATA_BLOCK_CELL_TEMPERATURE_s::state
uint8_t state
Definition: database_cfg.h:150
DATA_BLOCK_CELL_TEMPERATURE_s::invalidCellTemperature
uint16_t invalidCellTemperature[BS_NR_OF_STRINGS][BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:153
DATA_BLOCK_CELL_VOLTAGE_s
Definition: database_cfg.h:128
DATA_BLOCK_CELL_VOLTAGE_s::packVoltage_mV
int32_t packVoltage_mV[BS_NR_OF_STRINGS]
Definition: database_cfg.h:134
DATA_BLOCK_CELL_VOLTAGE_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:132
DATA_BLOCK_CELL_VOLTAGE_s::state
uint8_t state
Definition: database_cfg.h:133
DATA_BLOCK_CELL_VOLTAGE_s::invalidCellVoltage
uint64_t invalidCellVoltage[BS_NR_OF_STRINGS][BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:138
DATA_BLOCK_CELL_VOLTAGE_s::nrValidCellVoltages
uint16_t nrValidCellVoltages[BS_NR_OF_STRINGS]
Definition: database_cfg.h:139
DATA_BLOCK_CELL_VOLTAGE_s::cellVoltage_mV
int16_t cellVoltage_mV[BS_NR_OF_STRINGS][BS_NR_OF_CELL_BLOCKS_PER_STRING]
Definition: database_cfg.h:135
DATA_BLOCK_HEADER_s::uniqueId
DATA_BLOCK_ID_e uniqueId
Definition: database_cfg.h:122
DATA_BLOCK_OPEN_WIRE_s
Definition: database_cfg.h:301
DATA_BLOCK_OPEN_WIRE_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:305
DATA_BLOCK_OPEN_WIRE_s::state
uint8_t state
Definition: database_cfg.h:306
DATA_BLOCK_OPEN_WIRE_s::openWire
uint8_t openWire[BS_NR_OF_STRINGS][BS_NR_OF_MODULES_PER_STRING *BS_NR_OF_CELL_BLOCKS_PER_MODULE]
Definition: database_cfg.h:310
DATA_BLOCK_SLAVE_CONTROL_s
Definition: database_cfg.h:262
DATA_BLOCK_SLAVE_CONTROL_s::eepromWriteAddressToUse
uint32_t eepromWriteAddressToUse
Definition: database_cfg.h:270
DATA_BLOCK_SLAVE_CONTROL_s::eepromWriteAddressLastUsed
uint32_t eepromWriteAddressLastUsed
Definition: database_cfg.h:271
DATA_BLOCK_SLAVE_CONTROL_s::ioValueOut
uint8_t ioValueOut[BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:272
DATA_BLOCK_SLAVE_CONTROL_s::state
uint8_t state
Definition: database_cfg.h:267
DATA_BLOCK_SLAVE_CONTROL_s::eepromReadAddressToUse
uint32_t eepromReadAddressToUse
Definition: database_cfg.h:268
DATA_BLOCK_SLAVE_CONTROL_s::eepromReadAddressLastUsed
uint32_t eepromReadAddressLastUsed
Definition: database_cfg.h:269
DATA_BLOCK_SLAVE_CONTROL_s::ioValueIn
uint8_t ioValueIn[BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:273
DATA_BLOCK_SLAVE_CONTROL_s::eepromValueWrite
uint8_t eepromValueWrite[BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:274
DATA_BLOCK_SLAVE_CONTROL_s::externalTemperatureSensor
uint8_t externalTemperatureSensor[BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:277
DATA_BLOCK_SLAVE_CONTROL_s::eepromValueRead
uint8_t eepromValueRead[BS_NR_OF_MODULES_PER_STRING]
Definition: database_cfg.h:275
DATA_BLOCK_SLAVE_CONTROL_s::header
DATA_BLOCK_HEADER_s header
Definition: database_cfg.h:266
LTC_DATAPTR_s::openWireDetection
LTC_OPENWIRE_DETECTION_s * openWireDetection
Definition: ltc_defs.h:451
LTC_DATAPTR_s::allGpioVoltages
DATA_BLOCK_ALL_GPIO_VOLTAGES_s * allGpioVoltages
Definition: ltc_defs.h:448
LTC_DATAPTR_s::cellVoltage
DATA_BLOCK_CELL_VOLTAGE_s * cellVoltage
Definition: ltc_defs.h:443
LTC_DATAPTR_s::cellTemperature
DATA_BLOCK_CELL_TEMPERATURE_s * cellTemperature
Definition: ltc_defs.h:444
LTC_DATAPTR_s::txBuffer
uint16_t * txBuffer
Definition: ltc_defs.h:440
LTC_DATAPTR_s::errorTable
LTC_ERRORTABLE_s * errorTable
Definition: ltc_defs.h:452
LTC_DATAPTR_s::balancingFeedback
DATA_BLOCK_BALANCING_FEEDBACK_s * balancingFeedback
Definition: ltc_defs.h:445
LTC_DATAPTR_s::pSpiInterface
SPI_INTERFACE_CONFIG_s * pSpiInterface
Definition: ltc_defs.h:439
LTC_DATAPTR_s::rxBuffer
uint16_t * rxBuffer
Definition: ltc_defs.h:441
LTC_DATAPTR_s::usedCellIndex
uint16_t * usedCellIndex
Definition: ltc_defs.h:450
LTC_DATAPTR_s::frameLength
uint32_t frameLength
Definition: ltc_defs.h:442
LTC_DATAPTR_s::slaveControl
DATA_BLOCK_SLAVE_CONTROL_s * slaveControl
Definition: ltc_defs.h:447
LTC_DATAPTR_s::openWire
DATA_BLOCK_OPEN_WIRE_s * openWire
Definition: ltc_defs.h:449
LTC_DATAPTR_s::balancingControl
DATA_BLOCK_BALANCING_CONTROL_s * balancingControl
Definition: ltc_defs.h:446
LTC_ERRORTABLE_s
Definition: ltc_defs.h:71
LTC_ERRORTABLE_s::PEC_valid
uint8_t PEC_valid[BS_NR_OF_STRINGS][LTC_N_LTC]
Definition: ltc_defs.h:72
LTC_ERRORTABLE_s::mux3
uint8_t mux3[BS_NR_OF_STRINGS][LTC_N_LTC]
Definition: ltc_defs.h:76
LTC_ERRORTABLE_s::mux2
uint8_t mux2[BS_NR_OF_STRINGS][LTC_N_LTC]
Definition: ltc_defs.h:75
LTC_ERRORTABLE_s::mux0
uint8_t mux0[BS_NR_OF_STRINGS][LTC_N_LTC]
Definition: ltc_defs.h:73
LTC_ERRORTABLE_s::mux1
uint8_t mux1[BS_NR_OF_STRINGS][LTC_N_LTC]
Definition: ltc_defs.h:74
LTC_MUX_CH_CFG_s
Definition: ltc_defs.h:426
LTC_MUX_CH_CFG_s::muxCh
uint8_t muxCh
Definition: ltc_defs.h:428
LTC_MUX_CH_CFG_s::muxID
uint8_t muxID
Definition: ltc_defs.h:427
LTC_MUX_SEQUENCE_s::nr_of_steps
uint8_t nr_of_steps
Definition: ltc_defs.h:433
LTC_MUX_SEQUENCE_s::seqptr
LTC_MUX_CH_CFG_s * seqptr
Definition: ltc_defs.h:434
LTC_OPENWIRE_DETECTION_s
Definition: ltc_defs.h:80
LTC_OPENWIRE_DETECTION_s::openWireDelta
int32_t openWireDelta[BS_NR_OF_STRINGS][BS_NR_OF_CELL_BLOCKS_PER_STRING]
Definition: ltc_defs.h:83
LTC_OPENWIRE_DETECTION_s::openWirePdown
int16_t openWirePdown[BS_NR_OF_STRINGS][BS_NR_OF_CELL_BLOCKS_PER_STRING]
Definition: ltc_defs.h:82
LTC_OPENWIRE_DETECTION_s::openWirePup
int16_t openWirePup[BS_NR_OF_STRINGS][BS_NR_OF_CELL_BLOCKS_PER_STRING]
Definition: ltc_defs.h:81
LTC_REQUEST_s
Definition: ltc_defs.h:514
LTC_REQUEST_s::request
LTC_STATE_REQUEST_e request
Definition: ltc_defs.h:515
LTC_REQUEST_s::string
uint8_t string
Definition: ltc_defs.h:516
LTC_STATE_s
Definition: ltc_defs.h:523
LTC_STATE_s::commandDataTransferTime
uint32_t commandDataTransferTime
Definition: ltc_defs.h:547
LTC_STATE_s::ltcData
LTC_DATAPTR_s ltcData
Definition: ltc_defs.h:582
LTC_STATE_s::voltMeasDiagErrorEntry
DIAG_ID_e voltMeasDiagErrorEntry
Definition: ltc_defs.h:580
LTC_STATE_s::adcModereq
LTC_ADCMODE_e adcModereq
Definition: ltc_defs.h:534
LTC_STATE_s::statereq
LTC_REQUEST_s statereq
Definition: ltc_defs.h:526
LTC_STATE_s::pecDiagErrorEntry
DIAG_ID_e pecDiagErrorEntry
Definition: ltc_defs.h:578
LTC_STATE_s::triggerentry
uint8_t triggerentry
Definition: ltc_defs.h:545
LTC_STATE_s::muxDiagErrorEntry
DIAG_ID_e muxDiagErrorEntry
Definition: ltc_defs.h:579
LTC_STATE_s::muxmeas_nr_end
uint8_t muxmeas_nr_end[BS_NR_OF_STRINGS]
Definition: ltc_defs.h:588
LTC_STATE_s::tempMeasDiagErrorEntry
DIAG_ID_e tempMeasDiagErrorEntry
Definition: ltc_defs.h:581
LTC_STATE_s::spiSeqPtr
SPI_INTERFACE_CONFIG_s * spiSeqPtr
Definition: ltc_defs.h:572
LTC_STATE_s::commandTransferTime
uint32_t commandTransferTime
Definition: ltc_defs.h:548
LTC_STATE_s::spiSeqEndPtr
SPI_INTERFACE_CONFIG_s * spiSeqEndPtr
Definition: ltc_defs.h:573
LTC_STATE_s::substate
uint8_t substate
Definition: ltc_defs.h:528
LTC_STATE_s::laststate
LTC_STATEMACH_e laststate
Definition: ltc_defs.h:529
LTC_STATE_s::lastsubstate
uint8_t lastsubstate
Definition: ltc_defs.h:530
LTC_STATE_s::adcMeasCh
LTC_ADCMEAS_CHAN_e adcMeasCh
Definition: ltc_defs.h:536
LTC_STATE_s::reusageMeasurementMode
LTC_REUSE_MODE_e reusageMeasurementMode
Definition: ltc_defs.h:562
LTC_STATE_s::gpioClocksTransferTime
uint32_t gpioClocksTransferTime
Definition: ltc_defs.h:550
LTC_STATE_s::timer
uint16_t timer
Definition: ltc_defs.h:524
LTC_STATE_s::resendCommandCounter
uint8_t resendCommandCounter
Definition: ltc_defs.h:569
LTC_STATE_s::state
LTC_STATEMACH_e state
Definition: ltc_defs.h:527
LTC_STATE_s::spiDiagErrorEntry
DIAG_ID_e spiDiagErrorEntry
Definition: ltc_defs.h:577
LTC_STATE_s::spiNumberInterfaces
uint8_t spiNumberInterfaces
Definition: ltc_defs.h:574
LTC_STATE_s::muxmeas_seqendptr
LTC_MUX_CH_CFG_s * muxmeas_seqendptr[BS_NR_OF_STRINGS]
Definition: ltc_defs.h:586
LTC_STATE_s::adcMode
LTC_ADCMODE_e adcMode
Definition: ltc_defs.h:531
LTC_STATE_s::currentString
uint8_t currentString
Definition: ltc_defs.h:575
LTC_STATE_s::muxmeas_seqptr
LTC_MUX_CH_CFG_s * muxmeas_seqptr[BS_NR_OF_STRINGS]
Definition: ltc_defs.h:584
LTC_STATE_s::ErrRequestCounter
uint32_t ErrRequestCounter
Definition: ltc_defs.h:544
LTC_STATE_s::balance_control_done
STD_RETURN_TYPE_e balance_control_done
Definition: ltc_defs.h:568
LTC_STATE_s::check_spi_flag
STD_RETURN_TYPE_e check_spi_flag
Definition: ltc_defs.h:567
LTC_STATE_s::first_measurement_made
bool first_measurement_made
Definition: ltc_defs.h:564
LTC_STATE_s::requestedString
uint8_t requestedString
Definition: ltc_defs.h:576
LTC_STATE_s::adcMeasChreq
LTC_ADCMEAS_CHAN_e adcMeasChreq
Definition: ltc_defs.h:538
SPI_INTERFACE_CONFIG_s
Definition: spi_cfg.h:125
SPI_INTERFACE_CONFIG_s::pNode
spiBASE_t * pNode
Definition: spi_cfg.h:127