Diy Arduino Schrittzähler

Fitness-Bands werden heutzutage immer beliebter, was nicht nur die Schritte zählt, sondern auch Ihren Kalorienverbrauch, die Herzschlagfrequenz, die Showzeit und vieles mehr erfasst. Diese IoT-Geräte werden mit der Cloud synchronisiert, sodass Sie den gesamten Verlauf Ihrer körperlichen Aktivität auf einem Smartphone abrufen können. Wir haben auch ein IoT-basiertes Patientenüberwachungssystem entwickelt, bei dem die kritischen Daten an ThingSpeak gesendet wurden, um von überall aus überwacht zu werden.

Schrittzähler sind Geräte, mit denen nur Schritte gezählt werden. In diesem Tutorial werden wir einen einfachen und billigen DIY-Schrittzähler mit Arduino und Beschleunigungsmesser bauen. Dieser Schrittzähler zählt die Anzahl der Schritte und zeigt sie auf einem 16x2-LCD-Modul an. Dieser Schrittzähler kann in diese Arduino Smart Watch integriert werden.

Erforderliche Komponenten

Arduino Nano
ADXL 335 Beschleunigungsmesser
16 * 2 LCD
LCD I2C-Modul
Batterie

ADXL335 Beschleunigungsmesser

Der ADXL335 ist ein vollständiger 3-Achsen-Analogbeschleunigungsmesser und arbeitet nach dem Prinzip der kapazitiven Erfassung. Es ist ein kleines, dünnes Modul mit geringem Stromverbrauch, einem oberflächenmikrobearbeiteten Polysiliziumsensor und einer Signalaufbereitungsschaltung. Der ADXL335-Beschleunigungsmesser kann sowohl die statische als auch die dynamische Beschleunigung messen. Hier in diesem Arduino Pedometer-Projekt fungiert der ADXL335-Beschleunigungsmesser als Schrittzählersensor.

Ein Beschleunigungsmesser ist ein Gerät, das die Beschleunigung in jede Richtung in seine jeweilige variable Spannung umwandeln kann. Dies wird durch die Verwendung von Kondensatoren erreicht (siehe Bild). Wenn sich der Accel bewegt, ändert sich der darin enthaltene Kondensator ebenfalls (siehe Bild) basierend auf der Bewegung. Da die Kapazität variiert wird, kann auch eine variable Spannung erhalten werden.

Unten sind die Bilder für den Beschleunigungsmesser von der Vorder- und Rückseite zusammen mit der Stiftbeschreibung.

Pin Beschreibung des Beschleunigungsmessers:

Die Vcc-5-Volt-Versorgung sollte an diesem Pin angeschlossen werden.
X-OUT- Dieser Pin gibt einen Analogausgang in x-Richtung
Y-OUT- Dieser Pin gibt einen Analogausgang in y-Richtung
Z-OUT- Dieser Pin gibt einen Analogausgang in z-Richtung
GND-Ground
ST- Dieser Pin dient zum Einstellen der Empfindlichkeit des Sensors

Wir bauen viele Projekte mit dem Beschleunigungsmesser ADXL335, einschließlich gestengesteuertem Roboter, Erdbebenmelder-Alarm, Tischtennis-Spiel usw.

Schaltplan

Das Schaltbild für den Arduino-Beschleunigungsmesser-Schrittzähler ist unten angegeben.

In dieser Schaltung verbinden wir Arduino Nano mit dem ADXL335-Beschleunigungsmesser. Die X-, Y- und Z-Pins des Beschleunigungsmessers sind mit den Analogpins (A1, A2 und A3) von Arduino Nano verbunden. Um 16x2 LCD-Module mit Arduino zu verbinden, verwenden wir das I2C-Modul. SCL- und SDA-Pins des I2C-Moduls sind mit A5- bzw. A4-Pins von Arduino Nano verbunden. Vollständige Verbindungen sind in der folgenden Tabelle angegeben:

Arduino Nano	ADXL335
3,3V	VCC
GND	GND
A1	X.
A2	Y.
A3	Z.
Arduino Nano	LCD I2C-Modul
5V	VCC
GND	GND
A4	SDA
A5	SCL

Wir haben diesen Schrittzähler zuerst mit dem Arduino- Setup auf einem Steckbrett gebaut

Nach erfolgreichem Test haben wir es auf Perfboard repliziert, indem wir alle Komponenten wie unten gezeigt auf Perfboard gelötet haben:

Wie funktioniert der Schrittzähler?

Ein Schrittzähler berechnet die Gesamtzahl der Schritte, die eine Person unter Verwendung der drei Bewegungskomponenten vorwärts, vertikal und seitlich ausführt. Das Schrittzählersystem verwendet einen Beschleunigungsmesser, um diese Werte zu erhalten. Der Beschleunigungsmesser aktualisiert kontinuierlich die Maximal- und Minimalwerte der 3-Achsen-Beschleunigung nach jeder definierten Nr. von Proben. Der Durchschnittswert dieser 3-Achsen (Max + Min) / 2 wird als dynamischer Schwellenwert bezeichnet, und dieser Schwellenwert wird verwendet, um zu entscheiden, ob der Schritt ausgeführt wird oder nicht.

Während des Laufens kann sich der Schrittzähler in einer beliebigen Ausrichtung befinden, sodass der Schrittzähler die Schritte anhand der Achse berechnet, deren Beschleunigungsänderung am größten ist.

Lassen Sie mich nun einen kurzen Überblick über die Funktionsweise dieses Arduino-Schrittzählers geben:

Zunächst startet der Schrittzähler die Kalibrierung, sobald er mit Strom versorgt wird.
In der Void-Loop- Funktion werden dann kontinuierlich die Daten von der X-, Y- und Z-Achse abgerufen.
Danach berechnet es den Gesamtbeschleunigungsvektor vom Startpunkt aus.
Der Beschleunigungsvektor ist die Quadratwurzel (x ^ 2 + y ^ 2 + z ^ 2) der Werte der X-, Y- und Z-Achse.
Anschließend werden die durchschnittlichen Beschleunigungswerte mit den Schwellenwerten verglichen, um die Schrittnummer zu zählen.
Wenn der Beschleunigungsvektor den Schwellenwert überschreitet, erhöht er die Schrittzahl. Andernfalls werden die ungültigen Vibrationen verworfen.

Programmieren des Arduino-Schrittzählers

Der vollständige Arduino Step Counter Code ist am Ende dieses Dokuments angegeben. Hier erklären wir einige wichtige Ausschnitte dieses Codes.

Starten Sie den Code wie gewohnt, indem Sie alle erforderlichen Bibliotheken einschließen. Der ADXL335-Beschleunigungsmesser benötigt keine Bibliothek, da er einen analogen Ausgang bietet.

#einschließen

Definieren Sie danach die Arduino Pins, an denen der Beschleunigungsmesser angeschlossen ist.

const int xpin = A1; const int ypin = A2; const int zpin = A3;

Definieren Sie den Schwellenwert für den Beschleunigungsmesser. Dieser Schwellenwert wird mit dem Beschleunigungsvektor verglichen, um die Anzahl der Schritte zu berechnen.

Float-Schwelle = 6;

Innerhalb des Hohlraum-Setups kalibriert die Funktion das System, wenn es mit Strom versorgt wird.

kalibrieren();

Innerhalb der Void-Loop- Funktion werden die X-, Y- und Z-Achsenwerte für 100 Samples gelesen.

für (int a = 0; a <100; a ++) {xaccl = float (analogRead (xpin) - 345); Verzögerung (1); yaccl = float (analogRead (ypin) - 346); Verzögerung (1); zaccl = float (analogRead (zpin) - 416); Verzögerung (1);

Berechnen Sie nach Erhalt der 3-Achsen-Werte den Gesamtbeschleunigungsvektor, indem Sie die Quadratwurzel der X-, Y- und Z-Achsenwerte ziehen.

totvect = sqrt (((xaccl - xavg) * (xaccl - xavg)) + ((yaccl - yavg) * (yaccl - yavg)) + ((zval - zavg) * (zval - zavg)));

Berechnen Sie dann den Durchschnitt der maximalen und minimalen Beschleunigungsvektorwerte.

totave = (totvect + totvect) / 2;

Vergleichen Sie nun die durchschnittliche Beschleunigung mit der Schwelle. Wenn der Durchschnitt größer als der Schwellenwert ist, erhöhen Sie die Schrittzahl und setzen Sie das Flag.

if (totave> Schwelle && Flag == 0) {Schritte = Schritte + 1; flag = 1; }}

Wenn der Durchschnitt größer als der Schwellenwert ist, aber das Flag angehoben ist, tun Sie nichts.

sonst wenn (totave> Schwelle && flag == 1) {// Nicht zählen}

Wenn der Gesamtdurchschnitt unter dem Schwellenwert liegt und das Flag angehoben ist, setzen Sie das Flag ab.

if (totave <Schwelle && flag == 1) {flag = 0; }}

Drucken Sie die Anzahl der Schritte auf dem seriellen Monitor und dem LCD.

Serial.println (Schritte); lcd.print ("Schritte:"); lcd.print (Schritte);

Testen des Arduino-Schrittzählers

Sobald Ihre Hardware und Ihr Code fertig sind, verbinden Sie das Arduino mit dem Laptop und laden Sie den Code hoch. Nehmen Sie nun das Schrittzähler-Setup in die Hand und gehen Sie Schritt für Schritt. Es sollte die Anzahl der Schritte auf dem LCD anzeigen. Manchmal erhöht es die Anzahl der Schritte, wenn der Schrittzähler sehr schnell oder sehr langsam vibriert.

Das vollständige Arbeitsvideo und der Code für den ADXL335-Schrittzähler Arduino sind unten angegeben.