comment calculer exacte pied de l'étape de comptage à l'aide de l'accéléromètre dans android?

La première chose que vous devez faire est de décider sur un algorithme. Pour autant que je sais qu'il y a grosso modo trois façons pour détecter les étapes à l'aide d'accéléromètres qui sont décrits dans la littérature:

1. Utiliser le théorème de Pythagore pour calculer la magnitude du vecteur d'accélération de chaque échantillon à partir de l'accéléromètre. Filtre passe-bas de l'amplitude du signal pour supprimer le bruit à haute fréquence, et ensuite chercher des pics et des vallées dans le signal filtré. Vous pouvez avoir besoin d'ajouter des exigences supplémentaires pour éliminer les faux positifs. C'est de loin le moyen le plus simple pour détecter les étapes, c'est aussi de cette manière que la plupart, si pas tous les ordinaires podomètres de la sorte que vous pouvez les acheter à partir d'un magasin de sport à travailler.

2. Utilisation de Pythagore, comme dans (1), puis de lancer le signal par une FFT et de comparer la sortie de la FFT connu des sorties de marche. Cela vous oblige à avoir accès à une assez grande quantité de données d'apprentissage.

3. Nourrir les données de l'accéléromètre dans un algorithme qui utilise une machine adaptée à l'apprentissage de la technique, par exemple un réseau de neurones ou un numérique de la transformée en ondelettes. Bien sûr, vous pouvez inclure d'autres capteurs dans cette approche. Cela implique également d'avoir accès à une assez grande quantité de données d'apprentissage.

Une fois que vous avez décidé sur un algorithme, vous aurez probablement besoin d'utiliser quelque chose comme Matlab ou SciPy pour tester votre algorithme sur votre ordinateur à l'aide d'enregistrements que vous avez faits sur les téléphones Android. Dump l'accéléromètre de données à un fichier cvs sur votre téléphone, faire une trace du nombre de mesures représente le fichier, copier le fichier sur votre ordinateur et exécuter l'algorithme sur les données pour voir si il obtient le nombre de pas à droite. De cette façon, vous pouvez détecter des problèmes avec l'algorithme et de les corriger.

Si cela vous semble difficile, alors la meilleure façon d'obtenir l'accès à une bonne étape de détection est probablement attendre jusqu'à ce que plus de téléphones sont livrés avec le haut-compteur de pas que KitKat permet.

Je suis l'aide de l'étape de détection dans ma marche de l'instrument.
Je obtenir de bons résultats de l'étape de détection.
J'utilise achartengine pour tracer les données de l'accéléromètre.
Jetez un oeil ici.
Ce que je fais:

1. Analyse de ampleur vecteur pour la sonde d'accéléromètre.
2. Définition d'un variable seuil niveau. Quand le signal de l'accéléromètre est au-dessus d'elle, j'ai compté comme une étape.
3. Réglage de l'heure de l'état inactif (pour l'étape de détection) après première franchissement du seuil.

Point 3. est calculé:

• arbitraire réglage de la maximum tempo de notre marche (par exemple 120bpm)
• si 60bpm - 1000msec par étape, puis 120bpm - 500msec par étape
• accéléromètre transmet les données avec une certaine fréquence souhaitée (SENSOR_DELAY_NORMAL, SENSOR_DELAY_GAME, etc.). Lorsque DELAY_GAME: T ~= 20ms (il est inclus dans Android documentation)
• n - échantillons d'omettre (après le passage du seuil)
• n = 500msec /T
• n = 500 /20 = 25 (beaucoup d'entre eux. Vous pouvez ajuster cette valeur).
• après, le seuil devient actif.

Prendre un coup d'oeil à cette image:

C'est ma réalisation. Il a été écrit environ 1,5-2 ans. Et je ne me souviens pas de tout ce que j'ai écrit. Mais il a travaillé. Et ça fonctionnait bien pour mes besoins.

Je sais que c'est une très grande classe (certaines méthodes sont supprimés), mais peut-être que ce sera utile. Si non, je vais juste supprimer cette réponse...

public class StepDetector implements SensorEventListener
{
public static final int MAX_BUFFER_SIZE = 5;
private static final int Y_DATA_COUNT = 4;
private static final double MIN_GRAVITY = 2;
private static final double MAX_GRAVITY = 1200;
public void onSensorChanged(final SensorEvent sensorEvent)
{
final float[] values = sensorEvent.values;
final Sensor sensor = sensorEvent.sensor;
if (sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
{
magneticDetector(values, sensorEvent.timestamp / (500 * 10 ^ 6l));
}
if (sensor.getType() == Sensor.TYPE_ACCELEROMETER)
{
accelDetector(values, sensorEvent.timestamp / (500 * 10 ^ 6l));
}
}
private ArrayList<float[]> mAccelDataBuffer = new ArrayList<float[]>();
private ArrayList<Long> mMagneticFireData = new ArrayList<Long>();
private Long mLastStepTime = null;
private ArrayList<Pair> mAccelFireData = new ArrayList<Pair>();
private void accelDetector(float[] detectedValues, long timeStamp)
{
float[] currentValues = new float[3];
for (int i = 0; i < currentValues.length; ++i)
{
currentValues[i] = detectedValues[i];
}
mAccelDataBuffer.add(currentValues);
if (mAccelDataBuffer.size() > StepDetector.MAX_BUFFER_SIZE)
{
double avgGravity = 0;
for (float[] values : mAccelDataBuffer)
{
avgGravity += Math.abs(Math.sqrt(
values[0] * values[0] + values[1] * values[1] + values[2] * values[2]) -    SensorManager.STANDARD_GRAVITY);
}
avgGravity /= mAccelDataBuffer.size();
if (avgGravity >= MIN_GRAVITY && avgGravity < MAX_GRAVITY)
{
mAccelFireData.add(new Pair(timeStamp, true));
}
else
{
mAccelFireData.add(new Pair(timeStamp, false));
}
if (mAccelFireData.size() >= Y_DATA_COUNT)
{
checkData(mAccelFireData, timeStamp);
mAccelFireData.remove(0);
}
mAccelDataBuffer.clear();
}
}
private void checkData(ArrayList<Pair> accelFireData, long timeStamp)
{
boolean stepAlreadyDetected = false;
Iterator<Pair> iterator = accelFireData.iterator();
while (iterator.hasNext() && !stepAlreadyDetected)
{
stepAlreadyDetected = iterator.next().first.equals(mLastStepTime);
}
if (!stepAlreadyDetected)
{
int firstPosition = Collections.binarySearch(mMagneticFireData, accelFireData.get(0).first);
int secondPosition = Collections
.binarySearch(mMagneticFireData, accelFireData.get(accelFireData.size() - 1).first - 1);
if (firstPosition > 0 || secondPosition > 0 || firstPosition != secondPosition)
{
if (firstPosition < 0)
{
firstPosition = -firstPosition - 1;
}
if (firstPosition < mMagneticFireData.size() && firstPosition > 0)
{
mMagneticFireData = new ArrayList<Long>(
mMagneticFireData.subList(firstPosition - 1, mMagneticFireData.size()));
}
iterator = accelFireData.iterator();
while (iterator.hasNext())
{
if (iterator.next().second)
{
mLastStepTime = timeStamp;
accelFireData.remove(accelFireData.size() - 1);
accelFireData.add(new Pair(timeStamp, false));
onStep();
break;
}
}
}
}
}
private float mLastDirections;
private float mLastValues;
private float mLastExtremes[] = new float[2];
private Integer mLastType;
private ArrayList<Float> mMagneticDataBuffer = new ArrayList<Float>();
private void magneticDetector(float[] values, long timeStamp)
{
mMagneticDataBuffer.add(values[2]);
if (mMagneticDataBuffer.size() > StepDetector.MAX_BUFFER_SIZE)
{
float avg = 0;
for (int i = 0; i < mMagneticDataBuffer.size(); ++i)
{
avg += mMagneticDataBuffer.get(i);
}
avg /= mMagneticDataBuffer.size();
float direction = (avg > mLastValues ? 1 : (avg < mLastValues ? -1 : 0));
if (direction == -mLastDirections)
{
//Direction changed
int extType = (direction > 0 ? 0 : 1); //minumum or maximum?
mLastExtremes[extType] = mLastValues;
float diff = Math.abs(mLastExtremes[extType] - mLastExtremes[1 - extType]);
if (diff > 8 && (null == mLastType || mLastType != extType))
{
mLastType = extType;
mMagneticFireData.add(timeStamp);
}
}
mLastDirections = direction;
mLastValues = avg;
mMagneticDataBuffer.clear();
}
}
public static class Pair implements Serializable
{
Long first;
boolean second;
public Pair(long first, boolean second)
{
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o)
{
if (o instanceof Pair)
{
return first.equals(((Pair) o).first);
}
return false;
}
}
}