As per the Sensor BMM350/BMA456/BME280/BMP390, I wanted to know the full range test procedure of factory and how we are actually tested Full range of All mentioned Sensor.

and

I wanted to know is thr any Test chambers to check full range and how!

1) How we can test full range of all sensors Indoor and Outdoor

Regards,

        BMI2_ACCEL,
        BMI2_ANY_MOTION,
        BMI2_NO_MOTION,
        BMI2_STEP_COUNTER,
        BMI2_STEP_ACTIVITY,

Monitoring the current consumption the behavior I see is while system is mostly idle with a bit on motion the current consumption is around 10 to 15uA. I have my no motion duration set to 30 seconds so after 30 seconds I get an IRQ indicating no motion then the current usage of the device steps up to ~55uA

As soon as I move the device at all I get an any motion IRQ and the current drops back again

Anyone else observe this? The application currently does not do anything with these events so I don't think it is something like my higher level FW is in some other strange mode when this occurs

Thank you!

-Kyler

 // Defines
#define T_AVG			3

// Exponential Moving Average (EMA) coefficient used to slowly update the baseline 
// when the parking slot is confidently detected as empty
#define ALPHA			0.05f

#define CALIBRATION_SAMPLES	5

// Private Typedef
typedef struct
{
	float x;
	float y;
	float z;
	float temperature;
} BMM350_data_t;

// Global Variables
bool parked = false;
float THRESHOLD = 4.5f;
BMM350_data_t BMM350_CALIBRATED_BASE;

// Private function prototypes
static int BMM350_Init(void);
static int BMM350_Read(BMM350_data_t *s_data);
static float ComputeMagnitude(BMM350_data_t *reading);
void timer_callback();


int main(void)
{

	int status = 0;
	float mag = 0;
	BMM350_data_t reading;
	BMM350_data_t BMM350_CALIBRATION_DATA[CALIBRATION_SAMPLES];

	// Initialize the BMM350 sensor
	status = BMM350_Init();

	// ------------------------------------------------------------------ 
	// Initial calibration: 
	// Collect 5 readings while the parking slot is known to be empty. 
	// These samples are averaged to create the baseline magnetic field. 
	// ------------------------------------------------------------------
	for (int i = 0 ; i < CALIBRATION_SAMPLES ; i++)
	{
		if (BMM350_Read(&reading) != 0)
    		{
      			APP_LOG(TS_ON, VLEVEL_L, "BMM350 read failed — skipping scan\r\n");
      			return 0;
    		}
		
		BMM350_CALIBRATION_DATA[i] = reading;
	}
	
	// Reset baseline accumulators before averaging
	BMM350_CALIBRATED_BASE.x = 0;
        BMM350_CALIBRATED_BASE.y = 0;
        BMM350_CALIBRATED_BASE.z = 0;
        BMM350_CALIBRATED_BASE.temperature = 0;

	// Average of 5 Samples 
        for (int j = 0; j < CALIBRATION_SAMPLES; j++)
        {
          BMM350_CALIBRATED_BASE.x += BMM350_CALIBRATION_DATA[j].x;
          BMM350_CALIBRATED_BASE.y += BMM350_CALIBRATION_DATA[j].y;
          BMM350_CALIBRATED_BASE.z += BMM350_CALIBRATION_DATA[j].z;
          BMM350_CALIBRATED_BASE.temperature += BMM350_CALIBRATION_DATA[j].temperature;
        }

        BMM350_CALIBRATED_BASE.x /= CALIBRATION_SAMPLES;
        BMM350_CALIBRATED_BASE.y /= CALIBRATION_SAMPLES;
        BMM350_CALIBRATED_BASE.z /= CALIBRATION_SAMPLES;
        BMM350_CALIBRATED_BASE.temperature /= CALIBRATION_SAMPLES;

	// ------------------------------------------------------------------ 
	// Main detection loop 
	// Executed once every minute after the MCU wakes from low-power mode. 
	// ------------------------------------------------------------------
	while(timer_flag)
	{
		if (BMM350_Read(&reading) != 0)
    		{
      			APP_LOG(TS_ON, VLEVEL_L, "BMM350 read failed — skipping scan\r\n");
      			return 0;
    		}
		
		// Compute Euclidean distance between current reading and Base values
		mag = ComputeMagnitude(&reading);
		
		//Detection Logic
		if (!parked)
      		{
        		if (mag >= THRESHOLD)
        		{
          			//Threshold crossed 
				parked = true;
        		}
      		}
      		else
      		{
        		if (mag < THRESHOLD * 0.9f)
        		{
          			// Threshold crossed
				parked = false;
        		}
      		}

		// -------------------------------------------------------------- 
		// Adaptive baseline update 
		// When the slot is confidently empty and the measured magnetic 
		// field is still close to the baseline, slowly update the 
		// baseline using an Exponential Moving Average (EMA) to 
		// compensate for gradual environmental or temperature-related 
		// drift. 
		// --------------------------------------------------------------
		if (!parked)
      		{
          		// Check if the current reading is reasonably close to the baseline
			if (mag < (THRESHOLD * 0.5f))
         		 {
              			// Apply an ultra-slow tracking factor (Alpha)
              			// This allows the baseline to smoothly absorb ambient temperature drift
              			BMM350_CALIBRATED_BASE.x = (BMM350_CALIBRATED_BASE.x * (1 - ALPHA)) + (reading.x * ALPHA);
              			BMM350_CALIBRATED_BASE.y = (BMM350_CALIBRATED_BASE.y * (1 - ALPHA)) + (reading.y * ALPHA);
              			BMM350_CALIBRATED_BASE.z = (BMM350_CALIBRATED_BASE.z * (1 - ALPHA)) + (reading.z * ALPHA);
              			BMM350_CALIBRATED_BASE.temperature = (BMM350_CALIBRATED_BASE.temperature * (1 - ALPHA)) + (reading.temperature * ALPHA);
          		}
      		}

	}
	return 0;
}

// ------------------------------------------------------------------ 
// Initialize the BMM350 sensor 
// ------------------------------------------------------------------
static int BMM350_Init(void)
{
	HAL_GPIO_WritePin(MAGNETIC_PWR_GPIO_Port, MAGNETIC_PWR_Pin, GPIO_PIN_SET);
	HAL_Delay(1);
	uint8_t chip_id;
	uint8_t int_ctrl, err_reg_data = 0;
	struct bmm350_pmu_cmd_status_0 pmu_cmd_stat_0;

	rslt = bmm350_interface_init(&dev);

	rslt = bmm350_init(&dev);
	chip_id = dev.chip_id;
	if (chip_id == 0x33)
	{
		  /* Check PMU busy */
		  rslt = bmm350_get_pmu_cmd_status_0(&pmu_cmd_stat_0, &dev);

		  /* Get error data */
		  rslt = bmm350_get_regs(BMM350_REG_ERR_REG, &err_reg_data, 1, &dev);

		  /* Configure interrupt settings */
		  rslt = bmm350_configure_interrupt(BMM350_PULSED,
		                                    BMM350_ACTIVE_HIGH,
		                                    BMM350_INTR_PUSH_PULL,
		                                    BMM350_UNMAP_FROM_PIN,
		                                    &dev);

		  /* Enable data ready interrupt */
		  rslt = bmm350_enable_interrupt(BMM350_ENABLE_INTERRUPT, &dev);

		  /* Set ODR and performance */
		  rslt = bmm350_set_odr_performance(BMM350_DATA_RATE_100HZ, BMM350_LOWPOWER, &dev);

		  /* Enable all axis */
		  rslt = bmm350_enable_axes(BMM350_X_EN, BMM350_Y_EN, BMM350_Z_EN, &dev);

		  rslt = bmm350_set_powermode(BMM350_SUSPEND_MODE, &dev);

		  return 0;
	}
	return 1;
}

// ------------------------------------------------------------------ 
// Read the BMM350 
// For each measurement:
// 1. Switch the sensor to FORCED mode. 
// 2. Read compensated X/Y/Z and temperature. 
// 3. Repeat T_AVG times. 
// 4. Return the average of all samples. 
// ------------------------------------------------------------------
static int BMM350_Read(BMM350_data_t *s_data)
{
    int_status = 0;

    sx = 0;
    sy = 0;
    sz = 0;
    st = 0;

  	  for (int i = 0; i < T_AVG; i++)
  	  {
  		  	rslt = bmm350_set_powermode(BMM350_FORCED_MODE, &dev);
  		  	if (rslt != BMM350_OK)
  		  	{
  		  		return -1;  /* I2C/sensor fault — caller must not act on this read */
  		  	}
            rslt = bmm350_get_compensated_mag_xyz_temp_data(&mag_temp_data, &dev);
            if (rslt != BMM350_OK)
            {
                return -1;
            }
            sx += mag_temp_data.x;
            sy += mag_temp_data.y;
            sz += mag_temp_data.z;
            st += mag_temp_data.temperature;
  	  }

  	  s_data->x = sx/T_AVG;
  	  s_data->y = sy/T_AVG;
  	  s_data->z = sz/T_AVG;
  	  s_data->temperature = st/T_AVG;

    return 0;
}

// Compute Euclidean distance between the current magnetic field vector 
// and the calibrated baseline.
static float ComputeMagnitude(BMM350_data_t *reading)
{
  float dx = fabs(reading->x - BMM350_CALIBRATED_BASE.x);
  float dy = fabs(reading->y - BMM350_CALIBRATED_BASE.y);
  float dz = fabs(reading->z - BMM350_CALIBRATED_BASE.z);
  return sqrtf((dx * dx) + (dy * dy) + (dz * dz));
}

// Timer callback executed every 1 minute to trigger a new measurement cycle.
void timer_callback()
{
	timer_flag = 1;
	return;
}

Questions:
1. How to handle this kind of issue?
2. Are there any recommended register settings or operating modes for low-power periodic wake-up applications?
3. Is this amount of X/Y/Z variation expected for the BMM350 after waking from sleep every minute?
4. Is there any known offset drift or baseline drift that should be compensated separately from temperature?
5. For parking detection applications, is it recommended to continuously update the baseline (slow adaptive filter) while the slot is known to be empty?

Any guidance or recommended best practices for using the BMM350 in this type of low-power parking sensor application would be greatly appreciated.

Since the SDK is not source-available, I cannot reduce internal buffers or disable features.

My questions are:

1. Is there a minimal or sensor-only version of the BMV080 SDK with reduced SRAM usage?

2. Are there any configuration options to disable debug/logging, history buffers, or optional processing modules?
   

   Any guidance on reducing RAM footprint or a recommended minimal configuration would be greatly appreciated.

Hardware: SparkFun SEN-26554

Chip ID (0x0079)

Can you possibly confirm whether this hardware revision is supported and whether a newer SDK build is available?

we use BMI270 for our mini drones in series production. From a recent batch however, a few drones (around 5%) show weird flight behavior. After inspecting the flight log, we figure out that the Z-axis gyro signal of the "faulty" drones has significant DC bias and higher noise content in comparison to the "healthy" drones, which led to deviations in yaw estimation.

We are aware that mechanical strain on the IMU can lead to abnormal gyro sensing. The layout of the PCB has been designed following this guideline "https://www.bosch-sensortec.com/media/boschsensortec/downloads/handling_soldering_mounting_instructions/bst-mis-hs000.pdf" (e.g. off-center of strain line, no vias under the chip). Also soldering process was configured according to it.

Any idea about what can be the reason? Is there any extra advice that we should pay attention to?

Please let me know if you need more context.

Thanks,

Min

We're a startup from Munich that built a platform for assembling AI solutions out of reusable building blocks, such as IO connector blocks, model inference blocks, rules, tracking or denoising algorithms, etc.

Once you train your model with AI studio, the next bottleneck becomes how to use it to build different applications. This is where we come in.

Anyone interested in collaboration to add connector blocks for your sensors and inference blocks to be able to assemble solutions fast?

Please reach out and share any technical contact we should talk to. Happy to organize a short call to showcase a live demo.

Thank you! -- Iki

I have successfully built the sample SDK example from BHI360_SDK_1.1.18.2_rc7 and generated the firmware image.

I would like to understand the expected functionality of this firmware. Specifically, could you please clarify:

• What is the intended purpose of this sample application?

• What sensor features or algorithms are enabled in this build?

• What output data should I expect after flashing this firmware onto a BHI360 Shuttle Board?

• Are there any specific host commands or interfaces required to observe the expected output?

• Is the output available through I2C, UART, or another communication interface?

For my setup, I am not using the Application Board. Instead, I am using a custom board and transferring the firmware to the BHI360 device over I2C. I would like to verify whether any additional configuration is required and what behaviour or output I should expect after the firmware is loaded.

Any documentation or guidance regarding the functionality of this sample firmware would be greatly appreciated.

Thank you for your support.

I am a graduate student at the University of Southern California (USC) interested in Linux kernel, embedded systems, and open-source software development.

Recently, I have been studying Bosch sensor software, including the upstream Linux BMI323 driver and Bosch SensorAPI projects, to learn more about sensor driver development and Linux upstream processes.

I would like to ask whether Bosch Sensortec has any current or upcoming Linux, embedded software, open-source, or driver development efforts where community contributors or students may participate.

I am particularly interested in Linux driver development, testing, validation, and upstream open-source contributions.

Thank you for your time and consideration.

Best regards,

Hung-Yu Lin
Graduate Student
University of Southern California (USC)