adbms6380.h

Go to the documentation of this file.

 
#ifndef _ADBMS6380_H_
#define _ADBMS6380_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "common/phal/spi.h"
#include "common/strbuf/strbuf.h"
 
// Number of cells per ADBMS6380 device.
#define ADBMS6380_CELL_COUNT (16)
// Number of GPIO/aux channels per ADBMS6380 device.
#define ADBMS6380_GPIO_COUNT (10)
 
// PEC size in bytes for ADBMS6380 commands and data packets. Is 2 bytes for both PEC10 (data) and PEC15 (commands).
#define ADBMS6380_PEC_SIZE (2)
// Raw command size (bytes) for one module without PEC.
#define ADBMS6380_COMMAND_RAW_SIZE (2)
// Command packet size (bytes) for one module including PEC.
#define ADBMS6380_COMMAND_PKT_SIZE (ADBMS6380_COMMAND_RAW_SIZE + ADBMS6380_PEC_SIZE)
// Single data payload size (bytes) for one module without PEC.
#define ADBMS6380_SINGLE_DATA_RAW_SIZE (6)
// Single data packet size (bytes) for one module including PEC.
#define ADBMS6380_SINGLE_DATA_PKT_SIZE (ADBMS6380_SINGLE_DATA_RAW_SIZE + ADBMS6380_PEC_SIZE)
 
// Number of commands to read all 16 cell voltages (5 for 3 cells each, 1 for the last cell)
// {RDCVA, RDCVB, RDCVC, RDCVD, RDCVE, RDCVF}
#define ADBMS6380_RDCV_CMD_COUNT (6)
 
// Number of commands to read all 10 GPIO voltages (3 for 3 GPIOs each, 1 for the last GPIO)
// {RDAUXA, RDAUXB, RDAUXC, RDAUXD}
#define ADBMS6380_RDAUX_CMD_COUNT (4)
 
#define ADBMS6380_WAKE_DELAY_MS (1)
 
typedef enum {
    ADBMS6380_READ_SUCCESS = 0,
    ADBMS6380_READ_PEC_FAILURE,
    ADBMS6380_READ_SPI_FAILURE,
} adbms6380_read_result_t;
 
void adbms6380_set_cs_low(SPI_InitConfig_t *spi);
void adbms6380_set_cs_high(SPI_InitConfig_t *spi);
 
void adbms6380_wake(SPI_InitConfig_t *spi, size_t module_count);
 
uint16_t adbms6380_get_threshold_voltage_cfg(float threshold_voltage);
int16_t adbms6380_extract_i16(uint8_t *data, int idx);
float adbms6380_raw_to_v(int16_t raw);
 
void adbms6380_adcv(uint8_t output_cmd[ADBMS6380_COMMAND_RAW_SIZE],
                    bool rd,
                    bool cont,
                    bool dcp,
                    bool rstf,
                    uint8_t ow);
void adbms6380_adsv(uint8_t output_cmd[ADBMS6380_COMMAND_RAW_SIZE],
                    bool cont,
                    bool dcp,
                    uint8_t ow);
 
void adbms6380_adax(uint8_t output_cmd[ADBMS6380_COMMAND_RAW_SIZE], bool ow, bool pup, uint8_t ch);
 
void adbms6380_prepare_command(strbuf_t *output_buffer,
                               const uint8_t command[ADBMS6380_COMMAND_RAW_SIZE]);
void adbms6380_prepare_data_packet(strbuf_t *output_buffer,
                                   const uint8_t data[ADBMS6380_SINGLE_DATA_RAW_SIZE]);
 
void adbms6380_calculate_cfg_rega(uint8_t output_cfg_rega[ADBMS6380_SINGLE_DATA_RAW_SIZE],
                                  bool refon,
                                  uint8_t cth);
void adbms6380_calculate_cfg_regb(uint8_t output_cfg_regb[ADBMS6380_SINGLE_DATA_RAW_SIZE],
                                  float overvoltage_threshold,
                                  float undervoltage_threshold,
                                  const bool is_discharging[ADBMS6380_CELL_COUNT]);
 
bool adbms6380_check_data_pec(const uint8_t *rx_bytes, size_t rx_len);
 
adbms6380_read_result_t adbms6380_read(SPI_InitConfig_t *spi,
                                       size_t module_count,
                                       const uint8_t cmd_buffer[ADBMS6380_COMMAND_PKT_SIZE],
                                       uint8_t *rx_buffer,
                                       size_t rx_length_per_module);
adbms6380_read_result_t adbms6380_read_data(SPI_InitConfig_t *spi,
                                            size_t module_count,
                                            const uint8_t cmd_buffer[ADBMS6380_COMMAND_PKT_SIZE],
                                            uint8_t *rx_buffer);
 
adbms6380_read_result_t
adbms6380_read_data_with_retries(SPI_InitConfig_t *spi,
                                 size_t max_retries,
                                 size_t module_count,
                                 const uint8_t cmd_buffer[ADBMS6380_COMMAND_PKT_SIZE],
                                 uint8_t *rx_buffer);
 
bool adbms6380_read_cell_voltages(SPI_InitConfig_t *spi,
                                  strbuf_t *cmd_buffer,
                                  uint8_t *rx_buffer,
                                  float **cell_voltages,
                                  int16_t **cell_voltages_raw,
                                  bool pec_error_flags[ADBMS6380_RDCV_CMD_COUNT],
                                  size_t module_count,
                                  size_t max_retries_on_pec_failure);
bool adbms6380_read_gpio_voltages(SPI_InitConfig_t *spi,
                                  strbuf_t *cmd_buffer,
                                  uint8_t *rx_buffer,
                                  float **gpio_voltages,
                                  bool pec_error_flags[ADBMS6380_RDAUX_CMD_COUNT],
                                  size_t module_count,
                                  size_t max_retries_on_pec_failure);
 
// Other adbms6380 related function declarations can go here
 
#endif // _ADBMS6380_H_