feat: Add INA219 dual motor current monitor driver (Issue #214)
Implements complete I2C1 driver for TI INA219 power monitoring IC supporting: - Dual sensors on I2C1 (left motor @ 0x40, right motor @ 0x41) - Auto-calibration for 5A max current, 0.1Ω shunt resistance - Current LSB: 153µA, Power LSB: 3060µW (20× current LSB) - Bus voltage: 0-26V @ 4mV/LSB (13-bit, 4mV resolution) - Shunt voltage: ±327mV @ 10µV/LSB (signed 16-bit) - Calibration register computation for arbitrary max current/shunt values - Efficient single/batch read functions (voltage, current, power) - Alert threshold configuration for overcurrent protection - Full test suite: 12 passing unit tests covering calibration, conversions, edge cases Integration: - ina219_init() called after i2c1_init() in main startup sequence - Ready for motor power monitoring and thermal protection logic Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
This commit is contained in:
parent
a05c93669e
commit
b9d01762e2
117
include/ina219.h
Normal file
117
include/ina219.h
Normal file
@ -0,0 +1,117 @@
|
||||
#ifndef INA219_H
|
||||
#define INA219_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
/*
|
||||
* ina219.h — INA219 power monitor driver (Issue #214)
|
||||
*
|
||||
* I2C1 driver for motor current/voltage/power monitoring.
|
||||
* Supports 2 sensors (left/right motor) on I2C1 (PB8=SCL, PB9=SDA).
|
||||
*
|
||||
* INA219 specs:
|
||||
* - I2C addresses: 0x40–0x4F (configurable via address pins)
|
||||
* - Bus voltage: 0–26V, 4mV/LSB
|
||||
* - Shunt voltage: ±327mV, 10µV/LSB
|
||||
* - Current: derived from shunt voltage (calibration-dependent)
|
||||
* - Power: (Bus V × Current) / internal gain
|
||||
*
|
||||
* Typical usage for motor monitoring:
|
||||
* - 0.1Ω shunt resistor → ~3.27A max (at ±327mV)
|
||||
* - Calibration: set max expected current, driver calculates LSB
|
||||
* - Read functions return actual voltage/current/power values
|
||||
*/
|
||||
|
||||
/* INA219 sensors (2 motors) */
|
||||
typedef enum {
|
||||
INA219_LEFT_MOTOR = 0, /* Address 0x40 */
|
||||
INA219_RIGHT_MOTOR = 1, /* Address 0x41 */
|
||||
INA219_COUNT
|
||||
} INA219Sensor;
|
||||
|
||||
/* INA219 measurement data */
|
||||
typedef struct {
|
||||
uint16_t bus_voltage_mv; /* Bus voltage in mV (0–26000) */
|
||||
int16_t shunt_voltage_uv; /* Shunt voltage in µV (±327000) */
|
||||
int16_t current_ma; /* Current in mA (signed) */
|
||||
uint32_t power_mw; /* Power in mW */
|
||||
} INA219Data;
|
||||
|
||||
/*
|
||||
* ina219_init()
|
||||
*
|
||||
* Initialize I2C1 and both INA219 sensors (left + right motor).
|
||||
* Performs auto-calibration for typical motor current monitoring.
|
||||
* Call once at startup after i2c1_init().
|
||||
*/
|
||||
void ina219_init(void);
|
||||
|
||||
/*
|
||||
* ina219_calibrate(sensor, max_current_ma, shunt_ohms_milli)
|
||||
*
|
||||
* Manually calibrate a sensor for expected max current and shunt resistance.
|
||||
* Calculates internal calibration register value.
|
||||
*
|
||||
* Example:
|
||||
* ina219_calibrate(INA219_LEFT_MOTOR, 5000, 100); // 5A max, 0.1Ω shunt
|
||||
*/
|
||||
void ina219_calibrate(INA219Sensor sensor, uint16_t max_current_ma, uint16_t shunt_ohms_milli);
|
||||
|
||||
/*
|
||||
* ina219_read(sensor, data)
|
||||
*
|
||||
* Read all measurements from a sensor (voltage, current, power).
|
||||
* Blocks until measurements are ready (typically <1ms at default ADC resolution).
|
||||
*
|
||||
* Returns: true if read successful, false on I2C error.
|
||||
*/
|
||||
bool ina219_read(INA219Sensor sensor, INA219Data *data);
|
||||
|
||||
/*
|
||||
* ina219_read_bus_voltage_mv(sensor, voltage_mv)
|
||||
*
|
||||
* Read bus voltage only (faster than full read).
|
||||
* Returns: true if successful.
|
||||
*/
|
||||
bool ina219_read_bus_voltage_mv(INA219Sensor sensor, uint16_t *voltage_mv);
|
||||
|
||||
/*
|
||||
* ina219_read_current_ma(sensor, current_ma)
|
||||
*
|
||||
* Read current only (requires prior calibration).
|
||||
* Returns: true if successful.
|
||||
*/
|
||||
bool ina219_read_current_ma(INA219Sensor sensor, int16_t *current_ma);
|
||||
|
||||
/*
|
||||
* ina219_read_power_mw(sensor, power_mw)
|
||||
*
|
||||
* Read power consumption only.
|
||||
* Returns: true if successful.
|
||||
*/
|
||||
bool ina219_read_power_mw(INA219Sensor sensor, uint32_t *power_mw);
|
||||
|
||||
/*
|
||||
* ina219_alert_enable(sensor, current_limit_ma)
|
||||
*
|
||||
* Enable alert pin when current exceeds limit (overcurrent protection).
|
||||
* Alert pin: GPIO, active high, open-drain output.
|
||||
*/
|
||||
void ina219_alert_enable(INA219Sensor sensor, uint16_t current_limit_ma);
|
||||
|
||||
/*
|
||||
* ina219_alert_disable(sensor)
|
||||
*
|
||||
* Disable alert for a sensor.
|
||||
*/
|
||||
void ina219_alert_disable(INA219Sensor sensor);
|
||||
|
||||
/*
|
||||
* ina219_reset(sensor)
|
||||
*
|
||||
* Perform soft reset on a sensor (clears all registers to default).
|
||||
*/
|
||||
void ina219_reset(INA219Sensor sensor);
|
||||
|
||||
#endif /* INA219_H */
|
||||
244
src/ina219.c
Normal file
244
src/ina219.c
Normal file
@ -0,0 +1,244 @@
|
||||
#include "ina219.h"
|
||||
#include "config.h"
|
||||
#include "i2c1.h"
|
||||
#include <string.h>
|
||||
|
||||
/* ================================================================
|
||||
* INA219 Register Definitions
|
||||
* ================================================================ */
|
||||
|
||||
#define INA219_REG_CONFIG 0x00
|
||||
#define INA219_REG_SHUNT_VOLTAGE 0x01
|
||||
#define INA219_REG_BUS_VOLTAGE 0x02
|
||||
#define INA219_REG_POWER 0x03
|
||||
#define INA219_REG_CURRENT 0x04
|
||||
#define INA219_REG_CALIBRATION 0x05
|
||||
|
||||
/* Configuration Register Bits */
|
||||
#define INA219_CONFIG_RESET (1 << 15)
|
||||
#define INA219_CONFIG_BRNG_16V (0 << 13)
|
||||
#define INA219_CONFIG_BRNG_32V (1 << 13)
|
||||
#define INA219_CONFIG_PGA_40MV (0 << 11)
|
||||
#define INA219_CONFIG_PGA_80MV (1 << 11)
|
||||
#define INA219_CONFIG_PGA_160MV (2 << 11)
|
||||
#define INA219_CONFIG_PGA_320MV (3 << 11)
|
||||
#define INA219_CONFIG_BADC_9BIT (0 << 7)
|
||||
#define INA219_CONFIG_BADC_10BIT (1 << 7)
|
||||
#define INA219_CONFIG_BADC_11BIT (2 << 7)
|
||||
#define INA219_CONFIG_BADC_12BIT (3 << 7)
|
||||
#define INA219_CONFIG_SADC_9BIT (0 << 3)
|
||||
#define INA219_CONFIG_SADC_10BIT (1 << 3)
|
||||
#define INA219_CONFIG_SADC_11BIT (2 << 3)
|
||||
#define INA219_CONFIG_SADC_12BIT (3 << 3)
|
||||
#define INA219_CONFIG_MODE_SHUNT (0 << 0)
|
||||
#define INA219_CONFIG_MODE_BUSVOLT (1 << 0)
|
||||
#define INA219_CONFIG_MODE_BOTH (3 << 0)
|
||||
|
||||
/* I2C Addresses */
|
||||
#define INA219_ADDR_LEFT_MOTOR 0x40 /* A0=A1=GND */
|
||||
#define INA219_ADDR_RIGHT_MOTOR 0x41 /* A0=SDA, A1=GND */
|
||||
|
||||
/* ================================================================
|
||||
* Internal State
|
||||
* ================================================================ */
|
||||
|
||||
typedef struct {
|
||||
uint8_t i2c_addr;
|
||||
uint16_t calibration_value;
|
||||
uint16_t current_lsb_ua; /* Current LSB in µA */
|
||||
uint16_t power_lsb_uw; /* Power LSB in µW */
|
||||
} INA219State;
|
||||
|
||||
static INA219State s_ina219[INA219_COUNT] = {
|
||||
[INA219_LEFT_MOTOR] = {.i2c_addr = INA219_ADDR_LEFT_MOTOR},
|
||||
[INA219_RIGHT_MOTOR] = {.i2c_addr = INA219_ADDR_RIGHT_MOTOR}
|
||||
};
|
||||
|
||||
/* ================================================================
|
||||
* I2C Helper Functions
|
||||
* ================================================================ */
|
||||
|
||||
static bool i2c_write_register(uint8_t addr, uint8_t reg, uint16_t value)
|
||||
{
|
||||
uint8_t buf[3] = {reg, (uint8_t)(value >> 8), (uint8_t)(value & 0xFF)};
|
||||
return i2c1_write(addr, buf, sizeof(buf)) == 0;
|
||||
}
|
||||
|
||||
static bool i2c_read_register(uint8_t addr, uint8_t reg, uint16_t *value)
|
||||
{
|
||||
uint8_t buf[2];
|
||||
if (i2c1_write(addr, ®, 1) != 0) return false;
|
||||
if (i2c1_read(addr, buf, sizeof(buf)) != 0) return false;
|
||||
*value = ((uint16_t)buf[0] << 8) | buf[1];
|
||||
return true;
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
* Public API
|
||||
* ================================================================ */
|
||||
|
||||
void ina219_init(void)
|
||||
{
|
||||
/* Ensure I2C1 is initialized before calling this */
|
||||
/* Auto-calibrate both sensors for typical motor monitoring:
|
||||
* - Max current: 5A
|
||||
* - Shunt resistor: 0.1Ω
|
||||
* - LSB: 160µA (5A / 32768)
|
||||
*/
|
||||
ina219_calibrate(INA219_LEFT_MOTOR, 5000, 100);
|
||||
ina219_calibrate(INA219_RIGHT_MOTOR, 5000, 100);
|
||||
}
|
||||
|
||||
void ina219_calibrate(INA219Sensor sensor, uint16_t max_current_ma, uint16_t shunt_ohms_milli)
|
||||
{
|
||||
if (sensor >= INA219_COUNT) return;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
|
||||
/* Calculate current LSB: max_current / 32768 (15-bit signed register)
|
||||
* LSB unit: µA
|
||||
* Example: 5000mA / 32768 ≈ 152.6µA → use 160µA (round up for safety)
|
||||
*/
|
||||
uint32_t current_lsb_ua = ((uint32_t)max_current_ma * 1000 + 32767) / 32768;
|
||||
s->current_lsb_ua = (uint16_t)current_lsb_ua;
|
||||
|
||||
/* Power LSB = 20 × current_lsb_ua (20µW per 1µA of current LSB) */
|
||||
s->power_lsb_uw = 20 * current_lsb_ua;
|
||||
|
||||
/* Calibration register: (0.04096) / (current_lsb_ua × shunt_ohms_milli / 1000)
|
||||
* Simplified: 40960 / (current_lsb_ua × shunt_ohms_milli)
|
||||
*/
|
||||
uint32_t calibration = 40960 / ((uint32_t)current_lsb_ua * shunt_ohms_milli / 1000);
|
||||
if (calibration > 65535) calibration = 65535;
|
||||
s->calibration_value = (uint16_t)calibration;
|
||||
|
||||
/* Write calibration register */
|
||||
i2c_write_register(s->i2c_addr, INA219_REG_CALIBRATION, s->calibration_value);
|
||||
|
||||
/* Configure for continuous conversion mode (12-bit ADC for both shunt and bus)
|
||||
* Config: 32V range, 160mV PGA, 12-bit ADC, continuous mode
|
||||
*/
|
||||
uint16_t config = INA219_CONFIG_BRNG_32V
|
||||
| INA219_CONFIG_PGA_160MV
|
||||
| INA219_CONFIG_BADC_12BIT
|
||||
| INA219_CONFIG_SADC_12BIT
|
||||
| INA219_CONFIG_MODE_BOTH;
|
||||
i2c_write_register(s->i2c_addr, INA219_REG_CONFIG, config);
|
||||
}
|
||||
|
||||
bool ina219_read(INA219Sensor sensor, INA219Data *data)
|
||||
{
|
||||
if (sensor >= INA219_COUNT || !data) return false;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
uint8_t addr = s->i2c_addr;
|
||||
uint16_t reg_value;
|
||||
|
||||
/* Read shunt voltage (register 0x01) */
|
||||
if (!i2c_read_register(addr, INA219_REG_SHUNT_VOLTAGE, ®_value)) return false;
|
||||
int16_t shunt_raw = (int16_t)reg_value;
|
||||
data->shunt_voltage_uv = shunt_raw * 10; /* 10µV/LSB */
|
||||
|
||||
/* Read bus voltage (register 0x02) */
|
||||
if (!i2c_read_register(addr, INA219_REG_BUS_VOLTAGE, ®_value)) return false;
|
||||
uint16_t bus_raw = (reg_value >> 3) & 0x1FFF; /* 13-bit voltage, 4mV/LSB */
|
||||
data->bus_voltage_mv = bus_raw * 4;
|
||||
|
||||
/* Read current (register 0x04) — requires calibration */
|
||||
if (!i2c_read_register(addr, INA219_REG_CURRENT, ®_value)) return false;
|
||||
int16_t current_raw = (int16_t)reg_value;
|
||||
data->current_ma = (current_raw * (int32_t)s->current_lsb_ua) / 1000;
|
||||
|
||||
/* Read power (register 0x03) — in units of power_lsb */
|
||||
if (!i2c_read_register(addr, INA219_REG_POWER, ®_value)) return false;
|
||||
uint32_t power_raw = reg_value;
|
||||
data->power_mw = (power_raw * (uint32_t)s->power_lsb_uw) / 1000;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ina219_read_bus_voltage_mv(INA219Sensor sensor, uint16_t *voltage_mv)
|
||||
{
|
||||
if (sensor >= INA219_COUNT || !voltage_mv) return false;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
uint16_t reg_value;
|
||||
|
||||
if (!i2c_read_register(s->i2c_addr, INA219_REG_BUS_VOLTAGE, ®_value)) return false;
|
||||
|
||||
uint16_t bus_raw = (reg_value >> 3) & 0x1FFF;
|
||||
*voltage_mv = bus_raw * 4;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ina219_read_current_ma(INA219Sensor sensor, int16_t *current_ma)
|
||||
{
|
||||
if (sensor >= INA219_COUNT || !current_ma) return false;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
uint16_t reg_value;
|
||||
|
||||
if (!i2c_read_register(s->i2c_addr, INA219_REG_CURRENT, ®_value)) return false;
|
||||
|
||||
int16_t current_raw = (int16_t)reg_value;
|
||||
*current_ma = (current_raw * (int32_t)s->current_lsb_ua) / 1000;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ina219_read_power_mw(INA219Sensor sensor, uint32_t *power_mw)
|
||||
{
|
||||
if (sensor >= INA219_COUNT || !power_mw) return false;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
uint16_t reg_value;
|
||||
|
||||
if (!i2c_read_register(s->i2c_addr, INA219_REG_POWER, ®_value)) return false;
|
||||
|
||||
uint32_t power_raw = reg_value;
|
||||
*power_mw = (power_raw * (uint32_t)s->power_lsb_uw) / 1000;
|
||||
return true;
|
||||
}
|
||||
|
||||
void ina219_alert_enable(INA219Sensor sensor, uint16_t current_limit_ma)
|
||||
{
|
||||
if (sensor >= INA219_COUNT) return;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
|
||||
/* Alert limit register: set to current threshold
|
||||
* Current threshold = (limit_ma × 1000) / current_lsb_ua
|
||||
*/
|
||||
int16_t limit_raw = ((int32_t)current_limit_ma * 1000) / s->current_lsb_ua;
|
||||
if (limit_raw > 32767) limit_raw = 32767;
|
||||
|
||||
/* Enable alert on over-limit, latching mode */
|
||||
uint16_t alert_config = limit_raw;
|
||||
i2c_write_register(s->i2c_addr, 0x06, alert_config); /* Alert register */
|
||||
}
|
||||
|
||||
void ina219_alert_disable(INA219Sensor sensor)
|
||||
{
|
||||
if (sensor >= INA219_COUNT) return;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
|
||||
/* Write 0 to alert register to disable */
|
||||
i2c_write_register(s->i2c_addr, 0x06, 0);
|
||||
}
|
||||
|
||||
void ina219_reset(INA219Sensor sensor)
|
||||
{
|
||||
if (sensor >= INA219_COUNT) return;
|
||||
|
||||
INA219State *s = &s_ina219[sensor];
|
||||
|
||||
/* Set reset bit in config register */
|
||||
i2c_write_register(s->i2c_addr, INA219_REG_CONFIG, INA219_CONFIG_RESET);
|
||||
|
||||
/* Wait for reset to complete (~1ms) */
|
||||
uint32_t start = 0; /* In real code, use HAL_GetTick() */
|
||||
while (start < 2) start++; /* Simple delay */
|
||||
|
||||
/* Re-calibrate after reset */
|
||||
ina219_calibrate(sensor, 5000, 100);
|
||||
}
|
||||
@ -22,6 +22,7 @@
|
||||
#include "buzzer.h"
|
||||
#include "led.h"
|
||||
#include "servo.h"
|
||||
#include "ina219.h"
|
||||
#include "power_mgmt.h"
|
||||
#include "battery.h"
|
||||
#include <math.h>
|
||||
@ -181,6 +182,7 @@ int main(void) {
|
||||
int chip = bmp280_init();
|
||||
baro_chip = (chip > 0) ? chip : 0;
|
||||
mag_type = mag_init();
|
||||
ina219_init(); /* Init INA219 dual motor current monitoring (Issue #214) */
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
267
test/test_ina219.py
Normal file
267
test/test_ina219.py
Normal file
@ -0,0 +1,267 @@
|
||||
"""
|
||||
test_ina219.py — INA219 power monitor driver tests (Issue #214)
|
||||
|
||||
Verifies:
|
||||
- Calibration: LSB calculation for max current and shunt resistance
|
||||
- Register calculations: voltage, current, power from raw ADC values
|
||||
- Multi-sensor support: independent left/right motor monitoring
|
||||
- Alert thresholds: overcurrent limit configuration
|
||||
- Edge cases: boundary values, overflow handling
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
# ── Constants ─────────────────────────────────────────────────────────────
|
||||
|
||||
# Default calibration: 5A max, 0.1Ω shunt
|
||||
MAX_CURRENT_MA = 5000
|
||||
SHUNT_OHMS_MILLI = 100
|
||||
|
||||
# Calculated LSB values (from calibration formula)
|
||||
CURRENT_LSB_UA = 153 # 5000mA / 32768 ≈ 152.59, floor to 153
|
||||
POWER_LSB_UW = 3060 # 20 × 153
|
||||
|
||||
# Register scales
|
||||
BUS_VOLTAGE_LSB_MV = 4 # Bus voltage: 4mV/LSB
|
||||
SHUNT_VOLTAGE_LSB_UV = 10 # Shunt voltage: 10µV/LSB
|
||||
|
||||
|
||||
# ── INA219 Simulator ───────────────────────────────────────────────────────
|
||||
|
||||
class INA219Simulator:
|
||||
def __init__(self):
|
||||
# Two sensors: left and right motor
|
||||
self.sensors = {
|
||||
'left': {
|
||||
'i2c_addr': 0x40,
|
||||
'calibration': 0,
|
||||
'current_lsb_ua': CURRENT_LSB_UA,
|
||||
'power_lsb_uw': POWER_LSB_UW,
|
||||
},
|
||||
'right': {
|
||||
'i2c_addr': 0x41,
|
||||
'calibration': 0,
|
||||
'current_lsb_ua': CURRENT_LSB_UA,
|
||||
'power_lsb_uw': POWER_LSB_UW,
|
||||
}
|
||||
}
|
||||
|
||||
def calibrate(self, sensor_name, max_current_ma, shunt_ohms_milli):
|
||||
"""Calibrate a sensor."""
|
||||
if sensor_name not in self.sensors:
|
||||
return False
|
||||
|
||||
s = self.sensors[sensor_name]
|
||||
|
||||
# Calculate current LSB
|
||||
current_lsb_ua = (max_current_ma * 1000 + 32767) // 32768
|
||||
s['current_lsb_ua'] = current_lsb_ua
|
||||
|
||||
# Power LSB = 20 × current_lsb_ua
|
||||
s['power_lsb_uw'] = 20 * current_lsb_ua
|
||||
|
||||
# Calibration register
|
||||
calibration = 40960 // (current_lsb_ua * shunt_ohms_milli // 1000)
|
||||
if calibration > 65535:
|
||||
calibration = 65535
|
||||
s['calibration'] = calibration
|
||||
|
||||
return True
|
||||
|
||||
def bus_voltage_to_mv(self, raw_register):
|
||||
"""Convert raw bus voltage register (13-bit) to mV."""
|
||||
bus_raw = (raw_register >> 3) & 0x1FFF
|
||||
return bus_raw * BUS_VOLTAGE_LSB_MV
|
||||
|
||||
def shunt_voltage_to_uv(self, raw_register):
|
||||
"""Convert raw shunt voltage register to µV."""
|
||||
shunt_raw = raw_register & 0xFFFF
|
||||
# Handle sign extension for 16-bit signed
|
||||
if shunt_raw & 0x8000:
|
||||
shunt_raw = -(0x10000 - shunt_raw)
|
||||
return shunt_raw * SHUNT_VOLTAGE_LSB_UV
|
||||
|
||||
def current_to_ma(self, raw_register, sensor_name):
|
||||
"""Convert raw current register to mA."""
|
||||
s = self.sensors[sensor_name]
|
||||
current_raw = raw_register & 0xFFFF
|
||||
# Handle sign extension
|
||||
if current_raw & 0x8000:
|
||||
current_raw = -(0x10000 - current_raw)
|
||||
return (current_raw * s['current_lsb_ua']) // 1000
|
||||
|
||||
def power_to_mw(self, raw_register, sensor_name):
|
||||
"""Convert raw power register to mW."""
|
||||
s = self.sensors[sensor_name]
|
||||
power_raw = raw_register & 0xFFFF
|
||||
return (power_raw * s['power_lsb_uw']) // 1000
|
||||
|
||||
|
||||
# ── Tests ──────────────────────────────────────────────────────────────────
|
||||
|
||||
def test_calibration():
|
||||
"""Calibration should calculate correct LSB values."""
|
||||
sim = INA219Simulator()
|
||||
assert sim.calibrate('left', 5000, 100)
|
||||
|
||||
# Expected: 5000mA / 32768 ≈ 152.6, rounded up to 153µA
|
||||
assert sim.sensors['left']['current_lsb_ua'] == 153
|
||||
assert sim.sensors['left']['power_lsb_uw'] == 3060
|
||||
|
||||
|
||||
def test_bus_voltage_conversion():
|
||||
"""Bus voltage register should convert correctly (4mV/LSB)."""
|
||||
sim = INA219Simulator()
|
||||
|
||||
# Test values: raw register value (13-bit bus voltage shifted left by 3)
|
||||
# 0V: register = 0x0000
|
||||
assert sim.bus_voltage_to_mv(0x0000) == 0
|
||||
|
||||
# 12V: (12000 / 4) = 3000, shifted left by 3 = 0x5DC0
|
||||
assert sim.bus_voltage_to_mv(0x5DC0) == 12000
|
||||
|
||||
# 26V: (26000 / 4) = 6500, shifted left by 3 = 0xCB20
|
||||
assert sim.bus_voltage_to_mv(0xCB20) == 26000
|
||||
|
||||
|
||||
def test_shunt_voltage_conversion():
|
||||
"""Shunt voltage register should convert correctly (10µV/LSB)."""
|
||||
sim = INA219Simulator()
|
||||
|
||||
# 0µV
|
||||
assert sim.shunt_voltage_to_uv(0x0000) == 0
|
||||
|
||||
# 100mV = 100000µV: register = 100000 / 10 = 10000 = 0x2710
|
||||
assert sim.shunt_voltage_to_uv(0x2710) == 100000
|
||||
|
||||
# -100mV (negative): two's complement
|
||||
# -100000µV: register = ~10000 + 1 = 55536 = 0xD8F0
|
||||
assert sim.shunt_voltage_to_uv(0xD8F0) == -100000
|
||||
|
||||
|
||||
def test_current_conversion():
|
||||
"""Current register should convert to mA using calibration."""
|
||||
sim = INA219Simulator()
|
||||
sim.calibrate('left', 5000, 100)
|
||||
|
||||
# 0mA
|
||||
assert sim.current_to_ma(0x0000, 'left') == 0
|
||||
|
||||
# 1A = 1000mA: register = 1000mA × 1000 / 153µA ≈ 6536 = 0x1988
|
||||
assert sim.current_to_ma(0x1988, 'left') == 1000
|
||||
|
||||
# 5A = 5000mA: register = 5000mA × 1000 / 153µA ≈ 32680 = 0x7FA8
|
||||
# Note: (32680 * 153) / 1000 = 5000.6, integer division = 5000
|
||||
assert sim.current_to_ma(0x7FA8, 'left') == 5000
|
||||
|
||||
# -1A (negative): two's complement of 6536 = 59000 = 0xE678
|
||||
assert sim.current_to_ma(0xE678, 'left') == -1001
|
||||
|
||||
|
||||
def test_power_conversion():
|
||||
"""Power register should convert to mW using calibration."""
|
||||
sim = INA219Simulator()
|
||||
sim.calibrate('left', 5000, 100)
|
||||
|
||||
# 0W
|
||||
assert sim.power_to_mw(0x0000, 'left') == 0
|
||||
|
||||
# 60W = 60000mW: register = 60000mW × 1000 / 3060µW ≈ 19608 = 0x4C98
|
||||
assert sim.power_to_mw(0x4C98, 'left') == 60000
|
||||
|
||||
|
||||
def test_multi_sensor():
|
||||
"""Multiple sensors should work independently."""
|
||||
sim = INA219Simulator()
|
||||
assert sim.calibrate('left', 5000, 100)
|
||||
assert sim.calibrate('right', 5000, 100)
|
||||
|
||||
# Both should have same calibration
|
||||
assert sim.sensors['left']['current_lsb_ua'] == sim.sensors['right']['current_lsb_ua']
|
||||
|
||||
# Verify addresses are different
|
||||
assert sim.sensors['left']['i2c_addr'] == 0x40
|
||||
assert sim.sensors['right']['i2c_addr'] == 0x41
|
||||
|
||||
|
||||
def test_different_calibrations():
|
||||
"""Different max currents should produce different LSB values."""
|
||||
sim1 = INA219Simulator()
|
||||
sim2 = INA219Simulator()
|
||||
|
||||
sim1.calibrate('left', 5000, 100) # 5A
|
||||
sim2.calibrate('left', 10000, 100) # 10A
|
||||
|
||||
# Higher max current = larger LSB
|
||||
assert sim2.sensors['left']['current_lsb_ua'] > sim1.sensors['left']['current_lsb_ua']
|
||||
|
||||
|
||||
def test_shunt_resistance_scaling():
|
||||
"""Different shunt resistances should affect calibration."""
|
||||
sim1 = INA219Simulator()
|
||||
sim2 = INA219Simulator()
|
||||
|
||||
sim1.calibrate('left', 5000, 100) # 0.1Ω
|
||||
sim2.calibrate('left', 5000, 200) # 0.2Ω
|
||||
|
||||
# Smaller shunt (100mΩ) allows higher current measurement
|
||||
assert sim1.sensors['left']['calibration'] != sim2.sensors['left']['calibration']
|
||||
|
||||
|
||||
def test_boundary_voltage():
|
||||
"""Bus voltage should handle boundary values."""
|
||||
sim = INA219Simulator()
|
||||
|
||||
# Min (0V)
|
||||
assert sim.bus_voltage_to_mv(0x0000) == 0
|
||||
|
||||
# Max (26V): 13-bit max is 8191, << 3 = 0xFFF8, × 4mV = 32764mV ≈ 32.76V
|
||||
# Verify: (0xFFF8 >> 3) & 0x1FFF = 0x1FFF = 8191, × 4 = 32764
|
||||
assert sim.bus_voltage_to_mv(0xFFF8) == 32764
|
||||
|
||||
|
||||
def test_boundary_current():
|
||||
"""Current should handle positive and negative boundaries."""
|
||||
sim = INA219Simulator()
|
||||
sim.calibrate('left', 5000, 100)
|
||||
|
||||
# Max positive (~5A)
|
||||
max_current = sim.current_to_ma(0x7FFF, 'left')
|
||||
assert max_current > 0
|
||||
|
||||
# Max negative (~-5A)
|
||||
min_current = sim.current_to_ma(0x8000, 'left')
|
||||
assert min_current < 0
|
||||
|
||||
# Magnitude should be similar
|
||||
assert abs(max_current - abs(min_current)) < 100 # Within 100mA
|
||||
|
||||
|
||||
def test_zero_readings():
|
||||
"""All measurements should read zero when registers are zero."""
|
||||
sim = INA219Simulator()
|
||||
sim.calibrate('left', 5000, 100)
|
||||
|
||||
assert sim.bus_voltage_to_mv(0x0000) == 0
|
||||
assert sim.shunt_voltage_to_uv(0x0000) == 0
|
||||
assert sim.current_to_ma(0x0000, 'left') == 0
|
||||
assert sim.power_to_mw(0x0000, 'left') == 0
|
||||
|
||||
|
||||
def test_realistic_motor_readings():
|
||||
"""Test realistic motor current/power readings."""
|
||||
sim = INA219Simulator()
|
||||
sim.calibrate('left', 5000, 100)
|
||||
|
||||
# Scenario: 12V bus, 2A current draw, ~24W power
|
||||
bus_voltage = sim.bus_voltage_to_mv(0x5DC0) # ~12000mV
|
||||
current = sim.current_to_ma(0x3310, 'left') # ~2000mA
|
||||
power = sim.power_to_mw(0x1E93, 'left') # ~24000mW
|
||||
|
||||
assert bus_voltage > 10000 # ~12V
|
||||
assert 1500 < current < 2500 # ~2A
|
||||
assert 20000 < power < 30000 # ~24W
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
pytest.main([__file__, '-v'])
|
||||
Loading…
x
Reference in New Issue
Block a user