AI Autonomous Systems in Simulation

Create a static, multi-link differential-drive robot model using a single URDF file, defining all visual, collision, and inertial properties.

Refactor the static URDF model into a modular and configurable system using xacro properties and macros.

Integrate and spawn the custom robot model in a Gazebo simulation environment.

Derive the differential drive kinematics equations for the simulated robot.

Implement a ROS2 node to compute and publish odometry from simulated wheel encoders.

Inject varying levels of uniform noise into encoder readings to simulate real-world hardware uncertainty.

Implement a standalone PID controller class for heading and linear velocity control.

Develop a ROS2 node that uses the PID controller to navigate the robot to a single, fixed waypoint.

Explain the fundamental building blocks of a Convolutional Neural Network (CNN), including convolutional layers, pooling layers, and activation functions.

Calibrate a simulated RGB camera in Gazebo to extract its intrinsic matrix.

Implement a ROS2 node using OpenCV to detect and decode ArUco markers in a camera feed.

Estimate the 6DOF 3D pose of detected markers relative to the camera coordinate frame.

Generate and annotate a synthetic dataset of obstacle images within the Gazebo simulation.

Configure a deep learning environment and fine-tune a pre-trained YOLO model on the custom dataset.

Evaluate the trained model's performance using standard object detection metrics like mean Average Precision (mAP).

Deploy the trained YOLO model within a ROS2 node for real-time bounding box prediction.

Define the state vector (e.g., position, velocity) and linear motion model for a constant velocity object tracker.

Implement the Kalman Filter 'predict' step to project the object's state forward in time based on the motion model.

Implement the Kalman Filter 'update' step to correct the predicted state using a new measurement from the YOLO object detector.

Implement a data association method (e.g., Hungarian algorithm or nearest neighbor) to match new detections to existing tracks.

Develop a track management system to handle the full lifecycle: creation for new detections, prediction for missed detections, and deletion of stale tracks.

Integrate the tracker into a ROS2 node that subscribes to detections and publishes tracked object states.

Define quantitative metrics, such as Multiple Object Tracking Accuracy (MOTA) and ID switches, to benchmark the tracker's performance.

Implement and execute a test scenario in Gazebo where a dynamic obstacle periodically occludes the tracked object to analyze tracker robustness.

Explain the mathematical transition from the linear Kalman Filter to the Extended Kalman Filter (EKF) for non-linear systems.

Configure and launch the `robot_localization` EKF node to fuse odometry and IMU data streams.

Visualize and analyze the EKF's output against raw odometry and ground truth to identify estimation errors.

Systematically tune the EKF's process and measurement noise covariance matrices to improve the filtered state estimate.

Configure a Gazebo plugin to introduce simulated wheel slip and measure the resulting odometry error.

Generate an occupancy grid map of a complex Gazebo environment using the Cartographer SLAM package.

Identify and tune key Cartographer parameters influencing scan matching to improve local SLAM accuracy under simulated wheel slip.

Adjust loop closure search parameters in Cartographer to correct for accumulated drift over a long trajectory.

Create a ROS2 launch file to bring up the core components of the Nav2 stack (controller, planner, BT navigator).

Adapt the main Nav2 parameter file to integrate the custom robot's TF frames and data topics (scan, odom).

Configure the global and local costmap layers, including sensor sources and the obstacle inflation radius.

Describe the A* algorithm and the Nav2 Global Planner C++ plugin interface.

Implement the data structures for A*, including a priority queue for the open set and a grid for cost storage.

Implement the main A* search loop in C++, including node expansion, neighbor evaluation, and heuristic calculation.

Integrate the A* logic into the Nav2 planner plugin skeleton, including path reconstruction.

Test the custom A* planner in simulation and compare its path and performance against the default Nav2 planner.

Define the dynamic window of feasible velocities based on the robot's kinematic and acceleration limits.

Implement a trajectory generation function that simulates circular arcs for a given velocity command over a short time horizon.

Develop a multi-objective cost function to score trajectories based on goal progress, obstacle clearance, and forward velocity.

Integrate trajectory generation and scoring into a ROS2 node to select and publish the optimal velocity command at each control step.

Compare the custom local planner's performance against the default Nav2 DWA planner on a standardized navigation task.

Implement a mechanism to apply CPU throttling to the navigation nodes and measure success under a fixed CPU constraint.

Systematically test the local planner in progressively denser obstacle fields to identify and categorize its specific failure modes.

Author a technical document for the project portfolio that details the identified failure modes, supported by simulation data and visualizations.

Explain the core concepts of Policy Gradient methods and the advantage of an Actor-Critic architecture.

Describe the purpose of the clipped surrogate objective function in the Proximal Policy Optimization (PPO) algorithm.

Implement a PPO agent using a standard library (e.g., Stable-Baselines3) to solve the classic CartPole-v1 environment.

Describe the key components of the Gymnasium Env class for custom environment creation (step, reset, spaces).

Define the observation and action spaces in Gymnasium for a robotic navigation task, formulating it as an MDP.

Implement the `reset` method for a custom environment that resets the Gazebo simulation state via a ROS2 service.

Implement the `step` method that applies an action, retrieves sensor data via ROS2 topics, and calculates the next state.

Integrate a reward function within the `step` method that penalizes collisions and encourages goal-reaching.

Train a baseline PPO agent in the non-randomized custom Gazebo environment to establish a performance benchmark.

Use Gazebo services to programmatically inspect and modify simulation physics properties during runtime.

Implement domain randomization by applying Gaussian noise to the robot's Lidar state vector to simulate sensor imprecision.

Implement domain randomization by applying randomized dropout on the Lidar state vector to simulate sensor failures.

Configure and launch a PPO training process for an agent in the randomized environment.

Analyze the learning curves (e.g., mean episode reward, policy loss) to verify that the agent is learning a robust policy.

Define a zero-shot transfer test by evaluating the final robust policy in a fixed, challenging environment it has not seen during training.

Compare the zero-shot success rate of the robustly trained policy against the baseline policy.

Explain the function of a 1D Convolutional Neural Network (CNN) for feature extraction from sequential sensor data like Lidar scans.

Design and implement a custom PPO policy network using a 1D CNN feature extractor followed by an MLP head.

Configure the Gazebo simulation environment with a cluttered layout and dynamic, moving obstacles for mapless navigation.

Integrate the custom policy network with the PPO algorithm and custom Gymnasium environment to create the main training script.

Launch the PPO training process and monitor its progress using logging tools to track cumulative reward and success rate.

Define a benchmarking methodology with metrics (e.g., success rate, path smoothness, clearance) and standardized evaluation scenarios.

Execute benchmark tests for both the RL agent and the Nav2 DWA planner, analyzing the data to compare obstacle avoidance capabilities.

Document the final MDP, reward shaping experiments, network architecture, and a comparative evaluation report.

Configure a multi-robot simulation by launching multiple namespaced robots into a single Gazebo world.

Integrate the Nav2 stack into the ground rover's launch configuration within the multi-agent simulation.

Integrate the vision-based object detection pipeline into an aerial drone's launch configuration.

Implement a ROS2 action server on the ground rover to accept navigation goals.

Implement a ROS2 action client on a central mission controller node to send goals to the rover.

Implement a communication bridge for the aerial drone to broadcast the 3D world coordinates of a detected target.

Implement a subscriber on the mission controller that receives target coordinates and triggers the action client to dispatch the rover.

Validate the complete 'detect-and-dispatch' mission segment in the multi-agent Gazebo environment.

Design a complete mission state machine (e.g., Search, Detect, Dispatch, Navigate, Confirm) for the multi-agent system.

Implement the full mission logic within the central controller node, coordinating the drone and rover.

Execute and troubleshoot the end-to-end 'search, detect, and retrieve' mission loop in the multi-agent Gazebo environment.

Instrument the ROS2 system to log timestamps for key events (e.g., detection, dispatch, goal arrival).

Analyze the logged data to measure and plot the distribution of end-to-end system latency.

Identify and document the primary communication and processing bottlenecks contributing to overall system latency.

Propose and theoretically justify three specific improvements to the system architecture to mitigate identified bottlenecks.

Produce a 2-3 minute portfolio video demonstrating the complete mission, using annotations to explain system phases and outcomes.