line source
/******************************************************************************
* Power Task (pwr)
* Design and coding by Svend Kristian Lindholm, skl@ti.com
*
* PWR Types and globals
*
* $Id: pwr.h 1.2 Wed, 20 Aug 2003 12:54:50 +0200 skl $
*
******************************************************************************/
#ifndef _LCC_H_
#define _LCC_H_
#include "lcc/lcc_cfg.h"
#ifdef _RVF
#include "rvf/rvf_api.h"
#include "rv/rv_general.h"
#include "lcc/lcc_api.h"
#include "lcc/lcc_cfg_i.h"
#endif
#define PWRVERSION 0x0202
/******************************************************************************
* Types
******************************************************************************/
#ifndef BASIC_TYPES
#define BASIC_TYPES
typedef signed char int8;
typedef unsigned char uint8;
typedef signed short int16;
typedef unsigned short uint16;
typedef signed int int32;
typedef unsigned int uint32;
#endif
typedef int8 epwr_t; // error type
/******************************************************************************
* RVF Types
******************************************************************************/
// Mail namings (REQ,IND,RSP) according to RIV010
// Request mail
struct pwr_req_s {
T_RV_HDR header;
};
// Indication mail with ADC measurements
struct pwr_adc_ind_s {
T_RV_HDR header;
unsigned short data[9+1]; // ADC measurements + status of VRPCSTS register
};
// Response mail sent to ETM
struct pwr_tm_req_s {
T_RV_HDR header;
};
typedef epwr_t T_PWR_RET;
typedef struct pwr_req_s T_PWR_REQ;
typedef struct
{
uint16 alfa_num; // Slope numerator
uint16 alfa_denom; // Slope denominator
int16 beta; // Offset
} T_PWR_I2V_CAL_BLOCK;
typedef struct
{
uint16 alfa_num; // Slope numerator
uint16 alfa_denom; // Slope denominator
int16 beta; // Offset
} T_PWR_VBAT_CAL_BLOCK;
// Corresponds to /pwr/i2v.cal and /pwr/vbat.cal
typedef struct
{
T_PWR_I2V_CAL_BLOCK i2v;
T_PWR_VBAT_CAL_BLOCK vbat;
} T_PWR_CAL_BLOCK;
// Corresponds to /pwr/common.cfg
typedef struct
{
uint32 sampling; /* 4 */ // The sampling time [ms] used
uint32 mod_cycle; /* 4 */ // The modulation cycle time [ms] used when performing modulation (Lithium only)
uint8 pins; /* 1 */ // Number of battery pins 2 - 3 - 4
uint8 chg_dedic; /* 1 */ // Charging performed (TRUE) or not (FALSE) in dedicated mode
uint8 alfa1; /* 1 */ // The regulation parameter N (Exponentially Weighted Moving Average) for Vbat
uint8 alfa2; /* 1 */ // The regulation parameter N (Exponentially Weighted Moving Average) for Tbat
uint8 alfa3; /* 1 */ // The regulation parameter N (Exponentially Weighted Moving Average) for Trf
uint8 rise_thr; /* 1 */ // The battery rise temperature follows RF rise temperature threshold (Nickel only)
} T_PWR_COMMON_CFG_BLOCK;
// Corresponds to /pwr/bat/bat<N>.cfg
typedef struct
{
uint16 type; /* 2 */ // Battery type - Nickel or Lithium
uint16 rf_temp; /* 2 */ // Use rf temperature (TRUE) or not (FALSE) if no battery temperature is availlable
uint32 id_low; /* 4 */ // Low battery id limit - used for identification
uint32 id_high; /* 4 */ // High battery id limit - used for identification
uint16 cbat; /* 2 */ // Standard battery capacity [mAh]
uint16 ratio; /* 2 */ // Time ratio of charge current [C] (%) - ratio x cbat = max charger current
uint32 T1; /* 4 */ // The total time charging counter
uint32 T2; /* 4 */ // The CV charging complete timer (-Nickel)
uint32 T3; /* 4 */ // The re-charge attempt timer counter
uint16 chg_start_thr; /* 2 */ // The CV charge begin battery voltage threshold value (-Nickel)
uint16 chg_stop_thr; /* 2 */ // The (CI and CV) charge end (stop) battery voltage threshold value
uint16 chg_ctrl_thr; /* 2 */ // The minimal charge control ('k_min') value threshold
uint16 chg_again_thr; /* 2 */ // The charge again capacity threshold (t=20 degrees)
} T_PWR_BAT_CFG_BLOCK;
// Corresponds to /pwr/bat/temp<N>.cfg
typedef struct
{
int16 tbat_min; /* 2 */ // Minimum battery temperature allowed
int16 tbat_max; /* 2*/ // Maximum battery temperature allowed
uint16 a0; /* 2 */ // Capacity temperature compensation a0 (a2*t*t + a1*t +a0)
uint16 a1; /* 2 */ // Capacity temperature compensation a1 (a2*t*t + a1*t +a0)
uint16 a2; /* 2 */ // Capacity temperature compensation a2 (a2*t*t + a1*t +a0)
// Capacity compensation function relative to t=20 degrees
// C(t=0) = C(t=20) + capacity compensation function(t=-20)
uint16 cap[9+1]; /* 20 */ // Capacity as a function of voltage measured at t=20 degrees - C(t=20)
// Capacity vector : 100%, 90%, 80%, 70% ,60% ,50%, 40%, 30%, 20%, 10%
uint16 i_meas1; /* 2 */ // The choosen measurement current, i_measure (typically 10uA and 50uA)
uint16 i_meas2; /* 2 */ // The choosen measurement current, i_measure (typically 10uA and 50uA)
uint16 v2t_1[8+1]; /* 18 */ // The voltage to temperature mapper for i_measure
uint16 v2t_2[8+1]; /* 18 */ // The voltage to temperature mapper for i_measure
// Temperature vector : -20, -10, 0, 10 ,20 ,30, 40, 50, 60
// Interpolation is applied when mapping
} T_PWR_BAT_TEMP_CFG_BLOCK;
// Corresponds to /pwr/chg/chg<N>.cfg
typedef struct
{
uint16 type; /* 2 */ // Charger type - Regulated (CI or CV) or unregulated (UNREGULATED)
uint16 ichg_max; /* 2 */ // Maximum charger current [mA] - normally decides the fast charging current
uint16 vchg_low; /* 2 */ // Low charger voltage limit (Open circuit - used for identification )
uint16 vchg_high; /* 2 */ // High charger voltage limit (Open circuit- used for identification)
} T_PWR_CHG_CFG_BLOCK;
// The power data block - dynamical data collected
typedef struct
{
uint16 bat_id; // Measured battery ID
uint16 chg_id; // Measured charger ID
uint16 Vbat; // Latest measured battery voltage
uint16 Vbat_avg; // Latest _average_ battery voltage
uint16 Vbat_avg_mV; // Latest _average_ battery voltage
uint16 Tbat; // Latest measured battery temperature
uint16 Tbat_avg; // Latest _average_ battery temperature
uint16 T_rf; // Latest measured RF temperature
uint16 T_rf_avg; // Latest _average_ RF temperature
uint16 Vchg; // Latest measured charger voltage
uint16 Ichg; // Latest measured charger current
uint16 Cbat; // Battery capacity in %
char cfg_id; // Configuration ID (bat<n>.cfg)
char chg_cfg_id; // Charger Configuration ID (chg<n>.cfg)
char bforce; // Force usage of battery configuration
char cforce; // Force usage of charger configuration
uint16 k; // Modulation value
uint32 T4; // The modulation ON T4 timer counter (variable!!)
} T_PWR_DATA_BLOCK;
// The PWR control block - state and debug info
typedef struct
{
int state; // The battery & charging state of the PWR task
uint8 flag_chg_plugged; // Charger has been plugged (1) or not (0) flag
uint8 flag_chg_prev_plugged; // The previous charger poll said plugged (1) or not plugged (0) flag
uint8 flag_chg_cfg_read; // Charger configuration has been read (1) or not (0) flag
uint8 flag_cal_cfg_read; // Calibration files has been read (1) or not (0) flag
uint8 flag_bat_unknown; // Battery was unknown (1) - or not (0) - the MMI must be told
uint8 flag_chg_unknown; // Charger plugged was unknown (1) - or not (0) - the MMI must be told
uint8 flag_mmi_registered; // MMI has registered (1) or not (0)
uint8 flag_prechg_started; // Stay in precharge state PRE - Apply fast charging no matter what charger type
uint8 flag_chg_int_disabled; // Charger interrupts are disabled (1) or enabled (0)
uint8 flag_ini_virgo; // Entering INI state for the very first time - in order to control some very basic initialization
uint8 cfg_id; // Applied battery configuration id
uint8 chg_cfg_id; // Applied charger configuration id
uint8 count_bat_type; // The number of battery identification measurements reported in state INI
uint8 count_chg_type; // The number of charger identification measurements made in state SUP
uint8 chg_unplug_vec[CONSECUTIVE_CHG_UNPLUGS]; // The charger unplug vector keeps the latest polled values of charger unplug
uint8 index; // The current index of the charger unplug vector
uint16 capacity; // The current capacity : 0..100%
// Timers
UINT32 time_begin_T0; // T0: Sampling timer (constant but modulo ADC updates)
UINT32 time_elapsed_T0;
UINT32 time_begin_T1; // T1: The total charging time timer (constant)
UINT32 time_elapsed_T1;
UINT32 time_begin_T2; // T2: The total CV charging time timer (constant)
UINT32 time_elapsed_T2;
UINT32 time_begin_T3; // T3: The charge-again-without start-stop of charging (constant)
UINT32 time_elapsed_T3;
UINT32 time_begin_T4; // T4: The duty cycle timer
UINT32 time_elapsed_T4;
UINT32 time_begin_mod_cycle; // The modulation cycle timer
UINT32 time_elapsed_mod_cycle;
UINT32 time_begin_mmi_rep; // MMI repetition
UINT32 time_elapsed_mmi_rep;
UINT32 tmask; // The trace mask used for the PWR process - activated by test mode
T_RVF_ADDR_ID addr_id; // Task address id assigned by Riviera framework
T_RVF_MB_ID prim_id; // Memory bank id assigned by Riviera framework
T_RV_RETURN rpath; // Return path of the MMI - initialized in pwr_register
struct mmi_info_ind_s *mmi_ptr; // Pointer to mmi event memory assigned by the MMI
} T_PWR_CTRL_BLOCK;
// The PWR configuration block - common, charger and battery
typedef struct
{
T_PWR_CAL_BLOCK cal; // Calibration matrix
T_PWR_COMMON_CFG_BLOCK common; // Common configuration
T_PWR_BAT_CFG_BLOCK bat; // Battery configuration
T_PWR_BAT_TEMP_CFG_BLOCK temp; // Battery temperature configuration
T_PWR_CHG_CFG_BLOCK chg; // Charger configuration
T_PWR_MMI_CFG_BLOCK mmi; // MMI configuration
T_PWR_DATA_BLOCK data; // Data (dynamic) related to configuration
} T_PWR_CFG_BLOCK;
// Use these values if no FFS files are found
// Units: [ms], [mV] and [mA]
#ifndef PWR_FFS_CFG
#define PWR_T0_THR 10000
#define PWR_T1_THR 1800000 // 1/2 hour
#define PWR_T2_THR 25000
#define PWR_T3_THR 10000
#define PWR_MOD_CYCLE_THR 10000
#define PWR_MMI_REP_THR 60000
#define PWR_ICHG_MAX 400
#define EXP_MOVING_AVG_FILTER1 5
#define EXP_MOVING_AVG_FILTER2 10
#define EXP_MOVING_AVG_FILTER3 10
#define PWR_TEMPERATURE_LOW -20
#define PWR_TEMPERATURE_HIGH 45
#define PWR_CV_START_THR 4050
#define PWR_CHG_STOP_THR 4100
#define PWR_RISE_THR 4
#define PWR_MIN_K 20
#define PWR_MAX_K 200
#endif
#define TYPEN 0x0080 /* Enables the 10uA bias current for the main battery type reading */
#define THERMAL_SENSOR_10uA 0x0041 /* THSENS0 , THSENS1, THSENS2 = 0, 0, 0 MESBAT = 1 */
#define THERMAL_SENSOR_30uA 0x0051 /* THSENS0 , THSENS1, THSENS2 = 0, 1, 0 MESBAT = 1 */
#define THERMAL_SENSOR_50uA 0x0061 /* THSENS0 , THSENS1, THSENS2 = 0, 0, 1 MESBAT = 1 */
#define THERMAL_SENSOR_80uA 0x0079 /* THSENS0 , THSENS1, THSENS2 = 1, 1, 1 MESBAT = 1 */
#define MESBAT 0x0001 /* Resistive divider connected to main battery */
#define CHARGER_IT_MSK 0x0008 /* Mask the charger plug/unplug interrupts */
#define ALL_IT_UMSK 0x0000 /* Unmask all interrupt 2 register related interrupts */
// Convert functions
#define ADC_to_mV(ADC) ((pwr_cfg->cal.vbat.alfa_num*(ADC))/(pwr_cfg->cal.vbat.alfa_denom) + pwr_cfg->cal.vbat.beta)
#define ADC_to_mA(ADC) ((pwr_cfg->cal.i2v.alfa_num*(ADC))/(pwr_cfg->cal.i2v.alfa_denom) + pwr_cfg->cal.i2v.beta)
// Inverse convert functions
#define mV_to_ADC(V) (pwr_cfg->cal.vbat.alfa_num*((V)/pwr_cfg->cal.vbat.alfa_denom) - pwr_cfg->cal.vbat.beta)
#define mA_to_ADC(I) (pwr_cfg->cal.i2v.alfa_num*((I)/pwr_cfg->cal.i2v.alfa_denom) - pwr_cfg->cal.i2v.beta)
/******************************************************************************
* Errors
******************************************************************************/
enum PWR_ERRORS {
EPWR_OK = 0 /* ok */
};
/******************************************************************************
* Enumerations
******************************************************************************/
// Message IDs for all PWR module messages
typedef enum PWR_MESSAGES {
NOP = 0,
/* Requests */
/* ABB */
/* MMI */
MMI_REGISTER_REQ = 20,
/* Timers*/
TIMER_T1_EXPIRED = 30,
TIMER_T2_EXPIRED,
TIMER_T3_EXPIRED,
TIMER_T4_EXPIRED,
TIMER_MOD_CYCLE_EXPIRED,
TIMER_MMI_INFO_EXPIRED,
/* Indications */
/* PWR */
PWR_CHARGER_PLUGGED_IND = 40,
PWR_CHARGER_UNPLUGGED_IND,
/* Confirmations */
/* Test mode */
/* Request */
PWR_TM_READ_REQ = 70,
PWR_TM_WRITE_REQ,
/* Indications */
PWR_TM_READ_IND = 80,
PWR_TM_WRITE_IND,
PWR_ADC_IND = 90
} pwr_msg_e;
// See LCC Detailed Design Specification
typedef enum PWR_STATES {
CAL = 0, // Reading calibration file(s)
PRE = 1, // Pre-charging no matter which charger type
INI = 2, // Reading configuration files
SUP = 3, // No charging - supervision only
CCI = 4, // Charging using CI/CV charger
LCI = 5, // Charging using linear charger
CCV = 6, // Charging using CI/CV charger
LCV = 7 // Charging using linear charger
} pwr_states_e;
// See RD818
typedef enum CHG_TYPES {
CI = 1,
CV = 2,
UNREGULATED = 3
} chg_types_e;
// See RD818
typedef enum BAT_TYPES {
LITHIUM = 1,
NICKEL = 2
} bat_types_e;
// See RIV261
typedef enum CAUSE_TYPES {
BATTERY_TEMPERATURE_OK = 0,
BATTERY_TEMPERATURE_LOW = 1,
BATTERY_TEMPERATURE_HIGH = 2
} cause_types_e;
enum PWR_Errors {
// PWR Common Target Errors
PWR_OK = 0, // Ok
PWR_INDEX = -1, // Unknown index
PWR_OK_MORE = -63, // Ok, more data coming
PWR_PACKET = -62, // Packet error (checksum or other)
PWR_FATAL = -61, // System fatal error
PWR_NOSYS = -60, // Module or function not present
PWR_INVAL = -59, // Invalid parameter/argument
PWR_BADOP = -58, // Operation not possible in current context
PWR_AGAIN = -57, // Not ready, try again later
PWR_NOMEM = -56, // Out of memory
PWR_MESSAGE = -55, // Received unknown message
// Errors that are related to the Riv env.
PWR_RV_NOT_SUPPORTED = -51, //
PWR_RV_MEMORY_ERR = -50, //
PWR_RV_INTERNAL_ERR = -49, //
PWR_RV_FATAL = -48 //
};
#endif //_LCC_H_