diff --git a/doc/nrf/releases_and_maturity/releases/release-notes-changelog.rst b/doc/nrf/releases_and_maturity/releases/release-notes-changelog.rst index 1c904c6022eb..dd3296ebf7d0 100644 --- a/doc/nrf/releases_and_maturity/releases/release-notes-changelog.rst +++ b/doc/nrf/releases_and_maturity/releases/release-notes-changelog.rst @@ -459,6 +459,10 @@ Peripheral samples PMIC samples ------------ +* :ref:`npm1300_fuel_gauge` sample: + + * Updated to accommodate API changes in nRF Fuel Gauge library v1.0.0. + |no_changes_yet_note| Protocol serialization samples diff --git a/samples/pmic/native/npm1300_fuel_gauge/prj.conf b/samples/pmic/native/npm1300_fuel_gauge/prj.conf index bc95ef63cb68..08263f432e62 100644 --- a/samples/pmic/native/npm1300_fuel_gauge/prj.conf +++ b/samples/pmic/native/npm1300_fuel_gauge/prj.conf @@ -9,5 +9,6 @@ CONFIG_REGULATOR=y CONFIG_SENSOR=y CONFIG_I2C_SHELL=y CONFIG_NRF_FUEL_GAUGE=y +CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL=y CONFIG_REQUIRES_FLOAT_PRINTF=y CONFIG_MAIN_STACK_SIZE=1536 diff --git a/samples/pmic/native/npm1300_fuel_gauge/src/fuel_gauge.c b/samples/pmic/native/npm1300_fuel_gauge/src/fuel_gauge.c index bd8f955bb313..92f10dcf8ff0 100644 --- a/samples/pmic/native/npm1300_fuel_gauge/src/fuel_gauge.c +++ b/samples/pmic/native/npm1300_fuel_gauge/src/fuel_gauge.c @@ -12,21 +12,22 @@ #include #include -#include "nrf_fuel_gauge.h" +#include -/* nPM1300 CHARGER.BCHGCHARGESTATUS.CONSTANTCURRENT register bitmask */ -#define NPM1300_CHG_STATUS_CC_MASK BIT(3) +/* nPM1300 CHARGER.BCHGCHARGESTATUS register bitmasks */ +#define NPM1300_CHG_STATUS_COMPLETE_MASK BIT(1) +#define NPM1300_CHG_STATUS_TRICKLE_MASK BIT(2) +#define NPM1300_CHG_STATUS_CC_MASK BIT(3) +#define NPM1300_CHG_STATUS_CV_MASK BIT(4) -static float max_charge_current; -static float term_charge_current; static int64_t ref_time; static const struct battery_model battery_model = { #include "battery_model.inc" }; -static int read_sensors(const struct device *charger, - float *voltage, float *current, float *temp, int32_t *chg_status) +static int read_sensors(const struct device *charger, float *voltage, float *current, float *temp, + int32_t *chg_status) { struct sensor_value value; int ret; @@ -51,13 +52,41 @@ static int read_sensors(const struct device *charger, return 0; } +static int charge_status_inform(int32_t chg_status) +{ + union nrf_fuel_gauge_ext_state_info_data state_info; + + if (chg_status & NPM1300_CHG_STATUS_COMPLETE_MASK) { + printk("Charge complete\n"); + state_info.charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_COMPLETE; + } else if (chg_status & NPM1300_CHG_STATUS_TRICKLE_MASK) { + printk("Trickle charging\n"); + state_info.charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_TRICKLE; + } else if (chg_status & NPM1300_CHG_STATUS_CC_MASK) { + printk("Constant current charging\n"); + state_info.charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_CC; + } else if (chg_status & NPM1300_CHG_STATUS_CV_MASK) { + printk("Constant voltage charging\n"); + state_info.charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_CV; + } else { + printk("Charger idle\n"); + state_info.charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_IDLE; + } + + return nrf_fuel_gauge_ext_state_update(NRF_FUEL_GAUGE_EXT_STATE_INFO_CHARGE_STATE_CHANGE, + &state_info); +} + int fuel_gauge_init(const struct device *charger) { struct sensor_value value; struct nrf_fuel_gauge_init_parameters parameters = { .model = &battery_model, .opt_params = NULL, + .state = NULL, }; + float max_charge_current; + float term_charge_current; int32_t chg_status; int ret; @@ -73,7 +102,33 @@ int fuel_gauge_init(const struct device *charger) max_charge_current = (float)value.val1 + ((float)value.val2 / 1000000); term_charge_current = max_charge_current / 10.f; - nrf_fuel_gauge_init(¶meters, NULL); + ret = nrf_fuel_gauge_init(¶meters, NULL); + if (ret < 0) { + printk("Error: Could not initialise fuel gauge\n"); + return ret; + } + + ret = nrf_fuel_gauge_ext_state_update(NRF_FUEL_GAUGE_EXT_STATE_INFO_CHARGE_CURRENT_LIMIT, + &(union nrf_fuel_gauge_ext_state_info_data){ + .charge_current_limit = max_charge_current}); + if (ret < 0) { + printk("Error: Could not set fuel gauge state\n"); + return ret; + } + + ret = nrf_fuel_gauge_ext_state_update(NRF_FUEL_GAUGE_EXT_STATE_INFO_TERM_CURRENT, + &(union nrf_fuel_gauge_ext_state_info_data){ + .charge_term_current = term_charge_current}); + if (ret < 0) { + printk("Error: Could not set fuel gauge state\n"); + return ret; + } + + ret = charge_status_inform(chg_status); + if (ret < 0) { + printk("Error: Could not set fuel gauge state\n"); + return ret; + } ref_time = k_uptime_get(); @@ -82,6 +137,8 @@ int fuel_gauge_init(const struct device *charger) int fuel_gauge_update(const struct device *charger, bool vbus_connected) { + static int32_t chg_status_prev; + float voltage; float current; float temp; @@ -90,7 +147,6 @@ int fuel_gauge_update(const struct device *charger, bool vbus_connected) float ttf; float delta; int32_t chg_status; - bool cc_charging; int ret; ret = read_sensors(charger, &voltage, ¤t, &temp, &chg_status); @@ -99,13 +155,30 @@ int fuel_gauge_update(const struct device *charger, bool vbus_connected) return ret; } - cc_charging = (chg_status & NPM1300_CHG_STATUS_CC_MASK) != 0; + ret = nrf_fuel_gauge_ext_state_update( + vbus_connected ? NRF_FUEL_GAUGE_EXT_STATE_INFO_VBUS_CONNECTED + : NRF_FUEL_GAUGE_EXT_STATE_INFO_VBUS_DISCONNECTED, + NULL); + if (ret < 0) { + printk("Error: Could not inform of state\n"); + return ret; + } + + if (chg_status != chg_status_prev) { + chg_status_prev = chg_status; + + ret = charge_status_inform(chg_status); + if (ret < 0) { + printk("Error: Could not inform of charge status\n"); + return ret; + } + } - delta = (float) k_uptime_delta(&ref_time) / 1000.f; + delta = (float)k_uptime_delta(&ref_time) / 1000.f; - soc = nrf_fuel_gauge_process(voltage, current, temp, delta, vbus_connected, NULL); + soc = nrf_fuel_gauge_process(voltage, current, temp, delta, NULL); tte = nrf_fuel_gauge_tte_get(); - ttf = nrf_fuel_gauge_ttf_get(cc_charging, -term_charge_current); + ttf = nrf_fuel_gauge_ttf_get(); printk("V: %.3f, I: %.3f, T: %.2f, ", (double)voltage, (double)current, (double)temp); printk("SoC: %.2f, TTE: %.0f, TTF: %.0f\n", (double)soc, (double)tte, (double)ttf); diff --git a/tests/lib/nrf_fuel_gauge/src/nrf_fuel_gauge_test.c b/tests/lib/nrf_fuel_gauge/src/nrf_fuel_gauge_test.c index a442099f1331..38e9bc22b349 100644 --- a/tests/lib/nrf_fuel_gauge/src/nrf_fuel_gauge_test.c +++ b/tests/lib/nrf_fuel_gauge/src/nrf_fuel_gauge_test.c @@ -12,7 +12,11 @@ #include -static const struct battery_model battery = { +static const struct battery_model_primary battery_primary = { +#include "battery_models/primary_cell/AAA_Alkaline.inc" +}; + +static const struct battery_model battery_secondary = { #include "battery_model.inc" }; @@ -24,30 +28,45 @@ void tearDown(void) { } -void test_nrf_fuel_gauge_init(void) +static int initialize_fuel_gauge(float vbat, float ibat, float tbat, void *state) { struct nrf_fuel_gauge_config_parameters opt_params; const struct nrf_fuel_gauge_init_parameters params = { - .v0 = 4.2f, - .i0 = 0.0f, - .t0 = 25.0f, - .model = &battery, + .v0 = vbat, + .i0 = ibat, + .t0 = tbat, +#if IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL) + .model = &battery_secondary, +#elif IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL) + .model_primary = &battery_primary, +#endif .opt_params = &opt_params, + .state = state, }; float v0; - int err; + + (void)battery_primary; + (void)battery_secondary; TEST_ASSERT_TRUE(strlen(nrf_fuel_gauge_version) > 0); TEST_ASSERT_TRUE(strlen(nrf_fuel_gauge_build_date) > 0); + TEST_ASSERT_TRUE(nrf_fuel_gauge_state_size > 0); nrf_fuel_gauge_opt_params_default_get(&opt_params); opt_params.tte_min_time = 0.0f; - err = nrf_fuel_gauge_init(¶ms, &v0); + return nrf_fuel_gauge_init(¶ms, &v0); +} + +void test_nrf_fuel_gauge_init(void) +{ + int err; + + err = initialize_fuel_gauge(4.2f, 0.0f, 25.0f, NULL); TEST_ASSERT_EQUAL(0, err); } -void test_nrf_fuel_gauge_sanity(void) +void test_nrf_fuel_gauge_sanity_discharge(void) { struct nrf_fuel_gauge_state_info state_info; float soc_begin; @@ -57,12 +76,20 @@ void test_nrf_fuel_gauge_sanity(void) float temperature; float current; float time_step; - bool vbus_connected; + float voltage_begin; + float voltage_end; + float voltage; + int err; const float voltage_step = 0.001f; - const float voltage_begin = 4.2f; - const float voltage_end = 3.2f; - float voltage; + +#if IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL) + voltage_begin = 4.2f; + voltage_end = 3.2f; +#elif IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL) + voltage_begin = 1.5f; + voltage_end = 1.0f; +#endif /* Simple sanity check: * decrease voltage over some iterations and verify that SOC and TTE changes accordingly. @@ -72,10 +99,12 @@ void test_nrf_fuel_gauge_sanity(void) temperature = 25.0f; current = 0.08f; time_step = 60.0f; - vbus_connected = false; - soc_begin = nrf_fuel_gauge_process( - voltage, current, temperature, time_step, vbus_connected, &state_info); + err = initialize_fuel_gauge(voltage, current, temperature, NULL); + TEST_ASSERT_EQUAL(0, err); + + (void)nrf_fuel_gauge_process(voltage, current, temperature, time_step, &state_info); + soc_begin = state_info.soc_raw; soc_end = soc_begin; TEST_ASSERT_FALSE(isnan(soc_begin)); @@ -85,41 +114,221 @@ void test_nrf_fuel_gauge_sanity(void) for (int i = 0; i < ((voltage_begin - voltage_end) / voltage_step); ++i) { voltage -= voltage_step; - soc_end = nrf_fuel_gauge_process( - voltage, current, temperature, time_step, - vbus_connected, &state_info); + (void)nrf_fuel_gauge_process(voltage, current, temperature, time_step, &state_info); + soc_end = state_info.soc_raw; TEST_ASSERT_FALSE(isnan(soc_end)); TEST_ASSERT_FALSE(signbit(soc_end)); - if (i > 100) { + if (IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL) && i > 100) { /* Expect "time-to-empty" to become valid after a few cycles */ - tte = nrf_fuel_gauge_tte_get(); TEST_ASSERT_FALSE(isnan(tte)); + } else if (IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL)) { + /* Always NAN for primary cell */ + ttf = nrf_fuel_gauge_ttf_get(); + TEST_ASSERT_TRUE(isnan(ttf)); } /* Don't expect time-to-full to be valid when discharging */ - ttf = nrf_fuel_gauge_ttf_get(false, 0.04f); + ttf = nrf_fuel_gauge_ttf_get(); TEST_ASSERT_TRUE(isnan(ttf)); } TEST_ASSERT_TRUE(soc_end < soc_begin); +} + +void test_nrf_fuel_gauge_sanity_state_resume(void) +{ + struct nrf_fuel_gauge_state_info state_info; + float temperature; + float current; + float time_step; + float voltage_begin; + float voltage_end; + float voltage; + float voltage_saved; + float soc_saved[100]; + int step_count; + int err; + + const float voltage_step = 0.001f; + + static uint8_t state_memory[1024]; + +#if IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL) + voltage_begin = 4.2f; + voltage_end = 3.2f; +#elif IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL) + voltage_begin = 1.5f; + voltage_end = 1.0f; +#endif + + /* Simple sanity check: + * Run the fuel gauge for a while, store the state, continue running, resume the stored + * state, and verify that SOC is the same. + */ + + voltage = voltage_begin; + temperature = 25.0f; + current = 0.08f; + time_step = 60.0f; + step_count = ((voltage_begin - voltage_end) / voltage_step); + + TEST_ASSERT_TRUE((step_count / 2) > ARRAY_SIZE(soc_saved)); + TEST_ASSERT_TRUE(sizeof(state_memory) >= nrf_fuel_gauge_state_size); + + err = initialize_fuel_gauge(voltage, current, temperature, NULL); + TEST_ASSERT_EQUAL(0, err); + + /* Run for a while to fill filters */ + for (int i = 0; i < step_count / 2; ++i) { + voltage -= voltage_step; + (void)nrf_fuel_gauge_process(voltage, current, temperature, time_step, &state_info); + } + + /* Store state */ + err = nrf_fuel_gauge_state_get(state_memory, sizeof(state_memory)); + TEST_ASSERT_EQUAL(0, err); + + voltage_saved = voltage; + + /* Fill comparison vector */ + for (int i = 0; i < ARRAY_SIZE(soc_saved); ++i) { + voltage -= voltage_step; + (void)nrf_fuel_gauge_process(voltage, current, temperature, time_step, &state_info); + soc_saved[i] = state_info.soc_raw; + } + + /* Re-init from previous state memory */ + err = initialize_fuel_gauge(voltage, current, temperature, state_memory); + TEST_ASSERT_EQUAL(0, err); + voltage = voltage_saved; + + /* Compare with previous run */ + for (int i = 0; i < ARRAY_SIZE(soc_saved); ++i) { + float soc; + + voltage -= voltage_step; + (void)nrf_fuel_gauge_process(voltage, current, temperature, time_step, &state_info); + soc = state_info.soc_raw; + TEST_ASSERT_EQUAL_FLOAT(soc_saved[i], soc); + } +} + +void test_nrf_fuel_gauge_sanity_charge(void) +{ + struct nrf_fuel_gauge_state_info state_info; + float soc_begin; + float soc_end; + float ttf; + float temperature; + float init_current; + float charge_current; + float time_step; + int err; + + const float voltage_step = 0.001f; + const float voltage_begin = 3.2f; + const float voltage_end = 4.2f; + float voltage; + + if (IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL)) { + /* Cannot charge primary cell batteries */ + return; + } + + /* Simple sanity check: + * apply negative current over some iterations and verify that SOC and TTF changes + * accordingly. + */ + + voltage = voltage_begin; + temperature = 25.0f; + init_current = 0.08f; + charge_current = -0.1f; + time_step = 60.0f; + + err = initialize_fuel_gauge(voltage, init_current, temperature, NULL); + TEST_ASSERT_EQUAL(0, err); + + (void)nrf_fuel_gauge_process(voltage, init_current, temperature, time_step, &state_info); + soc_begin = state_info.soc_raw; + soc_end = soc_begin; + + TEST_ASSERT_FALSE(isnan(soc_begin)); + TEST_ASSERT_FALSE(signbit(soc_begin)); + TEST_ASSERT_FALSE(isnan(state_info.yhat)); + TEST_ASSERT_FALSE(isnan(state_info.r0)); + + /* Inform library of charging */ + err = nrf_fuel_gauge_ext_state_update(NRF_FUEL_GAUGE_EXT_STATE_INFO_VBUS_CONNECTED, NULL); + TEST_ASSERT_EQUAL(0, err); + err = nrf_fuel_gauge_ext_state_update(NRF_FUEL_GAUGE_EXT_STATE_INFO_CHARGE_CURRENT_LIMIT, + &(union nrf_fuel_gauge_ext_state_info_data){ + .charge_current_limit = charge_current}); + TEST_ASSERT_EQUAL(0, err); + err = nrf_fuel_gauge_ext_state_update( + NRF_FUEL_GAUGE_EXT_STATE_INFO_TERM_CURRENT, + &(union nrf_fuel_gauge_ext_state_info_data){.charge_term_current = + charge_current * 0.1f}); + TEST_ASSERT_EQUAL(0, err); + err = nrf_fuel_gauge_ext_state_update( + NRF_FUEL_GAUGE_EXT_STATE_INFO_CHARGE_STATE_CHANGE, + &(union nrf_fuel_gauge_ext_state_info_data){ + .charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_CC}); + TEST_ASSERT_EQUAL(0, err); + + for (int i = 0; i < (fabsf(voltage_begin - voltage_end) / voltage_step); ++i) { + voltage += voltage_step; + (void)nrf_fuel_gauge_process(voltage, charge_current, temperature, time_step, + &state_info); + soc_end = state_info.soc_raw; + TEST_ASSERT_FALSE(isnan(soc_end)); + TEST_ASSERT_FALSE(signbit(soc_end)); + + /* Expect time-to-full to be valid after 1 iteration */ + if (i > 0) { + ttf = nrf_fuel_gauge_ttf_get(); + TEST_ASSERT_TRUE(!isnan(ttf)); + TEST_ASSERT_TRUE(ttf > 0.0f); + } + } + + TEST_ASSERT_TRUE(soc_end > soc_begin); +} + +void test_nrf_fuel_gauge_temp_range(void) +{ + struct nrf_fuel_gauge_state_info state_info; /* Verify that temperature is truncated to battery model range */ - const float model_temp_min = battery.temps[0]; + const float model_temp_min = battery_secondary.temps[0]; const float model_temp_max = - battery.temps[ARRAY_SIZE(((struct battery_model) {}).temps) - 1]; + battery_secondary.temps[ARRAY_SIZE(((struct battery_model){}).temps) - 1]; const float temp_range_begin = model_temp_min - 10.0f; const float temp_range_end = model_temp_max + 10.0f; const float temp_step_size = 0.5f; + float voltage = 4.2f; + float temperature = 25.0f; + float current = 0.08f; + float time_step = 60.0f; + int err; + + if (IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL)) { + /* Primary cell battery model does not have temperature range */ + return; + } + TEST_ASSERT_FALSE(isnan(model_temp_min)); TEST_ASSERT_FALSE(isnan(model_temp_max)); TEST_ASSERT_TRUE(model_temp_min < model_temp_max); + err = initialize_fuel_gauge(voltage, current, temperature, NULL); + TEST_ASSERT_EQUAL(0, err); + for (float t = temp_range_begin; t <= temp_range_end; t += temp_step_size) { - (void) nrf_fuel_gauge_process( - voltage, current, t, time_step, vbus_connected, &state_info); + (void)nrf_fuel_gauge_process(voltage, current, t, time_step, &state_info); if (t < model_temp_min) { TEST_ASSERT_TRUE(state_info.T_truncated == model_temp_min); } else if (t > model_temp_max) { @@ -136,16 +345,19 @@ void test_nrf_fuel_gauge_linking(void) .v0 = 4.2f, .i0 = 0.0f, .t0 = 25.0f, - .model = &battery, + .model = &battery_secondary, + .state = NULL, }; float v0; - (void) nrf_fuel_gauge_init(¶ms, &v0); - (void) nrf_fuel_gauge_process(4.2f, 0.07f, 25.0f, 60.0f, false, NULL); - (void) nrf_fuel_gauge_idle_set(4.2f, 25.0f, 0.0f); - (void) nrf_fuel_gauge_tte_get(); - (void) nrf_fuel_gauge_ttf_get(false, 0.0f); - (void) nrf_fuel_gauge_param_adjust(&(struct nrf_fuel_gauge_runtime_parameters) { + (void)nrf_fuel_gauge_init(¶ms, &v0); + (void)nrf_fuel_gauge_process(4.2f, 0.07f, 25.0f, 60.0f, NULL); + (void)nrf_fuel_gauge_idle_set(4.2f, 25.0f, 0.0f); + (void)nrf_fuel_gauge_tte_get(); + (void)nrf_fuel_gauge_ttf_get(); + (void)nrf_fuel_gauge_ext_state_update(NRF_FUEL_GAUGE_EXT_STATE_INFO_VBUS_CONNECTED, NULL); + (void)nrf_fuel_gauge_state_get(NULL, 0); + (void)nrf_fuel_gauge_param_adjust(&(struct nrf_fuel_gauge_runtime_parameters){ .a = 0.0f, .b = 0.0f, .c = 0.0f, @@ -153,6 +365,17 @@ void test_nrf_fuel_gauge_linking(void) }); } +void test_nrf_fuel_gauge_variant(void) +{ + if (IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL)) { + TEST_ASSERT_EQUAL(NRF_FUEL_GAUGE_VARIANT_PRIMARY, nrf_fuel_gauge_variant); + } else if (IS_ENABLED(CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL)) { + TEST_ASSERT_EQUAL(NRF_FUEL_GAUGE_VARIANT_SECONDARY, nrf_fuel_gauge_variant); + } else { + TEST_FAIL(); + } +} + extern int unity_main(void); int main(void) diff --git a/tests/lib/nrf_fuel_gauge/testcase.yaml b/tests/lib/nrf_fuel_gauge/testcase.yaml index 4734bacf1ae7..7fb8daed1a7e 100644 --- a/tests/lib/nrf_fuel_gauge/testcase.yaml +++ b/tests/lib/nrf_fuel_gauge/testcase.yaml @@ -1,39 +1,80 @@ tests: - unity.nrf_fuel_gauge_no_fpu: + unity.nrf_fuel_gauge_primary1_no_fpu: sysbuild: true platform_allow: - nrf5340dk/nrf5340/cpuapp - - nrf52840dk/nrf52840 - - nrf52dk/nrf52832 - nrf52dk/nrf52810 integration_platforms: - nrf5340dk/nrf5340/cpuapp - - nrf52840dk/nrf52840 + - nrf52dk/nrf52810 + tags: + - nrf_fuel_gauge + - sysbuild + - ci_tests_lib_nrf_fuel_gauge + build_only: true + extra_args: + - CONFIG_FPU=n + - CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL=y + unity.nrf_fuel_gauge_primary_fpu: + sysbuild: true + platform_allow: + - nrf5340dk/nrf5340/cpuapp + - nrf52dk/nrf52832 + integration_platforms: + - nrf5340dk/nrf5340/cpuapp - nrf52dk/nrf52832 + tags: + - nrf_fuel_gauge + - sysbuild + - ci_tests_lib_nrf_fuel_gauge + build_only: true + extra_args: + - CONFIG_FPU=y + - CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL=y + unity.nrf_fuel_gauge_secondary_no_fpu: + sysbuild: true + platform_allow: + - nrf5340dk/nrf5340/cpuapp + - nrf52dk/nrf52810 + integration_platforms: + - nrf5340dk/nrf5340/cpuapp - nrf52dk/nrf52810 tags: - nrf_fuel_gauge - sysbuild - ci_tests_lib_nrf_fuel_gauge build_only: true - extra_args: CONFIG_FPU=n - unity.nrf_fuel_gauge_fpu: + extra_args: + - CONFIG_FPU=n + - CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL=y + unity.nrf_fuel_gauge_secondary_fpu: sysbuild: true platform_allow: - nrf5340dk/nrf5340/cpuapp - - nrf52840dk/nrf52840 - nrf52dk/nrf52832 integration_platforms: - nrf5340dk/nrf5340/cpuapp - - nrf52840dk/nrf52840 - nrf52dk/nrf52832 tags: - nrf_fuel_gauge - sysbuild - ci_tests_lib_nrf_fuel_gauge build_only: true - extra_args: CONFIG_FPU=y - unity.nrf_fuel_gauge_qemu: + extra_args: + - CONFIG_FPU=y + - CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL=y + unity.nrf_fuel_gauge_qemu_primary: + sysbuild: true + platform_allow: qemu_cortex_m3 + integration_platforms: + - qemu_cortex_m3 + tags: + - nrf_fuel_gauge + - sysbuild + - ci_tests_lib_nrf_fuel_gauge + build_only: false + extra_args: CONFIG_NRF_FUEL_GAUGE_VARIANT_PRIMARY_CELL=y + unity.nrf_fuel_gauge_qemu_secondary: sysbuild: true platform_allow: qemu_cortex_m3 integration_platforms: @@ -43,3 +84,4 @@ tests: - sysbuild - ci_tests_lib_nrf_fuel_gauge build_only: false + extra_args: CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL=y diff --git a/west.yml b/west.yml index 2a8e7c23023c..b4c8ff22eca8 100644 --- a/west.yml +++ b/west.yml @@ -145,7 +145,7 @@ manifest: - name: nrfxlib repo-path: sdk-nrfxlib path: nrfxlib - revision: pull/1655/head + revision: 458cc626be5a321b3dc79cdb0181c2b8b6a2e9e9 - name: trusted-firmware-m repo-path: sdk-trusted-firmware-m path: modules/tee/tf-m/trusted-firmware-m