-
Testing on Class - Grass
-
Testing on Class - Gravel
-
Testing on Class - Smooth Tile
-
Vibration reading of each class
-
Confusion Matrix
Inspiration
I wanted to explore how a small, affordable rover could understand the ground beneath it and make better decisions while moving across different surfaces.
Many autonomous robotics projects use cameras and advanced computing hardware for perception. I wanted to investigate a different approach: could a rover identify terrain using only its own movement and motor-load data, without relying on a camera or cloud processing?
This led me to TerraNode, a project at the intersection of embedded systems, machine learning, and robotics. My long-term vision is to develop a rover that does not simply move from one point to another, but can recognize when the terrain is becoming difficult, adapt its movement, and attempt to recover when it struggles.
What it does
TerraNode is a 4WD rover built around an ESP32 microcontroller. Its current prototype focuses on recognizing terrain using data collected from onboard sensors.
The main capabilities of the current prototype are:
- Terrain classification: An MPU6050 IMU measures the rover's motion, while an INA219 sensor measures electrical current. These readings are processed into numerical features that a machine-learning model uses to classify terrain.
- Edge AI: A Softmax Regression model runs directly on the ESP32, allowing terrain predictions to be made locally without cloud processing.
- Sensor data logging: The system can store collected feature data and predictions on an SD card for further analysis and model improvement.
- A foundation for adaptive mobility: The terrain-classification system is the first stage of a larger goal: developing a rover that can respond to changing surface conditions instead of relying entirely on fixed motor speeds.
The current version is a prototype, not yet a fully autonomous, self-recovering industrial rover. Those capabilities are the next stage of development.
How we built it
I started with a 4WD robotic chassis, an ESP32, an MPU6050 IMU, an INA219 current sensor, and a motor driver. I used the sensor readings to investigate how the rover's movement and motor load change across different surfaces.
I then built a machine-learning pipeline in Python to process the sensor data and train a terrain-classification model. The model's parameters were integrated into the embedded C++ firmware so that inference could run directly on the ESP32.
The current implementation uses:
- ESP32 and C++ for embedded processing and motor control.
- MPU6050 and INA219 sensors for motion and motor-current measurements.
- Python, NumPy, Pandas, and scikit-learn for data processing and model development.
- Softmax Regression for terrain classification.
- SD-card logging for recording features and predictions.
I have kept the initial system focused on a small number of affordable components. This gives me a physical platform on which I can test the complete pipeline—from sensor acquisition and feature extraction to machine-learning inference on embedded hardware.
Challenges we ran into
One of the biggest challenges was getting the electronics and the rover's physical movement to behave consistently. Motor power distribution is especially important: an earlier power-distribution problem damaged an ESP32, which reinforced the need to design and test the power system carefully.
I also encountered inconsistent runtime and movement. The rover does not always travel straight, and differences in motor behaviour can affect the quality of the sensor data. These issues matter because a machine-learning model can only be as reliable as the data and measurements on which it depends.
Another challenge was moving beyond model training on a computer. Running inference on a microcontroller requires attention to feature extraction, normalization, memory, timing, and compatibility between the training pipeline and embedded implementation.
These challenges have shown me that building an intelligent robot involves much more than achieving a good model score. The sensors, electronics, mechanical platform, firmware, and testing process all need to work together.
Accomplishments that we're proud of
- Built a physical 4WD rover that combines embedded electronics with machine learning.
- Developed an initial terrain-classification pipeline using IMU and motor-current data rather than camera images.
- Integrated a Softmax Regression model into ESP32 firmware for on-device inference.
- Established a data-logging workflow to support further experiments and model improvements.
- Turned an initial robotics idea into a working prototype that can be improved through real-world testing.
The most important accomplishment is having a physical starting point for exploring terrain-aware robotics, rather than keeping the project limited to a software model or simulation.
What we learned
TerraNode has taught me that successful robotics requires the interaction of several disciplines. Machine learning, embedded programming, electronics, power management, and mechanical design cannot be treated as completely separate parts of the system.
I have also learned the importance of collecting representative data, maintaining consistent preprocessing between training and inference, and testing on the actual hardware. A model that performs well in a dataset is not automatically enough to make a rover reliable in the real world.
Most importantly, I learned to treat problems such as motor imbalance, unstable power, and inconsistent readings as engineering problems that must be measured and addressed, rather than assuming that improving the algorithm alone will solve them.
What's next for TerraNode: Camera-Free Edge AI for Adaptive Rover Mobility
The next stage is to develop TerraNode from a terrain-classification prototype into a rover that can respond to difficult mobility conditions.
My planned improvements include:
- Wheel encoders: Measure wheel rotation and support wheel-speed feedback.
- Closed-loop motor control: Use encoder readings and PID control to regulate motor speed rather than relying only on fixed PWM commands.
- Obstacle detection: Add ultrasonic sensing to detect nearby obstacles.
- Mobility monitoring: Combine terrain predictions, wheel rotation, and sensor readings to identify possible loss of traction or situations where the rover struggles to move.
- Adaptive movement and recovery: Develop control strategies that adjust motor behaviour and attempt recovery when mobility deteriorates.
- Improved electronics and mechanical design: Organize the electronics into a custom PCB and develop a more structured chassis and sensor-mounting layout.
- Real-world evaluation: Test the rover on different surfaces and measure classification performance, mobility, recovery success, and energy consumption.
In the longer term, I want to investigate whether this approach could support low-cost robotic inspection and exploration in challenging environments such as industrial facilities, mines, and underground tunnels. Those applications would require substantially more reliability testing and appropriate safety measures.
The central question behind TerraNode is simple: can an affordable rover use its own sensor data to understand the terrain and respond intelligently when moving becomes difficult, without depending on an expensive camera-based perception system?
That is what I want to investigate and build toward next.
Log in or sign up for Devpost to join the conversation.