Skate-Mate: Smart Roller Skate Tracker With Brake (MCT Howest)

Hello, i'm Kjell a student at Howest MCT (Multimedia and creative Technologies) and welcome to the Skate-Mate project! This guide will help you build a smart roller skate tracker with an integrated brake system. Skate-Mate combines hardware (electronics and mechanics) and software (Python, JavaScript, HTML, CSS, and SQL/MariaDB) to track your skating sessions and enhance safety with an electronic brake. The enclosure fits into a shoulder bag or tote with a laser-cut insert for the electronics. The servo brake is mounted directly onto the skate using glue and a screw.

All code is available on GitHub, and a detailed Fritzing circuit diagram is provided for easy hardware assembly.

1. Raspberry Pi 5 (1x) – main controller
2. USB-C power supply 27W (1x) – for the Raspberry Pi
3. 9V power supply (1x) – for the servo motor
4. Jumper wires (1 set) – for all connections
5. Push buttons (2x) – for manual brake activation
6. LCD display DFR0063 (1x) – shows status information
7. Gyroscope/accelerometer module MPU6050 (1x) – for fall and movement detection
8. Servo motor PowerHD PHD-LF20MG, metal gears (1x) – operates the brake
9. GPS module (1x) – for location tracking
10. Breadboard (1x) – for prototyping
11. Step-up converter (1x) – converts 9V to 6V for the servo
12. Set of resistors (1 set) – for various connections
13. Roller skates (1 pair) – base for mounting
14. RTC module (1x) – keeps time when the Pi is off
15. Cable (1x) – connects the servo to the enclosure
16. Shoulder bag or tote bag + laser-cut insert (1x) – enclosure for the electronics

The Skate-Mate uses a relational database (MariaDB) to log users, trips, GPS positions, brake events, and sensor data.

The Entity-Relationship Diagram (ERD) below illustrates the structure:

The structure is as follows:

1. Users:
2. Fields: userID, name, email, max_speed
3. Purpose: Stores user profile and preferences
4. Trips:
5. Fields: tripID, userID, start_time, end_time, avg_speed
6. Purpose: Logs each skating session per user
7. GPSData:
8. Fields: gpsID, tripID, latitude, longitude, timestamp
9. Purpose: Stores GPS location points for each trip
10. ServoData:
11. Fields: servoID, tripID, status, timestamp
12. Purpose: Logs each brake event (manual or automatic, with time)
13. AcceleroData:
14. Fields: acceleroID, tripID, accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z, timestamp
15. Purpose: Stores sensor data per trip

You can find the full SQL database creation scripts and ERD diagram in my GitHub repository.

1. Use the included Fritzing diagram for all wiring details.
2. Key connections:
3. The servo is powered via a 6V step-up converter from a 9V supply.
4. The MPU6050 (gyroscope/accelerometer) and RTC module connect to the Raspberry Pi via I2C.
5. The GPS module connects via Serial pins
6. The LCD display is connected directly to the pi.
7. Push buttons are attached to GPIO pins for manual brake activation and trip start
8. Enclosure:
9. Place all electronics in a laser-cut insert inside a shoulder bag or tote.
10. Route the servo cable from the skate to the enclosure.

1. Mount the servo motor to the roller skate using glue and a screw.
2. Make sure the brake mechanism can move freely and is robust for outdoor use.
3. Use your custom laser-cut insert and bag (or adapt a tote bag) to hold all electronics.
4. Ensure the LCD and buttons are accessible from outside the bag.

Backend (Python):

1. Clone the code from your GitHub repository.
2. make a venv, use pip install requirements and install additional dependencies like instructed below
3. Install dependencies (GPIO, I2C, MariaDB connector, etc.).
4. Backend tasks:
5. Read sensor data (MPU6050, GPS).
6. Log data to the MariaDB database.
7. Control the servo for braking (manual via button, or automatic on fall detection).
8. Serve data to the frontend via REST API or WebSocket.

Frontend (HTML, JS, CSS):

1. The web dashboard runs locally on the Pi and is accessible via browser.
2. It displays:
3. Live session data
4. Brake events
5. GPS route
6. Sensor data visualization (e.g., using Chart.js)
7. Communicates with the backend for real-time updates.

1. Test all sensor readings and button inputs.
2. Ensure the servo responds triggers.
3. Check that all events are recorded in the database.
4. Verify that the web interface displays updates in real time.

1. Power on the Raspberry Pi and servo supply.
2. Start a skating session from the web interface.
3. Skate as usual; the device tracks your route and logs all brake events.(if you want to skate you'll have to make sure to use a portable power supply)
4. Activate the brake manually with the button
5. Review your session data on the dashboard.

1. All source code is available on my GitHub repository.
2. The Fritzing circuit and breadboard PDFs are included in the attachments.
3. The database schema and migration scripts are in the GitHub repo.

1. Personalize your enclosure (color, logo, extra pockets).
2. Add more sensors for expanded functionality.
3. Improve the software (user profiles, export options, notifications).

Happy skating!