realiza codigo en python para un filtro kalman con los valores atrasados para poder ver el valor actual de la posicion de un mpu9250 que son los datos q ingresan en el filtro

Claro, aquí te dejo un ejemplo de cómo implementar un filtro de Kalman en Python para estimar la posición de un sensor MPU9250. Supondré que ya tienes los datos de las lecturas del sensor en forma de una lista o arreglo de valores. Este código incluye la estructura básica del filtro de Kalman, tomando en cuenta que los datos pueden llegar a estar ruidosos.

### Ejemplo de Código de Filtro de Kalman

```python
import numpy as np
import matplotlib.pyplot as plt

class KalmanFilter:
    def __init__(self, process_variance, measurement_variance):
        # Estado inicial
        self.x = np.zeros((2, 1))  # Estado: [posición, velocidad]
        self.P = np.eye(2)  # Covarianza del estado
        self.F = np.array([[1, 1],  # Matriz de transición de estado
                           [0, 1]])
        self.H = np.array([[1, 0]])  # Matriz de observación
        self.R = measurement_variance  # Ruido de medición
        self.Q = process_variance * np.eye(2)  # Ruido de proceso
    
    def predict(self):
        # Predicción del estado
        self.x = self.F @ self.x
        self.P = self.F @ self.P @ self.F.T + self.Q
    
    def update(self, measurement):
        # Actualización con la nueva medición
        y = measurement - (self.H @ self.x)  # Residual
        S = self.H @ self.P @ self.H.T + self.R  # Covarianza del residual
        K = self.P @ self.H.T @ np.linalg.inv(S)  # Ganancia de Kalman
        
        self.x = self.x + K @ y  # Nueva estimación del estado
        self.P = self.P - K @ self.H @ self.P  # Nueva covarianza del estado

    def get_position(self):
        return self.x[0, 0]

# Parámetros del filtro
process_variance = 1e-5  # Ruido de proceso (ajustable)
measurement_variance = 0.1  # Ruido de medición (ajustable)

# Crear el filtro de Kalman
kf = KalmanFilter(process_variance, measurement_variance)

# Datos de ejemplo (simulación de lecturas del MPU9250)
# Supongamos que estos son los datos de posición leída del sensor
measurements = [0, 1, 2, 1.8, 2.5, 3, 4, 3.8, 4.5, 5]  # Ejemplo de datos ruidosos
positions = []

# Aplicar el filtro de Kalman a las mediciones
for measurement in measurements:
    kf.predict()
    kf.update(measurement)
    positions.append(kf.get_position())

# Graficar resultados
plt.figure()
plt.plot(measurements, label='Mediciones', marker='o')
plt.plot(positions, label='Estimación con Filtro de Kalman', marker='x')
plt.xlabel('Tiempo')
plt.ylabel('Posición')
plt.legend()
plt.title('Filtro de Kalman para Posición del MPU9250')
plt.grid()
plt.show()
```

### Explicación del Código:

1. **Clase `KalmanFilter`**: Se define un filtro de Kalman que se inicializa con la varianza del proceso y la varianza de las mediciones. Contiene métodos para predecir y actualizar el estado.

2. **Parámetros**: Existen valores que puedes ajustar como la varianza del proceso (`process_variance`) y la varianza de las mediciones (`measurement_variance`), que afectan la suavidad de la estimación.

3. **Loop de Mediciones**: Se actualizan las mediciones pasadas en el filtro, donde se predice el estado y se actualiza utilizando las mediciones ruidosas.

4. **Grafico**: Se grafican los resultados, mostrando las mediciones originales y la estimación del filtro.

Este es un ejemplo básico. Para un caso real, asegúrate de ajustar los parámetros y quizás incluir más variables si tu aplicación lo requiere. También necesitarás añadir el código que recolecte datos del MPU9250 en tiempo real, dependiendo de la biblioteca que uses para comunicarte con el sensor.