Construire une semelle intelligente pour surveiller précisément la répartition de la pression plantaire

Composants et fournitures

Arduino MKR1000	×	1
Résistances sensibles à la force (FSR) – Modèle Interlink 402 (100N)	×	3
Câble OpenBuilds (au mètre)	×	1
Résistances 10 kΩ	×	3
Batterie externe (Power Bank)	×	1
Accéléromètre triple axe ADXL345 (SparkFun)	×	1

Outils nécessaires

• Fer à souder (avec soudure, gaines thermorétractables, accessoires)

Applications et services en ligne

• Plateforme Thinger.io
• Arduino IDE

À propos de ce projet

La mesure de pression plantaire est utilisée en clinique et dans le sport pour analyser la marche. Ce projet utilise des capteurs pour visualiser la répartition du poids en temps réel, ce qui facilite grandement la compréhension des données.

Matériel requis

• Arduino MKR1000 – La plupart des cartes 3,3V/5V avec Wi-Fi conviennent, mais évitez les ESP : plusieurs cartes ESP ont donné des mesures inexactes dans ce projet.
• FSR (3x) – Interlink 402 (100N). Le modèle 406 plus cher n'apporte pas plus. Plus de FSR = meilleure précision.
• Résistances 10kΩ – Ajustez la valeur pour adapter la plage de mesure. Plus la résistance est haute, plus les paliers sont grands. Voir détails ici.
• Accéléromètre ADXL345 16G – Pour mesurer l'accélération et le mouvement du pied. Utile pour analyser le cycle de marche, mais optionnel pour la seule pression.
• Fer à souder – Les pinces crocodiles ne tiennent pas dans une chaussure.

Câblage

Notes importantes sur les FSR : Soyez extrêmement prudent en soudant les fils aux FSR. Soudure très rapide sinon le plastique fond (expérience vécue). Pas de polarité sur les FSR. Les résistances de pull-down ajustent la plage de lecture.

Alimentation : Tous les capteurs sur la ligne 5V et la masse commune.

Accéléromètre : Optionnel. Connectez-le si vous voulez analyser la démarche.

Fixation du matériel sur la semelle

Testez le code avant de fixer le matériel : si une soudure est défectueuse, vous le verrez tout de suite et éviterez de tout démonter/remonter.

Les 3 FSR sont placés à trois points de la semelle :

• Haut gauche : mesure l'éversion (pied vers l'extérieur)
• Haut droite : mesure l'inversion (pied vers l'intérieur)
• Talon : mesure la pression du talon

La position optimale est là où la valeur analogique varie le plus pendant la marche. Maintenez les fils avec du ruban adhésif (sinon mouvement = parasites). Velcro sous la semelle et dans la chaussure pour tout maintenir.

Accéléromètre au dos du talon (ruban double-face).

Mesure des forces

Le code utilise la bibliothèque Thinger.io pour la visualisation Wi-Fi. Configuration Wi-Fi et identifiants Thinger.io à renseigner. Le programme utilise des tableaux pour gérer les 3 FSR de manière uniforme.

Structure du code :

• En-tête : includes, constantes, variables globales (tableaux pour 3 FSR).
• setup() : initialisation série, Wi-Fi, définition des « things » Thinger.io.
• loop() : uniquement thing.handle() – toute la logique est dans les « things ».

Quatre « things » définis :

1. pressure : lectures brutes analogiques des 3 FSR (sortie série + cloud).
2. voltage : conversion en tension (mV) via map(), stockée dans fsrVoltageArray.
3. newton : conversion tension → force (Newton). Logarithme pour réduire la pente. Gestion des seuils (trop bas = 0, trop haut = max). Résultat dans fsrForceArray.
4. weight : conversion Newton → grammes (facteur 1/9,80665 × 1000). Résultat dans fsrWeightInGramsArray.

Tableau de bord Thinger.io à configurer (résultat attendu : graphiques temps réel par capteur).

Mesure de l'accélération

Plus simple. Ajout des bibliothèques Wire.h, Adafruit_Sensor.h, Adafruit_ADXL345_U.h. Variables globales x, y, z. Dans setup() : initialisation capteur, plage 16G, définition du « thing » accelerometer envoyant x, y, z (m/s²) vers le cloud.

Assemblage complet

Code complet disponible en bas de page.

Envoi des données via Thinger.io

La bibliothèque Thinger.io utilise des fonctions lambda (« things ») :

thing["nom_unique"] >> [](pson & out) {
  // vos calculs
  out["clé"] = valeur;
};

• nom_unique : identifiant du thing.
• >> = sortie seulement (<< = entrée, = = bidirectionnel).
• pson &out : structure de sortie flexible (supporte JSON).
• out["clé"] = valeur : envoi vers le tableau de bord.

Tout le code de calcul doit être dans les « things » pour être mis à jour en continu. loop() ne contient que thing.handle().

FAQ

• Rien ne se passe ! Vérifiez le câblage. Activez #define _DEBUG_ en première ligne pour le moniteur série. TLS peut interférer. Vérifiez la connexion Thinger.io.
• Sortie inattendue : Le code de mise à jour est-il bien dans un « thing » ? Les ESP ne fonctionnent pas bien avec les FSR.
• Mise à jour irrégulière : Supprimez tout delay(). Réglez le taux de rafraîchissement sur Thinger.io.
• Tout sur un seul graphique : Regroupez tout dans un seul « thing ».

Bravo !

Ce tutoriel couvre les bases des FSR, accéléromètre et Thinger.io. Suggestions et partages bienvenus !

Code

Smart-Insole-Tutorial (Arduino)

Code complet du tutoriel :

#define _DEBUG_
#include 
#include 
#include 
#include 
#include 

#define USERNAME "yourUsername"
#define DEVICE_ID "yourDevice"
#define DEVICE_CREDENTIAL "yourCredential"
#define SSID "yourSSID"
#define SSID_PASSWORD "yourSSIDPassword"

Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);
int x = 0, y = 0, z = 0;

#define noFSRs 3
#define FSR1 A1
#define FSR2 A2
#define FSR3 A3

float fsrVoltageArray[3], fsrForceArray[3], fsrWeightInGramsArray[3];
int pinArray[3] = {FSR1, FSR2, FSR3};
float forceMaxArray[3] = {100.0, 100.0, 100.0};
float conversionToKgrams = 1.0/9.80665;
long K = 1000, R = 10*K, Vcc = 5000;
float voltageMax = 0.98 * Vcc;

ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL);

void setup() {
  Serial.begin(115200);
  thing.add_wifi(SSID, SSID_PASSWORD);

  if(!accel.begin()) {
    Serial.println("No ADXL345 detected.");
  } else {
    accel.setRange(ADXL345_RANGE_16_G);
    thing["accelerometer"] >> [](pson& out) {
      sensors_event_t event;
      accel.getEvent(&event);
      out["x"] = event.acceleration.x;
      out["y"] = event.acceleration.y;
      out["z"] = event.acceleration.z;
    };
  }

  thing["pressure"] >> [](pson & out) {
    out["FSR1"] = analogRead(FSR1);
    out["FSR2"] = analogRead(FSR2);
    out["FSR3"] = analogRead(FSR3);
  };

  thing["voltage"] >> [](pson & out) {
    for (int FSR = 0; FSR < noFSRs; FSR++) {
      fsrVoltageArray[FSR] = 0.0;
      fsrForceArray[FSR] = 0.0;
      int fsrPin = pinArray[FSR];
      int fsrReading = analogRead(fsrPin);
      fsrVoltageArray[FSR] = (float) map(fsrReading, 0, 1023, 0, 5000);
    }
    out["FSR1voltage"] = fsrVoltageArray[0];
    out["FSR2voltage"] = fsrVoltageArray[1];
    out["FSR3voltage"] = fsrVoltageArray[2];
  };

  thing["newton"] >> [](pson & out) {
    for (int FSR = 0; FSR < noFSRs; FSR++) {
      float force_value = (forceMaxArray[FSR]/voltageMax) * fsrVoltageArray[FSR];
      if (fsrVoltageArray[FSR] < voltageMax) {
        if (force_value <= 1.00) fsrForceArray[FSR] = 0.0;
        else fsrForceArray[FSR] = log10(force_value);
      } else {
        fsrForceArray[FSR] = log10(forceMaxArray[FSR]);
        Serial.print("Cut off activated for FSR = "); Serial.println(FSR);
      }
    }
    out["FSR1newton"] = fsrForceArray[0];
    out["FSR2newton"] = fsrForceArray[1];
    out["FSR3newton"] = fsrForceArray[2];
  };

  thing["weight"] >> [](pson & out) {
    for (int FSR = 0; FSR < noFSRs; FSR++) {
      fsrWeightInGramsArray[FSR] = fsrForceArray[FSR] * conversionToKgrams * 1000.0;
    }
    out["FSR1weight"] = fsrWeightInGramsArray[0];
    out["FSR2weight"] = fsrWeightInGramsArray[1];
    out["FSR3weight"] = fsrWeightInGramsArray[2];
  };
}

void loop() {
  thing.handle();
}

Schémas

Trois FSR (avec diviseurs de tension) et un accéléromètre.