Inteligentna skakanka z zastosowaniem Arduino

Poniedziałek, 01 Maj 2023

Na rynku dostępnych jest wiele różnych akcesoriów elektronicznych, które w jakimś stopniu pomagają nam w ćwiczeniach sportowych lub monitorują postępy i efekty np. poprzez zliczanie spalonych kalorii. Zaprezentowane urządzenie należy o drugiej kategorii - elektroniczna skakanka liczy skoki, a dzięki temu wyznacza liczbę spalonych kalorii.

W artykule opisany został projekt inteligentnej skakanki wykonanej z użyciem środowiska Arduino. Moduł ten zlicza liczbę skoków, a dzięki temu pozwala na śledzenie codziennej aktywności. Dane przechowywane są w chmurze - moduł wysyła dane do sieci w czasie rzeczywistym podczas skakania. Można przeglądać te dane w dowolnej przeglądarce internetowej. Moduł wyświetla liczbę skoków, szybkość w skokach na minutę i spalone kalorie. Po sesji rejestruje te same dane poprzez portal Thingspeak.

Opisany gadżet jest idealny dla wszystkich, którzy chcą być fit lub chcą schudnąć. Można go zintegrować z dowolnymi systemami w chmurze, które udostępniają swoje API. Urządzenie można dowolnie modyfikować, aby przekazywało dane do dowolnego systemu w sieci internetowej.

Potrzebne elementy

Obwód nie jest skomplikowany. Zasadniczo składa się z modułu Wemos, enkodera i baterii. Mówiąc dokładniej, do zestawienia omawianej inteligentnej skakanki potrzebne są:

moduł Wemos D1 mini,
enkoder obrotowy,
bateria Li-Po 3,7 V o pojemności 500 mAh,
miniprzełącznik suwakowy,
łożysko 608ZZ,
łożysko 624ZZ,
śruba M4 (o długości 25 mm),
nakrętka M4 × 2 szt.,
śruba montażowa o długości 8 mm × 4 szt.

Ponadto będą potrzebne:

drukarka 3D,
lutownica wraz z wymaganymi akcesoriami (cyna itp.),
podstawowe narzędzia - śrubokręty, kombinerki itp.,
ściągacz do izolacji.

Zebrane elementy do budowy układu pokazano na fotografii 1.

Fotografia 1. Elementy potrzebne do budowy inteligentnej skakanki

Obudowa

Skakanka ma dwa uchwyty do trzymania. Jeden zawiera w sobie całą elektronikę, drugi pełni tylko funkcję uchwytu dla linki skakanki. Linka skakanki zamontowana jest na łożyskach.

Wszystkie kluczowe elementy obudowy wykonane są w technologii druku 3D. Autor załączył wszystkie projekty 3D w postaci plików .STL na stronie z projektem. Można także pobrać wszystkie pliki z Thingiverse (link na końcu artykułu).

Wszystkie elementy zostały wydrukowane na drukarce Flashforge Creator pro z dyszą o otworze 0,4 mm i normalnymi ustawieniami wraz z podporami. Efekt pokazano na fotografii 2. Wydrukować je można w zasadzie z dowolnego materiału, np. PET.

Fotografia 2. Elementy obudowy i konstrukcji mechanicznej skakanki z druku 3D

Układ elektroniczny

Elektronika skakanki jest bardzo prosta, składa się z zaledwie kilku elementów. Na rysunku 1 pokazano schemat urządzenia. Do enkodera obrotowego podłączamy dwie linie zasilania (masa i 5 V) i linie CLK, DT oraz SW, które podpinamy, odpowiednio, do linii D2, D1 i D5 mikrokontrolera. Jeśli zmienimy te linie w module Wemos na inne, musimy dokonać odpowiedniej zmiany również w oprogramowaniu, co zostanie opisane w dalszej części artykułu.

Fotografia 3. Enkoder wraz z zainstalowanym wydrukowanym elementem

Enkoder obrotowy służy do zliczania skoków. Jest również znany jako enkoder kwadraturowy lub względny enkoder obrotowy. Jego wyjściem jest seria impulsów prostokątnych na dwóch wyjściach układu. Z różnicy faz pomiędzy tymi dwoma przebiegami odczytać można kierunek obrotów, a z częstotliwości impulsów liczbę obrotów. Przed wlutowaniem w płytkę należy włożyć element encoder_knob do enkodera obrotowego i włożyć tam nakrętkę M4, jak pokazano na fotografii 3.

Rysunek 1. Schemat układu

Wszystkie elementy dobrze jest przetestować przed zlutowaniem. Po połączeniu elementów (jak pokazano na schemacie na rysunku 1) można umieścić elektronikę w uchwycie, jak pokazano na fotografii 4. Pozwoli to na dopasowanie długości przewodów do wzajemnego ułożenia poszczególnych modułów.

Fotografia 4. Montaż elektroniki w obudowie

Montaż

Po wydrukowaniu elementów obudowy i zmontowania elektroniki, jak omówiono powyżej, można przystąpić do montażu poszczególnych elementów w obudowie. W pierwszej kolejności w główny uchwyt musimy wpasować łożysko 624ZZ. Należy umieścić je w uchwycie głównym, jak pokazano na fotografii 5. Jeśli poprawnie usunięte zostaną wszystkie wydrukowane w 3D podpory, to łożysko będzie idealnie pasować. Łożysko służy do zmniejszenia siły tarcia i zapewnia płynny obrót linki skakanki podczas jej ruchu.

Fotografia 5. Osadzenie łożyska

Teraz trzeba umieść wszystkie zlutowane elementy elektroniczne w uchwycie głównym, jak pokazano na fotografii 6. Należy się upewnić, że przewody nie są splątane z enkoderem. Powinien obracać się on bez żadnych problemów.

Fotografia 6. Wszystkie zlutowane elementy elektroniczne umieszczone w uchwycie głównym

Teraz można zamontować linkę skakanki. Do tego wykorzystujemy wydrukowany w 3D uchwyt linki, nakrętkę M4 i śrubę M4. Wkładamy nakrętkę M4 do uchwytu liny, a następnie śrubę do nakrętki. Tak przygotowany element montujemy do nakrętki na enkoderze obrotowym. Aby przymocować go do enkodera obrotowego, wkładamy śrubę przez otwór z przodu obudowy i przykręcamy, trzymając za wydrukowany element, zainstalowany na enkoderze. Po przykręceniu go do enkodera możemy zainstalować linkę skakanki w uchwycie, wiążąc ją do otworów przygotowanych w uchwycie, który właśnie przykręciliśmy.

Po skręceniu tego uchwytu zakrywamy elektronikę również drukowaną w 3D pokrywką. W tym celu używamy małych, 8 mm śrubek, jakie przygotowaliśmy. Po skręceniu należy upewnić się, że enkoder obrotowy obraca się płynnie, obracając linkę skakanki ręcznie. Należy również upewnić się, że można nacisnąć przycisk enkodera, naciskając część uchwytu linki. Jeśli enkoder obrotowy obraca się płynnie i można nacisnąć przycisk, oznacza to, że uchwyt główny jest gotowy.

Ostatni krok montażu jest opcjonalny. Można równie dobrze użyć uchwytu z gotowej skakanki. Jeśli jednak chcemy, aby oba uchwyty były takie same i wydrukowaliśmy komplet elementów dla drugiego uchwytu, przystąpmy do montażu. Rozpoczynamy go od zainstalowania łożyska 608ZZ w otworze z przodu uchwytu. Następnie drugi koniec linki wkładamy w drugi uchwyt przez otwór łożyska. Teraz koniec linki wkładamy do odpowiedniego uchwytu i zaciskamy tak, aby zaklinowała się ona w otworze łożyska. Następnie zakrywamy koniec drugiego uchwytu, mocując osłonę. Gotowa skakanka pokazana jest na fotografii tytułowej.

Oprogramowanie

Działanie tego urządzenia jest proste. Istnieją 4 główne kroki, jakie realizuje oprogramowanie. Pierwszy to połączenie z Wi-Fi, drugi to zliczanie skoków, trzeci to obliczanie liczby spalonych kalorii, a czwarty to wysyłanie tych danych na stronę internetową i rejestrowanie tych danych w Thingspeak w chmurze.

Połączenie z Wi-Fi

WiFiManager to świetna biblioteka, którą można dodać do projektów bazujacych na mikrokontrolerze ESP8266, ponieważ korzystając z tej biblioteki, nie trzeba zapisywać na stałe danych logowania do sieci bezprzewodowej (SSID i hasła) w kodzie programu. Mikrokontroler automatycznie dołączy do znanej sobie sieci lub skonfiguruje punkt dostępowy, który może zostać użyty do skonfigurowania poświadczeń sieciowych dla układu w dowolnym miejscu. Proces ten pokazano na rysunku 2 wraz z opisem uruchamiania systemu.

Rysunek 2. Sieciowe menu konfiguracyjne do wybierania sieci Wi-Fi, do jakiej podłączyć ma się urządzenie

Zliczanie liczby skoków

Do zliczania obrotów zastosowano prosty algorytm, działający w głównej pętli programu - loop(). Sprawdza on, czy obecny stan jest taki sam, jak stan w poprzedniej iteracji. Jeśli różnią się, to znaczy, że pomiędzy iteracjami wystąpiło zbocze sygnału. Od kierunku tego zbocza (narastające lub opadające) zależna jest detekcja kierunku obrotów enkodera, co w tym przypadku nie jest jednak aż tak istotne, gdyż zliczamy po prostu obroty.

Autor wyznaczył, że jeden skok przez skakankę to 5 impulsów z enkodera. Wykonał on 50 skoków na skakance i wyznaczył wartość średnią - było to właśnie 5 impulsów. Liczba zmierzonych impulsów dzielona jest w związku z tym przez 5 - każde pełne 5 impulsów to jeden skok przez skakankę.

Obliczanie częstotliwości skoków

Aby obliczyć szybkość skakania (na minutę), program zapisuje czas rozpoczęcia skakania za pomocą funkcji millis() w zmiennej. Oblicza on współczynnik skoków po każdych 20 zliczeniach, dzieląc liczbę wykonanych skoków przez czas, który upłynął. Wartość ta jest następnie mnożona przez 60, aby uzyskać wartość w liczbie skoków na minutę, która potrzebna będzie dalej, do obliczenia liczby spalonych kalorii.

Obliczanie spalonych kalorii

Każda czynność wymaga innego wydatku energetycznego. Spacer w spokojnym tempie z pewnością spali mniej kalorii niż bieganie czy aerobik. Ten wydatek energetyczny jest zwykle wyrażany w MET - metabolicznym odpowiedniku zadania. Ta miara mówi, ile kalorii spalane jest na godzinę aktywności i na jeden kilogram masy ciała. Możesz łatwo wybrać jeden z wielu rodzajów aktywności w kalkulatorze spalonych kalorii. Na przykład chodzenie ma wartość MET 3,8, podczas gdy piesze wędrówki już 6. Im wyższa jest ta wartość, tym więcej energii wymaga zadanie.

Czym więc dokładnie jest 1 MET? Definiuje się go jako stosunek energii zużytej w jednostce czasu podczas określonej aktywności fizycznej do wartości referencyjnej 3,5 ml O₂/(kg·min). Po ponownym obliczeniu i przeliczeniu mililitrów tlenu na kalorie dochodzimy do ostatecznego wzoru:

gdzie:

T - czas trwania aktywności (w godzinach),
W - masa ćwiczącego (w kilogramach).

Zintegrowany w skakance kalkulator spalonych kalorii korzysta z powyższego wzoru do najdokładniejszego oszacowania spalonych kalorii. Algorytm przyjmuje następujące wartości MET:

MET=8,8 dla skakania poniżej 100 skoków na minutę,
MET=11,8 dla skakania pomiędzy 100 a 120 skoków na minutę,
MET=12,3 dla skakania powyżej 120 skoków na minutę (tablice sportowe podają, że do 160 skoków na minutę, ale algorytm nie uwzględnia już większych prędkości skakania).

Wyświetlanie danych na stronie internetowej

Kiedy już wszystkie dane zostaną zebrane, system przesyła je na stronę za pomocą WebSocket. WebSocket to technologia, która utrzymuje otwarte połączenie TCP, dzięki czemu można stale przesyłać dane pomiędzy mikrokontrolerem a klientem z niskim opóźnieniem. A ponieważ jest to TCP, system ma pewność, że wysyłane pakiety dotrą do adresata w stanie nienaruszonym.

ESP hostuje stronę internetową z wynikiem (liczbą spalonych kalorii i szybkością skakania) na środku. Suwak w prawym górnym rogu pozwala ustawić masę osoby wykonującej ćwiczenie, aby zapewnić dokładne obliczenia. Masa jest przesyłana z przeglądarki do ESP za pośrednictwem połączenia WebSocket.

Aby rozpocząć sesję ćwiczeń, wystarczy nacisnąć przycisk enkodera i rozpocząć aktywność. Można zobaczyć liczbę skoków w czasie rzeczywistym na stronie internetowej.

Przesyłanie danych do Thingspeak

ThingSpeak to bezpłatna usługa internetowa, która umożliwia gromadzenie i przechowywanie danych z czujników w chmurze oraz tworzenie aplikacji Internetu Rzeczy (IoT). Wystarczy założyć konto na Thingspeak i stworzyć nowy kanał. W kanale tym należy utworzyć trzy pola. Jedno pole do liczenia skoków, drugie pole do szybkości skakania i trzecie pole do zliczania spalonych kalorii. Za pomocą polecenia Write_Key w kodzie można przesłać dane do Thingspeak, wystarczy po zakończeniu aktywności nacisnąć ponownie ten sam przycisk, a ESP prześle dane do Thingspeak.

Programowanie

Przed przesłaniem kodu należy zmienić klucz Thingspeak w kodzie. Jeśli stworzymy nowy kanał w naszym koncie; na Thingspeak uzyskamy specjalny klucz, pozwalający na przesyłanie do naszego kanału. W kodzie programu zapisać musimy nasz klucz, aby dane trafiały do naszego kanału w chmurze.

Fotografia 7. Podłączenie za pomocą kabla micro USB

Za pomocą kabla micro USB (fotografia 7) należy zaprogramować urządzenie Wemos D1 mini. W tym celu otwieramy Arduino IDE i przesyłamy szkic z listingu 1. Po przesłaniu kodu do urządzenia należy odłączyć kabel micro USB i włączyć przełącznik, aby zasilać Wemos D1 mini z baterii w systemie.

Listing 1. Szkic Arduino z oprogramowaniem inteligentnej skakanki

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <WebSocketsServer.h>
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <Hash.h>
#include <WiFiManager.h>
#include <EEPROM.h>
#include "play.h"

// Pierwsza linia enkoder
#define outputA 4
// Druga linia enkodera
#define outputB 5
// Przycisk enkoder
#define button 14
// Dioda LED
#define led 2

#define USE_SERIAL Serial

int counter = 0;
int aState;
int aLastState;
int skipCount = 0;
int prevskipCount = 0;
int skips = 0;
// Licznik naciśnięcia przycisku
int buttonPushCounter = 0;
// Aktualny stn przycisku
int buttonState = 0;
// Poprzedni stan przycisku
int lastButtonState = 0;
bool buttonPressed = false;
bool settingMode = false;
bool playing = false;

const char* Weight = "";
float met = 8.8;
int skippingRate = 0;
float caloriesBurnt;
int wght = 50;
unsigned long startTime = 0;
// Tutaj umieszczamy klucz do API Thingspeak
String apiKey = "*********************";
int calories = 0;
bool thingspeak = false;

// Adres IP skakanki
const IPAddress AP_IP(192, 168, 1, 1);
// SSID sieci skakanki
const char* AP_SSID = "Smart Skipping Rope";
boolean SETUP_MODE;
String SSID_LIST;
DNSServer DNS_SERVER;
String DEVICE_TITLE = "Smart Skipping Rope";

ESP8266WebServer server(80);
WebSocketsServer webSocket = WebSocketsServer(81);

void webSocketEvent(
uint8_t num,
WStype_t type,
uint8_t * payload,
size_t lenght) {
switch (type) {
   case WStype_DISCONNECTED:
     break;
   case WStype_CONNECTED: {
       IPAddress ip = webSocket.remoteIP(num);
       webSocket.sendTXT(num, "Ready!");
     }
     break;
   case WStype_TEXT:
     if (payload[0] == ‘#’) {
       String w = "";
       w = String((const char *) &payload[1]);
       wght = w.toInt();
     }
     break;
}
}

void logToThingspeak(
String key,
int burntCalories,
int skipRate,
int skips) {
const char* host = "api.thingspeak.com";
WiFiClient client;
int retries = 5;
while (!client.connect(host, 80)
   && (retries-- > 0)) {
}
if (!client.connected()) {
   //return false;
}
String postStr = key;
postStr += "&field1=";
postStr += String(skips);
postStr += "&field2=";
postStr += String(skipRate);
postStr += "&field3=";
postStr += String(burntCalories);
postStr += "\r\n\r\n";
client.print("POST /update HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: " + apiKey + "\n");
client.print(
   "Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(postStr.length());
client.print("\n\n");
client.print(postStr);
for (byte i = 0; i < 7; i++) {
   digitalWrite(led, LOW);
   delay(250);
   digitalWrite(led, HIGH);
   delay(250);
}
if (!client.available()) {
}
}

void setup() {
pinMode (outputA, INPUT);
pinMode (outputB, INPUT);
pinMode (button, INPUT_PULLUP);
pinMode (led, OUTPUT);
// Odczytaj początkowy stan outputA
aLastState = digitalRead(outputA);
USE_SERIAL.begin(115200);
for (uint8_t t = 4; t > 0; t--) {
   USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
   USE_SERIAL.flush();
   delay(500);
}
WiFiManager wifiManager;
wifiManager.autoConnect("Smart Skipping Rope");
Serial.println("connected to Smart Skipping Rope)");
Serial.println( WiFi.SSID().c_str());
Serial.println(WiFi.psk().c_str());
wifiManager.setConfigPortalTimeout(180);
// Uruchomienie serwera WebSocket
webSocket.begin();
webSocket.onEvent(webSocketEvent);
if (MDNS.begin("esp8266")) {
   USE_SERIAL.println("MDNS responder started");
   USE_SERIAL.println(WiFi.localIP());
}
server.on("/", []() {
   String s = MAIN_page;
   server.send(200, "text/html", s);
});
server.begin();
// Dodanie usługi do MDNSa
MDNS.addService("http", "tcp", 80);
MDNS.addService("ws", "tcp", 81);
}

void loop() {
webSocket.loop();
server.handleClient();
buttonState = digitalRead(button);
// Odczytuje aktualny stan outputA,
aState = digitalRead(outputA);
// Jeśli obecny i poprzedni stan outputA są różne
if (aState != aLastState) {
// Wykrywanie kierunku obrotów
   if (digitalRead(outputB) != aState) {
   // Inkrementacja licznika skoków
     counter ++;
   }
}
// Aktualizuj wartość stanu i przejdź dalej
aLastState = aState;
delay(18);
// Jeśli zmienił się stan przycisku
if (buttonState != lastButtonState) {
   if (buttonState == HIGH) {
   // Inkrementuj wartość licznika
     buttonPushCounter++;
   }
}
// Wykrycie naciśnięcia z opóźnieniem
if (buttonPushCounter % 2 == 0) {
   digitalWrite(led, HIGH);
   if (counter >= 5) {
     skipCount = skipCount + 1;
     counter = 0;
     playing = true;
   }
   if (skipCount == 1) {
     thingspeak = true;
     startTime = millis();
   }
   if (skippingRate < 100) met = 8.8;
   else if (skippingRate >= 100
     && skippingRate < 120) met = 11.8;
   else if (skippingRate >= 120
   && skippingRate < 160) met = 12.3;
   if (skipCount % 21 == 0) {
     skippingRate = (60000 * skipCount)
       / (millis() - startTime);
     String sRate = "S" + String(skippingRate);
     webSocket.sendTXT(0, sRate);
   } else if (skipCount % 50 == 0) {
     caloriesBurnt = float(
       millis() - startTime) / 60000.0)
       * met * 3.5 * float(wght) / 200.0;
     calories = caloriesBurnt;
     String cb = "$" + String(calories);
     webSocket.sendTXT(0, cb);
   } else {
     String thisString = String(skipCount);
     webSocket.sendTXT(0, thisString);

     prevskipCount = skipCount;
   }
} else {
   digitalWrite(led, LOW);
   webSocket.sendTXT(0, "Take some rest");
   if (thingspeak == true) {
     skippingRate = (60000 * skipCount)
       / (millis() - startTime);
     caloriesBurnt = float(
       (millis() - startTime) / 60000.0)
       * met * 3.5 * float(wght) / 200.0;
     logToThingspeak(apiKey, calories,
     skippingRate, skipCount);
     thingspeak = false;
   }
   skipCount = 0;
   skips = 0;
   playing = false;
   delay(100);
}
lastButtonState = buttonState;
}

Podsumowanie

Po włączeniu trzeba podłączyć mikrokontroler do sieci Wi-Fi. Aby połączyć go z siecią bezprzewodową, można użyć telefonu komórkowego lub laptopa, aby połączyć się ze skakanką, która początkowo uruchamia własny AP do konfiguracji. Następnie otwieramy przeglądarkę i wpisujemy następujący adres IP: 192.168.4.1. Spowoduje to załadowanie następnej strony internetowej, na której możesz ustawić dane uwierzytelniające do sieci Wi-Fi (rysunek 2). Teraz można połączyć inteligentną skakankę z siecią Wi-Fi za pomocą tej strony.

Po podłączeniu urządzenia do sieci Wi-Fi należy znaleźć adres IP skakanki. Można wtedy otworzyć przeglądarkę internetową na telefonie lub laptopie, wprowadzić ten adres IP i nacisnąć Enter, aby zobaczyć stronę raportującą liczbę skoków i spalone kalorie. Na stronie tej należy ustawić prawidłową masę za pomocą suwaka w prawym górnym rogu.

Wystarczy nacisnąć przycisk na enkoderze, aby rozpocząć działanie systemu. Teraz można skakać na skakance. Można zobaczyć liczbę skoków, ich częstotliwość (w skokach na minutę) i spalone kalorie na stronie internetowej wyświetlanej przez skakankę podczas ćwiczenia. Następnie, po zakończenia ćwiczenia, należy nacisnąć ponownie ten sam przycisk, aby przesłać wszystkie dane (liczba skoków, tempo skoków i spalone kalorie) do kanału w Thingspeak. Dzięki temu można śledzić swoją codzienną aktywność związaną z skakaniem.

Na jednym ładowaniu, jeśli używamy skakanki przez 2...3 godziny dziennie, urządzenie może działać do 7...8 dni. Aby naładować baterię, wystarczy podłączyć kabel micro USB do urządzenia, a rozpocznie się ładowanie (należy pozostawić włączony przełącznik zasilania na czas ładowania). Po około godzinie można odłączyć kabel micro USB i wrócić do skakania.

Nikodem Czechowski, EP

Bibliografia: