Een doe-het-zelf slimme binnenzool om je drukverdeling te controleren

Over dit project

Drukmeting wordt al in verschillende situaties toegepast. Het geeft informatie over loopmechanica en heeft een breed scala aan toepassingen, d.w.z. in klinische situaties en in de sport. In dit project worden de sensoren gebruikt om inzicht te krijgen in de gewichtsverdeling. Realtime visualisatie van drukmapping is ook opgenomen omdat het het veel gemakkelijker maakt om uw gegevens te begrijpen.

Vereiste hardware

• Arduino MKR1000 - De meeste 3.3V- of 5V-kaarten met wifi zullen het werk doen, maar ik zou het echter niet aanmoedigen om hiervoor een ESP te gebruiken. Om de een of andere reden hebben meerdere ESP-borden onnauwkeurige metingen geretourneerd tijdens het maken van dit project.
• Forceer gevoelige weerstanden (3). Ik gebruikte de Interlink 402 (100 N). Ik heb ook een duurdere Interlink 406 gebruikt, maar achteraf gezien zou de 402 ook hebben gewerkt. Gebruik meer FSR's voor een betere nauwkeurigheid.
• 10K Weerstanden. Verander de weerstand om uw metingen te schalen om in het bereik te zijn dat u wilt. Hoe hoger de weerstanden, hoe groter de stappen zijn. Vind hier meer informatie hierover.
• Versnellingsmeter, ik heb de 16G ADXL345 gebruikt. Gebruik dit om versnelling en beweging van de voet te meten.
• Een soldeerbout om alles in elkaar te zetten. Alligatorclips werken om voor de hand liggende redenen niet goed in een schoen.

Dingen aansluiten

Enkele korte opmerkingen over het circuit:

FSR's: Lees dit voor jij start solderen: wees uiterst voorzichtig bij het solderen van de draden aan de FSR's. Probeer dit niet te doen als u niet zeker weet of u over de vaardigheden beschikt. Je moet het heel solderen snel of het plastic smelt. Geloof me, ik kwam er op de harde manier achter...

Er is geen positieve of negatieve kant aan een FSR, dus daar hoef je je geen zorgen over te maken.

Zoals ik eerder al zei, kunt u de weerstanden wijzigen om uw meetwaarden te schalen naar het bereik dat u verkiest.

Grond/5V: Zoals je kunt zien, zijn alle sensoren gesoldeerd aan de 5V-lijn en de gemeenschappelijke.

Versnellingsmeter: U kunt de versnellingsmeter weglaten als u deze niet nodig heeft voor uw project. Het is niet nodig om het te gebruiken als u alleen de druk wilt meten, maar het kan handig zijn als u versnelling wilt meten of als u de loopcyclus wilt analyseren. Het is echter niet strikt noodzakelijk voor deze tutorial.

De hardware aan de binnenzool bevestigen

Ik raad aan om dit te doen nadat je de code eerst hebt uitgevoerd, want als je soldeerfouten hebt gemaakt, kom je er op dat moment achter. Dat kan u wat gedoe besparen bij het bevestigen en opnieuw bevestigen van de hardware aan de binnenzool voor het geval u iets opnieuw moet solderen.

De FSR's zijn bevestigd aan drie punten van de binnenzool. De FSR linksboven meet eversie, de FSR rechtsboven meet inversie en de FSR bij de hiel meet de hieldruk. Het vinden van de juiste plek voor uw FSR's is een kwestie van proberen. De beste positie om ze te bevestigen is de plek waar de analoge waarde het meest verandert tijdens het lopen.

Tape wordt gebruikt om de draden op hun plaats te houden. Als ze bewegen, kan dit interferentie veroorzaken met FSR-metingen. Ik heb ook klittenband aan de onderkant van de zool en de binnenkant van de schoen gebruikt om de binnenzool op zijn plaats te houden.

Bevestig de versnellingsmeter aan de achterkant van de hiel van de schoen als je er een gebruikt. Ik heb daarvoor dubbelzijdig plakband gebruikt.

Krachten meten

Nu zijn we helemaal klaar om de krachten te meten. Opmerking:in de volgende twee secties ga ik ervan uit dat ik bekend ben met de Thinger.io-bibliotheek. Voor meer informatie hierover verwijs ik naar de sectie met de titel "verstuur de gegevens via Thinger.io".

Het programma heeft een vrij lang kopgedeelte, inclusief de variabelen die nodig zijn om dingen in te stellen, zoals de wifi-verbindingsgegevens. Dit deel bevat ook de globale variabelen, meestal arrays, die in het programma worden gebruikt. Een belangrijke keuze die ik maakte was om zoveel mogelijk arrays te gebruiken. Het idee is om voor elke FSR-sensor afzonderlijke array-elementen te gebruiken. Dus in dit geval hebben de arrays een lengte van 3.

Maak er geen gewoonte van om te veel globale variabelen te gebruiken, vanwege ongewenste neveneffecten. We hebben ze gebruikt omdat ze in verschillende gevallen nodig zijn om de gegevens via Thinger.io te verzenden.

De code wordt uitgelegd in de opmerkingen. We zullen de code stap voor stap doornemen. Je kunt de volledige code hieronder downloaden.

#define _DEBUG_ // stelt ons in staat om de seriële monitor te gebruiken
#include 
#include 
#include  //Accelerometer
#include  //Accelerometer
#include  //Accelerometer
#include 
#define USERNAME "yourUsername"
#define DEVICE_ID "yourDeviceID"
#define DEVICE_CREDENTIAL "yourDeviceCredential"
#define SSID "yourSSID"
#define SSID_PASSWORD "yourSSIDPassword"
//* FSR-sensoren*/
#define noFSRs 3 // Aantal aangesloten FSRs
#define FSR1 A1 
#define FSR2 A2 
#define FSR3 A3 
float fsrVoltageArray[3 ]; // De analoge uitlezing omgezet en geschaald naar spanning als een getal met drijvende komma
float fsrForceArray[3]; // De kracht in Newton
float fsrWeightInGramsArray[3]; // Gewicht omgerekend naar gram
int pinArray[3] ={FSR1, FSR2, FSR3}; // De pin-ID voor de drie apparaten
float forceMaxArray[3] ={100.0, 100.0, 100.0}; // Maximale ondersteunde krachten
float miljoen =1000000.0; // Eenheid voor "1/micro
float conversieToKgrams =1.0/9.80665;
lange K =1000;
lange R =10*K; // R in K Ohm
lang Vcc =5000; // 5V=5000mV, 3,3V =3300 mV
floatspanning Max =0,98 * Vcc; // Maximale spanning ingesteld op 95% van Vcc. Stel de kracht in op het maximum voorbij deze waarde.
ThingerWifi101-ding (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); 

Geen paniek als je het nog niet allemaal begrijpt. Het is logischer als je de rest van de code hebt gezien.

We willen de resultaten visualiseren. Hiervoor gebruiken we de Thinger.io Wi-Fi-bibliotheek. Deze verbinding wordt tot stand gebracht via de volgende regel:

ThingerWifi101-ding (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); 

De invoerargumenten worden verkregen via uw account op Thinger.io, dus u moet dit eerst instellen.

In de setup()-functie wordt eerst de seriële verbinding tot stand gebracht. Dit wordt gevolgd door een oproep om de wifi-verbinding tot stand te brengen.

void setup(void) {
 Serial.begin(115200); //Start seriële communicatie
 thing.add_wifi(SSID, SSID_PASSWORD); //aanroep om wifi-functie in te stellen
}
void loop(void) {
 thing.handle();
} 

Vervolgens definiëren we een "ding" dat "druk" wordt genoemd. Een "ding" is een sleutelconcept uit de Thinger.io-bibliotheek. Het gedraagt ​​zich als een functie, maar heeft een speciale structuur. Het is nodig om de resultaatgegevens naar de cloud te sturen. Meer details over deze bibliotheek zijn te vinden in de sectie "De gegevens verzenden via Thinger.io".

Het "ding" genaamd "druk" leest de waarden van de drie FSR-sensoren en drukt ze af op de seriële console. Dezelfde waarden worden ook naar het "uit"-kanaal gestuurd. Op deze manier kunnen we de onbewerkte invoergegevens gemakkelijk verifiëren.

In het "ding" met de naam "voltage", worden de spanningswaarden gelezen en opgeslagen in een lokale variabele genaamd "fsrReading". Met de "map"-functie wordt de waarde geschaald, relatief aan de minimum- en maximumwaarden die worden ondersteund, en teruggestuurd naar de array "fsrVoltageArray". Via de for-loop zorgen we ervoor dat elke FSR zijn eigen locatie heeft in deze resultatenreeks.

Merk op dat alle code in de setup-functie wordt geplaatst. Stop niets in de lus (zoals je waarschijnlijk gewend bent). Dat kan de Thinger.io-bibliotheek niet aan...

void setup(void) {
 Serial.begin(115200); //Start seriële communicatie
 thing.add_wifi(SSID, SSID_PASSWORD); //aanroep om wifi-functie in te stellen
 /*FSR-sensoren*/ 
 thing["druk"]>> [](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)); 
 };
 thing["voltage"]>> [](pson &out) {
 for (int FSR =0; FSR  fsrVoltageArray[ FSR] =0,0; // Reset waarden bij invoer
 fsrForceArray[FSR] =0.0;
 int fsrPin =pinArray[FSR]; 
 int fsrReading =analogRead(fsrPin); 
 fsrVoltageArray [FSR] =(zwevende) kaart (fsrReading, 0, 1023, 0, 5000); // verander de 5000 in een andere waarde als je geen 5V-apparaat gebruikt
 } //einde van de lus over FSR's
 out["FSR1voltage"] =fsrVoltageArray[0];
 out ["FSR2voltage"] =fsrVoltageArray[1];
 out["FSR3voltage"] =fsrVoltageArray[2];
 };
void loop(void) {
 thing.handle ();
 //Plaats hier geen code, want dat zal Thinger.io niet leuk vinden.
} 

Nadat de for-loop is voltooid, worden de waarden naar het uitgangskanaal "out" gestuurd. Elke sensor heeft een unieke string, zoals "FSR1voltage".

Het "ding" genaamd "newton" is de meest complexe functie in dit programma. Het zet de spanning om in een kracht in Newton. Wederom wordt een for-loop gebruikt om dit voor elke FSR te doen.

De berekening is vrij complex, omdat we verschillende hoekgevallen moeten onderscheiden. In het geval dat de spanningswaarde te klein of te groot is, kennen we een vaste waarde toe aan de kracht. Als de spanning tussen de afkapwaarden ligt, wordt een logaritmische functie gebruikt om de kracht te berekenen. Deze functie is gekozen om de helling van de curve te verkleinen.

Merk op dat de formules slechts bij benadering zijn. Elke sensor kan een (iets) andere curve hebben, maar voor de eenvoud maken we hier geen onderscheid tussen.

De resulterende waarde van de berekeningen wordt opgeslagen in array "fsrForceArray". Nogmaals, elke FSR heeft zijn eigen positie in deze array. De drie laatste waarden worden naar het "uit"-uitgangskanaal gestuurd.

De laatste "ding" -functie wordt "gewicht" genoemd. Er wordt een eenvoudige conversie toegepast om de kracht terug te geven als het gewicht in grammen.

thing["newton"]>> [](pson &out) {
 for (int FSR =0; FSR  // De waarde van de kracht F als functie van de spanning V wordt berekend als:F(V) =(Fmax/Vmax) * V
 float force_value =(forceMaxArray[FSR]/voltageMax) * fsrVoltageArray[FSR];
 // Er worden drie situaties onderscheiden:
 //
 // 1. Als V te dicht bij het maximum ligt (zoals gedefinieerd door voltageMax), wordt de 
 //
 // 2 Als de berekende kracht F te klein is, stellen we deze op nul om geluidseffecten te voorkomen.
 //
 // 3. In alle andere gevallen nemen we de logaritmische waarde om de sloep te verkleinen en
 if ( fsrVoltageArray [FSR]  // V is niet te hoog in deze tak
 if ( force_value <=1.00 ) {
 fsrForceArray[FSR] =0.0; // Force is te klein, zet het op nul
 } else {
 fsrForceArray[FSR] =log10(force_value); // Waarde is in orde, neem het logboek hiervan
 }
 } else {
 // Cap de kracht als de spanning te dicht bij Vcc is (voor Vcc zou het oneindig zijn)
 fsrForceArray[FSR] =log10(forceMaxArray[FSR]);
 Serial.print("Cut-off geactiveerd voor FSR ="); Serial.println(FSR);
 }
 } // Einde van lus over FSR's
 out["FSR1newton"] =fsrForceArray[0];
 out["FSR2newton"] =fsrForceArray[1];
 out["FSR3newton"] =fsrForceArray[2];
 }; //einde van ding 
 ding ["gewicht"]>> [](pson &out) {
 // Eenvoudige berekening om de kracht in Newton om te zetten in het gewicht in gram
 voor ( int FSR =0; FSR  fsrWeightInGramsArray[FSR] =fsrForceArray[FSR] * conversionToKgrams * 1000.0;
 }
 out["FSR1weight"] =fsrWeightInGramsArray[0];
 out["FSR2weight"] =fsrWeightInGramsArray[1];
 out["FSR3weight"] =fsrWeightInGramsArray[2];
 }; //einde van de zaak 

Vergeet niet het dashboard op Thinger.io in te stellen. Ik neem aan dat je weet hoe dat werkt.

Hint :Als alles werkt zoals verwacht, zou uw dashboard er ongeveer zo uit moeten zien:

De versnelling meten

Dit is eigenlijk veel eenvoudiger dan het meten van de druk. We moeten eerst wat code aan het kopgedeelte toevoegen. We beginnen met het opnemen van de bibliotheken "Wire.h" (om te communiceren met de SDA- en SDL-pin), "Adafruit_Sensor.h" en "Adafruit_ADXL345_U.h". We hebben ook drie nieuwe globale variabelen nodig, zodat we de versnelling op de x-, y- en z-assen kunnen meten en overdragen

Verwijder de bibliotheken die u eerder heeft toegevoegd niet. Deze heb je nodig voor de verbinding met Thinger.io.

In het volgende codeblok controleren we of de versnellingsmeter reageert. Zo niet, dan gebeurt er niets. Anders wordt het bereik gedefinieerd en wordt een "ding" genaamd "versnellingsmeter" uitgevoerd. Dit ondervraagt ​​het apparaat en stuurt de drie versnellingswaarden in de x-, y- en z-richting naar het output "uit"-kanaal.

Dit deel van de code is vergelijkbaar met de bijgevoegde voorbeeldcode van Adafruit (Bestand> Voorbeelden> Adafruit ADXL345), maar ik heb enkele delen weggelaten, omdat we ze niet nodig hebben.

#include 
#include 
#include 
/* Wijs een unieke ID toe aan deze sensor op de tegelijkertijd */
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()) { // Initialiseer de sensor
 Serial.println("Nee ADXL345 gedetecteerd");
} else {
 // Bereik voor deze sensor - Als u het bereik niet weet, voer dan de
 // displayDataRate uit van de voorbeeldcode van de ADXL345 geleverd door Adafruit 
 accel.setRange(ADXL345_RANGE_16_G);
 thing["accelerometer"]>> [](pson&out){ // Een nieuwe "thing"-functie voor Thinger.io
 sensors_event_t event;
 accel.getEvent(&event); // Krijg een nieuwe sensorgebeurtenis
 out["x"] =event.acceleration.x; // Toon de resultaten (versnelling wordt gemeten in m/s^2)
 out["y"] =event.acceleration.y;
 out["z"] =event.acceleration.z; 
 Serial.print("X:"); Serial.print(gebeurtenis.acceleration.x); Serial.print(" ");
 Serial.print("Y:"); Serial.print(gebeurtenis.acceleration.y); Serial.print(" ");
 Serial.print("Z:"); Serial.print(gebeurtenis.acceleration.z); Serial.print(" ");Serial.println("m/s^2 ");
 }; //end of thing
} //end of if/else statement
} 

Hint: na het uitvoeren van de bovenstaande code, zou uw uitvoer er ongeveer zo uit moeten zien als in het onderstaande voorbeeld

Alles bij elkaar

De volledige code vindt u onderaan de pagina :)

Stuur de gegevens via Thinger.io

Deze bibliotheek is hier goed gedocumenteerd, maar hier is wat belangrijke informatie om "dingen" (geen woordspeling bedoeld) gemakkelijker te schrijven en te gebruiken.

Thinger.io is een zeer uitgebreide bibliotheek. In deze sectie behandelen we alleen de functionaliteit die nodig is en wordt gebruikt in onze applicatie. De structuur is als volgt (let op de puntkomma ";" na de afsluitende accolade "}"):

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

Dit wordt in C++ een lambda-functie genoemd. Het verplichte eerste woord om de definitie te starten is 'ding' en de hele functie wordt ook wel 'ding' genoemd.

De string ( bijvoorbeeld thing["myFirstThing"] ) geeft een naam aan de functie. Elk "ding" moet een unieke naam hebben.

Het ">>"-symbool geeft aan dat dit "ding" alleen uitvoerwaarden heeft. Indien invoer vereist is, wijzigt u dit in "<<". Als zowel invoer als uitvoer nodig is, moet het symbool "=" worden gebruikt. In ons geval hebben we alleen uitvoerwaarden.

Het argument "pson &out" betekent dat onze uitvoerwaarden worden verzonden via een gegevensstructuur die "out" wordt genoemd. Het datatype "pson" is zeer flexibel en kan verschillende soorten variabelen bevatten en ondersteunt ook JSON-documenten.

In onze code gebruiken we de vorm "out[] =value" t o stuur waarden naar het visualisatiescherm dat is verbonden met de oproep "ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL)" in het eerste deel van het programma.

Zoals je misschien hebt gemerkt, zit er meestal niet veel code in de loop-functie. U hoeft alleen "thing.handle()" aan te roepen. U kunt ook eindpunten aanroepen en bronnen in het lusgedeelte streamen. Alle andere code wordt afgehandeld in de "dingen" die u definieert.

De code binnen de "dingen" wordt continu doorgelust. Het is belangrijk om uw berekeningen binnen de "dingen" te plaatsen als uw gegevens regelmatig worden bijgewerkt, zoals in ons geval.

Veelgestelde vragen

Er gebeurt niets!

Controleer uw draden. De kans is groot dat er op dit niveau iets kapot is gegaan. Als er niets in uw seriële monitor verschijnt, controleer dan of "#define _DEBUG_" op de eerste regel van uw code staat. TLS kan ook interfereren. Je kunt dat uitschakelen, maar wees hier voorzichtig mee. Controleer ook of je verbinding met Thinger.io goed werkt.

De uitvoer is niet zoals verwacht

Is alle code die moet worden bijgewerkt in een "ding"? Als het buiten een "ding" staat, wordt het niet bijgewerkt. Ik heb ook geconstateerd dat de ESP-apparaten zonder duidelijke reden niet goed werken met de FSR-sensoren.

De uitvoer is niet bijgewerkt regelmatig

Heb je vertragingen aan je code toegevoegd? Verwijder ze :) Je kunt de verversingssnelheid op Thinger.io zelf instellen.

Ik heb liever alle output in één grafiek

Voeg alle code toe aan een enkel "ding"

Goed gedaan!

Ik hoop dat deze tutorial je heeft geholpen om de basis van FSR-sensoren, versnellingsmeters en Thinger.io te begrijpen. Ik zou graag suggesties lezen om deze code te verbeteren, en wees alsjeblieft niet verlegen en deel je creaties!

#define _DEBUG_ //Zorg ervoor dat dit vóór elke andere include komt, anders kan je bord crashen/*Hier vind je de tutorial:https://www.hackster.io/projects/a5ceae*/# include  //Thinger#include  //Thinger#include  //Accelerometer#include  //Accelerometer#include  //Accelerometer# definieer 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); // Accelerometerint x =0; // Reset naar 0 int y =0; int z =0; //*FSR-sensoren*/#define noFSR's 3 // Aantal aangesloten FSR's#define FSR1 A1 //Analoge poorten#define FSR2 A2 #define FSR3 A3 float fsrVoltageArray[3]; // De analoge uitlezing omgezet en // geschaald naar spanning als een drijvende komma //numberfloat fsrForceArray [3]; // De kracht in Newtonfloat fsrWeightInGramsArray [3]; // Gewicht geconverteerd naar gramint pinArray [3] ={FSR1, FSR2, FSR3}; // De pin-ID voor de //drie devicesfloat forceMaxArray [3] ={100.0, 100.0, 100.0}; // Maximale krachten //supportedfloat miljoen =1000000,0; // Eenheid voor "1/microfloat conversieToKgrams =1.0/9.80665;lange K =1000;lange R =10*K; // R in K Ohmlong Vcc =5000; // 5V=5000mV, 3,3V =3300 mVfloatspanning Max =0,98 * Vcc; // Maximale spanning ingesteld op 95% van Vcc. Stel // de kracht in op het maximum buiten deze // waarde.ThingerWifi101-ding (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); //Bel om wifi-functie ongeldig te maken setup (void) {Serial.begin(115200); thing.add_wifi(SSID, SSID_PASSWORD); if(!accel.begin()) { // Initialiseer de sensor Serial.println ("Geen ADXL345 gedetecteerd.");} else { accel.setRange (ADXL345_RANGE_16_G); //Bereik voor dit sensording ["versnellingsmeter"]>> [](pson&out){ sensors_event_t event; accel.getEvent(&event); out["x"] =event.acceleration.x; out[ "y"] =event.acceleration.y; out["z"] =event.acceleration.z; }; } /*FSR-sensoren*/ thing["druk"]>> [](pson &out) { out ["FSR1"] =analogRead(FSR1); // Serial.print("FSR1:"); // Serial.println(analogRead(FSR1)); out["FSR2"] =analogRead(FSR2); // Serieel .print("FSR2:"); // S erial.println(analogRead(FSR2)); out["FSR3"] =analogRead(FSR3); // Serial.print ("FSR3:"); // Serial.println (analogRead (FSR3)); }; thing ["voltage"]>> [](pson &out) { for (int FSR =0; FSR > [](pson &out) { for (int FSR =0; FSR > [](pson &out) {//Eenvoudige berekening om de kracht in Newton om te zetten in het gewicht in gram voor (int FSR =0; FSR   
 
 Schema's  
 Drie FSR's (met spanningsdeler) en een accelerometer.