1. Proceso de Alineación en Navegación Inercial y Combinada

Los sistemas de navegación inercial (INS) requieren una inicialización previa al uso, que incluye la configuración inicial de posición, velocidad y actitud. El proceso de establecer la actitud inicial se denomina alineación, con el objetivo de alinear los ejes de los sensores inerciales con el marco de referencia de navegación local. Generalmente, este proceso se divide en dos fases: alineación gruesa y alineación fina.

• Alineación Gruesa: Utiliza información como el vector de gravedad terrestre y la velocidad angular de rotación de la Tierra para calcular analíticamente la matriz de actitud inicial. Los resultados se expresan comúnmente como una matriz de actitud, a partir de la cual pueden derivarse ángulos de Euler, cuaterniones u otras representaciones.
• Alineación Fina: Sobre la base de la alineación gruesa, se emplean métodos como el filtro de Kalman para mejorar la precisión. En esta fase, la velocidad en el marco de navegación del INS strapdown puede usarse como observación.

2. Implementación de la Alineación Gruesa en MATLAB

A continuación se muestra un ejemplo de implementación para la alineación gruesa, simulando durante 1 minuto con datos proporcionados.

% Inicialización de datos para alineación gruesa
limpiar;
cargar('DATOS.mat'); % Cargar datos
frecuencia_muestreo = 200; % Frecuencia de muestreo en Hz
latitud_grados = 39.978848182;
latitud_radianes = deg2rad(latitud_grados); % Convertir latitud a radianes
aceleracion_gravedad = 9.7803*(1 + 0.0053024*((sin(latitud_radianes))^(2)) - 0.000005*((sin(2*latitud_radianes))^(2)));
velocidad_rotacion_tierra = 7.292115e-5; % Velocidad angular de rotación terrestre en rad/s
tiempo_alineacion = 60; % Duración de la alineación gruesa en segundos

3. Implementación de la Alineación Fina en MATLAB

Este es un ejemplo que aplica el filtro de Kalman para la alineación fina, utilizando la velocidad como medición.

function [actitud_inicial, actitud_filtrada, estados_covarianza] = alinear_con_velocidad(datos_imu, cuaternion_inicial, posicion, angulo_desajuste_inicial, error_imu, ruido_velocidad, intervalo_muestreo, actitud_referencia)
    % Alineación inicial de SINS usando filtro de Kalman con velocidad como observación
    % Vector de estados: [error_azimut, error_cabeceo, error_balance, dv_Este, dv_Norte, dv_Up, bias_giro_x, bias_giro_y, bias_giro_z, bias_acel_x, bias_acel_y, bias_acel_z]
    % Entradas:
    %   datos_imu - Datos del IMU
    %   cuaternion_inicial - Cuaternión de actitud de alineación gruesa
    %   posicion - Posición geográfica [latitud, longitud, altitud]
    %   angulo_desajuste_inicial - Estimación inicial del ángulo de desajuste
    %   error_imu - Configuración de errores del IMU
    %   ruido_velocidad - Ruido en mediciones de velocidad
    %   intervalo_muestreo - Intervalo de muestreo del IMU
    %   actitud_referencia - Actitud de referencia para comparación
    % Salidas:
    %   actitud_inicial - Resultado de la actitud alineada
    %   actitud_filtrada, estados_covarianza - Datos para depuración
    global parametros_globales;
    if nargin < 4, angulo_desajuste_inicial = [1.5; 1.5; 3]*parametros_globales.grados; end
    if nargin < 5, configurar_error_imu(0.01, 100, 0.001, 1); end
    if nargin < 6, ruido_velocidad = [0.01; 0.01; 0.01]; end
    if nargin < 7, intervalo_muestreo = datos_imu(2,7) - datos_imu(1,7); end
    if length(cuaternion_inicial) == 3, cuaternion_inicial = angulo_a_cuaternion(cuaternion_inicial); end % Convertir si se pasan ángulos de Euler
    factor_submuestreo = 2;
    paso_tiempo = factor_submuestreo * intervalo_muestreo;
    longitud_datos = fix(length(datos_imu) / factor_submuestreo) * factor_submuestreo;
    
    % Cálculo de parámetros terrestres
    parametros_tierra = calcular_tierra(posicion);
    velocidad_navegacion = zeros(3,1);
    matriz_correccion_terrestre = rotacion_a_matriz(-parametros_tierra.velocidad_angular_nie * paso_tiempo / 2);
    
    % Inicializar filtro de Kalman
    filtro_kalman = inicializar_filtro_velocidad(paso_tiempo, posicion, angulo_desajuste_inicial, error_imu, ruido_velocidad);
    [actitud_filtrada, estados_covarianza] = preasignar_memoria(fix(longitud_datos / factor_submuestreo), 4, 2*filtro_kalman.dimension);
    indice_tiempo = barra_tiempo(factor_submuestreo, longitud_datos, 'Alineación inicial usando velocidad como medición');
    
    for k = 1:factor_submuestreo:longitud_datos - factor_submuestreo + 1
        paquete_datos = datos_imu(k:k+factor_submuestreo-1,1:6);
        % Procesar incrementos angulares y de velocidad
        [incremento_angulo, incremento_velocidad] = cancelar_sesgo(paquete_datos);
        matriz_actitud = cuaternion_a_matriz(cuaternion_inicial);
        
        % Actualizar velocidad sin cambiar posición
        delta_velocidad_navegacion = matriz_correccion_terrestre * matriz_actitud * incremento_velocidad;
        velocidad_navegacion = velocidad_navegacion + delta_velocidad_navegacion + parametros_tierra.gravedad_navegacion * paso_tiempo;
        
        % Actualizar cuaternión de actitud
        cuaternion_inicial = actualizar_cuaternion(cuaternion_inicial, incremento_angulo, parametros_tierra.velocidad_angular_navegacion * paso_tiempo);
        matriz_actitud_escala = matriz_actitud * paso_tiempo;
        
        % Actualizar matriz de transición de estados (matriz dependiente del tiempo)
        filtro_kalman.matriz_transicion(4:6,1:3) = producto_antisimetrico(delta_velocidad_navegacion);
        filtro_kalman.matriz_transicion(1:3,7:9) = -matriz_actitud_escala; % Transformación de bias del giróscopo al marco de navegación
        filtro_kalman.matriz_transicion(4:6,10:12) = matriz_actitud_escala; % Transformación de bias del acelerómetro al marco de navegación
        
        % Ejecutar actualización del filtro de Kalman
        filtro_kalman = actualizar_filtro(filtro_kalman, velocidad_navegacion);
        
        % Corrección parcial de estados
        cuaternion_inicial = corregir_cuaternion(cuaternion_inicial, 0.1*filtro_kalman.estado(1:3));
        filtro_kalman.estado(1:3) = 0.9 * filtro_kalman.estado(1:3);
        velocidad_navegacion = velocidad_navegacion - 0.1*filtro_kalman.estado(4:6);
        filtro_kalman.estado(4:6) = 0.9 * filtro_kalman.estado(4:6);
        
        actitud_filtrada(indice_tiempo,:) = [cuaternion_a_angulo(cuaternion_inicial)', datos_imu(k+factor_submuestreo-1, end)];
        estados_covarianza(indice_tiempo,:) = [filtro_kalman.estado; diag(filtro_kalman.covarianza_estado)];
        indice_tiempo = barra_tiempo;
    end
    actitud_filtrada(indice_tiempo:end,:) = []; estados_covarianza(indice_tiempo:end,:) = [];
    actitud_inicial = actitud_filtrada(end,1:3)';
    mostrar_resultado('Actitudes de alineación inicial (arcdeg)', actitud_inicial/parametros_globales.grados);
    graficar_resultados(paso_tiempo, actitud_filtrada, estados_covarianza, actitud_referencia);
end

4. Algoritmos de Cuaterniones y Ángulos de Euler

• Algoritmo de Cuaterniones: Emplea cuaterniones para representar la actitud, ofreciando estabilidad numérica y eficiencia computacional. La ecuación de actualización se muestra a continuación: ``` cuaternion_inicial = actualizar_cuaternion2(cuaternion_inicial, incremento_angulo, parametros_tierra.velocidad_angular_navegacion * paso_tiempo);

• Algoritmo de Ángulos de Euler: Utiliza ángulos de Euler para una representación intuitiva de la actitud, aunque puede presentar problemas de bloqueo de cardán. La conversión a ángulos de Euler se realiza mediante cuaterniones: ``` actitud_filtrada(indice_tiempo,:) = [cuaternion_a_angulo(cuaternion_inicial)', datos_imu(k+factor_submuestreo-1, end)];

5. Método de Runge-Kutta

El método de Runge-Kutta es un enfoque numérico ampliamente utilizado para resolver ecuaciones diferenciales ordinarias. En la navegación inercial, se aplica para integrar las ecuaciones de movimiento. Por ejemplo, la actualización de cuaterniones puede implementarse mediante el método de Runge-Kutta de cuarto orden para una integración numérica precisa.