foxBMS - Unit Tests  1.2.1
The foxBMS Unit Tests API Documentation
mxm_1785x_tools.h
Go to the documentation of this file.
1 /**
2  *
3  * @copyright © 2010 - 2021, Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V.
4  * All rights reserved.
5  *
6  * SPDX-License-Identifier: BSD-3-Clause
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright notice, this
12  * list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright notice,
15  * this list of conditions and the following disclaimer in the documentation
16  * and/or other materials provided with the distribution.
17  *
18  * 3. Neither the name of the copyright holder nor the names of its
19  * contributors may be used to endorse or promote products derived from
20  * this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * We kindly request you to use one or more of the following phrases to refer to
34  * foxBMS in your hardware, software, documentation or advertising materials:
35  *
36  * - ″This product uses parts of foxBMS®″
37  * - ″This product includes parts of foxBMS®″
38  * - ″This product is derived from foxBMS®″
39  *
40  */
41 
42 /**
43  * @file mxm_1785x_tools.h
44  * @author foxBMS Team
45  * @date 2020-07-15 (date of creation)
46  * @updated 2021-12-06 (date of last update)
47  * @ingroup DRIVERS
48  * @prefix MXM
49  *
50  * @brief This is a collection of helper functions for the MAX1785x ICs
51  *
52  * @details This collection of helper functions for the MAX1785x ICs helps to
53  * calculate the lsb and msb for register values and similar tasks.
54  *
55  */
56 
57 #ifndef FOXBMS__MXM_1785X_TOOLS_H_
58 #define FOXBMS__MXM_1785X_TOOLS_H_
59 
60 /*========== Includes =======================================================*/
61 #include "mxm_cfg.h"
62 
63 #include "database.h"
64 #include "mxm_basic_defines.h"
65 #include "mxm_battery_management.h"
66 #include "mxm_register_map.h"
67 
68 /*========== Macros and Definitions =========================================*/
69 /**
70  * @brief States of the global Maxim state-machine
71  *
72  * State transitions are currently autonomous and will have to be integrated into
73  * the Battery System state-machine.
74  */
75 typedef enum {
76  MXM_STATEMACHINE_STATES_UNINITIALIZED, /*!< uninitialized state */
77  MXM_STATEMACHINE_STATES_SELFCHECK_PRE_INIT, /*!< self-check that has to be executed before initialization */
78  MXM_STATEMACHINE_STATES_INIT, /*!< initialization sequence */
79  MXM_STATEMACHINE_STATES_SELFCHECK_POST_INIT, /*!< self-check that has to be executed after initialization */
80  MXM_STATEMACHINE_STATES_IDLE, /*!< idle state, the driver waits for operation here */
81  MXM_STATEMACHINE_STATES_OPERATION, /*!< operating state, the measurement cycle is executed here */
82  MXM_STATEMACHINE_STATES_MAXSTATE, /*!< highest state */
84 
85 /** states of the #MXM_StateMachineOperation() statemachine */
86 typedef enum {
161 
162 /** intermediate state-definition for #MXM_MonGetVoltages() */
163 typedef enum {
164  MXM_MONITORING_STATE_PENDING, /*!< state completion is pending */
165  MXM_MONITORING_STATE_PASS, /*!< state passed successfully */
167 
168 /**
169  * struct describing the different return values of selfchecks that the driver can execute
170  */
171 typedef struct {
172  STD_RETURN_TYPE_e crc; /*!< CRC self-check; stores the return value of #MXM_CRC8SelfTest(). */
173  STD_RETURN_TYPE_e conv; /*!< Conversion self-check; stores the return value of #MXM_ConvertTest(). */
174  STD_RETURN_TYPE_e firstSetBit; /*!< First Set Bit self-check; stores the return value of #MXM_FirstSetBitTest(). */
176  extractValueFromRegister; /*!< Extract value from Register self-check; stores the return value of #MXM_ExtractValueFromRegisterTest(). */
178  parseVoltageReadall; /*!< Voltage parsing of READALL; stores the return value of #MXM_ParseVoltageReadallTest(). */
180  addressSpaceChecker; /*!< Address space checker; stores the return value of #MXM_5XUserAccessibleAddressSpaceCheckerSelfCheck(). */
182  fmeaStatusASCI; /*!< MAX17841B FMEA register; stores the value of the FMEA check conducted in the state #MXM_STATEMACH_41B_CHECK_FMEA. */
184 
185 /* TODO implement filling of values */
186 /* TODO read and verify OTP register */
187 
188 /** struct describing an entry into the monitoring registry */
189 typedef struct {
190  bool connected; /*!< state variable, indicates whether monitoring IC is connected */
191  uint8_t deviceAddress; /*!< address that has been assigned during enumeration */
192  MXM_MODEL_ID_e model; /*!< model (e.g. 17853) */
193  MXM_siliconVersion_e siliconVersion; /*!< silicon version of chip */
194  uint32_t deviceID; /*!< 24-bit unique device ID */
195  uint16_t registerStatus1; /*!< content of the STATUS1 register */
196  uint16_t registerStatus2; /*!< content of the STATUS2 register */
197  uint16_t registerStatus3; /*!< content of the STATUS3 register */
198  uint16_t registerFmea1; /*!< content of the FMEA1 register */
199  uint16_t registerFmea2; /*!< content of the FMEA2 register */
201 
202 /**
203  * @brief Length of RX buffer
204  * @details This define describes the length of the array
205  * #MXM_MONITORING_INSTANCE_s::rxBuffer. It is large enough to fit the largest
206  * message that can be written into a single buffer which consists of
207  * 6 command bytes and #MXM_MAXIMUM_NR_OF_MODULES times 2 receive
208  * bytes for the maximum number of connected monitoring ICs.
209  */
210 #define MXM_RX_BUFFER_LENGTH (100u)
211 
212 /** struct that contains the state of the balancing subsystem */
213 typedef struct {
214  uint8_t moduleBalancingIndex; /*!< index of the module that is currently handled */
215  bool evenCellsNeedBalancing; /*!< indicates that even cells need balancing */
216  bool oddCellsNeedBalancing; /*!< indicates that odd cells need balancing */
217  bool evenCellsBalancingProcessed; /*!< balancing of even cells has been processed */
218  bool oddCellsBalancingProcessed; /*!< balancing of odd cells has been processed */
219  uint16_t cellsToBalance; /*!< bitfield used for register BALSWCTRL, 16 bits for upt to 14 cells */
220  uint32_t previousTimeStamp; /*!< timestamp of previous balancing checkpoint */
221  uint32_t currentTimeStamp; /*!< timestamp of current balancing checkpoint */
222  DATA_BLOCK_BALANCING_CONTROL_s *const pBalancingControl_table; /*!< balancing control table */
224 
225 /** Status of the Maxim-main-state-machine. */
226 typedef struct {
227  bool resetNecessary; /*!< a reset of the whole driver is requested (due to an error) */
228  uint8_t errorCounter; /*!< counts the number of errors and issues a reset when the counter trips */
229  uint32_t timestampLastError; /*!< timestamp of last error counter increment; will be reset if old enough */
230  MXM_STATEMACHINE_STATES_e state; /*!< state of the maxim state-machine */
231  MXM_STATEMACHINE_OPERATION_STATES_e operationSubstate; /*!< substate during operation of monitoring */
232  bool allowStartup; /*!< indicates whether start of state-machine has been requested */
233  bool operationRequested; /*!< indicates whether the measurement cycle should run */
234  bool firstMeasurementDone; /*!< this bit is set after the first measurement cycle */
235  bool stopRequested; /*!< indicates that no new measurement cycles should be run */
236  bool openwireRequested; /*!< indicates that an openwire-check has been requested */
237  bool undervoltageAlert; /*!< whether undervoltage alert has occurred. TODO remove? replaced by DC? */
238  uint8_t muxCounter; /*!< counter for the currently selected mux channel */
239  uint8_t diagnosticCounter; /*!< upward counter for determining when a diagnostic cycle should be entered */
240  MXM_DC_BYTE_e dcByte; /*!< content of the data-check-byte */
241  uint8_t mxmVoltageCellCounter; /*!< counter for getting all cellvoltages */
242  uint8_t highest5xDevice; /*!< address of highest monitoring device of the 5x family */
243  MXM_5X_STATE_REQUEST_STATUS_e requestStatus5x; /*!< status of request to 5x */
244  MXM_5X_COMMAND_PAYLOAD_s batteryCmdBuffer; /*!< buffer for Battery Management Commands */
245  STD_RETURN_TYPE_e resultSelfCheck; /*!< Status of driver-wide self-check */
246  MXM_SELFCHECK_s selfCheck; /*!< stores self check return values */
247  MXM_BALANCING_STATE_s *const pBalancingState; /*!< pointer to the balancing structure */
248  MXM_41B_INSTANCE_s *const pInstance41B; /*!< instance-pointer of the 41b-state-machine */
249  MXM_5X_INSTANCE_s *const pInstance5X; /*!< instance-pointer of the 5x-state-machine */
250  DATA_BLOCK_CELL_VOLTAGE_s *const pCellVoltages_table; /*!< cell voltages table */
251  DATA_BLOCK_CELL_TEMPERATURE_s *const pCellTemperatures_table; /*!< cell temperatures table */
252  DATA_BLOCK_OPEN_WIRE_s *const pOpenwire_table; /*!< open wire table */
253  /**
254  * @brief Local storage for cell-voltages
255  *
256  * This local variable stores the measured cell- and AUX-voltages. Independent
257  * of the actual configuration, it stores the measurement values always at the
258  * same place and never changes in size.
259  * As an example the voltage of cell 5 (cells are numbered from 1 to 14)
260  * in module 0 (modules are numbered from 0 to 31) will be in entry 4.
261  * The voltage of cell 14 of module 1 will be in entry 27. This is independent
262  * of the size of the setup which is defined in the defines
263  * #BS_NR_OF_CELLS_PER_MODULE and #BS_NR_OF_MODULES.
264  * Therefore, the size of the arrays inside this struct is defined as
265  * #MXM_MAXIMUM_NR_OF_MODULES times #MXM_MAXIMUM_NR_OF_CELLS_PER_MODULE.
266  */
268  MXM_REGISTRY_ENTRY_s registry[MXM_MAXIMUM_NR_OF_MODULES]; /*!< registry for connected monitoring ICs */
269  uint8_t rxBuffer[MXM_RX_BUFFER_LENGTH]; /*!< buffer that stores the incoming data from the lower state-machines.
270  It contains the command sequence as it is received on the ASCI together with the Battery Management Protocol command. */
272 
273 /*========== Extern Constant and Variable Declarations ======================*/
274 
275 /*========== Extern Function Prototypes =====================================*/
276 /**
277  * @brief Convert a measurement value to a voltage value.
278  * @details This function converts measurement values from the monitoring
279  * IC into a voltage value. It assumes that measurement values are
280  * spread over the LSB and MSB according to the data sheet. This
281  * means that the two lowest bits are 0 and the 14-bit measurement
282  * is spread over the 14 highest bits.
283  *
284  * The conversion type describes the kind of measurement that has
285  * been executed.
286  * @param[in] lsb LSB of the value
287  * @param[in] msb MSB of the value
288  * @param[out] pTarget pointer in which the converted value
289  * shall be written
290  * @param[in] convType type of conversion (bipolar or unipolar)
291  * @param[in] fullScaleReference_mV reference voltage of full scale
292  * (for voltage measurements 5000)
293  */
294 extern void MXM_Convert(
295  uint8_t lsb,
296  uint8_t msb,
297  uint16_t *pTarget,
298  MXM_CONVERSION_TYPE_e convType,
299  uint32_t fullScaleReference_mV);
300 
301 /**
302  * @brief Test the #MXM_Convert()-function.
303  * @details This test-function is intended as a self-check. It tests whether
304  * the #MXM_Convert()-function computes the values as expected.
305  * @return #STD_OK on successful execution, otherwise #STD_NOT_OK
306  */
308 
309 /**
310  * @brief Extract a value from a single register.
311  * @details This function extracts a single value from a single register.
312  * The register has to be supplied as MSB and LSB. The bitmask has to
313  * be of type #MXM_REG_BM. The extracted value will be written into
314  * value.
315  *
316  * The function can only extract values from single registers
317  * (MSB and LSB)and does not handle values that span multiple
318  * registers.
319  * @param[in] lsb least significant byte of the register
320  * @param[in] msb most significant byte of the register
321  * @param[in] bitmask bitmask for the value
322  * @param[out] pValue pointer to a variable in which the value
323  * should be written
324  */
325 extern void MXM_ExtractValueFromRegister(uint8_t lsb, uint8_t msb, MXM_REG_BM bitmask, uint16_t *pValue);
326 
327 /**
328  * @brief Test #MXM_ExtractValueFromRegister().
329  * @details Self-check that tests whether #MXM_ExtractValueFromRegister() works
330  * as expected.
331  * @return #STD_OK if the self-check has passed successfully
332  */
334 
335 /**
336  * @brief Test #MXM_FirstSetBit().
337  * @details Tests the function #MXM_FirstSetBit() if it works as expected.
338  * @return #STD_OK if the self-check has passed successfully
339  */
341 
342 /**
343  * @brief convert a unipolar 14bit-value and shifts it into the 16bit-format
344  * @details Takes a value in the unipolar 14bit format and transforms it into
345  * a 16bit register entry for the monitoring IC (separated into LSB
346  * and MSB).
347  * @param[in] inputValue unipolar 14bit-value
348  * @param[out] lsb LSB in 16bit-format
349  * @param[out] msb MSB in 16bit-format
350  */
351 extern void MXM_Unipolar14BitInto16Bit(uint16_t inputValue, uint8_t *lsb, uint8_t *msb);
352 
353 /**
354  * @brief convert a voltage value into a unipolar 14bit value
355  * @details Takes a voltage value in mV together with a reference for fullscale
356  * values into a unipolar 14bit value.
357  * @param[in] voltage_mV voltage in mV
358  * @param[in] fullscaleReference_mV value of the fullscale in mV;
359  * typically 5000
360  * @return unipolar 14bit value for usage with
361  * #MXM_Unipolar14BitInto16Bit()
362  */
363 extern uint16_t MXM_VoltageIntoUnipolar14Bit(uint16_t voltage_mV, uint16_t fullscaleReference_mV);
364 
365 /**
366  * @brief Get the string and module number from a global module number
367  * @details Maxim driver knows only one string internally and maps on demand
368  * this one string onto several strings (for instances where several
369  * modules are in the same daisy-chain but belong to different
370  * strings).
371  *
372  * This function assumes that a string contains #BS_NR_OF_MODULES modules
373  * in #BS_NR_OF_STRINGS strings and that they are connected in
374  * a daisy-chain.
375  * @param[in] moduleNumber number of the module in the daisy-chain (starts with 0)
376  * @param[out] pStringNumber pointer where the string number will be written
377  * @param[out] pModuleNumberInString module number in the string
378  */
379 extern void MXM_ConvertModuleToString(
380  const uint16_t moduleNumber,
381  uint8_t *pStringNumber,
382  uint16_t *pModuleNumberInString);
383 
384 /*========== Externalized Static Functions Prototypes (Unit Test) ===========*/
385 
386 #endif /* FOXBMS__MXM_1785X_TOOLS_H_ */
Database module header.
enum STD_RETURN_TYPE STD_RETURN_TYPE_e
#define must_check_return
Allows functions to generate warnings in GCC for unused returns.
Definition: general.h:101
void MXM_Unipolar14BitInto16Bit(uint16_t inputValue, uint8_t *lsb, uint8_t *msb)
convert a unipolar 14bit-value and shifts it into the 16bit-format
void MXM_ConvertModuleToString(const uint16_t moduleNumber, uint8_t *pStringNumber, uint16_t *pModuleNumberInString)
Get the string and module number from a global module number.
STD_RETURN_TYPE_e must_check_return MXM_ConvertTest(void)
Test the MXM_Convert()-function.
STD_RETURN_TYPE_e must_check_return MXM_FirstSetBitTest(void)
Test MXM_FirstSetBit().
MXM_MONITORING_STATE_e
@ MXM_MONITORING_STATE_PASS
@ MXM_MONITORING_STATE_PENDING
uint16_t MXM_VoltageIntoUnipolar14Bit(uint16_t voltage_mV, uint16_t fullscaleReference_mV)
convert a voltage value into a unipolar 14bit value
STD_RETURN_TYPE_e must_check_return MXM_ExtractValueFromRegisterTest(void)
Test MXM_ExtractValueFromRegister().
void MXM_Convert(uint8_t lsb, uint8_t msb, uint16_t *pTarget, MXM_CONVERSION_TYPE_e convType, uint32_t fullScaleReference_mV)
Convert a measurement value to a voltage value.
MXM_STATEMACHINE_OPERATION_STATES_e
@ MXM_INIT_I2C_GET_STAT1
@ MXM_OP_DIAGNOSTIC_CLEAR_FMEA1
@ MXM_INIT_BALEXP5
@ MXM_OP_WRITE_MUX0
@ MXM_INIT_BALEXP6
@ MXM_OP_DIAGNOSTIC_FMEA2
@ MXM_INIT_STATUS1
@ MXM_INIT_BALEXP13
@ MXM_INIT_OVTHSETREG
@ MXM_INIT_BALEXP1
@ MXM_INIT_BALEXP9
@ MXM_OP_PINOPEN_RESTORE_CURRENT_SOURCE_CONF
@ MXM_INIT_SET_STATUS2
@ MXM_OP_DIAGNOSTIC_FMEA1
@ MXM_INIT_I2C_SEND_MUX1
@ MXM_INIT_MEASUREEN1
@ MXM_OP_PINOPEN_SET_CURRENT_SOURCES
@ MXM_INIT_GET_ID2
@ MXM_INIT_MEASUREEN2
@ MXM_OP_PINOPEN_GET_SCAN_STROBE
@ MXM_OP_DIAGNOSTIC_CLEAR_STATUS2
@ MXM_INIT_I2C_PNTR
@ MXM_OP_BAL_START
@ MXM_INIT_BALEXP8
@ MXM_INIT_UVTHSETREG
@ MXM_OP_PINOPEN_COMPSCAN
@ MXM_INIT_I2C_SEND_MUX0
@ MXM_INIT_BALSWDLY
@ MXM_INIT_GET_VERSION
@ MXM_OP_DIAGNOSTIC_CLEAR_FMEA2
@ MXM_OP_BAL_CONTROL_SET_ALL
@ MXM_INIT_ENTRY
@ MXM_INIT_GET_ID1
@ MXM_OP_DIAGNOSTIC_EXIT
@ MXM_OP_DIAGNOSTIC_STATUS1
@ MXM_INIT_GET_I2C_STAT2
@ MXM_OP_PINOPEN_EXIT
@ MXM_OP_PINOPEN_ENTRY
@ MXM_OP_PINOPEN_PROCESS_OPENWIRE
@ MXM_INIT_BALEXP10
@ MXM_INIT_BALEXP14
@ MXM_INIT_BALEXP12
@ MXM_OP_INCREMENT_MUX_COUNTER
@ MXM_OP_BAL_EXIT
@ MXM_OP_PARSE_VOLTAGES_INTO_DB
@ MXM_INIT_I2C_CFG
@ MXM_INIT_ALRTUVEN
@ MXM_INIT_BALEXP3
@ MXM_OP_SELECT_MUX_CHANNEL
@ MXM_INIT_BALEXP2
@ MXM_OP_WRITE_MUX1
@ MXM_INIT_ALRTOVEN
@ MXM_OP_ENTRY_STATE
@ MXM_INIT_BALEXP7
@ MXM_OP_CYCLE_END_EXIT
@ MXM_OP_GET_VOLTAGES
@ MXM_OP_GET_ALRTSUM
@ MXM_OP_CYCLE_END_ENTRY
@ MXM_OP_BAL_CONTROL_RESET_ALL
@ MXM_OP_BAL_ENTRY
@ MXM_INIT_ACQCFG
@ MXM_INIT_COMPOPNTHREG
@ MXM_OP_PINOPEN_GET_ALRT
@ MXM_OP_DIAGNOSTIC_STATUS2
@ MXM_INIT_BALEXP4
@ MXM_OP_DIAGNOSTIC_STATUS3
@ MXM_OP_SET_SCAN_STROBE
@ MXM_OP_GET_SCAN_STROBE
@ MXM_INIT_DEVCFG1
@ MXM_INIT_BALEXP11
@ MXM_INIT_AUXTIMEREG
@ MXM_INIT_AUXGPIOCFG
@ MXM_OP_DIAGNOSTIC_ENTRY
MXM_STATEMACHINE_STATES_e
States of the global Maxim state-machine.
@ MXM_STATEMACHINE_STATES_OPERATION
@ MXM_STATEMACHINE_STATES_INIT
@ MXM_STATEMACHINE_STATES_SELFCHECK_POST_INIT
@ MXM_STATEMACHINE_STATES_UNINITIALIZED
@ MXM_STATEMACHINE_STATES_IDLE
@ MXM_STATEMACHINE_STATES_SELFCHECK_PRE_INIT
@ MXM_STATEMACHINE_STATES_MAXSTATE
#define MXM_RX_BUFFER_LENGTH
Length of RX buffer.
void MXM_ExtractValueFromRegister(uint8_t lsb, uint8_t msb, MXM_REG_BM bitmask, uint16_t *pValue)
Extract a value from a single register.
Basic defines for the complete Maxim driver.
MXM_MODEL_ID_e
Type of monitoring device.
MXM_DC_BYTE_e
MXM_CONVERSION_TYPE_e
MXM_siliconVersion_e
#define MXM_MAXIMUM_NR_OF_MODULES
Maximum number of modules.
Headers for the driver for the MAX17841B ASCI and MAX1785x monitoring chip.
MXM_5X_STATE_REQUEST_STATUS_e
Request status of Battery Management Protocol states.
Header for the configuration for the Maxim monitoring chip.
Register map of the MAX1785x monitoring IC.
uint16_t MXM_REG_BM
Type for register access for monitoring ICs.
Struct for the state-variable of state-machine.
Definition: mxm_17841b.h:157
5x statemachine structure
DATA_BLOCK_BALANCING_CONTROL_s *const pBalancingControl_table
MXM_5X_COMMAND_PAYLOAD_s batteryCmdBuffer
MXM_41B_INSTANCE_s *const pInstance41B
STD_RETURN_TYPE_e resultSelfCheck
MXM_STATEMACHINE_OPERATION_STATES_e operationSubstate
MXM_BALANCING_STATE_s *const pBalancingState
MXM_STATEMACHINE_STATES_e state
MXM_5X_INSTANCE_s *const pInstance5X
MXM_5X_STATE_REQUEST_STATUS_e requestStatus5x
MXM_DATA_STORAGE_s localVoltages
Local storage for cell-voltages.
DATA_BLOCK_OPEN_WIRE_s *const pOpenwire_table
DATA_BLOCK_CELL_VOLTAGE_s *const pCellVoltages_table
DATA_BLOCK_CELL_TEMPERATURE_s *const pCellTemperatures_table
uint16_t registerStatus2
uint16_t registerStatus3
MXM_siliconVersion_e siliconVersion
uint32_t deviceID
uint16_t registerFmea2
uint8_t deviceAddress
MXM_MODEL_ID_e model
uint16_t registerStatus1
uint16_t registerFmea1
bool connected
STD_RETURN_TYPE_e firstSetBit
STD_RETURN_TYPE_e parseVoltageReadall
STD_RETURN_TYPE_e fmeaStatusASCI
STD_RETURN_TYPE_e crc
STD_RETURN_TYPE_e extractValueFromRegister
STD_RETURN_TYPE_e addressSpaceChecker
STD_RETURN_TYPE_e conv
uint16_t rxBuffer[100]