The Dive into the Deep: Building AquaLab
I was just 15, when I decided to take on a challenge that felt absolutely massive: building a fully operational robot submarine. Not just a toy, but a real submersible lab I called AquaLab. Looking back, it was one of the coolest, most intense projects I’ve ever tackled.
Why I Built AquaLab
You know how researchers usually check water quality? They grab a tiny sample near the shore and haul it back to a lab. I looked at that and thought, "There has to be a better way." The lakes and natural waters around us deserve continuous, deep-dive monitoring. I wanted to see how water quality parameters, like pH and turbidity, changed as you went deeper and further out.
That's when the idea for a robotic, underwater laboratory, AquaLab, was born. It wasn't about finding sunken treasure (though that was the original plan, believe it or not! 😅), but about building an automated helper for marine biologists. I believed, and still do, that knowing the true state of our waters is the first step to protecting them.
Tech Stack
My final robot was a 25-kilogram beast, essentially a tough PVC pipe housing all my dreams and a ton of electronics.
- The Brains: I used an Arduino Mega for low-level, real-time control (like the motors and the awesome ballast system) and a Raspberry Pi for the high-level stuff, like managing communication and sending back the live camera feed. The Pi was the bridge between me on the shore and the robot below.
- The Muscles: Brushless motors were the way to go for propulsion. They were tricky at first; I even had to upgrade the speed controllers (ESCs) to the professional-grade ones from Blue Robotics because I needed precise control, not just raw speed.
- The Body: I actually tried two earlier versions! The second one, built with a boat builder using fiberglass, looked super sleek, but it was a total disaster. It was impossible to balance and would flop over with the smallest nudge. Lesson learned: sometimes the simplest design (back to the PVC pipe!) is the most functional.
The Innovation: The Ballast System
This is the part I'm proudest of. Other similar-sized robots usually use vertical thrusters to force themselves up or down. I didn't like that—it uses too much power and isn't precise for hovering. I wanted to use Archimedes' Principle, just like a real submarine!
- The Setup: It uses two high-pressure tanks (I cleverly modified old fire extinguishers for this—they're cheap and built to handle the pressure!) and two flexible, variable-volume tanks (think heavy-duty, silicone water bottles, also a cheap solution).
- The Magic: To sink, I release air from the variable tanks into the water, decreasing the robot's volume and reducing the buoyant force. To rise, I open a solenoid valve and let high-pressure air flow from the fire extinguisher tanks into the flexible tanks, expanding them. This increases the robot’s volume, creating more buoyancy, and up it goes!
- The Control: The key was time-based control. I'd only open the solenoid valves for tiny bursts—like 20 to 60 milliseconds. This small, precise shot of air allowed me to perfectly tune the buoyancy and achieve that magical neutral buoyancy (hovering). It worked way better than I had calculated!
💻 Building the Control Center
The robot's hardware was intense, but the software was the heart of it all. I wrote the entire control system from the ground up in C++ using the Qt framework.
- The Pilot Seat: On the surface, I had a custom-built GUI (Graphical User Interface) that was my command center. It gave me a live camera feed, a real-time horizon widget using gyroscope data to see the robot's tilt, and hardware controls for the motors and the precise ballast system with a joystick and potentiometers.
- The Power of Data: The system was constantly refreshing data every 5 milliseconds. I used the faster, connectionless UDP protocol for communication because speed was critical. My ballast control was based on "set values" (scale) rather than "add/subtract," ensuring stability even if a command was missed.
- Reliving the Dive: I even built a full data logging and playback system inside the system. I could run a mission, save every single data point, and then "replay" the dive later, watching the graphical interface move exactly as it did in real-time. This was super helpful for analysis and debugging!
- The Biologist's View: I also built a separate, streamlined interface just for the biologists; a dashboard with graphs and data visualization to make those complex sensor readings instantly useful (also in cpp)
Looking Back: What I Really Learned
Thinking back on those two years, it was a total rollercoaster. I remember the low points; like seeing that sleek fiberglass hull (Version 2!) just flop over and realizing it was a disaster. But then there were the highs, like that moment of pure triumph when the Archimedes ballast system finally clicked, and the 25-kilo PVC pipe perfectly hovered for the first time. That feeling? Unforgettable.
The technical skills were huge - C++, Arduino, pressure systems, networking - but the biggest lesson? It was learning how to take an idea scribbled on a notebook and actually manage that complex project all the way to a working underwater vehicle. It taught me persistence, problem-solving, and a lot of patience.
The AquaLab is still out there, though. I'm always thinking about the next upgrade: adding that automated sediment sampler and making the system even more bulletproof. It was a wild ride for a high school kid, and honestly, I wouldn't trade the experience for anything.
To be honest one mistake was greater than the others: the documentation is not good enough to open-source it. Clearly, I’ll have to do it.