Member of the Platform Team for Wayfinder (https://acubed.airbus.com/projects/wayfinder/)

Designed and implemented ROS 2 infrastructure to support air/ground data collection systems. Wrote C++ ROS 2 nodes to receive/publish data from RTL-SDR and micro-fabricated atomic magnetometer (MFAM) devices. Configured the following devices on Nuvo computers for the system: 1) Netplan Configs; 2) RTL-SDR Software-Defined Radios; 3) FLIR Cameras; 4) Honeywell n580 Inertial Navigation System; 5) Ouster OS-2 LIDAR; and 6) Geometrics Micro-Fabricated Atomic Magnetometers. Performed camera intrinsics calibration for the FLIR cameras with Kalibr. Drove POC effort from initial requirements gathering to live data collection runs.

Configured, debugged, and fixed issues on the Honeywell n580 Inertial Navigation System (INS). Debugged why the INS was not sending the PPS signal from the GPS. Used Honeywell HGuide software to configure: 1) INS reference frames; 2) GPS antenna offsets; and 3) origin heading. Enabled better INS message collection in C++ ROS 2 node.

Improved data extraction, visualization, and reporting for downstream stakeholders (pilots, flight test engineers, and ML teams).

Designed multiple URDFs of a swerve drive system for a robotic cane that aids visually-impaired people to walk. Some URDFs were for multiple-camera systems.

Designed and implemented a swerve drive controller plugin in C++ using the ROS 2 controls framework. This controller took in desired robot velocities and translated them into steering headings for the cane's wheels. Derived the kinematics/odometry equations for this controller. Wrote the initial hardware interface to allow this plugin to communicate with the steering motors.

Designed and implemented a C++ Node that processed depth camera scans into different regions to compute steering headings used to avoid obstacles while walking. Company leadership demonstrated this feature to visually-impaired individuals at the annual National Federation of the Blind convention and was also mentioned on the Double Tap (https://doubletaponair.com/) podcast.

Created a C++ Node to forward computed steering headings/wheel velocities to the steering servos.

Created a C++ Node to parse sensor data from the embedded system into ROS 2 messages.

Tuned Navigation 2 parameters for indoor navigation. These included tuning Costmap 2D layer parameters (i.e. obstacle/inflation layers) and the Progress Checker.

Created a custom Behavior Tree for indoor navigation with the cane.

Created a unified Python launch file to support the simulation and all cane models.

Created a Gazebo URDF of a "handle pusher" model to simulate a user pushing the simulated cane.

Created a Python test utility to send goals to the Navigation2 stack.

Debugged and fixed various bugs, including: 1) colliding TF frame data from conflicting publishers; 2) fixing the embedded system encoder node's read buffer size; and 3) fixing a CPU bottleneck in the servo node.

Provided suggestions to the Machine Learning team on how to improve their image segmentation pipeline; the team implemented my suggestions successfully.

Features were for a restaurant serving robot.

Designed/implemented a feature which triggered a global map refresh whenever the robot was stuck; this reduced the number of times the robot got stuck while making a table delivery.

Designed/implemented a feature which allows users to draw zones that specified the maximum robot velocity on a global map.

Designed and implemented a feature that allows the robot to find an alternative destination close to a table destination if the original destination is blocked; this feature helped reduce the robot stuck rate.

Designed and implemented a safety controller for a restaurant robot to compute the braking deceleration rate needed to stop the robot from colliding with dynamic obstacles given the robot’s current velocity.

Designed and implemented a feature that allowed users to draw zones that guided the robot to follow certain paths. Restaurant field operators would use these zones to encourage the robot to stick to certain pathways.

Modified Move Base’s Recovery Behaviors infrastructure to support multiple Recovery Behavior profiles. This allowed the marketing/product teams to request and easily add new Recovery Behavior profiles to the robot depending on customer expectations.

Designed and implemented a coverage local planner plugin for a disinfection robot.

Created a Gazebo URDF/Plugin dynamic obstacle to aid in navigation simulation testing. This is a 3D differential drive robot that had a ROS service to accept waypoints; on receiving waypoints a basic proportional controller would follow and loop through these waypoints. Navigation team members would spawn different Gazebo testing scenarios with this obstacle to ensure their features would not collide with moving objects.

Designed and implemented several Python utilities to aid in navigation debugging, such as a utility to allow navigation team to inspect a single costmap cell value.

Implemented multiple bug fixes in the navigation stack.

Developed and implemented algorithms and features for an autonomous robotic vacuum cleaner. I also developed and implemented system-side modules in C++ for the robot (i.e. database modules and supporting cloud infrastructure modules).

Designed and implemented a feature which allows users to draw a target cleaning zone on a robot-generated map. Once drawn, the robot would navigate to the zone’s interior and begin cleaning within the user-defined zone boundaries.

Designed and implemented a feature where users can take an existing map image of a previously cleaned environment and draw virtual boundaries on the map. In a future run of the same area the robot will avoid crossing these virtual boundaries without the need for physical ones.

Designed and implemented a built-in calibration tool in C++ to allow manufacturing lines to calibrate time-of-flight drop sensors and a 3-axis accelerometer.

Designed and implemented algorithms to suggest to users better locations to place the robot's charging station.

Designed and implemented C++ algorithms to take a map generated by the robot and determine room boundaries in the map (room segmentation).

Designed and Implemented C++ modules to create and upload maps of the areas that the robot had visited and cleaned to a mobile app. This allows end users to view areas that the robot cleaned and also view areas that the robot may have been unable to reach.

Implemented a Euclidean Distance Transform module to aid with improving robot navigation.

Improved the performance and memory efficiency of an A* path planning algorithm by improving the implementation of a priority queue data structure.

Found and implemented fixes for memory leaks in the C++ robot code.

Implemented improvements in system-side modules involving OpenSSL.

Designed and implemented a ROS framework for a 6 Degree-of-Freedom Robotic Arm (Schunk Powerball LWA 4.6). Derived and implemented the forward and inverse kinematic calculations for this arm. This allowed other graduate students to use this arm for their coursework.