#ifndef INA226_CFG_H_
#define INA226_CFG_H_
//
#ifdef __cplusplus
extern "C" {
#endif
    //
    #include"complier_lib.h"
    #include "i2c_task.h"
    #include "gpio_task.h"
    //
    
    //===配置寄存区--[0x4127]
    #define CONFIGURATION_REG                            0x00
    //===采样电阻上的压降---[0x00000],满量程是81.92mV,最小单位是2.5uV
    #define SHUNT_VOLTAGE_REG                            0x01
    //===总线电压---[0x00000],满量程是40.96V,最小单位是1.25mV
    #define BUS_VOLTAGE_REG                                0x02
    //===功率寄存器---[0x00000]
    #define POWER_REG                                    0x03
    //===电流寄存器---[0x00000]
    #define CURRENT_REG                                    0x04
    //===校准寄存器---[0x00000]
    #define CALIBRATION_REG                                0x05
    //===功能控制寄存器---[0x00000]
    #define MASK_ENABLE_REG                                0x06
    //===设置的报警阈值---[0x00000]
    #define ALERT_LIMIT_REG                                0x07
    //===制造商ID---[0x5449]
    #define MANUFACTURER_ID_REG                            0xFE
    //===设备ID---[0x2260]
    #define DIE_ID_REG                                    0xFF

//===使能过压
    #define SHUNT_OVER_VOLTAGE_ENABLE                    (1<<15)
    //===不使能过压
    #define SHUNT_OVER_VOLTAGE_DISABLE                    ~(1<<15)
        //===使能欠压
    #define SHUNT_UNDER_VOLTAGE_ENABLE                    (1<<14)
    //===不使能欠压
    #define SHUNT_UNDER_VOLTAGE_DISABLE                    ~(1<<14)

//===使能过压
    #define BUS_OVER_VOLTAGE_ENABLE                        (1<<13)
    //===不使能过压
    #define BUS_OVER_VOLTAGE_DISABLE                    ~(1<<13)
    //===使能欠压
    #define BUS_UNDER_VOLTAGE_ENABLE                    (1<<12)
    //===不使能欠压
    #define BUS_UNDER_VOLTAGE_DISABLE                    ~(1<<12)

//===使能功率阈值
    #define POWER_OVER_LIMIT_ENABLE                        (1<<11)
    //===不使能功率阈值
    #define POWER_OVER_LIMIT_DISABLE                    (1<<11)

//===使能转换准备好标致
    #define CONVERSION_READY_ENABLE                        (1<<10)
    //===不使能转换准备好标致
    #define CONVERSION_READY_DISABLE                    (1<<10)
    
    //===报警端口低有效
    #define    ALERT_POLARITY_ACTIVE_LOW                    ~(1<<1)
    //===报警端口搞有效
    #define    ALERT_POLARITY_ACTIVE_HIGH                    (1<<1)

//===报警端口锁存使能
    #define    ALERT_LATCH_ENABLE                            (1)
    //===报警端口锁存不使能
    #define ALERT_LATCH_DISABLE                            0xFFFE
    //===配置平均转换的次数
    #define    AVERAGING_MODE_MASK                            ~(7<<9)
    #define    AVERAGING_MODE_1                            (0<<9)
    #define    AVERAGING_MODE_4                            (1<<9)
    #define    AVERAGING_MODE_16                            (2<<9)
    #define    AVERAGING_MODE_64                            (3<<9)
    #define    AVERAGING_MODE_128                            (4<<9)
    #define    AVERAGING_MODE_256                            (5<<9)
    #define    AVERAGING_MODE_512                            (6<<9)
    #define    AVERAGING_MODE_1024                            (7<<9)

//===配置总线电压转换的时间
    #define BUS_VOLTAGE_CONVERSIOM_TIME_MASK            ~(7<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_140_US            (0<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_204_US            (1<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_332_US            (2<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_588_US            (3<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_1100_US            (4<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_2116_US            (5<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_4156_US            (6<<6)
    #define BUS_VOLTAGE_CONVERSIOM_TIME_8244_US            (7<<6)

//===配置采样电压转换的时间
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_MASK            ~(7<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_140_US        (0<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_204_US        (1<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_332_US        (2<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_588_US        (3<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_1100_US        (4<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_2116_US        (5<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_4156_US        (6<<3)
    #define SHUNT_VOLTAGE_CONVERSIOM_TIME_8244_US        (7<<3)

//===配置操作模式
    #define OPERATING_MODE_MASK                            ~(7<<0)
    #define OPERATING_MODE_POWER_DOWN_1                    (0<<0)
    #define OPERATING_MODE_SHUNT_VOLTAGE_TRIG            (1<<0)
    #define OPERATING_MODE_BUS_VOLTAGE_TRIG                (2<<0)
    #define OPERATING_MODE_SHUNT_BUS_VOLTAGE_TRIG        (3<<0)
    #define OPERATING_MODE_POWER_DOWN_2                    (4<<0)
    #define OPERATING_MODE_SHUNT_VOLTAGE_CONT            (5<<0)
    #define OPERATING_MODE_BUS_VOLTAGE_CONT                (6<<0)
    #define OPERATING_MODE_SHUNT_BUS_VOLTAGE_CONT        (7<<0)

//===总线电压量程每BIT对应的电压值，单位是毫伏
    #define INA226_RANG_BUS_VOLTAGE_MV_BIT                1.25f
    //===采样电阻上电压量程每BIT对应的电压值，单位是微伏
    #define INA226_RANG_SHUNT_VOLTAGE_UV_BIT            2.5f
    //===采样电阻的大小,单位是毫欧
    #define INA226_SAMPLE_RES_MR                        1
    //===INA226的电流最大采集量程，这个和校准寄存器有关
    #define INA226_RANG_CURRENT_MA_MAX                    15000
    //===INA226的电流量程每BIT对应电流值，单位是微安安
    #define INA226_RANG_CURRENT_UA_BIT_X1                (UINT16_T)( INA226_RANG_CURRENT_MA_MAX*1000/(1<<15))
    //===校准寄存器的值
    #define INA226_CALIB_REG_DEFAULT_X1                    (UINT16_T)( 5120*1000/(INA226_RANG_CURRENT_UA_BIT_X1*INA226_SAMPLE_RES_MR) )
    //===
    #define INA226_RANG_CURRENT_UA_BIT_X2                (UINT16_T)( INA226_RANG_CURRENT_UA_BIT_X1*2 )
    //===
    #define INA226_CALIB_REG_DEFAULT_X2                    (UINT16_T)( INA226_CALIB_REG_DEFAULT_X1*2 )

//===结构体定义
    typedef struct _INA226_HandlerType                    INA226_HandlerType;
    //===指针结构体定义
    typedef struct _INA226_HandlerType                    * pINA226_HandlerType;

//===AT24Cxx的数据结构体
    struct _INA226_HandlerType
    {
        UINT16_T            msgCFGReg;                    //---配置寄存器
        UINT16_T            msgMaskReg;                    //---功能配置寄存器
        UINT16_T            msgShuntReg;                //---采样电压寄存器
        UINT16_T            msgBusVReg;                    //---总线电压寄存器
        UINT16_T            msgPowerReg;                //---功率寄存器
        UINT16_T            msgCurrentReg;                //---采样电流寄存器
        UINT16_T            msgCalibReg;                //---校准寄存器
        float                msgBusmV;                    //---总线电压，单位毫伏
        float                msgShuntuV;                    //---采样电阻电压,单位微伏
        float                msgShuntuA;                    //---采样电阻电流，单位微安
        float                msgPowermW;                    //---负载的功耗，单位微瓦
        GPIO_HandlerType    msgAlert;                    //---报警端口的配置，INA226是开漏模式，需要外接上拉电阻
        I2C_HandlerType        msgI2C;                        //---使用的I2C
    };

//===定义的任务函数
    #define INA226_TASK_ONE                                pINA226Device0
    #define INA226_TASK_TWO                                0
    #define INA226_TASK_THREE                            0

//===外部调用
    extern INA226_HandlerType        g_INA226Device0 ;
    extern pINA226_HandlerType        pINA226Device0  ;

//===函数定义
    UINT8_T INA226_I2C_Device0_Init(INA226_HandlerType* INA226x);
    UINT8_T INA226_I2C_Device1_Init(INA226_HandlerType* INA226x);
    UINT8_T INA226_I2C_Device2_Init(INA226_HandlerType* INA226x);
    UINT8_T INA226_I2C_Init(INA226_HandlerType* INA226x, void(*pFuncDelayus)(UINT32_T delay), UINT8_T isHWI2C);
    UINT8_T INA226_ConfigInit(INA226_HandlerType* INA226x);
    UINT8_T INA226_GetDieID(INA226_HandlerType* INA226x);
    UINT8_T INA226_GetManuID(INA226_HandlerType* INA226x);
    UINT8_T INA226_GetBusVoltage(INA226_HandlerType* INA226x);
    //
#ifdef __cplusplus
}
#endif
//
#endif /*INA226_CFG_H_ */

#include "ina226_cfg.h"

//===全局变量定义
INA226_HandlerType        g_INA226Device0 = { 0 };
pINA226_HandlerType        pINA226Device0 = &g_INA226Device0;

///
//函       数：
//功       能：初始化
//输入参数:isHWI2C---1 硬件，0 软件
//输出参数:
//说       明：
//
UINT8_T INA226_I2C_Init(INA226_HandlerType* INA226x, void(*pFuncDelayus)(UINT32_T delay), UINT8_T isHWI2C)
{
    UINT8_T _return = OK_0;

//---指定设备的初始化
    if ((INA226x != NULL) && (INA226x == INA226_TASK_ONE))
    {
        INA226_I2C_Device0_Init(INA226x);
    }
    else if ((INA226x != NULL) && (INA226x == INA226_TASK_TWO))
    {
        INA226_I2C_Device1_Init(INA226x);
    }
    else if ((INA226x != NULL) && (INA226x == INA226_TASK_THREE))
    {
        INA226_I2C_Device2_Init(INA226x);
    }
    else
    {
        return ERROR_1;
    }

//---判断是硬件I2C还是软件I2C
    if (isHWI2C)
    {
        //---初始化硬件I2C
        _return = I2CTask_MHW_Init(&(INA226x->msgI2C));
        //---设置为硬件模式
        INA226x->msgI2C.msgModelIsHW = 1;
    }
    else
    {
        //---初始化软件模拟I2C
        _return = I2CTask_MSW_Init(&(INA226x->msgI2C), pFuncDelayus);
        //---设置为软件件模式
        INA226x->msgI2C.msgModelIsHW = 0;
    }
    //---配置初始化
    _return = INA226_ConfigInit(INA226x);
    return _return;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_I2C_Device0_Init(INA226_HandlerType* INA226x)
{
    INA226x->msgI2C.msgI2Cx = NULL;
    INA226x->msgI2C.msgSCL.msgGPIOPort = GPIOB;
    INA226x->msgI2C.msgSCL.msgGPIOBit = LL_GPIO_PIN_6;
    INA226x->msgI2C.msgSDA.msgGPIOPort = GPIOB;
    INA226x->msgI2C.msgSDA.msgGPIOBit = LL_GPIO_PIN_7;
    INA226x->msgI2C.msgModelIsHW = 0;
    INA226x->msgI2C.msgPluseWidth = 2;
    INA226x->msgI2C.msgFuncDelayus = NULL;
    INA226x->msgI2C.msgAddr = 0x80;
    INA226x->msgI2C.msgClockSpeed = 0;
    return OK_0;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_I2C_Device1_Init(INA226_HandlerType* INA226x)
{
    return OK_0;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_I2C_Device2_Init(INA226_HandlerType* INA226x)
{
    return OK_0;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_SWI2C_WriteReg(INA226_HandlerType* INA226x, UINT8_T addr, UINT16_T val)
{
    UINT8_T _return = OK_0;
    //---启动IIC并发送器件地址，写数据
    _return = I2CTask_MSW_START(&(INA226x->msgI2C), 1);
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_1;
        goto GoToExit;
    }
    //---发送寄存器地址
    I2CTask_MSW_SendByte(&(INA226x->msgI2C), addr);
    //---读取ACK
    _return = I2CTask_MSW_ReadACK(&(INA226x->msgI2C));
    if (_return != OK_0)
    {
        //---发送寄存器地址错误
        _return = ERROR_2;
        goto GoToExit;
    }
    //---发送高位数据
    I2CTask_MSW_SendByte(&(INA226x->msgI2C), (UINT8_T)(val>>16));
    //---读取ACK
    _return = I2CTask_MSW_ReadACK(&(INA226x->msgI2C));
    if (_return != OK_0)
    {
        //---发送数据错误
        _return = ERROR_3;
        goto GoToExit;
    }
    //---发送低位数据
    I2CTask_MSW_SendByte(&(INA226x->msgI2C), (UINT8_T)(val&0xFF));
    //---读取ACK
    _return = I2CTask_MSW_ReadACK(&(INA226x->msgI2C));
    if (_return != OK_0)
    {
        //---发送数据错误
        _return = ERROR_4;
        goto GoToExit;
    }
    //---退出操作入口
GoToExit:
    //---发送停止信号
    I2CTask_MSW_STOP(&(INA226x->msgI2C));
    return _return;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_HWI2C_WriteReg(INA226_HandlerType* INA226x, UINT8_T addr, UINT16_T val)
{
    return ERROR_1;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_I2C_WriteReg(INA226_HandlerType* INA226x, UINT8_T addr, UINT16_T val)
{
    if (INA226x->msgI2C.msgModelIsHW == 1)
    {
        return INA226_HWI2C_WriteReg(INA226x, addr, val);
    }
    else
    {
        return INA226_SWI2C_WriteReg(INA226x, addr, val);
    }
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_SWI2C_ReadReg(INA226_HandlerType* INA226x, UINT8_T addr, UINT16_T *pVal)
{
    UINT8_T _return = OK_0;
    //---启动IIC并发送器件地址，写数据
    _return = I2CTask_MSW_START(&(INA226x->msgI2C), 1);
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_1;
        goto GoToExit;
    }
    //---发送寄存器地址
    I2CTask_MSW_SendByte(&(INA226x->msgI2C), addr);
    //---读取ACK
    _return = I2CTask_MSW_ReadACK(&(INA226x->msgI2C));
    if (_return != OK_0)
    {
        //---发送数据失败
        _return = ERROR_2;
        goto GoToExit;
    }
    //---启动IIC并发送器件地址，读数据
    _return = I2CTask_MSW_START(&(INA226x->msgI2C), 0);
    if (_return != OK_0)
    {
        //---启动读数据失败
        _return = ERROR_3;
        goto GoToExit;
    }
    UINT16_T readTemp = 0;
    //---读取高位数据
    readTemp= I2CTask_MSW_ReadByte(&(INA226x->msgI2C));
    //---发送应答信号
    _return = I2CTask_MSW_SendACK(&(INA226x->msgI2C), 0);
    readTemp <<= 8;
    //---读取低位数据
    readTemp |= I2CTask_MSW_ReadByte(&(INA226x->msgI2C));
    //---发送不应答信号
    _return = I2CTask_MSW_SendACK(&(INA226x->msgI2C), 1);
    *pVal = readTemp;
GoToExit:
    //---发送停止信号
    I2CTask_MSW_STOP(&(INA226x->msgI2C));
    return _return;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_HWI2C_ReadReg(INA226_HandlerType* INA226x, UINT8_T addr, UINT16_T* pVal)
{
    return ERROR_1;
}

///
//函        数：
//功        能：
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_I2C_ReadReg(INA226_HandlerType* INA226x, UINT8_T addr, UINT16_T* pVal)
{
    if (INA226x->msgI2C.msgModelIsHW == 1)
    {
        return INA226_HWI2C_ReadReg(INA226x, addr, pVal);
    }
    else
    {
        return INA226_SWI2C_ReadReg(INA226x, addr, pVal);
    }
}

///
//函        数：
//功        能：设备ID
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetDieID(INA226_HandlerType* INA226x)
{
    UINT16_T deviceID = 0;
    UINT8_T _return = INA226_I2C_ReadReg(INA226x, DIE_ID_REG, &deviceID);
    if (_return==OK_0)
    {
        if (deviceID != 0x2260)
        {
            _return = ERROR_1;
        }
    }
    return _return;
}

///
//函        数：
//功        能：制造商ID
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetManuID(INA226_HandlerType* INA226x)
{
    UINT16_T deviceID = 0;
    UINT8_T _return = INA226_I2C_ReadReg(INA226x, MANUFACTURER_ID_REG, &deviceID);
    if (_return == OK_0)
    {
        if (deviceID != 0x5449)
        {
            _return = ERROR_1;
        }
    }
    return _return;
}

///
//函        数：
//功        能：读取配置寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetCFGReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, CONFIGURATION_REG, &(INA226x->msgCFGReg));
}

///
//函        数：
//功        能：设置配置寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_SetCFGReg(INA226_HandlerType* INA226x, UINT16_T val)
{
    INA226x->msgCFGReg = val;
    return INA226_I2C_WriteReg(INA226x, CONFIGURATION_REG, INA226x->msgCFGReg);
}

///
//函        数：
//功        能：复位设备
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_Reset(INA226_HandlerType* INA226x)
{
    INA226x->msgCFGReg = 0x4000;
    return INA226_SetCFGReg(INA226x,0xC000);
}

///
//函        数：
//功        能：读取校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetCalibReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, CALIBRATION_REG, &(INA226x->msgCalibReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_SetCalibReg(INA226_HandlerType* INA226x,UINT16_T val)
{
    INA226x->msgCalibReg = val;
    return INA226_I2C_WriteReg(INA226x, CALIBRATION_REG, INA226x->msgCalibReg);
}

///
//函        数：
//功        能：读取校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetMaskReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, MASK_ENABLE_REG, &(INA226x->msgMaskReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_SetMaskReg(INA226_HandlerType* INA226x, UINT16_T val)
{
    INA226x->msgMaskReg=val;
    return INA226_I2C_WriteReg(INA226x, MASK_ENABLE_REG, INA226x->msgMaskReg);
}

///
//函        数：
//功        能：清楚转换就绪标志位
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_ClearConversionReadyFlag(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, MASK_ENABLE_REG, &(INA226x->msgMaskReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetShuntReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, SHUNT_VOLTAGE_REG, &(INA226x->msgShuntReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetCurrentReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, CURRENT_REG, &(INA226x->msgCurrentReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetBusVReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, BUS_VOLTAGE_REG, &(INA226x->msgBusVReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetPowerReg(INA226_HandlerType* INA226x)
{
    return INA226_I2C_ReadReg(INA226x, POWER_REG, &(INA226x->msgPowerReg));
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetBusVoltage(INA226_HandlerType* INA226x)
{
    UINT8_T _return = INA226_GetBusVReg(INA226x);
    INA226x->msgBusmV = 0.0f;
    if (_return==OK_0)
    {
        INA226x->msgBusmV = INA226x->msgBusVReg;
        INA226x->msgBusmV *= INA226_RANG_BUS_VOLTAGE_MV_BIT;
    }
    return _return;
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetShuntVoltage(INA226_HandlerType* INA226x)
{
    UINT8_T _return = INA226_GetShuntReg(INA226x);
    INA226x->msgShuntuV = 0.0f;
    if (_return == OK_0)
    {
        if ((INA226x->msgShuntReg&0x8000)!=0)
        {
            INA226x->msgShuntuV =(-1.0)*(0x10000 - INA226x->msgShuntReg);
        }
        else
        {
            INA226x->msgShuntuV = INA226x->msgShuntReg;
        }
        INA226x->msgShuntuV *= INA226_RANG_SHUNT_VOLTAGE_UV_BIT;
    }
    return _return;
}

///
//函        数：
//功        能：设置校准寄存器的值
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetShuntCurrent(INA226_HandlerType* INA226x)
{
    UINT8_T _return = INA226_GetCurrentReg(INA226x);
    INA226x->msgShuntuA = 0.0f;
    if (_return == OK_0)
    {
        if (INA226x->msgCalibReg == 0)
        {
            if ((INA226x->msgCurrentReg & 0x8000) != 0)
            {
                INA226x->msgShuntuA =(-1.0)*(0x10000 - INA226x->msgCurrentReg);
            }
            else
            {
                INA226x->msgShuntuA = INA226x->msgCurrentReg;
            }
            if (INA226x->msgCalibReg == INA226_CALIB_REG_DEFAULT_X1)
            {
                INA226x->msgShuntuA *= INA226_RANG_CURRENT_UA_BIT_X1;
            }
            else if (INA226x->msgCalibReg == INA226_CALIB_REG_DEFAULT_X2)
            {
                INA226x->msgShuntuA *= INA226_RANG_CURRENT_UA_BIT_X2;
            }
            else
            {
                _return = INA226_GetShuntVoltage(INA226x);
                if (_return == OK_0)
                {
                    if ((INA226x->msgShuntReg & 0x8000) != 0)
                    {
                        INA226x->msgShuntuA = (-1000.0) * (INA226x->msgShuntuV / INA226_SAMPLE_RES_MR);
                    }
                    else
                    {
                        INA226x->msgShuntuA = (1000.0) * (INA226x->msgShuntuV / INA226_SAMPLE_RES_MR);
                    }
                }
            }
        }
        else
        {
            _return = INA226_GetShuntVoltage(INA226x);
            if (_return == OK_0)
            {
                if ((INA226x->msgShuntReg & 0x8000) != 0)
                {
                    INA226x->msgShuntuA = (-1.0)*(0x10000 - INA226x->msgShuntReg);;
                }
                else
                {
                    INA226x->msgShuntuA = INA226x->msgShuntReg;
                }
                INA226x->msgShuntuA = (1000.0) * (INA226x->msgShuntuA * INA226x->msgCalibReg / 2048);
            }
        }
    }
    return _return;
}

///
//函        数：
//功        能：获取负载的功耗
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_GetPower(INA226_HandlerType* INA226x)
{
    UINT8_T _return = INA226_GetShuntVoltage(INA226x);
    INA226x->msgPowermW = 0.0f;
    if (_return == OK_0)
    {
        _return = INA226_GetShuntCurrent(INA226x);
        if (_return==OK_0)
        {
            INA226x->msgPowermW = INA226x->msgBusmV * INA226x->msgShuntuA / 1000000.0;
        }
    }
    return _return;
}
///
//函        数：
//功        能：配置初始化
//输入参数:
//输出参数:
//说        明：
//
UINT8_T INA226_ConfigInit(INA226_HandlerType* INA226x)
{
    UINT8_T _return = OK_0;
    INA226x->msgCFGReg = 0x4000;
    //---平局64，采集时间204us
    _return= INA226_SetCFGReg(INA226x,    0x4000| AVERAGING_MODE_64|
                                        BUS_VOLTAGE_CONVERSIOM_TIME_204_US|
                                        SHUNT_VOLTAGE_CONVERSIOM_TIME_204_US|
                                        OPERATING_MODE_SHUNT_BUS_VOLTAGE_CONT
                            );
    if (_return==OK_0)
    {
        //---设置校准寄存器
        _return = INA226_SetCalibReg(INA226x, INA226_RANG_CURRENT_UA_BIT_X2);
    }
    if (_return==OK_0)
    {
        //---将报警端口设置为装换完成，标志低有效，高电平无效
        _return = INA226_SetMaskReg(INA226x, CONVERSION_READY_ENABLE);
    }
    return _return;
}

STM32使能IIC驱动电流检测芯片INA226相关推荐

1. 15 玩转STM32之IIC通信（芯片硬件篇）

   15.1 IIC控制器说明(硬件部分) 在14 玩转STM32之IIC通信(软件模拟篇)我们讲了软件模拟的方式,本章讲解芯片自带的硬件部分(并非所有的芯片都含有IIC,像51系列的是没有的,但是绝大多 ...

2. stm32之IIC应用实例（AT24C02芯片，硬件和软件方式驱动）

   目录 1.物理层: 2.协议层: 3.数据的传输: 4.程序设计 写完回头一看发现字数还不少,如果你觉得文字太枯燥,那么可以跳到后面程序设计,直接动手做实验.如果想仔细了解关于IIC协议的细节,那么希 ...

3. STM32模拟IIC协议驱动AD7991/AD7995/AD7999芯片

   STM32模拟IIC协议驱动AD7991/AD7995/AD7999芯片 AD7991/AD7995/AD7999是12位/10位/8位 4通道模拟输入的AD转换芯片 通信方式采用的是:I2C 芯片供 ...

4. STM32的IIC应用详解3

   分享: 这两天将STM32的IIC按照原子哥的程序,大致走了一遍,多少对IIC不是那么地陌生了,也多少有了自己的一些感悟,在这里,将这两天的学习的一个大致步骤总结下,一来可以让自己形成一个清晰地思路, ...

5. STM32使用IIC总线通讯协议在OLED屏幕上显示字符串、汉字、图像（硬件IIC）

   参考:基于STM32-Oled(IIC)的使用 作者:奋斗的小殷 发布时间: 2021-05-07 13:09:26 网址:https://blog.csdn.net/boybs/article/de ...

6. 【STM32】IIC的基本原理（实例：普通IO口模拟IIC时序读取24C02）(转载)

   版权声明:本文为博主原创文章,允许转载,但希望标注转载来源. https://blog.csdn.net/qq_38410730/article/details/80312357 IIC的基本介绍 I ...

7. STM32基于IIC控制E2PROM和io口扩展

   stm32的IIC 软件模拟和硬件的区别 IIC是常用的半双工总线,用来传递数据,好像st公司为了不交钱,自己做的IIC绕开了飞利浦的协议,但是不是很稳定,所以这次使用软件来模仿IIC的通信 其实都一 ...

8. STM32基于IIC协议的OLED模块的使用

   前言 一.项目涉及的内容 项目简介 二.模块实操 1. IIC模块 1.1 IIC协议格式 1.2 开始信号与停止信号 1.3 写数据 1.3.1 硬件IIC代码编写 1.3.2 软件模拟IIC代码编 ...

9. stm32之IIC总线概述

   1.IIC通信协议定义 IIC通讯协议(Inter----Integrted Circuit)是由Phiips飞利浦公司开发的, 由于他引脚少,硬件实现简单,可拓展性强,不需要UASRT,CAN通讯协 ...

最新文章

1. MobileViT: 一种更小，更快，高精度的轻量级Transformer端侧网络架构（附代码实现）...
2. 如何正确的对待设计模式——我的观点
3. go get报错unrecognized import path “golang.org/x/net/context”…
4. Help：立体图绘制以及根据X,Y,Z三坐标值，在图上描点
5. qt udp多线程收发过程_！ udp多线程的有关问题
6. java中apache安装与配置_Apache应用服务器之四：Apache与Tomcat安装与配置
7. 华为Mate30 Pro高清渲染图曝光：后置四摄+挖孔全面屏
8. ELJSTLMVC模式
9. Java中，异常处理try catch的作用域是局部的
10. vue引入百度地图使用JavaScript API GL渲染点位的图片
11. pentaho mysql_pentaho移植到MySQL
12. matlab 变量的定义变量名称,matlab定义变量名
13. 关于无线wifi漫游设置
14. 第14课：走向技术管理者的4种方式
15. 2019第二届中国天津国际智慧消防高峰论坛
16. 苹果考虑推迟发布5G iPhone
17. scrapy框架爬取校花网站的升级版
18. 微信指数批量采集、导出
19. android自定义Dcloud插件，调用android原生界面并获取返回数据
20. 【时序】DeepGLO：可以学习全局依赖和局部信息的多时间序列预测模型

热门文章

1. 推荐系统工业界顶会论文总结——WSDM 2021
2. a标签，相对地址，绝对地址，锚点技术
3. iOS身份证的正则验证
4. PDFObject.js的使用
5. Vivado IP中的Shared Logic到底是干嘛的？
6. SDWebImage如何避免复用
7. DEM数据(ASTER GDEM|SRTM|GLS2005|ALOS DEM|NASA DEM)下载
8. C#序列化与反序列化学习
9. Python实现线性回归（公式推导+源代码）
10. L1-012 计算指数 (5 分) C语言