[IMU] Análisis y uso del controlador BMI160

Artículos relacionados

1. "Introducción al protocolo de comunicación SPI"
2. "Uso de periféricos STM32 SPI"
3. "Análisis [IMU] y uso del controlador BMI160"

1. ¿Qué es IMU?

IMU (inglés: unidad de medida inercial, referida IMU), en circunstancias normales, la IMU estará equipada con un giroscopio de tres ejes y tres direcciones de acelerómetros , se utilizan para medir objetos en un espacio tridimensional de velocidad angular y aceleración , y a Esta solución calcula la postura del objeto. Para mejorar la fiabilidad, también es posible equipar más sensores para cada eje. En términos generales, la IMU debe instalarse en el centro de gravedad del objeto medido.

2. Principio de funcionamiento del sensor G

En el modelo que se muestra en la figura, ambos extremos de una masa están fijados por resortes. En ausencia de aceleración, el resorte no se deformará y la masa estará estacionaria. Cuando ocurre la aceleración, el resorte se deforma y la posición del bloque de masa cambia. La cantidad de deformación del resorte aumenta a medida que aumenta la aceleración. Cuando se conocen el sistema de rigidez del resorte k y la masa m de la masa, se puede obtener la aceleración del sistema siempre que se mida la deformación del resorte.

Hay juegos de dedos dentro del sensor G, que se utilizan para medir el desplazamiento de la masa cuando se genera la aceleración. Cada juego de dedos equivale a dos placas de condensadores.Cuando hay aceleración, la masa se moverá entre sí y el cambio de desplazamiento provocará el cambio de la capacitancia diferencial. Por supuesto, el proceso de cálculo de aceleración y detección de capacitancia diferencial específica se completa internamente mediante el sensor G, y solo necesitamos leer directamente el valor convertido. El valor de salida del sensor G no es un valor de aceleración directa. Su unidad de medida generalmente se expresa en g. 1g representa una aceleración gravitacional, es decir, 9,8 m / s ^ 2. 1g = 1000 mg.

Parámetros importantes del sensor G :

• Rango de medición El rango de medición
  es el rango de aceleración de salida que puede soportar el sensor, generalmente expresado como ± g. Esta es la aceleración máxima que el sensor G puede medir y generar con precisión. Por ejemplo, un rango de medición es ± 8g G-sensor, y su salida es lineal hasta que la aceleración alcanza ± 8g.

• Sensibilidad La sensibilidad
  representa la relación entre la salida del sensor y la aceleración (entrada) Define la relación lineal entre la aceleración y la salida del sensor en condiciones ideales. La sensibilidad de los sensores de salida digital generalmente se expresa en LSB / g. Por ejemplo, un sensor G con una sensibilidad de S _2g = 16384 LSB / g , si su salida del eje Z es 4205 , la aceleración del eje Z se puede calcular en 0,25 g . (Observaciones: consulte la hoja de datos de BMI160)

• 0g offset Zero-g Offset
  0g offset representa la salida del valor medido cuando no hay aceleración (entrada cero). La compensación Zero-g de diferentes modelos de sensor G es diferente, y la compensación 0g de diferentes chips del mismo modelo también es diferente, e incluso la compensación Zero-g de diferentes ejes en el mismo chip también es diferente. la corrección necesaria depende de la aplicación específica. Si la aplicación solo se preocupa por el cambio relativo de aceleración y no se preocupa por el valor específico de la aceleración, no es necesaria ninguna corrección. Si le preocupa el valor específico de la aceleración y la compensación de cero g del dispositivo seleccionado es relativamente grande, debe corregirlo. Algunos sensores G tienen sus propios registros de compensación, que solo necesitan colocar el eje a calibrar estáticamente en la dirección horizontal, medir su salida en 0g y multiplicar este valor por -1 para escribir en el registro de compensación. Si el sensor G en sí no tiene un registro de compensación, debe registrar este valor en su procesador y restar esta compensación del resultado de la medición real

• ODR
  ODR (Velocidad de datos de salida) indica la frecuencia de actualización de los datos de salida del sensor G. Cuanto mayor sea el ODR, más rápido se actualizan los datos de salida y mayor es el consumo de energía. El ODR del sensor G a menudo se puede configurar. (Nota: la frecuencia de actualización máxima del sensor G BMI160 es 1600Hz)

3. Principio de funcionamiento del sensor Gyro

El giroscopio es un dispositivo que se utiliza para medir la velocidad angular. Basado en la función de aceleración, se puede desarrollar aún más para construir un giroscopio. El principio interno del giroscopio es el siguiente: aplique un voltaje a un dedo fijo y cambie alternativamente el voltaje para hacer que una masa se mueva hacia adelante y hacia atrás de manera oscilante. Cuando gira, producirá una aceleración de Coriolis, que se puede medir en esta vez.; Esto es un poco similar a un acelerómetro, el método de decodificación es aproximadamente el mismo y se usa un amplificador. Parámetros importantes del Gyro-sensor :

• El rango de medición
  es el rango de medición de salida que puede soportar el sensor, generalmente expresado en ° / s. Esta es la velocidad angular máxima que Gyro-sensor puede medir y generar con precisión.
• Sensibilidad La sensibilidad
  representa la relación de la salida del sensor con la velocidad angular y define la relación lineal entre la velocidad angular y la salida del sensor en condiciones ideales. La sensibilidad de un sensor de salida digital generalmente se expresa en LSB / ° / s. Por ejemplo, un sensor _giroscópico con una sensibilidad de R _FS2000 = 16,4LSB / ° / s , si su salida del eje Z es 53 , entonces la velocidad angular del eje Z se puede calcular en 3,23 ° / s . (Observaciones: consulte la hoja de datos de BMI160)
• Compensación de tasa cero Compensación de tasa cero La
  compensación de velocidad 0 representa la salida del valor medido cuando no hay velocidad angular (entrada cero). La compensación se puede realizar a través del registro OFFSET. En el caso de errores relativamente grandes, la compensación también se puede realizar en la capa de aplicación del usuario.
• ODR
  ODR (Output Data Rate) indica la frecuencia de actualización de los datos de salida del Gyro-sensor. Cuanto mayor sea el ODR, más rápido se actualizan los datos de salida y mayor es el consumo de energía. El ODR del Gyro-sensor a menudo es configurable. (Nota: la frecuencia de actualización máxima del sensor giroscópico BMI160 es 3200Hz)

4. Introducción al hardware BMI160

usarSTM32F103 + BMI160Plataforma de hardware, lee y escribe datos a través de la interfaz SPI .

Las conexiones de clavijas de STM32F103 y BMI160 son las siguientes:

Número de pin de MCU	Función descriptiva	Número de pin BMI160
GPIOA4	CS	P12
GPIOA5	SCK	P13
GPIOA6	MISO	P1
GPIOA7	HOLGAZANEAR	P14
GPIOB0	IMC 160 INT1	P4

5. Uso de BMI160 FIFO

• Cuando se usa FIFO, los datos almacenados se pueden obtener realizando una lectura en ráfaga en el registro (0x24) FIFO_DATA . La unidad de almacenamiento de datos se llama marco .

• El registro (0x46 ~ 0x47) FIFO_CONFIG configura la velocidad de fotogramas de FIFO para configurar la velocidad máxima de datos de salida del sensor.

El formato del marco es muy importante para que el software analice correctamente la información leída del FIFO. FIFO se puede configurar paraalmacenar datos en modo de cabezal o modo sin cabezal (consulte la figura a continuación). En el proceso de recolección de datos, cuando la estructura de datos y el número de sensores no cambian, generalmente se usa el modo sin cabeza . En este caso, se puede maximizar el número de fotogramas almacenables. Por el contrario, el modo de cabezal es adecuado para situaciones que requieren flexibilidad en la estructura de datos, como sensores (Accel & Gyro) que se ejecutan en diferentes ODR, o sensores de conmutación dinámica durante el funcionamiento.

Dado que Accel está configurado en 1600Hz y Gyro está configurado en 3200Hz, estoy usando el Modo de encabezado aquí. El encabezado de datos FIFO se define de la siguiente manera: Los

datos reales leídos de FIFO se analizan de la siguiente manera:

• FIFO admite 2 interrupciones, interrupción completa FIFO e interrupción de marca de agua FIFO . Cuando el FIFO está lleno, se emite la interrupción del FIFO completo y la siguiente muestra de datos completa hará que el FIFO se desborde, lo que provocará que se elimine la muestra. Técnicamente hablando, esto significa que cuando el espacio restante en el FIFO es menor que las dos tramas más grandes, se emitirá una interrupción completa de FIFO. Cuando el nivel de llenado FIFO en Fifo_byte_counter FIFO_LENGTH es mayor que el umbral de marca de agua preconfigurado en el registro (0x22 ~ 0x23) , se activa la interrupción de marca de agua FIFO. Este umbral se configura en Fifo_watermark en el registro (0x46 ~ 0x47) FIFO_CONFIG .
  Puede llamar a la API para configurar, de la siguiente manera:

bmi160_set_fifo_wm(200, &sensor);

6.Controlador de software BMI160

• Inicializar el sensor BMI160 a través de 4Line SPI

struct bmi160_dev sensor;

/* You may assign a chip select identifier to be handled later */
sensor.id = 0;
sensor.interface = BMI160_SPI_INTF;
sensor.read = user_spi_read;
sensor.write = user_spi_write;
sensor.delay_ms = user_delay_ms;


int8_t rslt = BMI160_OK;
rslt = bmi160_init(&sensor);

• Configurar sensores de aceleración y giroscopio en modo normal

int8_t rslt = BMI160_OK;

/* Select the Output data rate, range of accelerometer sensor */
sensor.accel_cfg.odr = BMI160_ACCEL_ODR_1600HZ;
sensor.accel_cfg.range = BMI160_ACCEL_RANGE_2G;
sensor.accel_cfg.bw = BMI160_ACCEL_BW_NORMAL_AVG4;

/* Select the power mode of accelerometer sensor */
sensor.accel_cfg.power = BMI160_ACCEL_NORMAL_MODE;

/* Select the Output data rate, range of Gyroscope sensor */
sensor.gyro_cfg.odr = BMI160_GYRO_ODR_3200HZ;
sensor.gyro_cfg.range = BMI160_GYRO_RANGE_2000_DPS;
sensor.gyro_cfg.bw = BMI160_GYRO_BW_NORMAL_MODE;

/* Select the power mode of Gyroscope sensor */
sensor.gyro_cfg.power = BMI160_GYRO_NORMAL_MODE; 

/* Set the sensor configuration */
rslt = bmi160_set_sens_conf(&sensor);

• Configurar la interrupción de FIFO y Watermark

#define ACCEL_SWITCH_UNIT(x)  ((float)(x*9.8)/16384)  	// Sensivity S2g ex:(x*9.8)/(0x8000/2)
#define GYRO_SWITCH_UNIT(x)   ((float)x/16.4)   		// RFS2000 ex: (x*2000)/0x7fff

/* Declare memory to store the raw FIFO buffer information */
#define FIFO_BUF_MAX_SIZE		800
static uint8_t fifo_buff[FIFO_BUF_MAX_SIZE];
struct bmi160_fifo_frame fifo_frame;

static void app_bmi160_fifo_watermark_int_cfg(void)
{
    
    
	struct bmi160_int_settg int_config;
	
	/* Select the Interrupt channel/pin */
	int_config.int_channel = BMI160_INT_CHANNEL_1;// Interrupt channel/pin 1
	
	/* Select the Interrupt type */
	int_config.int_type = BMI160_ACC_GYRO_FIFO_WATERMARK_INT;// Choosing Step Detector interrupt
	/* Select the interrupt channel/pin settings */
	int_config.int_pin_settg.output_en = BMI160_ENABLE;// Enabling interrupt pins to act as output pin
	int_config.int_pin_settg.output_mode = BMI160_DISABLE;// Choosing push-pull mode for interrupt pin
	int_config.int_pin_settg.output_type = BMI160_ENABLE;// Choosing active High output
	int_config.int_pin_settg.edge_ctrl = BMI160_ENABLE;// Choosing edge triggered output
	int_config.int_pin_settg.input_en = BMI160_DISABLE;// Disabling interrupt pin to act as input
	int_config.int_pin_settg.latch_dur =BMI160_LATCH_DUR_NONE;// non-latched output

	int_config.fifo_full_int_en = BMI160_ENABLE;
	int_config.fifo_wtm_int_en = BMI160_ENABLE;
	
	/* Set the Step Detector interrupt */
	bmi160_set_int_config(&int_config, &sensor); /* sensor is an instance of the structure bmi160_dev */


	/* Modify the FIFO buffer instance and link to the device instance */
	fifo_frame.data = fifo_buff;
	fifo_frame.length = FIFO_BUF_MAX_SIZE;
	sensor.fifo = &fifo_frame;
	/* Configure the sensor's FIFO settings */
	bmi160_set_fifo_config(BMI160_FIFO_ACCEL | BMI160_FIFO_GYRO | BMI160_FIFO_HEADER | BMI160_FIFO_TAG_INT1,
					BMI160_ENABLE, &sensor);

	bmi160_set_fifo_wm(200, &sensor);
}

int8_t fifo_accel_gyro_header_time_data(struct bmi160_dev *dev)
{
    
    
	int8_t rslt = 0;
	//uint16_t index = 0;

	struct bmi160_sensor_data accel_data[12]; // 300 bytes / ~7bytes per frame ~ 42 data frames	
	uint8_t accel_frames_req = 12; 
	uint8_t accel_index;
	
	/* Declare instances of the sensor data structure to store the parsed FIFO data */
	struct bmi160_sensor_data gyro_data[12]; // 300 bytes / ~7bytes per frame ~ 42 data frames	
	uint8_t gyro_frames_req = 12; 
	uint8_t gyro_index;
	
	/* Read data from the sensor's FIFO and store it the FIFO buffer,"fifo_buff" */
	printf("\n USER REQUESTED FIFO LENGTH : %d\n",dev->fifo->length);
	rslt = bmi160_get_fifo_data(dev);

	if (rslt == BMI160_OK) {
    
    
		printf("\n AVAILABLE FIFO LENGTH : %d\n",dev->fifo->length);
		/* Print the raw FIFO data */
		/*for (index = 0; index < dev->fifo->length; index++) {
			printf("\n FIFO DATA INDEX[%d] = 0x%02x", index,
				dev->fifo->data[index]);
		}
		*/
		
		/* ##################################GYRO DATA######################################### */			
		/* Parse the FIFO data to extract gyro data from the FIFO buffer */
		printf("\n REQUESTED GYRO DATA FRAMES : %d\n ",gyro_frames_req);
		rslt = bmi160_extract_gyro(gyro_data, &gyro_frames_req, dev);

		if (rslt == BMI160_OK) {
    
    
			printf("\n AVAILABLE GYRO DATA FRAMES : %d\n ",gyro_frames_req);
			
			/* Print the parsed gyro data from the FIFO buffer */
			for (gyro_index = 0; gyro_index < gyro_frames_req; gyro_index++) {
    
    
				printf("\nFIFO GYRO FRAME[%d]",gyro_index);
				printf("\nGYRO X: %.2f°/s\t Y: %.2f°/s\t Z: %.2f°/s"
					,GYRO_SWITCH_UNIT(gyro_data[gyro_index].x),GYRO_SWITCH_UNIT(gyro_data[gyro_index].y)
					,GYRO_SWITCH_UNIT(gyro_data[gyro_index].z));
			}
		} else {
    
    
			printf("\n Gyro data extraction failed");
		}


		/* ##################################ACCEL DATA######################################### */			
		printf("\n REQUESTED ACCEL DATA FRAMES : %d\n ",accel_frames_req);
		rslt = bmi160_extract_accel(accel_data, &accel_frames_req, dev);	
		if (rslt == BMI160_OK) {
    
    
			printf("\n AVAILABLE ACCEL DATA FRAMES : %d\n ",accel_frames_req);
			
			/* Print the parsed accel data from the FIFO buffer */
			for (accel_index = 0; accel_index < accel_frames_req; accel_index++) {
    
    
				printf("\nFIFO ACCEL FRAME[%d]",accel_index);
				printf("\nACCEL X: %.2fg/s \t Y: %.2fg/s \t Z: %.2fg/s"
					,ACCEL_SWITCH_UNIT(accel_data[accel_index].x), ACCEL_SWITCH_UNIT(accel_data[accel_index].y)
					,ACCEL_SWITCH_UNIT(accel_data[accel_index].z));
			}
		} else {
    
    
			printf("\n Accel data extraction failed");
		}
	} else {
    
    
		printf("\n Reading FIFO data failed");
	}

	return rslt;
}

7. Resultados de la verificación

8. Dirección de descarga de datos

La dirección de descarga del código completo para un trasplante exitoso es la siguiente:
https://download.csdn.net/download/ZHONGCAI0901/13218801
Hoja de datos de BMI160 y controlador descargado del sitio web oficial:
https://download.csdn.net/download/ZHONGCAI0901 / 13256127

9. Materiales de referencia

"Descripción general del sensor G y acabado de viruta común"
"Principio de funcionamiento del giroscopio MEMS"