BMM150 init kills BMI270 on Nano 33 BLE Rev2

[grnsingh]

Board: Arduino Nano 33 BLE Rev 2 (nRF52840)
OS: Zephyr v3.7.0
Drivers: bmi270, bmm150

Description

I am encountering a reproducible hard failure where the BMI270 (IMU) functions perfectly in isolation but immediately stops generating interrupts and returns 0.00 data the moment the BMM150 (Magnetometer) is initialized.

On this hardware revision, both sensors share:

The same I2C bus.

The same Power Rail (VDD_ENV controlled by P0.22).

Note: The BMM150 is connected directly to the main I2C bus, NOT via the BMI270's auxiliary interface.

Steps to Reproduce

Flash a Zephyr 3.7.0 application with standard overlays for the Nano 33 BLE Rev 2.

Instrument the code to defer BMM150 initialization until the BMI270 is up and streaming.

Observe valid data from BMI270 (Samples 0-63).

Trigger device_init(bmm150).

Expected Behavior:
Both sensors should stream data concurrently.

Actual Behavior:

BMM150 initializes.

BMI270 interrupts cease immediately.

BMI270 data output becomes flat (0.00).

Logs / Evidence

The following log capture shows the transition from valid operation to failure at Sample 64 (Mag Init):

[62] A:-0.02 4.28 8.74 | G:0.00 -0.00 -0.00
!
[63] A:-0.01 4.29 8.73 | G:0.00 -0.00 -0.00
! <-- Triggers stop here immediately after BMM150 Init
[65] A:0.00 0.00 0.00 | G:0.00 0.00 0.00 <-- BMI270 is dead.

Troubleshooting Attempts

I have spent significant time debugging this to rule out basic configuration errors:

[x] Priority Inversion: Tested initializing Mag first/IMU last, and vice versa. Result is identical: as soon as the second device touches the bus/rail, the system fails.

[x] Power Sequencing (SYS_INIT): Moved VDD_ENV (P0.22) power-up to POST_KERNEL priority 40 using a SYS_INIT macro. Added a 200ms delay to allow capacitors to charge before driver binding.

[x] Pin Configuration: Verified GPIO_PULL_DOWN vs GPIO_ACTIVE_HIGH on interrupt pins. The IMU works perfectly in isolation, confirming pin config is generally correct.

Question

Has anyone successfully run the BMI270 and BMM150 simultaneously on Zephyr 3.x with this specific topology (Shared I2C + Shared Power Rail)?

The "Invalid Trim Data" on the BMM150 combined with the BMI270 silence suggests a bus collision or a power dip resetting the I2C logic on the sensors, but standard delays and drive strength adjustments have failed to resolve it.

[grnsingh]

app.overlay file

&uart0 {
    status = "okay";
    current-speed = <115200>;
};

&lsm9ds1 {
    status = "disabled";
};

&i2c1 {
    status = "okay";
    clock-frequency = <I2C_BITRATE_FAST>;
    zephyr,concat-buf-size = <257>;

	bmi270: bmi270@68 {
        compatible = "bosch,bmi270";
        reg = <0x68>;
        status = "okay";
        irq-gpios = <&gpio0 11 GPIO_ACTIVE_HIGH>, <&gpio0 20 GPIO_ACTIVE_HIGH>;
    };


    bmm150: bmm150@10 {
        compatible = "bosch,bmm150";
        reg = <0x10>;
        status = "okay";
        zephyr,deferred-init
    };
};

/ {
    aliases {
        vdd-env-enable = &gpio0;
        i2c-pullup-enable = &gpio1;
    };
};

&gpio0 {
    status = "okay";
};

&gpio1 {
    status = "okay";
};

prj.conf

CONFIG_STDOUT_CONSOLE=y
CONFIG_UART_CONSOLE=y

CONFIG_I2C=y
CONFIG_GPIO=y

CONFIG_SENSOR=y
CONFIG_BMI270=y
CONFIG_BMI270_TRIGGER_OWN_THREAD=y
CONFIG_BMI270_THREAD_STACK_SIZE=2048
CONFIG_BMI270_THREAD_PRIORITY=10

CONFIG_BMM150=y
CONFIG_BMM150_TRIGGER_NONE=y

CONFIG_LOG=y
CONFIG_SENSOR_LOG_LEVEL_DBG=y
CONFIG_LOG_MODE_IMMEDIATE=y
CONFIG_LOG_BACKEND_UART=y
CONFIG_CBPRINTF_FP_SUPPORT=y

main.c

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <stdio.h>

static K_SEM_DEFINE(imu_sem, 0, 1);
static int sample_count = 0;

static const struct gpio_dt_spec vdd_pwr = GPIO_DT_SPEC_GET_OR(DT_ALIAS(vdd_env_enable), gpios, {0});
static const struct gpio_dt_spec i2c_pwr = GPIO_DT_SPEC_GET_OR(DT_ALIAS(i2c_pullup_enable), gpios, {0});

static void imu_trigger_handler(const struct device *dev, const struct sensor_trigger *trig)
{	
	printf("!\n");
    k_sem_give(&imu_sem);
}

int init_sensor_power(void)
{
    const struct device *gpio0 = DEVICE_DT_GET(DT_NODELABEL(gpio0));
    const struct device *gpio1 = DEVICE_DT_GET(DT_NODELABEL(gpio1));

    if (!device_is_ready(gpio0) || !device_is_ready(gpio1)) {
        return -ENODEV;
    }

    gpio_pin_configure(gpio0, 22, GPIO_OUTPUT_ACTIVE);
    
    gpio_pin_configure(gpio1, 0, GPIO_OUTPUT_ACTIVE);

    k_msleep(250);
    return 0;
}

int main(void)
{
    const struct device *const bmi270 = DEVICE_DT_GET_ONE(bosch_bmi270);
    const struct device *const bmm150 = DEVICE_DT_GET_ONE(bosch_bmm150);

    /* Hardware Power-Up */
    if (init_sensor_power() != 0) {
        printf("Error: Power Init Failed\n");
        return 0;
    }
		

	struct sensor_value cfg;

    /* Accel: 100Hz, 2G */
    cfg.val1 = 100; cfg.val2 = 0;
    sensor_attr_set(bmi270, SENSOR_CHAN_ACCEL_XYZ, SENSOR_ATTR_SAMPLING_FREQUENCY, &cfg);
    cfg.val1 = 2;
    sensor_attr_set(bmi270, SENSOR_CHAN_ACCEL_XYZ, SENSOR_ATTR_FULL_SCALE, &cfg);

    /* Gyro: 100Hz, 500dps */
    cfg.val1 = 100;
    sensor_attr_set(bmi270, SENSOR_CHAN_GYRO_XYZ, SENSOR_ATTR_SAMPLING_FREQUENCY, &cfg);
    cfg.val1 = 500;
    sensor_attr_set(bmi270, SENSOR_CHAN_GYRO_XYZ, SENSOR_ATTR_FULL_SCALE, &cfg);

    /* Enable Interrupts */
    struct sensor_trigger trig;
    trig.type = SENSOR_TRIG_DATA_READY;
    trig.chan = SENSOR_CHAN_ACCEL_XYZ;

    if (sensor_trigger_set(bmi270, &trig, imu_trigger_handler) < 0) {
        printf("Error: Failed to set trigger.\n");
        return 0;
    }

	int init_flag = 1;

    printf("Initialization Complete. Starting Loop.\n");
    while (1) {
        /* Wait for IMU Interrupt*/
        k_sem_take(&imu_sem, K_FOREVER);

        struct sensor_value acc[3], gyr[3];

        /* Fetch & Print IMU */
        sensor_sample_fetch(bmi270);
        sensor_channel_get(bmi270, SENSOR_CHAN_ACCEL_XYZ, acc);
        sensor_channel_get(bmi270, SENSOR_CHAN_GYRO_XYZ, gyr);

        printf("[%d] A:%.2f %.2f %.2f | G:%.2f %.2f %.2f", 
               sample_count,
               sensor_value_to_double(&acc[0]), sensor_value_to_double(&acc[1]), sensor_value_to_double(&acc[2]),
               sensor_value_to_double(&gyr[0]), sensor_value_to_double(&gyr[1]), sensor_value_to_double(&gyr[2]));

        if (sample_count%64 == 0) {

			if(init_flag){
				device_init(bmm150);
				k_msleep(200);
				printf("INIT Done\n");
				init_flag=0;
			}
            struct sensor_value mag[3];
            if (sensor_sample_fetch(bmm150) == 0) {
                sensor_channel_get(bmm150, SENSOR_CHAN_MAGN_XYZ, &mag);
                
                printf(" | M:%.2f %.2f %.2f", 
                       sensor_value_to_double(&mag[0]), 
                       sensor_value_to_double(&mag[1]), 
                       sensor_value_to_double(&mag[2]));
            }
        }
        
        printf("\n");
        sample_count++;
    }
    return 0;
}