Software Projects
Outside of work, I have developed and contributed to a variety of software projects using a multitude of languages, resources, and environments. Included here are some notable projects that I’ve worked on over the years.
Python
Machine Learning
Computer Vision
OpenCV
Structure-from-Motion
Serving as my senior project at the University of Florida during my last two semesters, I participated in the Integrated Products and Processes Design program, in which students are sorted into teams sponsored by various companies to find solutions to real-world problems.
My team was sponsored by Verizon, and tasked with writing software that could estimate the orientation (azimuth and tilt) of cell tower antennas based on video recorded by drones. Verizon’s solution at the time was either sending a person to climb the tower and physically measure the antennas, or sending drone videos to a third-party company that could take up to several days to return results. The job of our team, dubbed TowerVizion, was to develop an in-house solution to this problem that could get accurate results at comparable or faster speeds.
The solution we developed had two main parts. First, we used structure-from-motion to generate a point cloud in 3D space of the cell tower based on the drone footage. Next, we trained an object detection model using YOLOv8 to detect cell tower antennas. This was used to determine which points in the point cloud were associated with which antennas on the tower. Once the relevant points were labelled, we were able to draw a plane of best fit for each antenna to determine its azimuth and tilt.
A significant challenge we faced was finding an algorithm capable of generating enough keypoints. The keypoint detection algorithms used to generate the point cloud typically rely on visually distinct features, which made it difficult for them to produce a large quantity of keypoints on the uniform white surface of the antennas. Additionally, the plane of best fit drawn through the point cloud for each antenna did not have a direction assigned to be the ‘face’ of the antenna, which created ambiguity in how the azimuth was calculated.
Knowing that Verizon had their own team of engineers working on the same problem using a different process, we prioritized getting the fundamental proof-of-concept presentable. That way, Verizon engineers could utilize the basic ideas as they saw fit, and make their own decisions on how to proceed with more time or resource intensive performance improvements like developing a custom keypoint-detection algorithm.
Ultimately, we effectively proved the potential of our solution, meeting or exceeding many of the metrics we had set for ourselves. Our antenna detection algorithm had an intersection over union of over 99% and no false positives, we were able to estimate the tilt of each antenna within a few degrees, and our algorithm ran in 2-4 hours, compared to the multiple days of the third-party company.
Throughout the project, we wrote blog posts documenting our progress, thought processes, and results. An archive of this blog is available here: https://www.ippd.ufl.edu/blogs/ay2324team17/blog-posts/
Python
C++
Linux
Ubuntu
ROS
I worked in University of Florida’s Machine Intelligence Lab. The Machine Intelligence Lab is a multi-disciplinary research lab in which software, electrical, and mechanical engineers collaborate to develop an autonomous submarine to complete various challenges for the annual RoboSub competition.
While at the lab, I worked alongside a more experienced member, both in learning Robot Operating System (ROS) and writing software to integrate the submarine’s new doppler velocity log (DVL). Specifically, getting the drivers for the DVL working, and writing code to communicate the information from the drivers to the rest of the system through ROS topics. This software was successfully implemented and behaved as expected.
I also assisted other team members in various tasks around the lab such as soldering components on PCBs, debugging software, and assembling the submarine.
C
Assembly
Custom RTOS
Low-Level Hardware
I2C
SPI
UART
This was my final project for my Microprocessor Applications II class. Throughout the semester I had been developing a real-time operating system (RTOS) from scratch on the Tiva TM4C123GH6PM microcontroller with several peripherals including joysticks, an LCD screen, buttons, and a variety of sensors. My project was to use this hardware to create a program with two functionalities implemented within the RTOS: First, a digital level, and second, being able to mark points on an image to calculate an angle.
The primary challenge of this project was that the operating system to manage threads and peripheral I/O was designed from scratch, and needed to be interfaced with directly in order to implement the functionality.
The level function had two interactions activated by buttons: one to change which direction is considered “down” for the purpose of calculating the angle, and another to return to the menu to select the function to run. While the level function was active, it would read the accelerometer, calculate the board’s angle based on the force of gravity, and display that angle to the LCD.
The picture-based angle-finder function was more complex. The image came from a Beaglebone board connected to a computer with a camera. The image would then be sent via serial communication to the Tiva microcontroller to be displayed on the LCD, where the user could use a joystick to control a cursor and place three points on the image. The function would then draw lines between those points, and calculate the angle between those lines.
This was particularly challenging due to the limitations of the microcontroller. Specifically, there was not enough RAM on the Tiva microcontroller to store the entire image, and although pixels written to the LCD would remain until they were overwritten, there was no way for it to read the current value associated with a pixel. This meant that drawing a cursor on the screen for the user to control would erase portions of the image. To address this, I stored the image on the Beaglebone, and had it maintain constant serial communication with the Tiva. The Tiva would send which pixels were being overwritten, and the Beaglebone would return what colors would need to be put in those locations to restore the image once the cursor moved.
Both of these functionalities were implemented and behaved as expected, and the project was demonstrated as part of the assignment.
A copy of the code can be found in this Github repository: https://github.com/Haengele/Microprocessor-Applications-II-Final-Project
The README also contains links to the presentation where the project was explained and demonstrated, and an in-depth explanation of the code.
Javascript
CSS
HTML
React
Linear
Git
Github
Agile
While at the University of Florida, I worked with three other students to develop a website for the Pair-A-Dice Board Gaming Club. This website was intended to bridge the separate communities that had formed on different social media platforms (namely Facebook and Discord) in order to create a common hub for these two groups.
One of the members of the team had work-experience designing and developing websites and was an invaluable resource throughout the project, as this was my first real exposure to web-development. They were able to assist the team in getting familiarized with Javascript and CSS, as well as in sharing tools and strategies to keep things organized and productive.
The project followed the Agile methodology, and utilized the project management tool, Linear, along with Github for version control. These provided a helpful framework for us to maintain consistent communication across the team, and manage what issues needed to be addressed in what order, and with what level of priority. I primarily worked on the website’s front-end, and added a variety of components that the user would see and interact with.
The team successfully implemented many of the features intended to be included in the website, but due to a change in the club’s leadership, the project was not fully completed. As of writing this, the website is still hosted at http://pairadice.club/ and https://pair-a-dice-website.ue.r.appspot.com/ and the Github repository can be viewed here: https://github.com/marissamanley/SEProj
Python
ROS 2
Linux
OpenCV
SLAM
3D Kinematics
Computer Vision
Kalman Filter
Raspberry Pi
Jetson Nano
Git
Github
During my Autonomous Robots class at the University of Florida, I learned a variety of topics relating to the design and operation of robots including Robot Operating System 2 (ROS 2), operation of various sensors, computer vision systems, simultaneous localization and mapping (SLAM), and 3D kinematics. The goal of this project was to work with a group to demonstrate those principles with a topic of our choice on a TurtleBot robot.
The basis of our project was to have the TurtleBot use SLAM to navigate an area, then identify and track a printed image of a red target through the camera’s field of view (processed by a Kalman filter). While we could have accomplished the last part with something like a laser pointer, we thought it would add a fun challenge to instead use an impractically large NERF blaster.
The NERF blaster being this large relative to the actual robot caused some difficulties, however it was also very funny.
I primarily worked on integrating the NERF blaster into the system, designing and 3D printing the mount that would allow servos to aim the blaster up and down, and press the trigger (aiming left and right was handled by the TurtleBot itself rotating into position). I also wrote the code to interface with the TurtleBot and the servos according to where the camera sees the target.
We were able to successfully implement our intended features, with the TurtleBot being able to recognize, track, and shoot at the printed targets, and navigate the area with SLAM. Though we didn’t have time to integrate those two halves of the project into the same continuous program, the project was able to effectively demonstrate the topics we learned throughout the semester.
The Github repository with the code for this project can be found here: https://github.com/MjAdrian/eel4930_turtlebot4_pkg
Python
ROS 2
Linux
Controls
Lidar
GPS
IMU
Path Planning
Path Following
PID Controller
Stanley Controller
Ackermann Steering
During my Autonomous Vehicles class at UF, I worked on a small team to interface with a variety of sensors and tools using ROS 2 to implement different methods of controlling a 1/10th scale car. The course covered the mechanics and kinematics of how the vehicle moved, and various methods of controlling the vehicle to follow a path.
The first major project was using a PID controller with a Lidar sensor to travel down a hallway, maintaining a certain distance from walls and obstacles.
The next project discussed principles of path planning and path following, and combined that with pose estimation. For this, we used GPS in coordination with the vehicle’s IMU and magnetometer to estimate the vehicle’s position and orientation, and use that to follow a path outdoors using the Stanley controller.
My group was successful in completing both of these projects. I had experience from other classes with some of the concepts used in the course such as ROS, and pose estimation, however it was still an informative and fun experience to reinforce what I had already learned, and explore how those topics can be utilized in a different application.
Python
Finite State Automata
Markov Decision Process
For this project, as the final presentation for my Formal Methods of Robotics class, I worked with another student to represent the game blackjack as a partially observable Markov decision process (POMDP). Throughout the semester, we discussed various methods of analyzing such systems to determine optimal decision-making, so this scenario was chosen to demonstrate those methods.
The main obstacle of this project was how many possible game states are in blackjack, and the challenge of keeping those states organized. So many states, in fact, that when I was trying to generate a graphic to discuss this issue, the diagram generator crashed when trying to display just the possible initial states. We were able to address this by simplifying our model and removing extraneous information. For instance, rather than tracking individual cards, we could only consider the player’s total, and the dealer’s total (excluding their hidden card). While this made the mapping of transitions between states more complex, it cut down the sample space to be far more manageable without changing any of the actual behavior of the system.
I was able to successfully model the system as a Python class, working with my teammate to determine what information needed to be accessible via functions and class features, and in what format, and then implementing those features accordingly. This made it significantly easier for my teammate to perform the necessary analysis for our presentation.
We were able to verify that our model and analysis was correct by comparing it to the known basic strategy of blackjack. Our results matched very closely, indicating that the processes of our project were accurate.
C
Assembly
Custom RTOS
Low-Level Hardware
I2C
SPI
UART
This was my final project for my Microprocessor Applications II class. Throughout the semester I had been developing a real-time operating system (RTOS) from scratch on the Tiva TM4C123GH6PM microcontroller with several peripherals including joysticks, an LCD screen, buttons, and a variety of sensors. My project was to use this hardware to create a program with two functionalities implemented within the RTOS: First, a digital level, and second, being able to mark points on an image to calculate an angle.
The primary challenge of this project was that the operating system to manage threads and peripheral I/O was designed from scratch, and needed to be interfaced with directly in order to implement the functionality.
The level function had two interactions activated by buttons: one to change which direction is considered “down” for the purpose of calculating the angle, and another to return to the menu to select the function to run. While the level function was active, it would read the accelerometer, calculate the board’s angle based on the force of gravity, and display that angle to the LCD.
The picture-based angle-finder function was more complex. The image came from a Beaglebone board connected to a computer with a camera. The image would then be sent via serial communication to the Tiva microcontroller to be displayed on the LCD, where the user could use a joystick to control a cursor and place three points on the image. The function would then draw lines between those points, and calculate the angle between those lines.
This was particularly challenging due to the limitations of the microcontroller. Specifically, there was not enough RAM on the Tiva microcontroller to store the entire image, and although pixels written to the LCD would remain until they were overwritten, there was no way for it to read the current value associated with a pixel. This meant that drawing a cursor on the screen for the user to control would erase portions of the image. To address this, I stored the image on the Beaglebone, and had it maintain constant serial communication with the Tiva. The Tiva would send which pixels were being overwritten, and the Beaglebone would return what colors would need to be put in those locations to restore the image once the cursor moved.
Both of these functionalities were implemented and behaved as expected, and the project was demonstrated as part of the assignment.
A copy of the code can be found in this Github repository: https://github.com/Haengele/Microprocessor-Applications-II-Final-Project
The README also contains links to the presentation where the project was explained and demonstrated, and an in-depth explanation of the code.
Javascript
CSS
HTML
React
Linear
Git
Github
Agile
While at the University of Florida, I worked with three other students to develop a website for the Pair-A-Dice Board Gaming Club. This website was intended to bridge the separate communities that had formed on different social media platforms (namely Facebook and Discord) in order to create a common hub for these two groups.
One of the members of the team had work-experience designing and developing websites and was an invaluable resource throughout the project, as this was my first real exposure to web-development. They were able to assist the team in getting familiarized with Javascript and CSS, as well as in sharing tools and strategies to keep things organized and productive.
The project followed the Agile methodology, and utilized the project management tool, Linear, along with Github for version control. These provided a helpful framework for us to maintain consistent communication across the team, and manage what issues needed to be addressed in what order, and with what level of priority. I primarily worked on the website’s front-end, and added a variety of components that the user would see and interact with.
The team successfully implemented many of the features intended to be included in the website, but due to a change in the club’s leadership, the project was not fully completed. As of writing this, the website is still hosted at http://pairadice.club/ and https://pair-a-dice-website.ue.r.appspot.com/ and the Github repository can be viewed here: https://github.com/marissamanley/SEProj
Python
ROS 2
Linux
Controls
Lidar
GPS
IMU
Path Planning
Path Following
PID Controller
Stanley Controller
Ackermann Steering
During my Autonomous Vehicles class at UF, I worked on a small team to interface with a variety of sensors and tools using ROS 2 to implement different methods of controlling a 1/10th scale car. The course covered the mechanics and kinematics of how the vehicle moved, and various methods of controlling the vehicle to follow a path.
The first major project was using a PID controller with a Lidar sensor to travel down a hallway, maintaining a certain distance from walls and obstacles.
The next project discussed principles of path planning and path following, and combined that with pose estimation. For this, we used GPS in coordination with the vehicle’s IMU and magnetometer to estimate the vehicle’s position and orientation, and use that to follow a path outdoors using the Stanley controller.
My group was successful in completing both of these projects. I had experience from other classes with some of the concepts used in the course such as ROS, and pose estimation, however it was still an informative and fun experience to reinforce what I had already learned, and explore how those topics can be utilized in a different application.
Python
Finite State Automata
Markov Decision Process
For this project, as the final presentation for my Formal Methods of Robotics class, I worked with another student to represent the game blackjack as a partially observable Markov decision process (POMDP). Throughout the semester, we discussed various methods of analyzing such systems to determine optimal decision-making, so this scenario was chosen to demonstrate those methods.
The main obstacle of this project was how many possible game states are in blackjack, and the challenge of keeping those states organized. So many states, in fact, that when I was trying to generate a graphic to discuss this issue, the diagram generator crashed when trying to display just the possible initial states. We were able to address this by simplifying our model and removing extraneous information. For instance, rather than tracking individual cards, we could only consider the player’s total, and the dealer’s total (excluding their hidden card). While this made the mapping of transitions between states more complex, it cut down the sample space to be far more manageable without changing any of the actual behavior of the system.
I was able to successfully model the system as a Python class, working with my teammate to determine what information needed to be accessible via functions and class features, and in what format, and then implementing those features accordingly. This made it significantly easier for my teammate to perform the necessary analysis for our presentation.
We were able to verify that our model and analysis was correct by comparing it to the known basic strategy of blackjack. Our results matched very closely, indicating that the processes of our project were accurate.