TailTrack - DIY WiFi Activity Monitor for Senior Dogs

A $15 WiFi activity tracker for my 13-year-old lab. Classifies Resting, Walking, Active and pushes state to my phone. No subscription.

BeginnerFull instructions provided3 hours9

TailTrack - DIY WiFi Activity Monitor for Senior Dogs

Things used in this project

Hardware components

Espressif Wemos D1 Mini

DFRobot 6 DOF Sensor - MPU6050

TP4056 Lithium Battery Charger Module

LiPo battery

Story

The Problem

This is Pie Pie. He's a yellow lab, he's 13, and for the last few months I've been watching him like a hawk trying to figure out if he's fine or if something's wrong.

The problem with senior dogs is they sleep a lot normally. So when my dog sleeps 18 hours a day, is that his new baseline or is something off? By the time a limp or a whine shows up, you've usually missed weeks of warning signs.

My vet basically said "keep an eye on his activity patterns." Cool. How.

Commercial dog activity trackers start at $200+ and require a monthly subscription. For a 13-year-old dog whose range is "the yard and the couch, " I didn't need GPS or cellular. I just needed to see his activity pattern. So I built one.

How It Works

A tiny box on his collar contains:

WeMos D1 Mini Pro (ESP8266) - microcontroller + WiFi
MPU-6050 - 3-axis accelerometer + gyro
TP4056 - LiPo charging circuit
LiPo battery - 3.7V, ~500mAh

Every ~100ms the D1 Mini reads the accelerometer, computes magnitude = sqrt(x² + y² + z²), subtracts gravity (~9.81), and classifies the state:

magnitude < ~1.0 → Resting
1.0 ≤ magnitude < 1.5 → Walking
magnitude ≥ 1.5 → Active / Running

When the state changes, the D1 Mini pushes it over WiFi (HTTP POST) to a small dashboard endpoint. My phone gets a push notification ("Pie Pie is now Active/Running") and the day's pattern logs so I can compare today to last week.

It's not a medical device. It's the closest thing a regular person can build to "is my dog doing okay today" without a subscription.

Circuit Overview

MPU-6050 → D1 Mini (I²C):

VCC → 3V3
GND → GND
SCL → D1
SDA → D2

Power (TP4056 charger):

BAT+ / BAT− → LiPo battery leads
OUT+ / OUT− → D1 Mini 5V / GND

Step-by-Step Assembly

Flash the firmware first - easier before the board is in the enclosure. Install the ESP8266 core in Arduino IDE, set the board to LOLIN(WEMOS) D1 mini Pro, set WiFi credentials + phone endpoint URL at the top of the sketch, and upload.
Wire the MPU-6050 to the D1 Mini over I²C (VCC/GND/SCL/SDA as above). Open the Serial Monitor - you should see accelerometer values updating.
Wire the TP4056 between the LiPo and the D1 Mini. Double-check polarity before connecting the battery; LiPos do not forgive reverse polarity.
Test on the bench. Shake the assembly - both the Serial Monitor and your phone endpoint should show state transitions Resting → Walking → Active.
Mount in the enclosure. I used a small plastic food container. Battery on the bottom, D1 Mini on top, MPU-6050 taped in a fixed orientation so accelerometer axes stay consistent.
Seal the lid and velcro the enclosure to the collar. Run two zip ties through the box and around the collar as a mechanical backup (see "Tips and Lessons Learned" - velcro alone will fail on a moving dog).

Mounting on the Collar

Real lesson from a week of dog-testing: do not trust velcro alone. Pie Pie shook the enclosure off inside 24 hours on the first build. What actually worked:

Velcro to hold the enclosure flat against the collar
Plus two zip ties through the box and around the collar for structural hold
Enclosure positioned on the underside of the collar (less impact when he rolls, less visually annoying)

Tips and Lessons Learned

Jumper wires vibrate loose on a moving dog. Within a week the first build was half disconnected. Solutions, in order of durability: tape the headers down (minimum), solder everything (better), use heat-shrink tubing on each joint (best).
Thresholds are breed-dependent. 1.5G is too sensitive for a large calm dog. For Pie Pie (a big lab) 1.8–2.0G works better. Small or high-energy dogs need different values. Watch raw values for a few hours, then set thresholds where your dog's resting / walking / running clearly separate.
Push on state change only. Pushing every sample will spam your phone, kill the battery, and tell you nothing new. Only send when the classified state changes, and add a small hysteresis so a one-frame blip doesn't fire a notification.
Seal the cable entry if you live somewhere wet. If you do, use silicone, not hot glue - hot glue doesn't bond to most project box plastics long-term.

Results

Within about a week I had a real baseline for Pie Pie's day:

Morning walk - sharp activity spike
Late morning - quiet rest, usually on the good couch
Mid-afternoon - long rest (by far the biggest block of his day)
Dinnertime - small pacing spike (genuinely surprising; I didn't know that was a thing until the data showed it)
Evening walk - second sharp spike
Night - asleep

When that pattern changes, I'll know on day one instead of day fourteen. That's the whole point.

Credits

Planning: I described what I wanted ("wearable WiFi activity monitor for a senior dog, under $20 in parts, no subscription") to Make-It and it generated the initial parts list, wiring, and starter code. Threshold calibration and mount approach I figured out myself after a week with Pie Pie.

Dog modeling services: Pie Pie.

TailTrack firmware (.ino)

/*
 * TailTrack WiFi Activity Monitor
 * 
 * Description:
 * Monitors senior dog mobility using an MPU-6050 accelerometer/gyroscope
 * and a WeMos D1 Mini Pro (ESP8266). Data is processed to detect activity
 * levels and transmitted via WiFi to a local monitoring endpoint.
 * 
 * PIN CONNECTIONS (WeMos D1 Mini Pro):
 * ------------------------------------
 * MPU-6050 VCC  -> 3.3V
 * MPU-6050 GND  -> GND
 * MPU-6050 SCL  -> D1 (GPIO 5)
 * MPU-6050 SDA  -> D2 (GPIO 4)
 * 
 * LIBRARIES REQUIRED:
 * - Adafruit MPU6050
 * - Adafruit Unified Sensor
 * - ESP8266WiFi
 */

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
#include <ESP8266WiFi.h>

// --- Configuration ---
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* host = "192.168.1.100"; // IP of your monitoring server/dashboard
const uint16_t port = 8080;

// --- Constants & Thresholds ---
const float ACTIVITY_THRESHOLD = 1.5; // G-force threshold for movement
const unsigned long REPORT_INTERVAL = 5000; // Send data every 5 seconds

// --- Global Objects ---
Adafruit_MPU6050 mpu;
WiFiClient client;
unsigned long lastReportTime = 0;

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);

  Serial.println("\nTailTrack Initializing...");

  // Initialize I2C on WeMos D1 Mini default pins (D1=SCL, D2=SDA)
  Wire.begin(4, 5); 

  // Initialize MPU-6050
  if (!mpu.begin()) {
    Serial.println("Failed to find MPU6050 chip! Check wiring.");
    while (1) {
      delay(10);
    }
  }
  Serial.println("MPU6050 Found!");

  // Configure Sensor Ranges
  mpu.setAccelerometerRange(MPU6050_RANGE_2_G);
  mpu.setGyroRange(MPU6050_RANGE_250_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);

  // Connect to WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  
  int retryCount = 0;
  while (WiFi.status() != WL_CONNECTED && retryCount < 20) {
    delay(500);
    Serial.print(".");
    retryCount++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWiFi Connected!");
    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\nWiFi Connection Failed. Operating in offline mode.");
  }

  Serial.println("Setup Complete.");
}

void loop() {
  sensors_event_t a, g, temp;
  
  // Read sensor data with timeout protection (handled by library)
  if (!mpu.getEvent(&a, &g, &temp)) {
    Serial.println("Error reading MPU6050 data!");
    delay(1000);
    return;
  }

  // Calculate Magnitude of Acceleration (Vector Sum)
  float magnitude = sqrt(sq(a.acceleration.x) + sq(a.acceleration.y) + sq(a.acceleration.z));
  
  // Normalize (Subtract gravity approx 9.8 m/s^2)
  float activityLevel = abs(magnitude - 9.81);

  // Determine State
  String state = "Resting";
  if (activityLevel > ACTIVITY_THRESHOLD) {
    state = "Moving";
  }

  // Debug Output to Serial Monitor
  Serial.print("Accel X: "); Serial.print(a.acceleration.x);
  Serial.print(" | Y: "); Serial.print(a.acceleration.y);
  Serial.print(" | Z: "); Serial.print(a.acceleration.z);
  Serial.print(" | Activity: "); Serial.print(activityLevel);
  Serial.print(" | State: "); Serial.println(state);

  // Transmit Data periodically
  if (millis() - lastReportTime > REPORT_INTERVAL) {
    if (WiFi.status() == WL_CONNECTED) {
      if (client.connect(host, port)) {
        // Simple HTTP GET request to log data
        String url = "/log?activity=";
        url += String(activityLevel);
        url += "&state=";
        url += state;

        client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                     "Host: " + host + "\r\n" +
                     "Connection: close\r\n\r\n");
        
        Serial.println("Data transmitted to server.");
        client.stop();
      } else {
        Serial.println("Server connection failed.");
      }
    }
    lastReportTime = millis();
  }

  delay(100); // Sampling rate
}