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

imuSensor

modelo de simulación IMU

Descripción

Los modelos imuSensor System object™ reciben datos de una unidad de medición inercial (IMU). Puede especificar el marco de referencia de las entradas del bloque como el marco NED (Noreste-Abajo) o ENU (Este-Norte-Arriba) utilizando el argumento ReferenceFrame.

Para modelar una IMU:

1. Cree el objeto imuSensor y configure sus propiedades.

2. Llame al objeto con argumentos, como si fuera una función.

Para más información sobre el funcionamiento de los System objects, consulte ¿Qué son los System Objects?

Creación

Sintaxis

IMU = imuSensor

IMU = imuSensor('accel-gyro')

IMU = imuSensor('accel-mag')

IMU = imuSensor('accel-gyro-mag')

IMU = imuSensor(___,"ReferenceFrame",RF)

IMU = imuSensor(___,Name=Value)

Descripción

IMU = imuSensor devuelve un System object, IMU, que calcula una lectura de unidad de medida inercial basada en una señal de entrada inercial. IMU tiene un acelerómetro y giroscopio ideales.

IMU = imuSensor('accel-gyro') devuelve un imuSensor System object con un acelerómetro y giroscopio ideales. imuSensor y imuSensor('accel-gyro') son sintaxis de creación equivalentes.

IMU = imuSensor('accel-mag') devuelve un imuSensor System object con un acelerómetro y magnetómetro ideales.

IMU = imuSensor('accel-gyro-mag') devuelve un imuSensor System object con un acelerómetro, giroscopio y magnetómetro ideales.

IMU = imuSensor(___,"ReferenceFrame",RF) devuelve un imuSensor System object que calcula una lectura de unidad de medida inercial relativa al marco de referencia RF.

IMU = imuSensor(___,Name=Value) establece una o más propiedades utilizando argumentos de nombre-valor además de cualquiera de los argumentos de entrada anteriores.

Argumentos de entrada

RF — Marco de referencia de las entradas de los sensores

'NED' (predeterminado) | 'ENU'

Marco de referencia de las entradas del sensor, especificado como 'NED' (Noreste-Abajo) o 'ENU' (Este-Norte-Arriba).

Nota

• Si elige el marco de referencia NED, especifique las entradas del sensor en el marco de referencia NED. Además, el sensor modela la aceleración gravitacional como [0 0 9,81] m/s².

• Si elige el marco de referencia ENU, especifique las entradas del sensor en el marco de referencia ENU. Además, el sensor modela la aceleración gravitacional como [0 0 −9,81] m/s².

Tipos de datos: char | string

Propiedades

A menos que se indique lo contrario, las propiedades son no ajustables, lo que significa que no puede modificar sus valores después de llamar al objeto. Los objetos se bloquean cuando llama a ellos, y la función release los desbloquea.

Si una propiedad es ajustable, puede modificar su valor en cualquier momento.

Para obtener más información sobre cómo modificar los valores de las propiedades, consulte Diseñar sistemas en MATLAB utilizando System objects.

IMUType — Tipo de unidad de medida inercial

'accel-gyro' (predeterminado) | 'accel-mag' | 'accel-gyro-mag'

Tipo de unidad de medida inercial, especificada como 'accel-gyro', 'accel-mag' o 'accel-gyro-mag'.

El tipo de unidad de medida inercial especifica qué lecturas del sensor modelar:

• 'accel-gyro' –– Acelerómetro y giroscopio

• 'accel-mag' –– Acelerómetro y magnetómetro

• 'accel-gyro-mag' –– Acelerómetro, giroscopio y magnetómetro

Puede especificar IMUType como un argumento de solo valor durante la creación o como un par Name,Value.

Tipos de datos: char | string

SampleRate — Frecuencia de muestreo del sensor (Hz)

100 (predeterminado) | escalar positivo

Frecuencia de muestreo del modelo de sensor en Hz, especificada como escalar positivo.

Tipos de datos: single | double

Temperature — Temperatura de la IMU (^oC)

25 (predeterminado) | escalar real

Temperatura de funcionamiento de la IMU en grados Celsius, especificada como escalar real.

Cuando el objeto calcula factores de escala de temperatura y ruidos de deriva ambiental, se utiliza 25 ^oC como temperatura nominal.

Ajustable: Yes

Tipos de datos: single | double

MagneticField — Vector de campo magnético en el sistema de coordenadas de navegación local (μT)

[27.5550 -2.4169 -16.0849] (predeterminado) | vector de valor real de tres elementos

Vector de campo magnético en microtesla, especificado como un vector fila de tres elementos en el sistema de coordenadas de navegación local.

El campo magnético predeterminado corresponde al campo magnético en la latitud cero, longitud cero y altitud cero.

Ajustable: Yes

Tipos de datos: single | double

Accelerometer — Parámetros del sensor del acelerómetro

objeto accelparams (predeterminado)

Parámetros del sensor del acelerómetro, especificados por un objeto accelparams.

Ajustable: Yes

Gyroscope — Parámetros del sensor de giroscopio

objeto gyroparams (predeterminado)

Parámetros del sensor de giroscopio, especificados por un objeto gyroparams.

Ajustable: Yes

Magnetometer — Parámetros del sensor magnetómetro

objeto magparams (predeterminado)

Parámetros del sensor magnetómetro, especificados por un objeto magparams.

Ajustable: Yes

RandomStream — fuente de números aleatorios

'Global stream' (predeterminado) | 'mt19937ar with seed'

Fuente de números aleatorios, especificada como un vector de caracteres o una cadena:

• 'Global stream' –– Los números aleatorios se generan utilizando el flujo de números aleatorios global actual.

• 'mt19937ar with seed' –– Los números aleatorios se generan utilizando el algoritmo mt19937ar con la semilla especificada por la propiedad Seed.

Tipos de datos: char | string

Seed — semilla inicial

67 (predeterminado) | escalar entero no negativo

Semilla inicial de un algoritmo generador de números aleatorios mt19937ar, especificado como un escalar entero real no negativo.

Dependencias

Para habilitar esta propiedad, establezca RandomStream en 'mt19937ar with seed'.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Uso

Sintaxis

[accelReadings,gyroReadings] = IMU(acc,angVel)

[accelReadings,gyroReadings] = IMU(acc,angVel,orientation)

[accelReadings,magReadings] = IMU(acc,angVel)

[accelReadings,magReadings] = IMU(acc,angVel,orientation)

[accelReadings,gyroReadings,magReadings] = IMU(acc,angVel)

[accelReadings,gyroReadings,magReadings] = IMU(acc,angVel,orientation)

Descripción

[accelReadings,gyroReadings] = IMU(acc,angVel) genera lecturas del acelerómetro y del giroscopio a partir de las entradas de aceleración y velocidad angular.

Esta sintaxis solo es válida si IMUType se establece en 'accel-gyro' o 'accel-gyro-mag'.

[accelReadings,gyroReadings] = IMU(acc,angVel,orientation) genera lecturas del acelerómetro y del giroscopio a partir de las entradas de aceleración, velocidad angular y orientación.

Esta sintaxis solo es válida si IMUType se establece en 'accel-gyro' o 'accel-gyro-mag'.

[accelReadings,magReadings] = IMU(acc,angVel) genera lecturas del acelerómetro y magnetómetro a partir de las entradas de aceleración y velocidad angular.

Esta sintaxis solo es válida si IMUType se establece en 'accel-mag'.

[accelReadings,magReadings] = IMU(acc,angVel,orientation) genera lecturas del acelerómetro y magnetómetro a partir de las entradas de aceleración, velocidad angular y orientación.

Esta sintaxis solo es válida si IMUType se establece en 'accel-mag'.

[accelReadings,gyroReadings,magReadings] = IMU(acc,angVel) genera lecturas del acelerómetro, giroscopio y magnetómetro a partir de las entradas de aceleración y velocidad angular.

Esta sintaxis solo es válida si IMUType se establece en 'accel-gyro-mag'.

[accelReadings,gyroReadings,magReadings] = IMU(acc,angVel,orientation) genera lecturas del acelerómetro, giroscopio y magnetómetro a partir de las entradas de aceleración, velocidad angular y orientación.

Esta sintaxis solo es válida si IMUType se establece en 'accel-gyro-mag'.

Argumentos de entrada

acc — Aceleración de la IMU en el sistema de coordenadas de navegación local (m/s²)

matriz de N por 3

Aceleración de la IMU en el sistema de coordenadas de navegación local, especificado como un arreglo real y finito de N por 3 en metros por segundo al cuadrado. N es el número de muestras en el cuadro actual. No incluya la aceleración gravitacional en esta entrada ya que el sensor modela la aceleración gravitacional de forma predeterminada.

Para especificar la orientación del marco del cuerpo del sensor IMU con respecto al marco de navegación local, utilice el argumento de entrada orientation.

Tipos de datos: single | double

angVel — Velocidad angular de IMU en el sistema de coordenadas de navegación local (rad/s)

matriz de N por 3

Velocidad angular de la IMU en el sistema de coordenadas de navegación local, especificada como un arreglo real y finito N por 3 en radianes por segundo. N es el número de muestras en el cuadro actual. Para especificar la orientación del marco del cuerpo del sensor IMU con respecto al marco de navegación local, utilice el argumento de entrada orientation.

Tipos de datos: single | double

orientation — Orientación de IMU en el sistema de coordenadas de navegación local.

vector columna de cuaternión de elemento N | Matriz de rotación de 3 por 3 por N elementos

Orientación de la IMU con respecto al sistema de coordenadas de navegación local, especificada como un vector columna de quaternion N elementos o una matriz de rotación de 3 por 3 por N. Cada quaternion o matriz de rotación representa una rotación de cuadro desde el sistema de coordenadas de navegación local al sistema de coordenadas del cuerpo del sensor IMU actual. N es el número de muestras en el cuadro actual.

Tipos de datos: single | double | quaternion

Argumentos de salida

accelReadings — Medición del acelerómetro de la IMU en el sistema de coordenadas del cuerpo del sensor (m/s²)

matriz de N por 3

Medición del acelerómetro de la IMU en el sistema de coordenadas del cuerpo del sensor, especificada como un arreglo real y finito de N por 3 en metros por segundo al cuadrado. N es el número de muestras en el cuadro actual.

Tipos de datos: single | double

gyroReadings — Medición giroscópica de IMU en el sistema de coordenadas del cuerpo del sensor (rad/s)

matriz de N por 3

Medición del giroscopio de la IMU en el sistema de coordenadas del cuerpo del sensor, especificada como un arreglo real y finito de N por 3 en radianes por segundo. N es el número de muestras en el cuadro actual.

Tipos de datos: single | double

magReadings — Medición magnetométrica de IMU en el sistema de coordenadas del cuerpo del sensor (μT)

matriz de N por 3 (predeterminado)

Medición del magnetómetro de la IMU en el sistema de coordenadas del cuerpo del sensor, especificada como un arreglo real y finito de N por 3 en microtelsa. N es el número de muestras en el cuadro actual.

Tipos de datos: single | double

Funciones del objeto

Para usar una función de objeto, especifique el System object como el primer argumento de entrada. Por ejemplo, para liberar recursos de sistema de un System object llamado obj, utilice la siguiente sintaxis:

release(obj)

Específico de imuSensor

loadparams	Cargar parámetros del sensor desde un archivo JSON
perturbations	Perturbación definida en el objeto.
perturb	Aplicar perturbaciones al objeto.

Comunes a todos los System objects

step	Ejecutar el algoritmo System object
release	Release resources and allow changes to System object property values and input characteristics
reset	Reset internal states of System object

Ejemplos

Crear imuSensor System object predeterminado

imuSensor System object™ le permite modelar los datos recibidos de una unidad de medición inercial que consta de una combinación de giroscopio, acelerómetro y magnetómetro.

Crea un objeto imuSensor predeterminado.

IMU = imuSensor

IMU = 
  imuSensor with properties:

          IMUType: 'accel-gyro'
       SampleRate: 100
      Temperature: 25
    Accelerometer: [1×1 accelparams]
        Gyroscope: [1×1 gyroparams]
     RandomStream: 'Global stream'

El objeto imuSensor, IMU, contiene un giroscopio y un acelerómetro idealizados. Utilice la notación de puntos para ver las propiedades del giroscopio.

IMU.Gyroscope

ans = 
  gyroparams with properties:

    MeasurementRange: Inf             rad/s      
          Resolution: 0               (rad/s)/LSB
        ConstantBias: [0 0 0]         rad/s      
    AxesMisalignment: [3⨯3 double]    %          

                   NoiseDensity: [0 0 0]           (rad/s)/√Hz
                BiasInstability: [0 0 0]           rad/s      
                     RandomWalk: [0 0 0]           (rad/s)*√Hz
                      NoiseType: "double-sided"               
    BiasInstabilityCoefficients: [1⨯1 struct]                 

           TemperatureBias: [0 0 0]    (rad/s)/°C    
    TemperatureScaleFactor: [0 0 0]    %/°C          
          AccelerationBias: [0 0 0]    (rad/s)/(m/s²)

Las propiedades del sensor están definidas por los objetos de parámetros correspondientes. Por ejemplo, el modelo de giroscopio utilizado por imuSensor está definido por una instancia de la clase gyroparams. Puede modificar las propiedades del modelo de giroscopio usando notación de puntos. Establezca el rango de medición del giroscopio en 4,3 rad/s.

IMU.Gyroscope.MeasurementRange = 4.3;

También puede configurar las propiedades del sensor para preestablecer objetos de parámetros. Cree un objeto accelparams para imitar un hardware específico y luego configure la propiedad IMU Accelerometer en el objeto accelparams. Muestra la propiedad Accelerometer para verificar que las propiedades estén configuradas correctamente.

SpecSheet1 = accelparams( ...
    'MeasurementRange',19.62, ...
    'Resolution',0.00059875, ...
    'ConstantBias',0.4905, ...
    'AxesMisalignment',2, ...
    'NoiseDensity',0.003924, ...
    'BiasInstability',0, ...
    'TemperatureBias', [0.34335 0.34335 0.5886], ...
    'TemperatureScaleFactor', 0.02);

IMU.Accelerometer = SpecSheet1;

IMU.Accelerometer

ans = 
  accelparams with properties:

    MeasurementRange: 19.62                     m/s²      
          Resolution: 0.00059875                (m/s²)/LSB
        ConstantBias: [0.4905 0.4905 0.4905]    m/s²      
    AxesMisalignment: [3⨯3 double]              %         

                   NoiseDensity: [0.003924 0.003924 0.003924]    (m/s²)/√Hz
                BiasInstability: [0 0 0]                         m/s²      
                     RandomWalk: [0 0 0]                         (m/s²)*√Hz
                      NoiseType: "double-sided"                            
    BiasInstabilityCoefficients: [1⨯1 struct]                              

           TemperatureBias: [0.34335 0.34335 0.5886]    (m/s²)/°C
    TemperatureScaleFactor: [0.02 0.02 0.02]            %/°C     

Generar datos IMU desde entrada estacionaria

Utilice imuSensor System object™ para modelar la recepción de datos desde una IMU ideal estacionaria que contiene un acelerómetro, un giroscopio y un magnetómetro.

Cree un modelo de sensor IMU ideal que contenga un acelerómetro, giroscopio y magnetómetro.

IMU = imuSensor('accel-gyro-mag')

IMU = 
  imuSensor with properties:

          IMUType: 'accel-gyro-mag'
       SampleRate: 100
      Temperature: 25
    MagneticField: [27.5550 -2.4169 -16.0849]
    Accelerometer: [1×1 accelparams]
        Gyroscope: [1×1 gyroparams]
     Magnetometer: [1×1 magparams]
     RandomStream: 'Global stream'

Defina ground-truth, el movimiento subyacente de la IMU que está modelando. La aceleración y la velocidad angular se definen en relación con el sistema de coordenadas NED local.

numSamples = 1000;
acceleration = zeros(numSamples,3);
angularVelocity = zeros(numSamples,3);

Llame a IMU con la aceleración y la velocidad angular de la ground-truth . El objeto genera lecturas del acelerómetro, del giroscopio y del magnetómetro, tal como lo modelan las propiedades de imuSensor System object. Las lecturas del acelerómetro, las lecturas del giroscopio y las lecturas del magnetómetro son relativas al sistema de coordenadas del cuerpo del sensor IMU.

[accelReading,gyroReading,magReading] = IMU(acceleration,angularVelocity);

Traza las lecturas del acelerómetro, las lecturas del giroscopio y las lecturas del magnetómetro.

t = (0:(numSamples-1))/IMU.SampleRate;
subplot(3,1,1)
plot(t,accelReading)
legend('X-axis','Y-axis','Z-axis')
title('Accelerometer Readings')
ylabel('Acceleration (m/s^2)')

subplot(3,1,2)
plot(t,gyroReading)
legend('X-axis','Y-axis','Z-axis')
title('Gyroscope Readings')
ylabel('Angular Velocity (rad/s)')

subplot(3,1,3)
plot(t,magReading)
legend('X-axis','Y-axis','Z-axis')
title('Magnetometer Readings')
xlabel('Time (s)')
ylabel('Magnetic Field (uT)')

La orientación no se especifica y el movimiento ground-truth es estacionario, por lo que el sistema de coordenadas del cuerpo del sensor IMU y el sistema de coordenadas NED local se superponen durante toda la simulación.

• Lecturas del acelerómetro: El eje z del cuerpo del sensor corresponde al eje hacia abajo. La aceleración de 9,8 m/s^2 a lo largo del eje z se debe a la gravedad.

• Lecturas del giroscopio: Las lecturas del giroscopio son cero en cada eje, como se esperaba.

• Lecturas del magnetómetro: Debido a que el sistema de coordenadas del cuerpo del sensor está alineado con el sistema de coordenadas NED local, las lecturas del magnetómetro corresponden a la propiedad MagneticField de imuSensor. La propiedad MagneticField se define en el sistema de coordenadas NED local.

Modelo de datos IMU giratorios de seis ejes

Utilice imuSensor para modelar datos obtenidos de una IMU giratoria que contiene un acelerómetro ideal y un magnetómetro ideal. Utilice kinematicTrajectory para definir el movimiento de ground-truth . Fusiona la salida del modelo imuSensor usando la función ecompass para determinar la orientación a lo largo del tiempo.

Defina el movimiento ground-truth para una plataforma que gira 360 grados en cuatro segundos y luego otros 360 grados en dos segundos. Utilice kinematicTrajectory para generar la orientación, la aceleración y la velocidad angular en el sistema de coordenadas NED.

fs = 100;
firstLoopNumSamples = fs*4;
secondLoopNumSamples = fs*2;
totalNumSamples = firstLoopNumSamples + secondLoopNumSamples;

traj = kinematicTrajectory('SampleRate',fs);

accBody = zeros(totalNumSamples,3);
angVelBody = zeros(totalNumSamples,3);
angVelBody(1:firstLoopNumSamples,3) = (2*pi)/4;
angVelBody(firstLoopNumSamples+1:end,3) = (2*pi)/2;

[~,orientationNED,~,accNED,angVelNED] = traj(accBody,angVelBody);

Crea un objeto imuSensor con un acelerómetro ideal y un magnetómetro ideal. Llame a IMU con la aceleración, la velocidad angular y la orientación de la ground-truth para generar lecturas del acelerómetro y del magnetómetro. Represente los resultados.

IMU = imuSensor('accel-mag','SampleRate',fs);

[accelReadings,magReadings] = IMU(accNED,angVelNED,orientationNED);

figure(1)
t = (0:(totalNumSamples-1))/fs;
subplot(2,1,1)
plot(t,accelReadings)
legend('X-axis','Y-axis','Z-axis')
ylabel('Acceleration (m/s^2)')
title('Accelerometer Readings')

subplot(2,1,2)
plot(t,magReadings)
legend('X-axis','Y-axis','Z-axis')
ylabel('Magnetic Field (\muT)')
xlabel('Time (s)')
title('Magnetometer Readings')

Las lecturas del acelerómetro indican que la plataforma no tiene traducción. Las lecturas del magnetómetro indican que la plataforma está girando alrededor del eje z.

Introduzca las lecturas del acelerómetro y del magnetómetro en la función ecompass para estimar la orientación a lo largo del tiempo. La función ecompass devuelve la orientación en formato de cuaternión. Convierta la orientación a ángulos de Euler y trace los resultados. El gráfico de orientación indica que la plataforma gira únicamente alrededor del eje z.

orientation = ecompass(accelReadings,magReadings);

orientationEuler = eulerd(orientation,'ZYX','frame');

figure(2)
plot(t,orientationEuler)
legend('Z-axis','Y-axis','X-axis')
xlabel('Time (s)')
ylabel('Rotation (degrees)')
title('Orientation')

Modelo de rotación de datos IMU de seis ejes con ruido

Utilice imuSensor para modelar datos obtenidos de una IMU giratoria que contiene un acelerómetro realista y un magnetómetro realista. Utilice kinematicTrajectory para definir el movimiento de ground-truth . Fusiona la salida del modelo imuSensor usando la función ecompass para determinar la orientación a lo largo del tiempo.

Defina el movimiento ground-truth para una plataforma que gira 360 grados en cuatro segundos y luego otros 360 grados en dos segundos. Utilice kinematicTrajectory para generar la orientación, la aceleración y la velocidad angular en el sistema de coordenadas NED.

fs = 100;
firstLoopNumSamples = fs*4;
secondLoopNumSamples = fs*2;
totalNumSamples = firstLoopNumSamples + secondLoopNumSamples;

traj = kinematicTrajectory('SampleRate',fs);

accBody = zeros(totalNumSamples,3);
angVelBody = zeros(totalNumSamples,3);
angVelBody(1:firstLoopNumSamples,3) = (2*pi)/4;
angVelBody(firstLoopNumSamples+1:end,3) = (2*pi)/2;

[~,orientationNED,~,accNED,angVelNED] = traj(accBody,angVelBody);

Crea un objeto imuSensor con un acelerómetro realista y un magnetómetro realista. Llame a IMU con la aceleración, la velocidad angular y la orientación de la ground-truth para generar lecturas del acelerómetro y del magnetómetro. Represente los resultados.

IMU = imuSensor('accel-mag','SampleRate',fs);

IMU.Accelerometer = accelparams( ...
    'MeasurementRange',19.62, ...            % m/s^2
    'Resolution',0.0023936, ...              % m/s^2 / LSB
    'TemperatureScaleFactor',0.008, ...      % % / degree C
    'ConstantBias',0.1962, ...               % m/s^2
    'TemperatureBias',0.0014715, ...         % m/s^2 / degree C
    'NoiseDensity',0.0012361);               % m/s^2 / Hz^(1/2)

IMU.Magnetometer = magparams( ...
    'MeasurementRange',1200, ...             % uT
    'Resolution',0.1, ...                    % uT / LSB
    'TemperatureScaleFactor',0.1, ...        % % / degree C
    'ConstantBias',1, ...                    % uT
    'TemperatureBias',[0.8 0.8 2.4], ...     % uT / degree C
    'NoiseDensity',[0.6 0.6 0.9]/sqrt(100)); % uT / Hz^(1/2)

[accelReadings,magReadings] = IMU(accNED,angVelNED,orientationNED);

figure(1)
t = (0:(totalNumSamples-1))/fs;
subplot(2,1,1)
plot(t,accelReadings)
legend('X-axis','Y-axis','Z-axis')
ylabel('Acceleration (m/s^2)')
title('Accelerometer Readings')

subplot(2,1,2)
plot(t,magReadings)
legend('X-axis','Y-axis','Z-axis')
ylabel('Magnetic Field (\muT)')
xlabel('Time (s)')
title('Magnetometer Readings')

Las lecturas del acelerómetro indican que la plataforma no tiene traducción. Las lecturas del magnetómetro indican que la plataforma está girando alrededor del eje z.

Introduzca las lecturas del acelerómetro y del magnetómetro en la función ecompass para estimar la orientación a lo largo del tiempo. La función ecompass devuelve la orientación en formato de cuaternión. Convierta la orientación a ángulos de Euler y trace los resultados. El gráfico de orientación indica que la plataforma gira únicamente alrededor del eje z.

orientation = ecompass(accelReadings,magReadings);

orientationEuler = eulerd(orientation,'ZYX','frame');

figure(2)
plot(t,orientationEuler)
legend('Z-axis','Y-axis','X-axis')
xlabel('Time (s)')
ylabel('Rotation (degrees)')
title('Orientation')

%

Inclinación del modelo mediante lecturas de giroscopio y acelerómetro

Modele una IMU inclinable que contenga un acelerómetro y un giroscopio utilizando imuSensor System object ™. Utilice modelos ideales y realistas para comparar los resultados del seguimiento de orientación utilizando imufilter System object.

Cargue una estructura que describa el movimiento ground-truth y una frecuencia de muestreo. La estructura de movimiento describe rotaciones secuenciales:

1. guiñada: 120 grados en dos segundos

2. paso: 60 grados en un segundo

3. rollo: 30 grados durante medio segundo

4. balanceo: -30 grados durante medio segundo

5. tono: -60 grados en un segundo

6. guiñada: -120 grados durante dos segundos

En la última etapa, la estructura de movimiento combina la primera, segunda y tercera rotación en una rotación de un solo eje. La aceleración, la velocidad angular y la orientación se definen en el sistema de coordenadas NED local.

load y120p60r30.mat motion fs
accNED = motion.Acceleration;
angVelNED = motion.AngularVelocity;
orientationNED = motion.Orientation;

numSamples = size(motion.Orientation,1);
t = (0:(numSamples-1)).'/fs;

Cree un objeto de sensor IMU ideal y un objeto de filtro IMU predeterminado.

IMU = imuSensor('accel-gyro','SampleRate',fs);

aFilter = imufilter('SampleRate',fs);

En un bucle:

1. Simule la salida de la IMU alimentando el movimiento ground-truth al objeto del sensor de la IMU.

2. Filtre la salida de la IMU utilizando el objeto de filtro de IMU predeterminado.

orientation = zeros(numSamples,1,'quaternion');
for i = 1:numSamples

    [accelBody,gyroBody] = IMU(accNED(i,:),angVelNED(i,:),orientationNED(i,:));

    orientation(i) = aFilter(accelBody,gyroBody);

end
release(aFilter)

Trazar la orientación a lo largo del tiempo.

figure(1)
plot(t,eulerd(orientation,'ZYX','frame'))
xlabel('Time (s)')
ylabel('Rotation (degrees)')
title('Orientation Estimation -- Ideal IMU Data, Default IMU Filter')
legend('Z-axis','Y-axis','X-axis')

Modifique las propiedades de su imuSensor para modelar sensores del mundo real. Ejecute el ciclo nuevamente y trace la estimación de orientación a lo largo del tiempo.

IMU.Accelerometer = accelparams( ...
    'MeasurementRange',19.62, ...
    'Resolution',0.00059875, ...
    'ConstantBias',0.4905, ...
    'AxesMisalignment',2, ...
    'NoiseDensity',0.003924, ...
    'BiasInstability',0, ...
    'TemperatureBias', [0.34335 0.34335 0.5886], ...
    'TemperatureScaleFactor',0.02);
IMU.Gyroscope = gyroparams( ...
    'MeasurementRange',4.3633, ...
    'Resolution',0.00013323, ...
    'AxesMisalignment',2, ...
    'NoiseDensity',8.7266e-05, ...
    'TemperatureBias',0.34907, ...
    'TemperatureScaleFactor',0.02, ...
    'AccelerationBias',0.00017809, ...
    'ConstantBias',[0.3491,0.5,0]);

orientationDefault = zeros(numSamples,1,'quaternion');
for i = 1:numSamples

    [accelBody,gyroBody] = IMU(accNED(i,:),angVelNED(i,:),orientationNED(i,:));

    orientationDefault(i) = aFilter(accelBody,gyroBody);

end
release(aFilter)

figure(2)
plot(t,eulerd(orientationDefault,'ZYX','frame'))
xlabel('Time (s)')
ylabel('Rotation (degrees)')
title('Orientation Estimation -- Realistic IMU Data, Default IMU Filter')
legend('Z-axis','Y-axis','X-axis')

La capacidad del imufilter para rastrear los datos ground-truth se reduce significativamente cuando se modela una IMU realista. Para mejorar el rendimiento, modifique las propiedades de su objeto imufilter. Estos valores se determinaron empíricamente. Ejecute el ciclo nuevamente y trace la estimación de orientación a lo largo del tiempo.

aFilter.GyroscopeNoise          = 7.6154e-7;
aFilter.AccelerometerNoise      = 0.0015398;
aFilter.GyroscopeDriftNoise     = 3.0462e-12;
aFilter.LinearAccelerationNoise = 0.00096236;
aFilter.InitialProcessNoise     = aFilter.InitialProcessNoise*10;

orientationNondefault = zeros(numSamples,1,'quaternion');
for i = 1:numSamples
    [accelBody,gyroBody] = IMU(accNED(i,:),angVelNED(i,:),orientationNED(i,:));

    orientationNondefault(i) = aFilter(accelBody,gyroBody);
end
release(aFilter)

figure(3)
plot(t,eulerd(orientationNondefault,'ZYX','frame'))
xlabel('Time (s)')
ylabel('Rotation (degrees)')
title('Orientation Estimation -- Realistic IMU Data, Nondefault IMU Filter')
legend('Z-axis','Y-axis','X-axis')

Para cuantificar el rendimiento mejorado del imufilter modificado, grafique la distancia del cuaternión entre el movimiento de ground-truth y la orientación devuelta por el imufilter con propiedades predeterminadas y no predeterminadas.

qDistDefault = rad2deg(dist(orientationNED,orientationDefault));
qDistNondefault = rad2deg(dist(orientationNED,orientationNondefault));

figure(4)
plot(t,[qDistDefault,qDistNondefault])
title('Quaternion Distance from True Orientation')
legend('Realistic IMU Data, Default IMU Filter', ...
       'Realistic IMU Data, Nondefault IMU Filter')
xlabel('Time (s)')
ylabel('Quaternion Distance (degrees)')

Algoritmos

Sugerencia

En la siguiente descripción del algoritmo, las variables en fuentes cursivas son entradas o salidas del objeto imuSensor. Las variables en negrita son propiedades de imuSensor. Las variables en fuentes normales son propiedades del objeto accelparams, gyroparams o magparams.

Acelerómetro

La siguiente descripción del algoritmo supone un marco de navegación NED. El modelo del acelerómetro utiliza las entradas de orientación y aceleración de la ground-truth y las propiedades imuSensor y accelparams para modelar las lecturas del acelerómetro.

Obtener aceleración total

Para obtener la aceleración total (totalAcc), la aceleración se preprocesa negando y sumando el vector de constante de gravedad (g= [0; 0; 9.8] m/s² asumiendo un marco NED) como:

$$totalAcc=-acceleration+g$$

El término acceleration se niega para obtener lecturas de aceleración total cero cuando el acelerómetro está en caída libre. El término acceleration también se conoce como fuerza específica.

Convertir a marco de sensor

Luego, la aceleración total se convierte del marco de navegación local al marco del sensor usando:

$$a=\left(orientation\right){\left(totalAcc\right)}^T$$

Si la orientación se ingresa en forma de cuaternión, se convierte en una matriz de rotación antes del procesamiento.

Modelo a granel

La aceleración de la ground-truth en el marco del sensor, a, pasa a través del modelo en masa, lo que agrega desalineación y sesgo de los ejes:

$$b={\left(\left[\begin{array}{ccc}1& \frac{{\alpha }_2}{100}& \frac{{\alpha }_3}{100}\\ \frac{{\alpha }_1}{100}& 1& \frac{{\alpha }_3}{100}\\ \frac{{\alpha }_1}{100}& \frac{{\alpha }_2}{100}& 1\end{array}\right]\left(a^T\right)\right)}^T+\text{ConstantBias}$$

donde ConstantBias es una propiedad de accelparams, y α₁, α₂ y α₃ están dados por el primer, segundo y tercer elemento de la propiedad AxesMisalignment de accelparams.

Deriva de la inestabilidad del sesgo

La deriva de inestabilidad de sesgo β₁ se modela como ruido blanco sesgado y luego filtrado:

$$\begin{array}{l}{g}_1{\beta }_1(k)=-g_2{\beta }_1(k-1)-g_3{\beta }_1(k-2)\dots -g_{n+1}{\beta }_1(k-n)\\ +f_{1}x(k)+f_{2}x(k-1)+\dots +f_{m+1}x(k-m)\\ x(k)=(\text{BiasInstability})w(k)\end{array}$$

donde k es el índice de paso de tiempo discreto, BiasInstability es una propiedad de accelparams, w es ruido blanco que sigue una distribución normal de media 0 y varianza 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate. [g₁, g₂, …, g_n+1] son los coeficientes del denominador especificados en la propiedad BiasInstabilityCoefficients del objeto accelparams. [f₁, f₂, …, f_m+1] son los coeficientes del numerador de la propiedad BiasInstabilityCoefficients. n y m son los órdenes de los coeficientes del denominador y numerador, respectivamente.

Deriva del ruido blanco

La deriva del ruido blanco se modela multiplicando elementos del flujo aleatorio de ruido blanco por la desviación estándar:

$${\beta }_2=\left(w\right)\left(\sqrt{\frac{\text{SampleRate}}{s}}\right)\left(\text{NoiseDensity}\right)$$

donde w es ruido blanco que sigue una distribución normal con media 0 y varianza 1, SampleRate es una propiedad imuSensor y NoiseDensity es una propiedad accelparams. La variable de escala s = 2 si la propiedad NoiseType del objeto accelparams es de doble cara y s = 1 si la propiedad NoiseType es de una sola cara.

Deriva de caminata aleatoria

La deriva del paseo aleatorio se modela polarizando elementos del flujo aleatorio de ruido blanco y luego filtrando:

$${\beta }_3(k)={\beta }_2(k-1)+w(k)\left(\frac{\text{RandomWalk}}{\sqrt{\frac{\text{SampleRate}}{s}}}\right)$$

donde k es el índice de paso de tiempo discreto, RandomWalk es una propiedad de accelparams, SampleRate es una propiedad de imuSensor, w es ruido blanco que sigue una distribución normal de media 0 y varianza 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate. La variable de escala s = 2 si la propiedad NoiseType del objeto accelparams es de doble cara y s = 1 si la propiedad NoiseType es de una sola cara.

Ruido de deriva ambiental

El ruido de deriva ambiental se modela multiplicando la diferencia de temperatura de un estándar con el sesgo de temperatura:

$${\Delta }_e=(\text{Temperature}-25)(\text{TemperatureBias})$$

donde Temperature es una propiedad de imuSensor y TemperatureBias es una propiedad de accelparams. La constante 25 corresponde a una temperatura estándar.

Modelo de error de factor de escala

El error del factor de escala de temperatura se modela como:

$$scaleFactorError=1+\left(\frac{\text{Temperature}-25}{100}\right)(\text{TemperatureScaleFactor})$$

donde Temperature es una propiedad de imuSensor y TemperatureScaleFactor es una propiedad de accelparams. La constante 25 corresponde a una temperatura estándar.

Modelo de cuantificación

La cuantificación se modela saturando primero el modelo de señal continua:

$$e=\{\begin{array}{c}\begin{array}{c}\text{MeasurementRange}\\ -\text{MeasurementRange}\end{array}\\ d\end{array}\begin{array}{c}\\ \\ \end{array}\begin{array}{c}\text{if}\\ \text{if}\\ \text{else}\end{array}\begin{array}{c}\\ \\ \end{array}\begin{array}{c}d>\text{MeasurementRange}\\ -d>\text{MeasurementRange}\\ \end{array}$$

y luego estableciendo la resolución:

$$accelReadings=(\text{Resolution})\left(\mathrm{round}\left(\frac{e}{\text{Resolution}}\right)\right)$$

donde MeasurementRange es una propiedad de accelparams.

Giroscopio

La siguiente descripción del algoritmo supone un marco de navegación NED. El modelo de giroscopio utiliza las entradas de orientación, aceleración y velocidad angular de la ground-truth , y las propiedades imuSensor y gyroparams para modelar las lecturas del acelerómetro.

Convertir a marco de sensor

La velocidad angular ground-truth se convierte del marco local al marco del sensor utilizando la orientación ground-truth:

$$a=\left(orientation\right){\left(angularVelocity\right)}^T$$

Si la orientación se ingresa en forma de cuaternión, se convierte en una matriz de rotación antes del procesamiento.

Modelo a granel

La velocidad angular de ground-truth en el marco del sensor, a, pasa a través del modelo en masa, lo que agrega desalineación y sesgo a los ejes:

$$b={\left(\left[\begin{array}{ccc}1& \frac{{\alpha }_2}{100}& \frac{{\alpha }_3}{100}\\ \frac{{\alpha }_1}{100}& 1& \frac{{\alpha }_3}{100}\\ \frac{{\alpha }_1}{100}& \frac{{\alpha }_2}{100}& 1\end{array}\right]\left(a^T\right)\right)}^T+\text{ConstantBias}$$

donde ConstantBias es una propiedad de gyroparams, y α₁, α₂ y α₃ están dados por el primer, segundo y tercer elemento de la propiedad AxesMisalignment de gyroparams.

Deriva de la inestabilidad del sesgo

La deriva de inestabilidad de sesgo β₁ se modela como ruido blanco sesgado y luego filtrado:

$$\begin{array}{l}{g}_1{\beta }_1(k)=-g_2{\beta }_1(k-1)-g_3{\beta }_1(k-2)\dots -g_{n+1}{\beta }_1(k-n)\\ +f_{1}x(k)+f_{2}x(k-1)+\dots +f_{m+1}x(k-m)\\ x(k)=(\text{BiasInstability})w(k)\end{array}$$

donde k es el índice de paso de tiempo discreto, BiasInstability es una propiedad de gyroparams, w es ruido blanco que sigue una distribución normal de media 0 y varianza 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate. [g₁, g₂, …, g_n+1] son los coeficientes del denominador especificados en la propiedad BiasInstabilityCoefficients del objeto gyroparams. [f₁, f₂, …, f_m+1] son los coeficientes del numerador de la propiedad BiasInstabilityCoefficients. n y m son los órdenes de los coeficientes del denominador y numerador, respectivamente.

Deriva del ruido blanco

La deriva del ruido blanco se modela multiplicando elementos del flujo aleatorio de ruido blanco por la desviación estándar:

$${\beta }_2=\left(w\right)\left(\sqrt{\frac{\text{SampleRate}}{s}}\right)\left(\text{NoiseDensity}\right)$$

donde w es ruido blanco que sigue una distribución normal con media 0 y varianza 1, SampleRate es una propiedad imuSensor y NoiseDensity es una propiedad gyroparams. La variable de escala s = 2 si la propiedad NoiseType del objeto gyroparams es de doble cara y s = 1 si la propiedad NoiseType es de una sola cara.

Deriva de caminata aleatoria

La deriva del paseo aleatorio se modela polarizando elementos del flujo aleatorio de ruido blanco y luego filtrando:

$${\beta }_3(k)={\beta }_2(k-1)+w(k)\left(\frac{\text{RandomWalk}}{\sqrt{\frac{\text{SampleRate}}{s}}}\right)$$

donde k es el índice de paso de tiempo discreto, RandomWalk es una propiedad de gyroparams, SampleRate es una propiedad de imuSensor y w es ruido blanco que sigue una distribución normal de media 0 y varianza 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate. La variable de escala s = 2 si la propiedad NoiseType del objeto gyroparams es de doble cara y s = 1 si la propiedad NoiseType es de una sola cara.

Ruido de deriva ambiental

El ruido de deriva ambiental se modela multiplicando la diferencia de temperatura de un estándar con el sesgo de temperatura:

$${\Delta }_e=(\text{Temperature}-25)(\text{TemperatureBias})$$

donde Temperature es una propiedad de imuSensor y TemperatureBias es una propiedad de gyroparams. La constante 25 corresponde a una temperatura estándar.

Deriva del sesgo de aceleración

La deriva del sesgo de aceleración se modela multiplicando la entrada de aceleración y el sesgo de aceleración:

$${\Delta }_a=acceleration*\text{AccelerationBias}$$

donde AccelerationBias es una propiedad de gyroparams.

Modelo de error de factor de escala

El error del factor de escala de temperatura se modela como:

$$scaleFactorError=1+\left(\frac{\text{Temperature}-25}{100}\right)(\text{TemperatureScaleFactor})$$

donde Temperature es una propiedad de imuSensor y TemperatureScaleFactor es una propiedad de gyroparams. La constante 25 corresponde a una temperatura estándar.

Modelo de cuantificación

La cuantificación se modela saturando primero el modelo de señal continua:

$$e=\{\begin{array}{c}\begin{array}{c}\text{MeasurementRange}\\ -\text{MeasurementRange}\end{array}\\ d\end{array}\begin{array}{c}\\ \\ \end{array}\begin{array}{c}\text{if}\\ \text{if}\\ \text{else}\end{array}\begin{array}{c}\\ \\ \end{array}\begin{array}{c}d>\text{MeasurementRange}\\ -d>\text{MeasurementRange}\\ \end{array}$$

y luego estableciendo la resolución:

$$gyroReadings=(\text{Resolution})\left(\mathrm{round}\left(\frac{e}{\text{Resolution}}\right)\right)$$

donde MeasurementRange es una propiedad de gyroparams.

Magnetómetro

La siguiente descripción del algoritmo supone un marco de navegación NED. El modelo del magnetómetro utiliza las entradas de orientación y aceleración de la ground-truth y las propiedades imuSensor y magparamsmagparams (Sensor Fusion and Tracking Toolbox) para modelar las lecturas del magnetómetro.

Convertir a marco de sensor

La aceleración ground-truth se convierte del marco local al marco del sensor utilizando la orientación ground-truth:

$$a=\left(orientation\right){\left(totalAcc\right)}^T$$

Si la orientación se ingresa en forma de cuaternión, se convierte en una matriz de rotación antes del procesamiento.

Modelo a granel

La aceleración de la ground-truth en el marco del sensor, a, pasa a través del modelo en masa, lo que agrega desalineación y sesgo de los ejes:

$$b={\left(\left[\begin{array}{ccc}1& \frac{{\alpha }_2}{100}& \frac{{\alpha }_3}{100}\\ \frac{{\alpha }_1}{100}& 1& \frac{{\alpha }_3}{100}\\ \frac{{\alpha }_1}{100}& \frac{{\alpha }_2}{100}& 1\end{array}\right]\left(a^T\right)\right)}^T+\text{ConstantBias}$$

donde ConstantBias es una propiedad de magparams, y α₁, α₂ y α₃ están dados por el primer, segundo y tercer elemento de la propiedad AxesMisalignment de magparams.

Deriva de la inestabilidad del sesgo

La deriva de inestabilidad de sesgo β₁ modelada como ruido blanco sesgado y luego filtrado:

$$\begin{array}{l}{g}_1{\beta }_1(k)=-g_2{\beta }_1(k-1)-g_3{\beta }_1(k-2)\dots -g_{n+1}{\beta }_1(k-n)\\ +f_{1}x(k)+f_{2}x(k-1)+\dots +f_{m+1}x(k-m)\\ x(k)=(\text{BiasInstability})w(k)\end{array}$$

donde k es el índice de paso de tiempo discreto, BiasInstability es una propiedad de magparams, w es ruido blanco que sigue una distribución normal de media 0 y varianza 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate. [g₁, g₂, …, g_n+1] son los coeficientes del denominador especificados en la propiedad BiasInstabilityCoefficients del objeto magparams. [f₁, f₂, …, f_m+1] son los coeficientes del numerador de la propiedad BiasInstabilityCoefficients. n y m son los órdenes de los coeficientes del denominador y numerador, respectivamente.

Deriva del ruido blanco

La deriva del ruido blanco se modela multiplicando elementos del flujo aleatorio de ruido blanco por la desviación estándar:

$${\beta }_2=\left(w\right)\left(\sqrt{\frac{\text{SampleRate}}{s}}\right)\left(\text{NoiseDensity}\right)$$

donde w es ruido blanco que sigue una distribución normal con media 0 y varianza 1, SampleRate es una propiedad imuSensor y NoiseDensity es una propiedad magparams. La variable de escala s = 2 si la propiedad NoiseType del objeto magparams es de doble cara y s = 1 si la propiedad NoiseType es de una sola cara.

Deriva de caminata aleatoria

La deriva del paseo aleatorio se modela polarizando elementos del flujo aleatorio de ruido blanco y luego filtrando:

$${\beta }_3(k)={\beta }_2(k-1)+w(k)\left(\frac{\text{RandomWalk}}{\sqrt{\frac{\text{SampleRate}}{s}}}\right)$$

donde k es el índice de paso de tiempo discreto, RandomWalk es una propiedad de magparams, SampleRate es una propiedad de imuSensor, w es ruido blanco que sigue una distribución normal de media 0 y varianza 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate. La variable de escala s = 2 si la propiedad NoiseType del objeto magparams es de doble cara y s = 1 si la propiedad NoiseType es de una sola cara.

Ruido de deriva ambiental

El ruido de deriva ambiental se modela multiplicando la diferencia de temperatura de un estándar con el sesgo de temperatura:

$${\Delta }_e=(\text{Temperature}-25)(\text{TemperatureBias})$$

donde Temperature es una propiedad de imuSensor y TemperatureBias es una propiedad de magparams. La constante 25 corresponde a una temperatura estándar.

Modelo de error de factor de escala

El error del factor de escala de temperatura se modela como:

$$scaleFactorError=1+\left(\frac{\text{Temperature}-25}{100}\right)(\text{TemperatureScaleFactor})$$

donde Temperature es una propiedad de imuSensor y TemperatureScaleFactor es una propiedad de magparams. La constante 25 corresponde a una temperatura estándar.

Modelo de cuantificación

La cuantificación se modela saturando primero el modelo de señal continua:

$$e=\{\begin{array}{c}\begin{array}{c}\text{MeasurementRange}\\ -\text{MeasurementRange}\end{array}\\ d\end{array}\begin{array}{c}\\ \\ \end{array}\begin{array}{c}\text{if}\\ \text{if}\\ \text{else}\end{array}\begin{array}{c}\\ \\ \end{array}\begin{array}{c}d>\text{MeasurementRange}\\ -d>\text{MeasurementRange}\\ \end{array}$$

y luego estableciendo la resolución:

$$magReadings=(\text{Resolution})\left(\mathrm{round}\left(\frac{e}{\text{Resolution}}\right)\right)$$

donde MeasurementRange es una propiedad de magparams.

Capacidades ampliadas

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Las funciones de objeto, perturbations y perturb, no admiten la generación de código.

Indicaciones y limitaciones de uso:

Consulte System Objects in MATLAB Code Generation (MATLAB Coder).

Historial de versiones

Introducido en R2019b

R2023b: Especifique los coeficientes de ruido de inestabilidad de sesgo y el tipo de ruido para el acelerómetro, el giroscopio y el magnetómetro

Puede utilizar la nueva propiedad BiasInstabilityCoefficients de los objetos accelparams, gyroparams y magparams para especificar los coeficientes de la función de transferencia utilizada para generar el ruido de inestabilidad de polarización. Además, puede utilizar la nueva propiedad NoiseType de estos objetos para establecer el factor de escala de los coeficientes de ruido como 1 o 2.

Consulte también

Clases

• accelparams | gyroparams | magparams

Objetos

• gpsSensor