Une semelle intérieure intelligente pour vérifier votre distribution de pression

Outils et machines nécessaires

Fer à souder (générique) N'oubliez pas d'acheter de la soudure, du thermorétractable et d'autres accessoires applicables si vous ne les avez pas

Applications et services en ligne

	Plateforme Thinger.io
	Arduino IDE

À propos de ce projet

La mesure de la pression est déjà utilisée dans diverses situations. Il fournit des informations sur la mécanique de la marche et a un large éventail d'applications, c'est-à-dire dans des situations cliniques et dans le sport. Dans ce projet, les capteurs sont utilisés pour mieux comprendre la répartition du poids. La visualisation en temps réel de la cartographie de la pression est également intégrée car elle facilite grandement la compréhension de vos données.

Matériel requis

• Arduino MKR1000 - La plupart des cartes 3,3 V ou 5 V avec Wi-Fi feront l'affaire, mais je n'encouragerais pas l'utilisation d'un ESP pour cela. Pour une raison quelconque, plusieurs cartes ESP ont renvoyé des mesures inexactes lors de la création de ce projet.
• Résistances sensibles à la force (3). J'ai utilisé l'Interlink 402 (100 N). J'ai également utilisé un Interlink 406 plus cher, mais avec le recul, le 402 aurait également fonctionné. Utilisez plus de FSR pour une meilleure précision.
• Résistances 10K. Changez la résistance pour mettre vos lectures à l'échelle afin qu'elles soient dans la plage que vous souhaitez. Plus les résistances sont élevées, plus les incréments sont grands. Trouvez plus d'informations à ce sujet ici.
• Accéléromètre, j'ai utilisé le 16G ADXL345. Utilisez-le pour mesurer l'accélération et le mouvement du pied.
• Un fer à souder pour tout assembler. Les pinces crocodiles ne fonctionnent pas bien dans une chaussure pour des raisons évidentes.

Câblage des choses

Quelques notes rapides sur le circuit :

FSR : Lire ceci avant vous commencer soudure : soyez extrêmement prudent lorsque vous soudez les fils aux FSR. N'essayez pas de le faire si vous n'êtes pas sûr d'avoir les compétences nécessaires. Vous devez le souder très rapidement ou le plastique fond. Croyez-moi, je l'ai découvert à la dure...

Il n'y a pas de côté positif ou négatif sur un FSR, vous n'avez donc pas à vous en soucier.

Comme je l'ai mentionné plus tôt, vous pouvez modifier les résistances pour mettre vos lectures à l'échelle afin qu'elles soient dans la plage que vous préférez.

Masse/5V : Comme vous pouvez le voir, tous les capteurs sont soudés à la ligne 5V et au commun.

Accéléromètre : Vous pouvez laisser l'accéléromètre de côté si vous n'en avez pas besoin pour votre projet. Il n'est pas nécessaire de l'utiliser si vous voulez juste mesurer la pression, mais cela peut s'avérer utile si vous aimez mesurer l'accélération ou si vous devez analyser le cycle de marche. Ce n'est cependant pas strictement nécessaire pour ce tutoriel.

Fixation du matériel à la semelle intérieure

Je recommande de le faire après avoir exécuté le code en premier, car si vous avez commis des erreurs de soudure, vous le découvrirez à ce stade. Cela peut vous éviter des tracas pour attacher et rattacher le matériel à la semelle intérieure au cas où vous auriez besoin de ressouder quoi que ce soit.

Les FSR sont attachés à trois points de la semelle intérieure. Le FSR supérieur gauche mesure l'éversion, le FSR supérieur droit mesure l'inversion et le FSR au talon mesure la pression du talon. Trouver le bon endroit pour vos FSR est une question d'essayer. La meilleure position pour les attacher est l'endroit où la valeur analogique change le plus en marchant.

Du ruban adhésif est utilisé pour maintenir les fils en place. S'ils bougent, cela peut provoquer des interférences avec les lectures FSR. J'ai également utilisé du velcro au bas de la semelle et à l'intérieur de la chaussure afin de maintenir la semelle intérieure en place.

Fixez l'accéléromètre à l'arrière du talon de la chaussure si vous en utilisez un. J'ai utilisé du ruban adhésif double face pour cela.

Mesurer les forces

Maintenant, nous sommes tous prêts à mesurer les forces. Remarque :dans les deux sections suivantes, je suppose que je suis familiarisé avec la bibliothèque Thinger.io. Pour plus d'informations à ce sujet, je me réfère à la section intitulée "envoyer les données via Thinger.io".

Le programme a une partie d'en-tête assez longue, y compris les variables nécessaires à la configuration, comme les données de connexion WiFi. Cette partie comprend également les variables globales, principalement des tableaux, utilisées dans le programme. Un choix important que j'ai fait était d'utiliser des tableaux autant que possible. L'idée est d'utiliser des éléments de réseau individuels pour chaque capteur FSR. Donc dans ce cas les tableaux ont une longueur de 3.

Ne prenez pas l'habitude d'utiliser trop de variables globales, à cause des effets secondaires indésirables. Nous les avons utilisés car dans plusieurs cas, ils sont nécessaires pour envoyer les données via Thinger.io.

Le code est expliqué dans les commentaires. Nous allons parcourir le code étape par étape. Vous pouvez télécharger le code complet ci-dessous.

#define _DEBUG_ //nous permet d'utiliser le Serial Monitor
#include 
#include 
#include  //Accéléromètre
#include  //Accéléromètre
#include  //Accéléromètre
#include 
#define USERNAME "yourUsername"
#define DEVICE_ID "yourDeviceID"
#define DEVICE_CREDENTIAL "yourDeviceCredential"
#define SSID "yourSSID"
#define SSID_PASSWORD "yourSSIDPassword"
//* Capteurs FSR*/
#define noFSRs 3 // Nombre de FSR connectés
#define FSR1 A1 
#define FSR2 A2 
#define FSR3 A3 
float fsrVoltageArray[3 ] ; // La lecture analogique convertie et mise à l'échelle en tension sous forme de nombre à virgule flottante
float fsrForceArray[3]; // La force en Newton
float fsrWeightInGramsArray[3]; // Poids converti en grammes
int pinArray[3] ={FSR1, FSR2, FSR3}; // L'ID de broche pour les trois appareils
float forceMaxArray[3] ={100.0, 100.0, 100.0} ; // Forces maximales supportées
float million =1000000.0 ; // Unité pour "1/micro
conversion floatToKgrams =1.0/9.80665;
long K =1000;
long R =10*K; // R en K Ohm
long Vcc =5000 ; // 5V=5000mV, 3.3V =3300 mV
Tension flottanteMax =0.98 * Vcc ; // Tension maximale réglée à 95 % de Vcc. Réglez la force au maximum au-delà de cette valeur.
ThingerWifi101 chose (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); 

Ne paniquez pas si vous ne comprenez pas encore tout. Cela aura plus de sens, une fois que vous aurez vu le reste du code.

Nous voulons visualiser les résultats. Pour cela, nous utilisons la bibliothèque Wi-Fi Thinger.io. Cette connexion est établie via la ligne suivante :

ThingerWifi101 chose (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); 

Les arguments d'entrée sont obtenus via votre compte sur Thinger.io, vous devez donc d'abord les configurer.

Dans la fonction setup(), la connexion série est établie en premier. Ceci est suivi d'un appel pour créer la connexion WiFi.

void setup(void) {
 Serial.begin(115200); //Démarrer la communication série
 thing.add_wifi(SSID, SSID_PASSWORD); //appel pour configurer la fonction WiFi
}
void loop(void) {
 thing.handle();
} 

Ensuite, nous définissons une "chose" appelée "pression". Une "chose" est un concept clé de la bibliothèque Thinger.io. Il se comporte comme une fonction, mais a une structure particulière. Il est nécessaire d'envoyer les données de résultat vers le cloud. Plus de détails sur cette bibliothèque peuvent être trouvés dans la section "Envoyer les données via Thinger.io".

La "chose" appelée "pression" lit les valeurs des trois capteurs FSR et les imprime sur la console série. Les mêmes valeurs sont également envoyées au canal "out". De cette façon, nous pouvons facilement vérifier les données d'entrée brutes.

Dans la "chose" avec le nom "tension", les valeurs de tension sont lues et stockées dans une variable locale appelée "fsrReading". Avec la fonction "map", la valeur est mise à l'échelle, par rapport aux valeurs minimales et maximales prises en charge, et renvoyée dans le tableau "fsrVoltageArray". Grâce à la boucle for, nous nous assurons que chaque FSR a son propre emplacement dans ce tableau de résultats.

Notez que tout le code est mis à l'intérieur de la fonction de configuration. Ne mettez rien dans la boucle (comme vous en avez probablement l'habitude). La bibliothèque Thinger.io ne peut pas gérer ça...

void setup(void) {
 Serial.begin(115200); //Démarrer la communication série
 thing.add_wifi(SSID, SSID_PASSWORD); //Appel pour configurer la fonction WiFi
 /*Capteurs FSR*/ 
 chose["pression"]>> [](pson &out) {
 out["FSR1"] =analogRead (FSR1);
 Serial.print("FSR1:");
 Serial.println(analogRead(FSR1));
 out["FSR2"] =analogRead(FSR2);
 Serial.print("FSR2:");
 Serial.println(analogRead(FSR2));
 out["FSR3"] =analogRead(FSR3);
 Serial.print( "FSR3:");
 Serial.println(analogRead(FSR3)); 
 };
 chose["voltage"]>> [](pson &out) {
 pour (int FSR =0; FSR  fsrVoltageArray[ FSR] =0,0 ; // Réinitialiser les valeurs à la saisie
 fsrForceArray[FSR] =0.0;
 int fsrPin =pinArray[FSR]; 
 int fsrReading =analogRead(fsrPin); 
 fsrVoltageArray[FSR] =(flotteur) map(fsrReading, 0, 1023, 0, 5000); //changez le 5000 en une autre valeur si vous n'utilisez pas un appareil 5V
 } //fin de boucle sur les FSR
 out["FSR1voltage"] =fsrVoltageArray[0];
 out ["FSR2voltage"] =fsrVoltageArray[1];
 out["FSR3voltage"] =fsrVoltageArray[2];
 };
void loop(void) {
 thing.handle ();
 //Ne mettez aucun code ici car Thinger.io n'aimera pas ça.
} 

Une fois la boucle for terminée, les valeurs sont envoyées au canal de sortie "out". Chaque capteur a une chaîne unique, comme "FSR1voltage".

La "chose" appelée "newton" est la fonction la plus complexe de ce programme. Il convertit la tension en une force en Newtons. Encore une fois, une boucle for est utilisée pour faire cela pour chaque FSR.

Le calcul est assez complexe, car il faut distinguer plusieurs cas de figure. Dans le cas où la valeur de la tension est soit trop petite, soit trop grande, nous attribuons une valeur fixe à la force. Si la tension se situe entre les valeurs de coupure, une fonction logarithmique est utilisée pour calculer la force. Cette fonction est choisie pour réduire la pente de la courbe.

Notez que les formules ne sont qu'approximatives. Chaque capteur peut avoir une courbe (un peu) différente, mais par souci de simplicité, nous ne le distinguons pas ici.

La valeur résultante des calculs est stockée dans le tableau "fsrForceArray". Encore une fois, chaque FSR a sa propre position dans ce tableau. Les trois valeurs finales sont envoyées au canal de sortie "out".

La fonction "chose" finale est appelée "poids". Une conversion simple est appliquée pour renvoyer la force sous forme de poids en grammes.

thing["newton"]>> [](pson &out) {
 for (int FSR =0; FSR  // La valeur du la force F en fonction de la tension V est calculée comme :F(V) =(Fmax/Vmax) * V
 float force_value =(forceMaxArray[FSR]/voltageMax) * fsrVoltageArray[FSR];
 // On distingue trois situations :
 //
 // 1. Si V est trop proche du maximum (tel que défini par voltageMax), le 
 //
 // 2 Si la force calculée F est trop petite, on la met à zéro pour éviter les effets de bruit.
 //
 // 3. Dans tous les autres cas, on prend la valeur logarithmique pour réduire le sloop et
 if ( fsrVoltageArray[FSR]  // V n'est pas trop élevé dans cette branche
 if ( force_value <=1.00 ) {
 fsrForceArray[FSR] =0.0; // La force est trop petite, définissez-la sur zéro
 } else {
 fsrForceArray[FSR] =log10(force_value); // La valeur est correcte, prenez le journal de ceci
 }
 } else {
 // Limitez la force si la tension est trop proche de Vcc (pour Vcc ce serait l'infini)
 fsrForceArray[FSR] =log10(forceMaxArray[FSR]);
 Serial.print("Cut off activé pour FSR ="); Serial.println(FSR);
 }
 } // Fin de la boucle sur les FSR
 out["FSR1newton"] =fsrForceArray[0];
 out["FSR2newton"] =fsrForceArray[1];
 out["FSR3newton"] =fsrForceArray[2];
 }; //fin de chose 
 chose["poids"]>> [](pson &out) {
 // Calcul simple pour convertir la force en Newton en poids en grammes
 pour ( int FSR =0; FSR  fsrWeightInGramsArray[FSR] =fsrForceArray[FSR] * conversionToKgrams * 1000.0;
 }
 out["FSR1weight"] =fsrWeightInGramsArray[0];
 out["FSR2weight"] =fsrWeightInGramsArray[1];
 out["FSR3weight"] =fsrWeightInGramsArray[2];
 }; //fin du truc 

N'oubliez pas de configurer le tableau de bord sur Thinger.io. Je suppose que vous savez comment cela fonctionne.

Astuce  :si tout fonctionne comme prévu, votre tableau de bord devrait ressembler à ceci :

Mesure de l'accélération

C'est en fait beaucoup plus facile que de mesurer la pression. Nous devons d'abord ajouter du code à la partie en-tête. Nous commençons par Inclure les librairies "Wire.h" (afin de communiquer avec les pins SDA et SDL), "Adafruit_Sensor.h", et "Adafruit_ADXL345_U.h". Nous aurons également besoin de trois nouvelles variables globales, afin de pouvoir mesurer et transférer l'accélération sur les axes x, y et z

Ne supprimez pas les bibliothèques que vous avez ajoutées précédemment. Vous en aurez besoin pour la connexion à Thinger.io.

Dans le prochain bloc de code, nous vérifions la réponse de l'accéléromètre. Sinon, il ne se passera rien. Sinon, la plage est définie et une "chose" appelée "accéléromètre" est exécutée. Cela interroge l'appareil et envoie les trois valeurs d'accélération dans les directions x, y et z au canal de sortie "out".

Cette partie du code est similaire à l'exemple de code inclus d'Adafruit (Fichier> Exemples> Adafruit ADXL345), mais j'ai omis certaines parties, car nous n'en avons pas besoin.

#include 
#include 
#include 
/* Attribuez un identifiant unique à ce capteur au même temps */
Adafruit_ADXL345_Unified accel =Adafruit_ADXL345_Unified(12345);
int x =0;
int y =0;
int z =0; 
void setup(void) {
 Serial.begin(115200);
if(!accel.begin()) { // Initialiser le capteur
 Serial.println("No ADXL345 détecté");
} else {
 // Plage pour ce capteur - Si vous ne connaissez pas la plage, exécutez le
 // displayDataRate de l'exemple de code de l'ADXL345 fourni par Adafruit 
 accel.setRange(ADXL345_RANGE_16_G);
 thing["accelerometer"]>> [](pson&out){ // Une nouvelle fonction "thing" pour Thinger.io
 sensor_event_t event;
 accel.getEvent(&event); // Obtenir un nouvel événement de capteur
 out["x"] =event.acceleration.x; // Affiche les résultats (l'accélération est mesurée en m/s^2)
 out["y"] =event.acceleration.y;
 out["z"] =event.acceleration.z; 
 Serial.print("X:"); Serial.print(event.acceleration.x); Serial.print(" ");
 Serial.print("Y:"); Serial.print(event.acceleration.y); Serial.print(" ");
 Serial.print("Z:"); Serial.print(event.acceleration.z); Serial.print(" ");Serial.println("m/s^2 ");
 }; //fin de la chose
} //fin de l'instruction if/else
} 

Indice : après avoir exécuté le code ci-dessus, votre sortie devrait ressembler à l'exemple ci-dessous

Tout assembler

Veuillez trouver le code complet en bas de la page :)

Envoyez les données via Thinger.io

Cette bibliothèque est bien documentée ici, mais voici quelques informations importantes pour rendre les "choses" (sans jeu de mots) plus faciles à écrire et à utiliser.

Thinger.io est une bibliothèque très complète. Dans cette section, nous ne couvrons que les fonctionnalités nécessaires et utilisées dans notre application. La structure est la suivante (notez le point-virgule ";" après l'accolade fermante "}") :

thing[]>> [](pson&out)
 {
 
 } ; 

C'est ce qu'on appelle une fonction lambda en C++. Le premier mot obligatoire pour commencer la définition est « chose » et toute la fonction est également appelée « chose ».

La chaîne ( par exemple thing["myFirstThing"] ) donne un nom à la fonction. Chaque "chose" doit avoir un nom unique.

Le symbole ">>" indique que cette "chose" n'a que des valeurs de sortie. Si une entrée est requise, remplacez-la par "<<". Si l'entrée et la sortie sont nécessaires, le symbole "=" doit être utilisé. Dans notre cas, nous n'avons que des valeurs de sortie.

L'argument "pson &out" signifie que nos valeurs de sortie sont envoyées via une structure de données appelée "out". Le type de données "pson" est très flexible et peut contenir différents types de variables, et prend également en charge les documents JSON.

Dans notre code, nous utilisons la forme "out[] =value" t o envoyer des valeurs à l'écran de visualisation connecté à l'appel "ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL)" dans la première partie du programme.

Comme vous l'avez peut-être remarqué, il n'y a généralement pas beaucoup de code dans la fonction de boucle. Vous n'aurez qu'à appeler "thing.handle()". Vous pouvez également appeler des points de terminaison et diffuser des ressources dans la partie boucle. Tout le reste du code est géré dans les "choses" que vous définissez.

Le code à l'intérieur des "choses" est bouclé en continu. Il est important de mettre vos calculs dans les "choses" si vos données sont mises à jour régulièrement, comme dans notre cas.

FAQ

Rien ne se passe !

Vérifiez vos fils. Il y a de fortes chances que quelque chose tombe en panne à ce niveau. Si rien n'apparaît dans votre Serial Monitor, vérifiez si "#define _DEBUG_" se trouve sur la première ligne de votre code. TLS peut également interférer. Vous pouvez désactiver cela, mais soyez prudent avec cela. Vérifiez également si votre connexion à Thinger.io fonctionne bien.

Le résultat n'est pas comme prévu

Tout le code qui doit être mis à jour est-il à l'intérieur d'une "chose" ? S'il est en dehors d'une "chose", il n'est pas mis à jour. J'ai également constaté que les appareils ESP ne fonctionnent pas bien avec les capteurs FSR sans raison apparente.

Le sortie est pas mis à jour régulièrement

Avez-vous ajouté des délais à votre code ? Supprimez-les :) Vous pouvez définir le taux de rafraîchissement sur Thinger.io lui-même.

Je préférerais avoir toutes les sorties dans un seul graphique

Ajouter tout le code dans une seule "chose"

Bravo !

J'espère que ce tutoriel vous a aidé à comprendre les bases des capteurs FSR, des accéléromètres et de Thinger.io. J'aimerais lire toutes les suggestions pour améliorer ce code, et s'il vous plaît ne soyez pas timide et partagez vos créations !

Code

• Tutoriel Smart-Insole

Smart-Insole-TutorielArduino

#define _DEBUG_ //Assurez-vous que cela vient avant toute autre inclusion ou votre carte pourrait planter/*Veuillez trouver le tutoriel ici :https://www.hackster.io/projects/a5ceae*/# include  //Thinger#include  //Thinger#include  //Accéléromètre#include  //Accéléromètre#include  //Accéléromètre# define USERNAME "yourUsername"#define DEVICE_ID "yourDevice"#define DEVICE_CREDENTIAL "yourCredential"#define SSID "yourSSID"#define SSID_PASSWORD "yourSSIDPassword"Adafruit_ADXL345_Unified accel =Adafruit_12345345); //Accéléromètreint x =0; //Remise à 0 int y =0;int z =0; //*Capteurs FSR*/#define noFSRs 3 // Nombre de FSR connectés#define FSR1 A1 //Ports analogiques#define FSR2 A2 #define FSR3 A3 float fsrVoltageArray[3] ; // La lecture analogique convertie et // mise à l'échelle en tension sous forme de virgule flottante // numberfloat fsrForceArray[3] ; // La force dans Newtonfloat fsrWeightInGramsArray[3]; // Poids converti en gramint pinArray[3] ={FSR1, FSR2, FSR3}; // L'ID de broche pour // trois appareils flottant forceMaxArray[3] ={100.0, 100.0, 100.0} ; // Forces maximales //supportedfloat million =1000000.0; // Unité pour "1/microfloat conversionToKgrams =1.0/9.80665;long K =1000;long R =10*K; // R in K Ohmlong Vcc =5000; // 5V=5000mV, 3.3V =3300 mVfloat voltageMax =0.98 * Vcc ; // Tension maximale définie sur 95 % de Vcc. Définissez // la force au maximum au-delà de cette // valeur.ThingerWifi101 chose (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); // Appel pour configurer la fonction WiFi void setup (void) { Serial.begin(115200); thing.add_wifi(SSID, SSID_PASSWORD); if(!accel.begin()) { //Initialise le capteur Serial.println("Aucun ADXL345 détecté."); } else { accel.setRange (ADXL345_RANGE_16_G); //Plage pour ce capteur["accéléromètre"]>> [](pson&out){ sensor_event_t event; accel.getEvent(&event); out["x"] =event.acceleration.x; out[ "y"] =event.acceleration.y; out["z"] =event.acceleration.z; }; } /*FSR sensor*/ thing["pressure"]>> [](pson &out) { out ["FSR1"] =analogRead(FSR1); // Serial.print("FSR1:"); // Serial.println(analogRead(FSR1)); out["FSR2"] =analogRead(FSR2); // Serial .print("FSR2:"); // S erial.println(analogRead(FSR2)); out["FSR3"] =analogRead(FSR3) ; // Serial.print("FSR3:"); // Serial.println(analogRead(FSR3)); } ; chose["voltage"]>> [](pson &out) { for (int FSR =0; FSR > [](pson &out) { for (int FSR =0; FSR > [](pson &out) { //Calcul direct pour convertir la force en Newton en poids en grammes pour (int FSR =0; FSR  

Schémas