Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

tunerconfig

Opciones de configuración del ajustador de filtro Fusion

Desde R2020b

Descripción

El objeto tunerconfig crea una configuración de ajustador para un filtro de fusión utilizado para ajustar el filtro para reducir el error de estimación.

Creación

Sintaxis

config = tunerconfig(filterName)

config = tunerconfig(filter)

config = tunerconfig(filterName,Name,Value)

Descripción

config = tunerconfig(filterName) crea un objeto tunerconfig que controla el algoritmo de optimización de la función de ajuste del filtro de fusión especificando un nombre de filtro.

config = tunerconfig(filter) crea un objeto tunerconfig que controla el algoritmo de optimización de la función de ajuste del filtro de fusión especificando un objeto de filtro.

config = tunerconfig(filterName,Name,Value) configura las propiedades del objeto tunerconfig creado utilizando uno o más argumentos de par nombre-valor. Name es un nombre de propiedad y Value es el valor correspondiente. Name debe aparecer entre comillas. Puede especificar varios argumentos de pares nombre-valor en cualquier orden como Name1,Value1,...,NameN,ValueN. Cualquier propiedad no especificada toma valores predeterminados.

Por ejemplo, tunerconfig('imufilter','MaxIterations',3) crea un objeto tunerconfig para el objeto imufilter con un máximo de tres iteraciones permitidas.

Argumentos de entrada

filterName — Nombre del filtro de fusión

'imufilter' | 'ahrsfilter' | 'ahrs10filter' | 'insfilterAsync' | 'insfilterMARG' | 'insfitlerErrorState' | 'insfilterNonholonomic'

Nombre del filtro Fusion, especificado como una de estas opciones:

• 'imufilter'

• 'ahrsfilter'

• 'ahrs10filter'

• 'insfilterAsync'

• 'insfilterMARG'

• 'insfitlerErrorState'

• 'insfilterNonholonomic'

filter — Filtro de fusión

objeto de filtro de fusión

Filtro de fusión, especificado como uno de estos objetos de filtro de fusión:

• insEKF

• ahrs10filter

• insfilterAsync

• insfilterMARG

• insfilterErrorState

• insfilterNonholonomic

• ahrsfilter

• imufilter

.

Propiedades

Filter — Nombre de clase del filtro

cadena

Esta propiedad o parámetro es de solo lectura.

Nombre de clase del filtro, especificado como una cadena. Su valor es una de estas cadenas:

• "imufilter"

• "ahrsfilter"

• "ahrs10filter"

• "insfilterAsync"

• "insfilterMARG"

• "insfitlerErrorState"

• "insfilterNonholonomic"

TunableParameters — Parámetros ajustables

arreglo de cadena (predeterminado) | arreglo de celdas

Parámetros ajustables, especificados como un arreglo de cadenas o un arreglo de celdas.

• Si desea ajustar todos los elementos de cada parámetro juntos (aumentando o reduciendo todos los elementos en una matriz de ruido de proceso, por ejemplo), especifique la propiedad como un arreglo de cadenas. Cada cadena corresponde a un nombre de propiedad.

  Para objetos de filtro distintos del objeto insEKF , esta es la opción predeterminada. Con la opción predeterminada, la propiedad contiene todos los nombres de los parámetros ajustables como un arreglo de cadenas. Cada cadena es un nombre de propiedad ajustable del filtro de fusión.

• Si desea ajustar un subconjunto de elementos para al menos un parámetro de ruido, especifíquelo como un arreglo de celdas. El número de celdas es el número de parámetros que desea ajustar.

  • Puede especificar cualquier elemento de celda como un vector de caracteres, que represente la propiedad que desea ajustar. En este caso, el filtro ajusta todos los elementos de la propiedad juntos.

  • También puede especificar cualquier elemento de celda como un arreglo de celdas de 1 por 2, en la que la primera celda es un vector de caracteres que representa la propiedad que desea ajustar. La segunda celda del arreglo de celdas es un vector de índices que representa los elementos que desea ajustar en la propiedad. Estos índices son índices basados ​​en columnas.

  Esta es la opción predeterminada para el objeto insEKF .

  Por ejemplo, ejecutando lo siguiente:

  >> filter = insEKF;
  config = tunerconfig(filter);
  tunable = config.TunableParameters

  y podrás obtener:

  
  tunable =
  
    1×3 cell array
  
      {1×2 cell}    {'AccelerometerNoise'}    {'GyroscopeNoise'}
  
  >> firstCell = tunable{1}
  
  firstCell =
  
    1×2 cell array
  
      {'AdditiveProcessNoise'}    {[1 15 29 43 57 71 85 99 113 127 141 155 169]}

  En el filtro, la matriz aditiva de ruido del proceso es una matriz de 13 por 13, y los índices basados ​​en columnas representan todos los elementos diagonales de la matriz.

Ejemplo: ["AccelerometerNoise" "GyroscopeNoise"]

StepForward — Factor de paso adelante

1.1 (predeterminado) | escalar mayor que 1

Factor de un paso hacia adelante, especificado como un escalar mayor que 1. Durante el proceso de ajuste, el ajustador aumenta o disminuye los parámetros de ruido para lograr errores de estimación más pequeños. Esta propiedad especifica la proporción de aumento de parámetros durante un paso de aumento de parámetros.

StepBackward — Factor de retroceso

0.5 (predeterminado) | escalar en rango (0,1)

Factor de un paso hacia atrás, especificado como un escalar en el rango de (0,1). Durante el proceso de ajuste, el ajustador aumenta o disminuye los parámetros de ruido para lograr errores de estimación más pequeños. Esta propiedad especifica el factor de disminución de parámetros durante un paso de disminución de parámetros.

MaxIterations — Número máximo de iteraciones

20 (predeterminado) | número entero positivo

Número máximo de iteraciones permitidas por el algoritmo de ajuste, especificado como un entero positivo.

ObjectiveLimit — Coste al que detener el proceso de ajuste

0.1 (predeterminado) | escalar positivo

Coste al que detener el proceso de ajuste, especificado como un escalar positivo.

FunctionTolerance — Cambio mínimo en el coste para continuar afinando

0 (predeterminado) | escalar no negativo

Cambio mínimo en el coste para continuar con el ajuste, especificado como un escalar no negativo. Si el cambio en el coste es menor que la tolerancia especificada, el proceso de ajuste se detiene.

Display — Habilitar mostrar los detalles de la iteración.

"iter" (predeterminado) | "none"

Habilite la visualización de los detalles de la iteración, especificados como "iter" o "none". Cuando se especifica como:

• "iter" : el programa muestra los detalles de los parámetros ajustados en cada iteración en la ventana de comandos.

• "none" — El programa no muestra ninguna información de sintonización.

Cost — Métrica para evaluar el rendimiento del filtro

"RMS" (predeterminado) | "Custom"

Métrica para evaluar el rendimiento del filtro, especificada como "RMS" o "Custom". Cuando se especifica como:

• "RMS" : el programa optimiza el error cuadrático medio (RMS) entre la estimación y la verdad.

• "Custom" : el programa optimiza el rendimiento del filtro mediante el uso de una función de coste personalizada especificada por la propiedad CustomCostFcn .

CustomCostFcn — Función de costes personalizada

[] (predeterminado) | identificador de función

Función de coste personalizada, especificada como identificador de función.

Dependencias

Para habilitar esta propiedad, establezca la propiedad Cost en 'Custom'.

OutputFcn — Función de salida llamada en cada iteración.

[] (predeterminado) | identificador de función

Función de salida llamada en cada iteración, especificada como un identificador de función. La función debe utilizar la siguiente sintaxis:

stop = myOutputFcn(params,tunerValues)

params es una estructura de la mejor estimación actual de cada parámetro al final de la iteración actual. tunerValues es una estructura que contiene información de la configuración del ajustador, datos del sensor y datos verdaderos. Tiene estos campos:

Nombre del campo	Descripción
Iteration	Recuento de iteraciones del ajustador, especificado como un número entero positivo
SensorData	Entrada de datos del sensor a la función tune
GroundTruth	Entrada de ground-truth a la función tune
Configuration	tunerconfig objeto utilizado para sintonizar
Cost	Coste de ajuste al final de la iteración actual

Sugerencia

Puede utilizar la función incorporada tunerPlotPose para visualizar los datos reales y las estimaciones para la mayoría de sus aplicaciones de tuning. Consulte el ejemplo Visualice los resultados de ajuste usando tunerPlotPose para obtener más detalles.

Ejemplos

Crear objeto Tunerconfig y mostrar parámetros ajustables

Cree un objeto tunerconfig para el objeto insfilterAsync .

config = tunerconfig('insfilterAsync')

config = 
  tunerconfig with properties:

               Filter: "insfilterAsync"
    TunableParameters: ["AccelerometerNoise"    "GyroscopeNoise"    "MagnetometerNoise"    "GPSPositionNoise"    "GPSVelocityNoise"    "QuaternionNoise"    "AngularVelocityNoise"    "PositionNoise"    "VelocityNoise"    ...    ] (1x14 string)
          StepForward: 1.1000
         StepBackward: 0.5000
        MaxIterations: 20
       ObjectiveLimit: 0.1000
    FunctionTolerance: 0
              Display: iter
                 Cost: RMS
            OutputFcn: []

Muestra los parámetros ajustables predeterminados.

config.TunableParameters

ans = 1x14 string
    "AccelerometerNoise"    "GyroscopeNoise"    "MagnetometerNoise"    "GPSPositionNoise"    "GPSVelocityNoise"    "QuaternionNoise"    "AngularVelocityNoise"    "PositionNoise"    "VelocityNoise"    "AccelerationNoise"    "GyroscopeBiasNoise"    "AccelerometerBiasNoise"    "GeomagneticVectorNoise"    "MagnetometerBiasNoise"

Ajuste insfilterAsync para optimizar la estimación de pose

Cargue los datos registrados del sensor y los datos ground-truth.

load('insfilterAsyncTuneData.mat');

Cree cronogramas para los datos de los sensores y los datos de verdad.

sensorData = timetable(Accelerometer, Gyroscope, ...
    Magnetometer, GPSPosition, GPSVelocity, 'SampleRate', 100);
groundTruth = timetable(Orientation, Position, ...
    'SampleRate', 100);

Cree un objeto de filtro insfilterAsync que tenga algunas propiedades de ruido.

filter = insfilterAsync('State', initialState, ...
    'StateCovariance', initialStateCovariance, ...
    'AccelerometerBiasNoise', 1e-7, ...
    'GyroscopeBiasNoise', 1e-7, ...
    'MagnetometerBiasNoise', 1e-7, ...
    'GeomagneticVectorNoise', 1e-7);

Cree un objeto de configuración de sintonizador para el filtro. Establezca el máximo de iteraciones en dos. Además, establezca los parámetros ajustables como propiedades no especificadas.

config = tunerconfig('insfilterAsync','MaxIterations',8);
config.TunableParameters = setdiff(config.TunableParameters, ...
    {'GeomagneticVectorNoise', 'AccelerometerBiasNoise', ...
    'GyroscopeBiasNoise', 'MagnetometerBiasNoise'});
config.TunableParameters

ans = 1×10 string
    "AccelerationNoise"    "AccelerometerNoise"    "AngularVelocityNoise"    "GPSPositionNoise"    "GPSVelocityNoise"    "GyroscopeNoise"    "MagnetometerNoise"    "PositionNoise"    "QuaternionNoise"    "VelocityNoise"

Utilice la función de ruido del ajustador para obtener un conjunto de ruidos iniciales del sensor utilizados en el filtro.

measNoise = tunernoise('insfilterAsync')

measNoise = struct with fields:
    AccelerometerNoise: 1
        GyroscopeNoise: 1
     MagnetometerNoise: 1
      GPSPositionNoise: 1
      GPSVelocityNoise: 1

Ajusteel filtro y obtenga los parámetros ajustados.

tunedParams = tune(filter,measNoise,sensorData,groundTruth,config);

    Iteration    Parameter               Metric
    _________    _________               ______
    1            AccelerationNoise       2.1345
    1            AccelerometerNoise      2.1264
    1            AngularVelocityNoise    1.9659
    1            GPSPositionNoise        1.9341
    1            GPSVelocityNoise        1.8420
    1            GyroscopeNoise          1.7589
    1            MagnetometerNoise       1.7362
    1            PositionNoise           1.7362
    1            QuaternionNoise         1.7218
    1            VelocityNoise           1.7218
    2            AccelerationNoise       1.7190
    2            AccelerometerNoise      1.7170
    2            AngularVelocityNoise    1.6045
    2            GPSPositionNoise        1.5948
    2            GPSVelocityNoise        1.5323
    2            GyroscopeNoise          1.4803
    2            MagnetometerNoise       1.4703
    2            PositionNoise           1.4703
    2            QuaternionNoise         1.4632
    2            VelocityNoise           1.4632
    3            AccelerationNoise       1.4596
    3            AccelerometerNoise      1.4548
    3            AngularVelocityNoise    1.3923
    3            GPSPositionNoise        1.3810
    3            GPSVelocityNoise        1.3322
    3            GyroscopeNoise          1.2998
    3            MagnetometerNoise       1.2976
    3            PositionNoise           1.2976
    3            QuaternionNoise         1.2943
    3            VelocityNoise           1.2943
    4            AccelerationNoise       1.2906
    4            AccelerometerNoise      1.2836
    4            AngularVelocityNoise    1.2491
    4            GPSPositionNoise        1.2258
    4            GPSVelocityNoise        1.1880
    4            GyroscopeNoise          1.1701
    4            MagnetometerNoise       1.1698
    4            PositionNoise           1.1698
    4            QuaternionNoise         1.1688
    4            VelocityNoise           1.1688
    5            AccelerationNoise       1.1650
    5            AccelerometerNoise      1.1569
    5            AngularVelocityNoise    1.1454
    5            GPSPositionNoise        1.1100
    5            GPSVelocityNoise        1.0778
    5            GyroscopeNoise          1.0709
    5            MagnetometerNoise       1.0675
    5            PositionNoise           1.0675
    5            QuaternionNoise         1.0669
    5            VelocityNoise           1.0669
    6            AccelerationNoise       1.0634
    6            AccelerometerNoise      1.0549
    6            AngularVelocityNoise    1.0549
    6            GPSPositionNoise        1.0180
    6            GPSVelocityNoise        0.9866
    6            GyroscopeNoise          0.9810
    6            MagnetometerNoise       0.9775
    6            PositionNoise           0.9775
    6            QuaternionNoise         0.9768
    6            VelocityNoise           0.9768
    7            AccelerationNoise       0.9735
    7            AccelerometerNoise      0.9652
    7            AngularVelocityNoise    0.9652
    7            GPSPositionNoise        0.9283
    7            GPSVelocityNoise        0.8997
    7            GyroscopeNoise          0.8947
    7            MagnetometerNoise       0.8920
    7            PositionNoise           0.8920
    7            QuaternionNoise         0.8912
    7            VelocityNoise           0.8912
    8            AccelerationNoise       0.8885
    8            AccelerometerNoise      0.8811
    8            AngularVelocityNoise    0.8807
    8            GPSPositionNoise        0.8479
    8            GPSVelocityNoise        0.8238
    8            GyroscopeNoise          0.8165
    8            MagnetometerNoise       0.8165
    8            PositionNoise           0.8165
    8            QuaternionNoise         0.8159
    8            VelocityNoise           0.8159

Fusione los datos del sensor utilizando el filtro ajustado.

dt = seconds(diff(groundTruth.Time));
N = size(sensorData,1);
qEst = quaternion.zeros(N,1);
posEst = zeros(N,3);
% Iterate the filter for prediction and correction using sensor data.
for ii=1:N
    if ii ~= 1
        predict(filter, dt(ii-1));
    end
    if all(~isnan(Accelerometer(ii,:)))
        fuseaccel(filter,Accelerometer(ii,:), ...
            tunedParams.AccelerometerNoise);
    end
    if all(~isnan(Gyroscope(ii,:)))
        fusegyro(filter, Gyroscope(ii,:), ...
            tunedParams.GyroscopeNoise);
    end
    if all(~isnan(Magnetometer(ii,1)))
        fusemag(filter, Magnetometer(ii,:), ...
            tunedParams.MagnetometerNoise);
    end
    if all(~isnan(GPSPosition(ii,1)))
        fusegps(filter, GPSPosition(ii,:), ...
            tunedParams.GPSPositionNoise, GPSVelocity(ii,:), ...
            tunedParams.GPSVelocityNoise);
    end
    [posEst(ii,:), qEst(ii,:)] = pose(filter);
end

Calcule los errores RMS.

orientationError = rad2deg(dist(qEst, Orientation));
rmsorientationError = sqrt(mean(orientationError.^2))

rmsorientationError = 2.7801

positionError = sqrt(sum((posEst - Position).^2, 2));
rmspositionError = sqrt(mean( positionError.^2))

rmspositionError = 0.5966

Visualiza los resultados.

figure();
t = (0:N-1)./ groundTruth.Properties.SampleRate;
subplot(2,1,1)
plot(t, positionError, 'b');
title("Tuned insfilterAsync" + newline + "Euclidean Distance Position Error")
xlabel('Time (s)');
ylabel('Position Error (meters)')
subplot(2,1,2)
plot(t, orientationError, 'b');
title("Orientation Error")
xlabel('Time (s)');
ylabel('Orientation Error (degrees)');

Ajuste imufilter para optimizar la estimación de orientación

Cargue datos de sensores registrados y datos ground-truth.

ld = load('imufilterTuneData.mat');
qTrue = ld.groundTruth.Orientation; % true orientation

Cree un objeto imufilter y fusione el filtro con los datos del sensor.

fuse = imufilter;
qEstUntuned = fuse(ld.sensorData.Accelerometer, ...
    ld.sensorData.Gyroscope);

Cree un objeto tunerconfig y ajuste el imufilter para mejorar la estimación de orientación.

cfg = tunerconfig('imufilter');
tune(fuse, ld.sensorData, ld.groundTruth, cfg);

    Iteration    Parameter                        Metric
    _________    _________                        ______
    1            AccelerometerNoise               0.1149
    1            GyroscopeNoise                   0.1146
    1            GyroscopeDriftNoise              0.1146
    1            LinearAccelerationNoise          0.1122
    1            LinearAccelerationDecayFactor    0.1103
    2            AccelerometerNoise               0.1102
    2            GyroscopeNoise                   0.1098
    2            GyroscopeDriftNoise              0.1098
    2            LinearAccelerationNoise          0.1070
    2            LinearAccelerationDecayFactor    0.1053
    3            AccelerometerNoise               0.1053
    3            GyroscopeNoise                   0.1048
    3            GyroscopeDriftNoise              0.1048
    3            LinearAccelerationNoise          0.1016
    3            LinearAccelerationDecayFactor    0.1002
    4            AccelerometerNoise               0.1001
    4            GyroscopeNoise                   0.0996
    4            GyroscopeDriftNoise              0.0996
    4            LinearAccelerationNoise          0.0962
    4            LinearAccelerationDecayFactor    0.0950
    5            AccelerometerNoise               0.0950
    5            GyroscopeNoise                   0.0943
    5            GyroscopeDriftNoise              0.0943
    5            LinearAccelerationNoise          0.0910
    5            LinearAccelerationDecayFactor    0.0901
    6            AccelerometerNoise               0.0900
    6            GyroscopeNoise                   0.0893
    6            GyroscopeDriftNoise              0.0893
    6            LinearAccelerationNoise          0.0862
    6            LinearAccelerationDecayFactor    0.0855
    7            AccelerometerNoise               0.0855
    7            GyroscopeNoise                   0.0848
    7            GyroscopeDriftNoise              0.0848
    7            LinearAccelerationNoise          0.0822
    7            LinearAccelerationDecayFactor    0.0818
    8            AccelerometerNoise               0.0817
    8            GyroscopeNoise                   0.0811
    8            GyroscopeDriftNoise              0.0811
    8            LinearAccelerationNoise          0.0791
    8            LinearAccelerationDecayFactor    0.0789
    9            AccelerometerNoise               0.0788
    9            GyroscopeNoise                   0.0782
    9            GyroscopeDriftNoise              0.0782
    9            LinearAccelerationNoise          0.0769
    9            LinearAccelerationDecayFactor    0.0768
    10           AccelerometerNoise               0.0768
    10           GyroscopeNoise                   0.0762
    10           GyroscopeDriftNoise              0.0762
    10           LinearAccelerationNoise          0.0754
    10           LinearAccelerationDecayFactor    0.0753
    11           AccelerometerNoise               0.0753
    11           GyroscopeNoise                   0.0747
    11           GyroscopeDriftNoise              0.0747
    11           LinearAccelerationNoise          0.0741
    11           LinearAccelerationDecayFactor    0.0740
    12           AccelerometerNoise               0.0740
    12           GyroscopeNoise                   0.0734
    12           GyroscopeDriftNoise              0.0734
    12           LinearAccelerationNoise          0.0728
    12           LinearAccelerationDecayFactor    0.0728
    13           AccelerometerNoise               0.0728
    13           GyroscopeNoise                   0.0721
    13           GyroscopeDriftNoise              0.0721
    13           LinearAccelerationNoise          0.0715
    13           LinearAccelerationDecayFactor    0.0715
    14           AccelerometerNoise               0.0715
    14           GyroscopeNoise                   0.0706
    14           GyroscopeDriftNoise              0.0706
    14           LinearAccelerationNoise          0.0700
    14           LinearAccelerationDecayFactor    0.0700
    15           AccelerometerNoise               0.0700
    15           GyroscopeNoise                   0.0690
    15           GyroscopeDriftNoise              0.0690
    15           LinearAccelerationNoise          0.0684
    15           LinearAccelerationDecayFactor    0.0684
    16           AccelerometerNoise               0.0684
    16           GyroscopeNoise                   0.0672
    16           GyroscopeDriftNoise              0.0672
    16           LinearAccelerationNoise          0.0668
    16           LinearAccelerationDecayFactor    0.0667
    17           AccelerometerNoise               0.0667
    17           GyroscopeNoise                   0.0655
    17           GyroscopeDriftNoise              0.0655
    17           LinearAccelerationNoise          0.0654
    17           LinearAccelerationDecayFactor    0.0654
    18           AccelerometerNoise               0.0654
    18           GyroscopeNoise                   0.0641
    18           GyroscopeDriftNoise              0.0641
    18           LinearAccelerationNoise          0.0640
    18           LinearAccelerationDecayFactor    0.0639
    19           AccelerometerNoise               0.0639
    19           GyroscopeNoise                   0.0627
    19           GyroscopeDriftNoise              0.0627
    19           LinearAccelerationNoise          0.0627
    19           LinearAccelerationDecayFactor    0.0624
    20           AccelerometerNoise               0.0624
    20           GyroscopeNoise                   0.0614
    20           GyroscopeDriftNoise              0.0614
    20           LinearAccelerationNoise          0.0613
    20           LinearAccelerationDecayFactor    0.0613

Fusione los datos del sensor nuevamente usando el filtro ajustado.

qEstTuned = fuse(ld.sensorData.Accelerometer, ...
    ld.sensorData.Gyroscope);

Compare el rendimiento de los errores RMS del filtro ajustado y no ajustado.

dUntuned = rad2deg(dist(qEstUntuned, qTrue));
dTuned = rad2deg(dist(qEstTuned, qTrue));
rmsUntuned = sqrt(mean(dUntuned.^2))

rmsUntuned = 6.5864

rmsTuned = sqrt(mean(dTuned.^2))

rmsTuned = 3.5098

Visualiza los resultados.

N = numel(dUntuned);
t = (0:N-1)./ fuse.SampleRate;
plot(t, dUntuned, 'r', t, dTuned, 'b');
legend('Untuned', 'Tuned');
title('imufilter - Tuned vs Untuned Error')
xlabel('Time (s)');
ylabel('Orientation Error (degrees)');

Guarde los parámetros ajustados en un archivo MAT usando la función de salida

Cargue los datos registrados del sensor y los datos ground-truth.

load('insfilterAsyncTuneData.mat');

Cree cronogramas para los datos de los sensores y los datos de verdad.

sensorData = timetable(Accelerometer, Gyroscope, ...
    Magnetometer, GPSPosition, GPSVelocity, 'SampleRate', 100);
groundTruth = timetable(Orientation, Position, ...
    'SampleRate', 100);

Cree un objeto de filtro insfilterAsync que tenga algunas propiedades de ruido.

filter = insfilterAsync('State', initialState, ...
    'StateCovariance', initialStateCovariance, ...
    'AccelerometerBiasNoise', 1e-7, ...
    'GyroscopeBiasNoise', 1e-7, ...
    'MagnetometerBiasNoise', 1e-7, ...
    'GeomagneticVectorNoise', 1e-7);

Cree un objeto de configuración de ajustador para el filtro. Defina la propiedad OutputFcn como una función personalizada, myOutputFcn, que guarda los últimos parámetros ajustados en un archivo MAT.

config = tunerconfig('insfilterAsync', ...
    'MaxIterations',5, ...
    'Display','none', ...
    'OutputFcn', @myOutputFcn);
config.TunableParameters = setdiff(config.TunableParameters, ...
    {'GeomagneticVectorNoise', 'AccelerometerBiasNoise', ...
    'GyroscopeBiasNoise', 'MagnetometerBiasNoise'});
config.TunableParameters

ans = 1x10 string
    "AccelerationNoise"    "AccelerometerNoise"    "AngularVelocityNoise"    "GPSPositionNoise"    "GPSVelocityNoise"    "GyroscopeNoise"    "MagnetometerNoise"    "PositionNoise"    "QuaternionNoise"    "VelocityNoise"

Utilice la función de ruido del ajustador para obtener un conjunto de ruidos iniciales del sensor utilizados en el filtro.

measNoise = tunernoise('insfilterAsync')

measNoise = struct with fields:
    AccelerometerNoise: 1
        GyroscopeNoise: 1
     MagnetometerNoise: 1
      GPSPositionNoise: 1
      GPSVelocityNoise: 1

Ajusteel filtro y obtenga los parámetros ajustados.

tunedParams = tune(filter,measNoise,sensorData,groundTruth,config);

Muestre los parámetros de guardado utilizando el archivo guardado.

fileObject = matfile('myfile.mat');
fileObject.params

ans = struct with fields:
         AccelerationNoise: [88.8995 88.8995 88.8995]
    AccelerometerBiasNoise: [1.0000e-07 1.0000e-07 1.0000e-07]
        AccelerometerNoise: 0.7942
      AngularVelocityNoise: [0.0089 0.0089 0.0089]
          GPSPositionNoise: 1.1664
          GPSVelocityNoise: 0.5210
    GeomagneticVectorNoise: [1.0000e-07 1.0000e-07 1.0000e-07]
        GyroscopeBiasNoise: [1.0000e-07 1.0000e-07 1.0000e-07]
            GyroscopeNoise: 0.5210
     MagnetometerBiasNoise: [1.0000e-07 1.0000e-07 1.0000e-07]
         MagnetometerNoise: 1.0128
             PositionNoise: [5.2100e-07 5.2100e-07 5.2100e-07]
           QuaternionNoise: [1.3239e-06 1.3239e-06 1.3239e-06 1.3239e-06]
         ReferenceLocation: [0 0 0]
                     State: [28x1 double]
           StateCovariance: [28x28 double]
             VelocityNoise: [6.3678e-07 6.3678e-07 6.3678e-07]

La función de salida

function stop = myOutputFcn(params, ~)
save('myfile.mat','params'); % overwrite the file with latest
stop = false;
end

Historial de versiones

Introducido en R2020b

Consulte también

insfilterAsync | insfilterNonholonomic | insfilterMARG | insfilterErrorState | ahrsfilter | ahrs10filter | imufilter