Eine intelligente Einlegesohle zum Selbermachen, um Ihre Druckverteilung zu überprüfen

Notwendige Werkzeuge und Maschinen

Lötkolben (generisch) Vergessen Sie nicht, Lötzinn, Schrumpfschlauch und anderes passendes Zubehör zu kaufen, wenn Sie diese nicht haben

Apps und Onlinedienste

	Thinger.io-Plattform
	Arduino-IDE

Über dieses Projekt

Druckmessung wird bereits in einer Vielzahl von Situationen eingesetzt. Es informiert über die Gangmechanik und hat ein breites Anwendungsspektrum, d.h. in klinischen Situationen und im Sport. In diesem Projekt werden die Sensoren verwendet, um Erkenntnisse über die Gewichtsverteilung zu gewinnen. Eine Echtzeit-Visualisierung der Druckkartierung ist ebenfalls integriert, da sie das Verständnis Ihrer Daten erheblich erleichtert.

Erforderliche Hardware

• Arduino MKR1000 - Die meisten 3,3-V- oder 5-V-Platinen mit Wi-Fi werden die Arbeit erledigen, aber ich würde nicht empfehlen, dafür einen ESP zu verwenden. Aus irgendeinem Grund haben mehrere ESP-Boards beim Erstellen dieses Projekts ungenaue Messungen zurückgegeben.
• Kraftempfindliche Widerstände (3). Ich habe den Interlink 402 (100 N) verwendet. Ich habe auch einen teureren Interlink 406 verwendet, aber im Nachhinein hätte der 402 auch funktioniert. Verwenden Sie mehr FSRs für eine bessere Genauigkeit.
• 10K Widerstände. Ändern Sie den Widerstand, um Ihre Messwerte auf den gewünschten Bereich zu skalieren. Je höher die Widerstände, desto größer die Inkremente. Weitere Informationen hierzu finden Sie hier.
• Beschleunigungsmesser, ich habe den 16G ADXL345 verwendet. Verwenden Sie dies, um die Beschleunigung und Bewegung des Fußes zu messen.
• Ein Lötkolben, um alles zusammenzufügen. Krokodilklemmen funktionieren aus offensichtlichen Gründen nicht gut in einem Schuh.

Dinge verkabeln

Einige kurze Anmerkungen zur Schaltung:

FSRs: Lesen dieses vor Sie Start Löten: Seien Sie beim Löten der Drähte an den FSR äußerst vorsichtig. Versuchen Sie dies nicht, wenn Sie sich nicht sicher sind, ob Sie über die erforderlichen Fähigkeiten verfügen. Sie müssen es sehr löten schnell oder der Kunststoff schmilzt. Glauben Sie mir, ich habe es auf die harte Tour herausgefunden...

Es gibt keine positive oder negative Seite eines FSR, also musst du dir darüber keine Sorgen machen.

Wie ich bereits erwähnt habe, können Sie die Widerstände ändern, um Ihre Messwerte in den von Ihnen bevorzugten Bereich zu skalieren.

Masse/5V: Wie Sie sehen können, sind alle Sensoren an die 5V-Leitung und den gemeinsamen gelötet.

Beschleunigungsmesser: Sie können den Beschleunigungsmesser weglassen, wenn Sie ihn für Ihr Projekt nicht benötigen. Es ist nicht notwendig, es zu verwenden, wenn Sie nur den Druck messen möchten, aber es kann praktisch sein, wenn Sie die Beschleunigung messen möchten oder wenn Sie den Gangzyklus analysieren müssen. Für dieses Tutorial ist dies jedoch nicht unbedingt erforderlich.

Anbringen der Hardware an der Einlegesohle

Ich empfehle, dies nach dem Ausführen des Codes zuerst zu tun, denn wenn Sie Lötfehler gemacht haben, werden Sie es an dieser Stelle herausfinden. Das erspart Ihnen möglicherweise einige Mühe beim Anbringen und erneuten Anbringen der Hardware an der Einlegesohle, falls Sie etwas nachlöten müssen.

Die FSR's sind an drei Punkten der Einlegesohle befestigt. Der obere linke FSR misst die Eversion, der obere rechte FSR misst die Inversion und der FSR an der Ferse misst den Fersendruck. Den richtigen Platz für Ihre FSR zu finden, ist eine Frage des Versuchs. Die beste Position zum Anbringen ist die Stelle, an der sich der Analogwert beim Gehen am stärksten ändert.

Klebeband wird verwendet, um die Drähte an Ort und Stelle zu halten. Wenn sie sich bewegen, können die FSR-Messwerte gestört werden. Ich habe auch Klettband unten an der Sohle und an der Innenseite des Schuhs verwendet, um die Einlegesohle an Ort und Stelle zu halten.

Bringen Sie den Beschleunigungsmesser an der Rückseite des Schuhabsatzes an, falls Sie einen verwenden. Dafür habe ich doppelseitiges Klebeband verwendet.

Messen der Kräfte

Jetzt sind wir alle bereit, die Kräfte zu messen. Hinweis:In den nächsten beiden Abschnitten gehe ich davon aus, dass ich mit der Thinger.io-Bibliothek vertraut bin. Für weitere Informationen hierzu verweise ich auf den Abschnitt "Daten über Thinger.io senden".

Das Programm hat einen ziemlich langen Header-Teil, einschließlich der Variablen, die zum Einrichten von Dingen wie den WiFi-Verbindungsdaten benötigt werden. Dieser Teil enthält auch die globalen Variablen, meist Arrays, die im Programm verwendet werden. Eine wichtige Entscheidung, die ich traf, war, so viel wie möglich Arrays zu verwenden. Die Idee ist, für jeden FSR-Sensor individuelle Array-Elemente zu verwenden. In diesem Fall haben die Arrays also eine Länge von 3.

Machen Sie es sich wegen unerwünschter Nebenwirkungen nicht zur Gewohnheit, zu viele globale Variablen zu verwenden. Wir haben sie verwendet, weil sie in einigen Fällen notwendig sind, um die Daten über Thinger.io zu senden.

Der Code wird in den Kommentaren erklärt. Wir gehen den Code Schritt für Schritt durch. Sie können den vollständigen Code unten herunterladen.

#define _DEBUG_ //ermöglicht uns die Verwendung des seriellen Monitors
#include 
#include 
#include  //Beschleunigungsmesser
#include  //Beschleunigungsmesser
#include  //Beschleunigungsmesser
#include 
#define USERNAME "yourUsername"
#define DEVICE_ID "yourDeviceID"
#define DEVICE_CREDENTIAL "yourDeviceCredential"
#define SSID "yourSSID"
#define SSID_PASSWORD "yourSSIDPassword"
//* FSR-Sensoren*/
#define noFSRs 3 // Anzahl der angeschlossenen FSRs
#define FSR1 A1 
#define FSR2 A2 
#define FSR3 A3 
float fsrVoltageArray[3 ]; // Der analoge Messwert wird als Gleitkommazahl konvertiert und auf Spannung skaliert
float fsrForceArray[3]; // Die Kraft in Newton
float fsrWeightInGramsArray[3]; // Gewicht in Gramm umgerechnet
int pinArray[3] ={FSR1, FSR2, FSR3}; // Die Pin-ID für die drei Geräte
float forceMaxArray[3] ={100.0, 100.0, 100.0}; // Maximal unterstützte Kräfte
float million =1000000.0; // Einheit für "1/micro
float ConversionToKgrams =1.0/9.80665;
long K =1000;
long R =10*K; // R in K Ohm
long Vcc =5000; // 5V=5000mV, 3,3V =3300 mV
float voltageMax =0,98 * Vcc; // Maximale Spannung auf 95% von Vcc eingestellt. Über diesen Wert hinaus die Kraft auf das Maximum einstellen.
ThingerWifi101-Ding(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); 

Keine Panik, wenn Sie noch nicht alles verstehen. Es macht mehr Sinn, wenn Sie den Rest des Codes gesehen haben.

Wir wollen die Ergebnisse visualisieren. Dazu verwenden wir die Thinger.io Wi-Fi-Bibliothek. Diese Verbindung wird über die folgende Zeile aufgebaut:

ThingerWifi101-Ding(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); 

Die Eingabeargumente werden über Ihr Konto auf Thinger.io abgerufen, daher müssen Sie dies zuerst einrichten.

In der Funktion setup() wird zuerst die serielle Verbindung aufgebaut. Es folgt ein Aufruf zum Herstellen der WLAN-Verbindung.

void setup (void) {
 Serial.begin(115200); //Serielle Kommunikation starten
 thing.add_wifi (SSID, SSID_PASSWORD); //Aufruf zum Einrichten der WLAN-Funktion
}
void loop(void) {
thing.handle();
} 

Als nächstes definieren wir ein "Ding" namens "Druck". Ein „Ding“ ist ein Schlüsselkonzept aus der Thinger.io-Bibliothek. Es verhält sich wie eine Funktion, hat aber eine besondere Struktur. Es wird benötigt, um die Ergebnisdaten an die Cloud zu senden. Weitere Details zu dieser Bibliothek finden Sie im Abschnitt "Daten über Thinger.io senden".

Das "Ding" namens "Druck" liest die Werte der drei FSR-Sensoren und druckt sie auf der seriellen Konsole aus. Dieselben Werte werden auch an den "out"-Kanal gesendet. Auf diese Weise können wir die rohen Eingabedaten leicht überprüfen.

Im „Ding“ mit dem Namen „Spannung“ werden die Spannungswerte gelesen und in einer lokalen Variablen namens „fsrReading“ gespeichert. Mit der Funktion "map" wird der Wert relativ zu den unterstützten Minimal- und Maximalwerten skaliert und in das Array "fsrVoltageArray" zurückgegeben. Durch die for-Schleife stellen wir sicher, dass jeder FSR seine eigene Position in diesem Ergebnisarray hat.

Beachten Sie, dass der gesamte Code in die Setup-Funktion eingefügt wird. Legen Sie nichts in die Schleife (wie Sie es wahrscheinlich gewohnt sind). Die Thinger.io-Bibliothek kann damit nicht umgehen...

void setup (void) {
 Serial.begin(115200); //Serielle Kommunikation starten
 thing.add_wifi (SSID, SSID_PASSWORD); //Aufruf zum Einrichten der WiFi-Funktion
 /*FSR-Sensoren*/ 
 thing["pressure"]>> [](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; // Werte bei Eingabe zurücksetzen
 fsrForceArray[FSR] =0.0;
 int fsrPin =pinArray[FSR]; 
 int fsrReading =analogRead(fsrPin); 
 fsrVoltageArray[FSR] =(float) map(fsrReading, 0, 1023, 0, 5000); //Ändere 5000 auf einen anderen Wert, wenn du kein 5V-Gerät verwendest
 } //Ende der Schleife über FSRs
 out["FSR1voltage"] =fsrVoltageArray[0];
 out ["FSR2voltage"] =fsrVoltageArray[1];
 out["FSR3voltage"] =fsrVoltageArray[2];
 };
void loop(void) {
 thing.handle ();
 //Füge hier keinen Code ein, weil Thinger.io das nicht mag.
} 

Nach Abschluss der for-Schleife werden die Werte an den Ausgangskanal „out“ gesendet. Jeder Sensor hat eine eindeutige Zeichenfolge, wie "FSR1voltage".

Das "Ding" namens "Newton" ist die komplexeste Funktion in diesem Programm. Es wandelt die Spannung in eine Kraft in Newton um. Auch hier wird für jeden FSR eine for-Schleife verwendet.

Die Berechnung ist ziemlich komplex, da wir mehrere Eckfälle unterscheiden müssen. Falls der Spannungswert entweder zu klein oder zu groß ist, weisen wir der Kraft einen festen Wert zu. Falls die Spannung zwischen den Abschaltwerten liegt, wird eine logarithmische Funktion verwendet, um die Kraft zu berechnen. Diese Funktion wird gewählt, um die Steigung der Kurve zu reduzieren.

Beachten Sie, dass die Formeln nur ungefähre Angaben sind. Jeder Sensor kann eine (etwas) andere Kurve haben, aber der Einfachheit halber unterscheiden wir dies hier nicht.

Der resultierende Wert aus den Berechnungen wird im Array "fsrForceArray" gespeichert. Auch hier hat jeder FSR seine eigene Position in diesem Array. Die drei Endwerte werden an den Ausgangskanal "out" gesendet.

Die letzte "Ding"-Funktion heißt "Gewicht". Eine einfache Umrechnung wird angewendet, um die Kraft als Gewicht in Gramm zurückzugeben.

thing["newton"]>> [](pson &out) {
 for (int FSR =0; FSR  // Der Wert von Kraft F als Funktion der Spannung V wird berechnet als:F(V) =(Fmax/Vmax) * V
 float force_value =(forceMaxArray[FSR]/VoltageMax) * fsrVoltageArray[FSR];
 // Drei Situationen werden unterschieden:
 //
 // 1. Wenn V zu nahe am Maximum liegt (wie durch voltageMax definiert), wird die 
 //
 // 2 Wenn die berechnete Kraft F zu klein ist, setzen wir sie auf Null, um Rauscheffekte zu vermeiden.
 //
 // 3. In allen anderen Fällen nehmen wir den logarithmischen Wert, um die Sloop zu reduzieren und
 if ( fsrVoltageArray[FSR]  // V ist in diesem Zweig nicht zu hoch
 if ( force_value <=1.00 ) {
 fsrForceArray[FSR] =0.0; // Kraft ist zu klein, setze sie auf Null
 } else {
 fsrForceArray[FSR] =log10(force_value); // Wert ist in Ordnung, nimm das Protokoll davon
 }
 } else {
 // Begrenze die Kraft, wenn die Spannung zu nahe an Vcc liegt (für Vcc wäre es unendlich)
 fsrForceArray[FSR] =log10(forceMaxArray[FSR]);
 Serial.print("Abschneiden für FSR aktiviert ="); Serial.println(FSR);
 }
 } // Ende der Schleife über FSRs
 out["FSR1newton"] =fsrForceArray[0];
 out["FSR2newton"] =fsrForceArray[1];
 out["FSR3newton"] =fsrForceArray[2];
 }; //Ende der Sache 
 thing["weight"]>> [](pson &out) {
 // Einfache Berechnung zur Umrechnung der Kraft in Newton in das Gewicht in Gramm
 for ( int FSR =0; FSR  fsrWeightInGramsArray[FSR] =fsrForceArray[FSR] * ConversionToKgrams * 1000.0;
 }
 out["FSR1weight"] =fsrWeightInGramsArray[0];
 out["FSR2weight"] =fsrWeightInGramsArray[1];
 out["FSR3weight"] =fsrWeightInGramsArray[2];
 }; //Ende der Sache 

Vergessen Sie nicht, das Dashboard auf Thinger.io einzurichten. Ich nehme an, Sie wissen, wie das funktioniert.

Hinweis :Wenn alles wie erwartet funktioniert, sollte Ihr Dashboard ungefähr so ​​aussehen:

Beschleunigung messen

Das ist eigentlich viel einfacher, als den Druck zu messen. Wir müssen dem Header-Teil zuerst etwas Code hinzufügen. Wir beginnen mit Einbinden der Bibliotheken "Wire.h" (um mit dem SDA- und SDL-Pin zu kommunizieren), "Adafruit_Sensor.h" und "Adafruit_ADXL345_U.h". Außerdem benötigen wir drei neue globale Variablen, damit wir die Beschleunigung auf den x-, y- und z-Achsen messen und übertragen können

Entfernen Sie nicht die Bibliotheken, die Sie zuvor hinzugefügt haben. Diese benötigst du für die Verbindung zu Thinger.io.

Im nächsten Codeblock prüfen wir, ob der Beschleunigungsmesser reagiert. Wenn nicht, passiert nichts. Andernfalls wird der Bereich definiert und ein "Ding" namens "Accelerometer" ausgeführt. Dieser fragt das Gerät ab und sendet die drei Beschleunigungswerte in x-, y- und z-Richtung an den Ausgangskanal "out".

Dieser Teil des Codes ähnelt dem mitgelieferten Beispielcode von Adafruit (Datei> Beispiele> Adafruit ADXL345), aber ich habe einige Teile weggelassen, weil wir sie nicht brauchen.

#include 
#include 
#include 
/* Weisen Sie diesem Sensor eine eindeutige ID zu gleichzeitig */
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()) {// Initialisieren des Sensors
 Serial.println("No ADXL345 erkannt");
} else {
 // Reichweite für diesen Sensor - Wenn Sie die Reichweite nicht kennen, führen Sie die
 // displayDataRate des Beispielcodes des von Adafruit bereitgestellten ADXL345 aus 
 accel.setRange(ADXL345_RANGE_16_G);
 thing["accelerometer"]>> [](pson&out){ // Eine neue "thing"-Funktion für Thinger.io
sensors_event_t event;
 accel.getEvent(&event); // Holen Sie sich ein neues Sensorereignis
 out["x"] =event.acceleration.x; // Ergebnis anzeigen (Beschleunigung wird in m/s^2 gemessen)
 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");
}; //Ende der Sache
} //Ende der if/else-Anweisung
} 

Hinweis: Nachdem Sie den obigen Code ausgeführt haben, sollte Ihre Ausgabe dem unten gezeigten Beispiel ähneln

Alles zusammenfügen

Den vollständigen Code finden Sie unten auf der Seite :)

Senden Sie die Daten über Thinger.io

Diese Bibliothek ist hier gut dokumentiert, aber hier sind einige wichtige Informationen, um "Dinge" (kein Wortspiel beabsichtigt) einfacher zu schreiben und zu verwenden.

Thinger.io ist eine sehr umfangreiche Bibliothek. In diesem Abschnitt behandeln wir nur die Funktionalität, die in unserer Anwendung benötigt und verwendet wird. Die Struktur ist wie folgt (beachten Sie das Semikolon ";" nach der schließenden geschweiften Klammer "}"):

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

Dies wird in C++ als Lambda-Funktion bezeichnet. Das obligatorische erste Wort, um die Definition zu beginnen, ist "Ding" und die gesamte Funktion wird auch als "Ding" bezeichnet.

Der String ( zum Beispiel thing["myFirstThing"] ) gibt der Funktion einen Namen. Jedes "Ding" muss einen eindeutigen Namen haben.

Das Symbol ">>" zeigt an, dass dieses "Ding" nur Ausgabewerte hat. Falls eine Eingabe erforderlich ist, ändern Sie dies in "<<". Wenn sowohl Eingabe als auch Ausgabe benötigt werden, sollte das Symbol "=" verwendet werden. In unserem Fall haben wir nur Ausgabewerte.

Das Argument "pson &out" bedeutet, dass unsere Ausgabewerte über eine Datenstruktur namens "out" gesendet werden. Der Datentyp "pson" ist sehr flexibel und kann verschiedene Typen von Variablen enthalten und unterstützt auch JSON-Dokumente.

In unserem Code verwenden wir die Form "out[] =value" t o Werte an das Visualisierungsdisplay senden verbunden mit dem Aufruf "ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL)" im ersten Teil des Programms.

Wie Sie vielleicht bemerkt haben, enthält die Schleifenfunktion normalerweise nicht viel Code. Sie müssen nur "thing.handle()" aufrufen. Sie können im Loop-Teil auch Endpunkte aufrufen und Ressourcen streamen. Der gesamte andere Code wird in den von Ihnen definierten "Dingen" behandelt.

Der Code innerhalb der "Dinge" wird kontinuierlich durchlaufen. Es ist wichtig, Ihre Berechnungen in die "Dinge" zu integrieren, wenn Ihre Daten wie in unserem Fall regelmäßig aktualisiert werden.

FAQ

Nichts passiert!

Überprüfen Sie Ihre Drähte. Es besteht die Möglichkeit, dass auf dieser Ebene etwas zusammengebrochen ist. Wenn in Ihrem Serial Monitor nichts angezeigt wird, überprüfen Sie, ob sich "#define _DEBUG_" in der ersten Zeile Ihres Codes befindet. TLS kann ebenfalls störend sein. Sie können das deaktivieren, aber seien Sie dabei vorsichtig. Überprüfen Sie auch, ob Ihre Verbindung zu Thinger.io gut funktioniert.

Die Ausgabe ist nicht wie erwartet

Ist der gesamte Code, der aktualisiert werden muss, in einem "Ding" enthalten? Wenn es sich außerhalb eines "Dings" befindet, wird es nicht aktualisiert. Ich habe auch festgestellt, dass die ESP-Geräte ohne ersichtlichen Grund nicht gut mit den FSR-Sensoren funktionieren.

Die Ausgabe ist nicht aktualisiert regelmäßig

Haben Sie Ihrem Code Verzögerungen hinzugefügt? Entfernen Sie sie :) Sie können die Aktualisierungsrate auf Thinger.io selbst einstellen.

Ich würde es vorziehen, die gesamte Ausgabe in einem Diagramm zu haben

Fügen Sie den gesamten Code in einem einzigen "Ding" hinzu

Gut gemacht!

Ich hoffe, dieses Tutorial hat Ihnen geholfen, die Grundlagen von FSR-Sensoren, Beschleunigungsmessern und Thinger.io zu verstehen. Ich würde gerne alle Vorschläge lesen, um diesen Code zu verbessern, und bitte seien Sie nicht schüchtern und teilen Sie Ihre Kreationen!

Code

• Smart-Insole-Tutorial

Smart-Insole-TutorialArduino

#define _DEBUG_ //Stellen Sie sicher, dass dies kommt, bevor andere enthalten oder Ihr Board abstürzen könnte/*Bitte finden Sie das Tutorial hier:https://www.hackster.io/projects/a5ceae*/# include  //Thinger#include  //Thinger#include  //Beschleunigungsmesser#include  //Beschleunigungsmesser#include  //Beschleunigungsmesser# 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(123) // Beschleunigungsmesserint x =0; // Auf 0 zurücksetzen int y =0;int z =0; //*FSR-Sensoren*/#define noFSRs 3 // Anzahl der angeschlossenen FSRs#define FSR1 A1 //Analoge Ports#define FSR2 A2 #define FSR3 A3 float fsrVoltageArray[3]; // Der analoge Messwert konvertiert und // auf Spannung als Gleitkomma skaliert //numberfloat fsrForceArray[3]; // Die Kraft in Newtonfloat fsrWeightInGramsArray[3]; // Gewicht in Grammint umgewandelt pinArray[3] ={FSR1, FSR2, FSR3}; // Die Pin-ID für //drei Gerätefloat forceMaxArray[3] ={100.0, 100.0, 100.0}; // Maximalkräfte //supportedfloat million =1000000.0; // Einheit für "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; // Maximale Spannung auf 95% von Vcc eingestellt. // Die Kraft auf das Maximum darüber hinaus einstellen // value.ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); //Aufruf zum Einrichten der WiFi-Funktionvoid setup (void) { Serial.begin (115200); thing.add_wifi (SSID, SSID_PASSWORD); if (!accel.begin ()) {//Initialisieren Sie den Sensor Serial.println ( "Kein ADXL345 erkannt."); } else { accel.setRange (ADXL345_RANGE_16_G); // Reichweite für dieses Sensording["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; }; } /*FSR-Sensoren*/ 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)); }; Ding["Spannung"]>> [](pson &out) { for (int FSR =0; FSR > [](pson &out) { for (int FSR =0; FSR > [](pson &out) { //Einfache Berechnung zur Umrechnung der Kraft in Newton in das Gewicht in Gramm für (int FSR =0; FSR  

Schaltpläne