Remote Programming
Pluto Nano Drone.
Building a Python-based communication interface for the Pluto nano drone and extending it with ArUco localization and PID-based autonomous flight.
Controlling a drone
without the mobile app.
The Pluto nano drone was originally operated through a mobile application. The project began by developing a programming interface that could send flight commands directly from a computer.
As part of the Inter-IIT Tech Meet 11.0 Pluto Drone Swarm Challenge, I developed a Python wrapper to communicate with the drone using MultiWii Serial Protocol (MSP) messages over sockets. This removed the dependency on the mobile application and provided a software interface for commanding pitch, roll, throttle, takeoff, and landing.
The communication interface was then extended toward autonomous flight using ArUco marker-based localization and PID control for hovering and path following.
From visual feedback
to flight commands.
The system connects a Python control program with the Pluto drone through an MSP communication interface. ArUco marker observations provide localization information, while PID controllers generate corrective flight commands for autonomous motion.
ArUco Markers
Visual marker observations used for localization.
Position Feedback
Estimated drone position relative to the desired target.
PID Controller
Corrective commands for hovering and trajectory tracking.
Python + MSP
Socket communication delivers commands to the Pluto drone.
Building the
control interface.
The first stage of the project focused on understanding the drone's communication protocol and creating a Python wrapper for sending commands. MSP messages were transmitted over sockets, allowing the drone to be controlled from a computer instead of the manufacturer-provided mobile application.
Socket Connection
Established communication between the Python program and the Pluto drone.
MSP Messages
Constructed and transmitted flight-control commands using MultiWii Serial Protocol.
Reusable Wrapper
Created a software interface for executing commands and integrating autonomous control logic.
This interface provided the foundation for sending commands programmatically and incorporating feedback-based control into the drone's flight behavior.
Turning camera observations
into position feedback.
ArUco markers were used to obtain localization information for autonomous flight. The marker-based position estimates provided feedback to the control system, allowing the drone to determine its position relative to a desired target and calculate corrective commands.
Marker Detection
Detect ArUco markers in the camera observations used by the localization system.
Localization Feedback
Determine the drone's position relative to the reference used for autonomous flight.
Position Error
Compare the estimated position with the desired target to generate feedback for the PID controller.
Closing the loop
around position error.
PID control was implemented to regulate the drone's motion using localization feedback. The controller compared the desired position with the estimated position and generated corrective commands to maintain hover and follow a specified trajectory.
The controller was used for hovering and autonomous path following. Controller gains were adjusted to improve the response of the drone to position errors during flight.
Hovering
Regulated the drone's position around a desired reference using feedback from the localization system.
Path Following
Generated corrective commands to follow a sequence of target positions.
Controller Tuning
Adjusted PID parameters to improve the stability and tracking behavior of the drone.
From manual commands
to autonomous motion.
The project progressed from programmatic command execution to feedback-based autonomous flight. The Python wrapper provided direct access to the drone's flight controls, while the localization and PID modules enabled autonomous hovering and trajectory following.
Remote Commands
Validate the Python communication interface through basic flight commands.
Localization
Integrate ArUco marker-based position feedback into the control program.
Autonomous Flight
Use PID control to execute hovering and path-following behavior.
Validating the
autonomous flight stack.
The project produced a working Python interface for controlling the Pluto nano drone without the mobile application. The communication system was extended with ArUco-based localization and PID control, enabling autonomous hovering and path following on the physical drone.
Python Wrapper
Implemented computer-based flight control using MSP messages transmitted over sockets.
Autonomous Hover
Used ArUco localization and PID feedback to regulate the drone's position.
Path Following
Executed autonomous trajectory tracking using the integrated localization and control system.
See the drone
in motion.
The project demonstrates remote programming and autonomous flight behavior using the Pluto nano drone. The source repository contains the implementation and supporting project material.
Autonomous Hovering & Path Following
Physical drone experiments using ArUco localization and PID-based position control.
Explore project repositoryExplore the
implementation.
The GitHub repository contains the Python communication wrapper and supporting project files.
Have a robotics
challenge in mind?
I'm interested in opportunities involving autonomous systems, robotics software, controls, simulation, and real-world deployment. If you're building something ambitious, I'd be glad to connect.
dheerajcnv@gmail.com