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
Descripción
crea un objeto config = tunerconfig(filterName)tunerconfig que controla el algoritmo de optimización de la función de ajuste del filtro de fusión especificando un nombre de filtro.
crea un objeto config = tunerconfig(filter)tunerconfig que controla el algoritmo de optimización de la función de ajuste del filtro de fusión especificando un objeto de filtro.
configura las propiedades del objeto config = tunerconfig(filterName,Name,Value)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
Nombre del filtro Fusion, especificado como una de estas opciones:
'imufilter''ahrsfilter''ahrs10filter''insfilterAsync''insfilterMARG''insfitlerErrorState''insfilterNonholonomic'
Filtro de fusión, especificado como uno de estos objetos de filtro de fusión:
.
Propiedades
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"
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:
y podrás obtener:>> filter = insEKF; config = tunerconfig(filter); tunable = config.TunableParameters
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"]
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.
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.
Número máximo de iteraciones permitidas por el algoritmo de ajuste, especificado como un entero positivo.
Coste al que detener el proceso de ajuste, especificado como un escalar positivo.
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.
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.
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 propiedadCustomCostFcn.
Función de coste personalizada, especificada como identificador de función.
Dependencias
Para habilitar esta propiedad, establezca la propiedad Cost en 'Custom'.
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
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"
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)');

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

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.paramsans = 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
MATLAB Command
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.
Seleccione un país/idioma
Seleccione un país/idioma para obtener contenido traducido, si está disponible, y ver eventos y ofertas de productos y servicios locales. Según su ubicación geográfica, recomendamos que seleccione: .
También puede seleccionar uno de estos países/idiomas:
Cómo obtener el mejor rendimiento
Seleccione China (en idioma chino o inglés) para obtener el mejor rendimiento. Los sitios web de otros países no están optimizados para ser accedidos desde su ubicación geográfica.
América
- América Latina (Español)
- Canada (English)
- United States (English)
Europa
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)