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

Descripción

El objeto tunerconfig crea una configuración de sintonizador para un filtro de fusión que se utiliza para sintonizar el filtro y reducir así 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 usando uno o más argumentos de pares nombre-valor. Name es un nombre de propiedad y Value es el valor correspondiente. Name debe aparecer entre comillas. Puede especificar varios argumentos de par 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

Solo lectura: 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 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 ajuste.

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 costo 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 sintonizador, datos del sensor y datos de verdad. 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 verdad fundamental a la función tune
Configuration	Objeto tunerconfig utilizado para la optimización
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 ajuste. Consulte el ejemplo Visualice los resultados del ajuste con tunerPlotPose para obtener más detalles.

Ejemplos

Crear objeto Tunerconfig y mostrar parámetros ajustables

Crea 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"    …    ] (1×14 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 = 1×14 string
    "AccelerometerNoise"    "GyroscopeNoise"    "MagnetometerNoise"    "GPSPositionNoise"    "GPSVelocityNoise"    "QuaternionNoise"    "AngularVelocityNoise"    "PositionNoise"    "VelocityNoise"    "AccelerationNoise"    "GyroscopeBiasNoise"    "AccelerometerBiasNoise"    "GeomagneticVectorNoise"    "MagnetometerBiasNoise"

Ajuste insfilterAsync para optimizar la estimación de la 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);

Crea 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

Visualizar 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 la 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 la orientación.

cfg = tunerconfig("imufilter",ObjectiveLimit=0.03);
reset(fuse)
tune(fuse,ld.sensorData,ld.groundTruth,cfg);

    Iteration    Parameter                        Metric
    _________    _________                        ______
    1            AccelerometerNoise               0.0857
    1            GyroscopeNoise                   0.0855
    1            GyroscopeDriftNoise              0.0855
    1            LinearAccelerationNoise          0.0851
    1            LinearAccelerationDecayFactor    0.0844
    2            AccelerometerNoise               0.0844
    2            GyroscopeNoise                   0.0842
    2            GyroscopeDriftNoise              0.0842
    2            LinearAccelerationNoise          0.0840
    2            LinearAccelerationDecayFactor    0.0836
    3            AccelerometerNoise               0.0836
    3            GyroscopeNoise                   0.0834
    3            GyroscopeDriftNoise              0.0834
    3            LinearAccelerationNoise          0.0834
    3            LinearAccelerationDecayFactor    0.0831
    4            AccelerometerNoise               0.0831
    4            GyroscopeNoise                   0.0829
    4            GyroscopeDriftNoise              0.0829
    4            LinearAccelerationNoise          0.0829
    4            LinearAccelerationDecayFactor    0.0827
    5            AccelerometerNoise               0.0827
    5            GyroscopeNoise                   0.0824
    5            GyroscopeDriftNoise              0.0824
    5            LinearAccelerationNoise          0.0824
    5            LinearAccelerationDecayFactor    0.0822
    6            AccelerometerNoise               0.0822
    6            GyroscopeNoise                   0.0819
    6            GyroscopeDriftNoise              0.0819
    6            LinearAccelerationNoise          0.0819
    6            LinearAccelerationDecayFactor    0.0818
    7            AccelerometerNoise               0.0818
    7            GyroscopeNoise                   0.0814
    7            GyroscopeDriftNoise              0.0814
    7            LinearAccelerationNoise          0.0814
    7            LinearAccelerationDecayFactor    0.0813
    8            AccelerometerNoise               0.0813
    8            GyroscopeNoise                   0.0808
    8            GyroscopeDriftNoise              0.0808
    8            LinearAccelerationNoise          0.0808
    8            LinearAccelerationDecayFactor    0.0807
    9            AccelerometerNoise               0.0807
    9            GyroscopeNoise                   0.0802
    9            GyroscopeDriftNoise              0.0802
    9            LinearAccelerationNoise          0.0802
    9            LinearAccelerationDecayFactor    0.0801
    10           AccelerometerNoise               0.0801
    10           GyroscopeNoise                   0.0794
    10           GyroscopeDriftNoise              0.0794
    10           LinearAccelerationNoise          0.0794
    10           LinearAccelerationDecayFactor    0.0794
    11           AccelerometerNoise               0.0794
    11           GyroscopeNoise                   0.0785
    11           GyroscopeDriftNoise              0.0785
    11           LinearAccelerationNoise          0.0785
    11           LinearAccelerationDecayFactor    0.0785
    12           AccelerometerNoise               0.0785
    12           GyroscopeNoise                   0.0775
    12           GyroscopeDriftNoise              0.0775
    12           LinearAccelerationNoise          0.0775
    12           LinearAccelerationDecayFactor    0.0774
    13           AccelerometerNoise               0.0774
    13           GyroscopeNoise                   0.0762
    13           GyroscopeDriftNoise              0.0762
    13           LinearAccelerationNoise          0.0762
    13           LinearAccelerationDecayFactor    0.0761
    14           AccelerometerNoise               0.0761
    14           GyroscopeNoise                   0.0746
    14           GyroscopeDriftNoise              0.0746
    14           LinearAccelerationNoise          0.0746
    14           LinearAccelerationDecayFactor    0.0745
    15           AccelerometerNoise               0.0745
    15           GyroscopeNoise                   0.0727
    15           GyroscopeDriftNoise              0.0727
    15           LinearAccelerationNoise          0.0727
    15           LinearAccelerationDecayFactor    0.0726
    16           AccelerometerNoise               0.0726
    16           GyroscopeNoise                   0.0706
    16           GyroscopeDriftNoise              0.0706
    16           LinearAccelerationNoise          0.0705
    16           LinearAccelerationDecayFactor    0.0705
    17           AccelerometerNoise               0.0705
    17           GyroscopeNoise                   0.0684
    17           GyroscopeDriftNoise              0.0684
    17           LinearAccelerationNoise          0.0683
    17           LinearAccelerationDecayFactor    0.0683
    18           AccelerometerNoise               0.0683
    18           GyroscopeNoise                   0.0662
    18           GyroscopeDriftNoise              0.0662
    18           LinearAccelerationNoise          0.0662
    18           LinearAccelerationDecayFactor    0.0662
    19           AccelerometerNoise               0.0662
    19           GyroscopeNoise                   0.0644
    19           GyroscopeDriftNoise              0.0644
    19           LinearAccelerationNoise          0.0644
    19           LinearAccelerationDecayFactor    0.0644
    20           AccelerometerNoise               0.0644
    20           GyroscopeNoise                   0.0630
    20           GyroscopeDriftNoise              0.0630
    20           LinearAccelerationNoise          0.0630
    20           LinearAccelerationDecayFactor    0.0630

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 = 
4.9108

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

rmsTuned = 
3.6116

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);

Crea 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. 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 = 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);

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: [28×1 double]
           StateCovariance: [28×28 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