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 medida inercial (IMU). Puede especificar el marco de referencia de las entradas del bloque como el NED (Noreste-Abajo) o ENU (Este-Norte-Arriba) usando el marco ReferenceFrame argumento.

Para modelar una IMU:

1. Cree el objeto imuSensor y establezca sus propiedades.

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

Para obtener más información sobre cómo funcionan los System objects, consulte What Are 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. Especifique RF como 'NED' (Noreste-Abajo) o 'ENU' (Este-Norte-Arriba). El valor predeterminado es 'NED'.

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².

IMU = imuSensor(___,Name,Value) establece cada propiedad Name en el Value especificado. Las propiedades no especificadas tienen valores predeterminados. Esta sintaxis se puede utilizar en combinación con cualquiera de los argumentos de entrada anteriores.

Propiedades

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

Si una propiedad es ajustable, puedes cambiar su valor en cualquier momento.

Para obtener más información sobre cómo cambiar los valores de las propiedades, consulte System Design in MATLAB Using 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 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 (^o C)

25 (predeterminado) | escalar real

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

Cuando el objeto calcula los factores de escala de temperatura y los ruidos de deriva ambiental, se utiliza 25 ^o C 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) | escalar real

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

accelparams objeto (predeterminado)

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

Ajustable: Yes

Gyroscope — Parámetros del sensor de giroscopio

gyroparams objeto (predeterminado)

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

Ajustable: Yes

Magnetometer — Parámetros del sensor magnetómetro

magparams objeto (predeterminado)

Parámetros del sensor del 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 de acelerómetro y giroscopio a partir de las entradas de aceleración y velocidad angular.

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

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

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

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

Esta sintaxis solo es válida si IMUType está establecido en 'accel-mag'.

[accelReadings,magReadings] = IMU(acc,angVel,orientation) genera lecturas de 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 está establecido en 'accel-mag'.

[accelReadings,gyroReadings,magReadings] = IMU(acc,angVel) genera lecturas de 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 de 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 IMU en el sistema de coordenadas de navegación local (m/s²)

N-por-3 matriz

Aceleración de la IMU en el sistema de coordenadas de navegación local, especificada como un arreglo real finito N-por-3 en arreglo 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, use 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)

N-por-3 matriz

Velocidad angular de la IMU en el sistema de coordenadas de navegación local, especificada como un arreglo real finito N por 3 en arreglo 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, use el argumento de entrada orientation .

Tipos de datos: single | double

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

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

Orientación de la IMU con respecto al sistema de coordenadas de navegación local, especificada como un vector columna de elemento quaternion N o un de 3 por 3 por N matriz de rotación. Cada quaternion o matriz de rotación representa una rotación de cuadro desde el sistema de coordenadas de navegación local hasta el 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 IMU en el sistema de coordenadas del cuerpo del sensor (m/s²)

N-por-3 matriz

Medición del acelerómetro de la IMU en el sistema de coordenadas del cuerpo del sensor, especificada como un arreglo real finito a N-por-3 en arreglo 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)

N-por-3 matriz

Medición giroscópica de la IMU en el sistema de coordenadas del cuerpo del sensor, especificada como un arreglo real finito N-por-3 en arreglo 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)

N-por-3 matriz (predeterminado)

Medición magnetométrica de la IMU en el sistema de coordenadas del cuerpo del sensor, especificada como un arreglo real finito 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 utilizar una función de objeto, especifique System object como primer argumento de entrada. Por ejemplo, para liberar recursos del sistema de un System object llamado obj, use esta sintaxis:

release(obj)

Específico para 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

El 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.

Cree un objeto imuSensor predeterminado.

IMU = imuSensor

IMU = 
  imuSensor with properties:

          IMUType: 'accel-gyro'
       SampleRate: 100
      Temperature: 25
    Accelerometer: [1x1 accelparams]
        Gyroscope: [1x1 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 hardware específico y luego establezca la propiedad IMU Accelerometer en el objeto accelparams . Muestre 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 el imuSensor System object™ para modelar la recepción de datos de una IMU estacionaria ideal que contiene un acelerómetro, giroscopio y 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: [1x1 accelparams]
        Gyroscope: [1x1 gyroparams]
     Magnetometer: [1x1 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 reales. El objeto genera lecturas de acelerómetro, lecturas de giroscopio y lecturas de magnetómetro, según el modelo de las propiedades del System object imuSensor . 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 descendente. 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 está definida en el sistema de coordenadas NED local.

Modelo de datos IMU giratorios de seis ejes

Utilice imuSensor para modelar los 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. Fusione 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, aceleración y 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);

Cree 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 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 gira alrededor del eje z.

Introduzca las lecturas del acelerómetro y el 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 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 sólo 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 los datos obtenidos de una IMU giratoria que contiene un acelerómetro y un magnetómetro realistas. Utilice kinematicTrajectory para definir el movimiento de ground-truth. Fusione 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, aceleración y 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 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 gira alrededor del eje z.

Introduzca las lecturas del acelerómetro y el 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 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 sólo 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 usando el imuSensor System object™. Utilice modelos ideales y realistas para comparar los resultados del seguimiento de orientación utilizando el System object imufilter .

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 reales se reduce significativamente al modelar 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, trace 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 cursiva 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 aceleración y orientación de 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 constante de gravedad (g= [0; 0; 9.8] m/sTG suponiendo 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 posición libre. caer. 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 ground-truth en el marco del sensor, a, pasa a través del modelo masivo, 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 α 1, α 2 y α 3 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 β 1 se modela como ruido blanco sesgado y luego se filtra:

$$\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 de 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate . [g 1 , g 2 , …, g n+1 ] son ​​los coeficientes del denominador especificado en la propiedad BiasInstabilityCoefficients del objeto accelparams . [g 1 , g 2 , …, g 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 el ruido blanco que sigue una distribución normal de media 0 y varianza de 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 unilateral.

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 de 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 unilateral.

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 cuantizació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 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 real en el marco del sensor, a, pasa a través del modelo masivo, 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 gyroparams y α 1, α 2 y α 3 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 β 1 se modela como ruido blanco sesgado y luego se filtra:

$$\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 de 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate . [g 1 , g 2 , …, g n+1 ] son ​​los coeficientes del denominador especificado en la propiedad BiasInstabilityCoefficients del objeto gyroparams . [g 1 , g 2 , …, g 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 el ruido blanco que sigue una distribución normal de media 0 y varianza de 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 unilateral.

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 de 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 unilateral.

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 cuantizació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 aceleración y orientación de ground-truth, y las propiedades imuSensor y magparams 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 ground-truth en el marco del sensor, a, pasa a través del modelo masivo, 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 α 1, α 2 y α 3 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 β 1 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 de 1. El tamaño del paso de tiempo discreto es el recíproco de la propiedad SampleRate . [g 1 , g 2 , …, g n+1 ] son ​​los coeficientes del denominador especificado en la propiedad BiasInstabilityCoefficients del objeto magparams . [g 1 , g 2 , …, g 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 el ruido blanco que sigue una distribución normal de media 0 y varianza de 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 unilateral.

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 de 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 unilateral.

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 cuantizació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.

Notas y limitaciones de uso:

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

Historial de versiones

Introducido en R2019b

Consulte también

Clases

• accelparams | gyroparams | magparams

Objetos

• gpsSensor