Marko Buha

Image is of the car that was used for the capstone project.

From September 2024 to April 2025, I completed a capstone project in a group of 5 to make a system to autonomously park a 1/10th scale car. The McMaster Centre for Software Certification provided the car, and we implemented the software.

We developed the system using ROS nodes coded in Python and C++.

We also conducted a hazard analysis.

Mitigation Strategies

• H1 (Actuator Failures):
  • Monitor actuator feedback for anomalies
  • Design fail-safe mechanisms (e.g., default to neutral position)
  • Schedule regular maintenance checks
• H2 (Sensor Failures):
  • Implement sensor fusion (i.e. using data from multiple sensors) to cross-validate data (FR9)
  • Monitor sensor status and perform regular self-checks
  • Continually check for sensor data that is outside of the possible range
  • Transition to a safe state and alert operator in case of failure
  • Utilize precise localization and mapping
• H3 (Software Errors):
  • Follow rigorous development practices, including code reviews and testing
  • Implement exception handling and watchdog timers
  • Use formal verification methods where applicable
  • Define a safe operational range
• H4 (Environmental Factors):
  • Calibrate sensors for different conditions
  • Use sensors less affected by environmental changes (e.g., radar instead of optical) (FR9)
  • Implement adaptive algorithms to adjust to sensor input variability
  • Use feedback-based control
• H5 (Human Interference):
  • Add tamper-detection mechanisms and operator alerts
  • Move out of the way of other drivers and pedestrians
• H6 (Latency Factors):
  • Optimize algorithms for real-time performance by reducing computational complexity
  • Use hardware acceleration (e.g., GPUs or FPGAs) for intensive tasks like image processing
  • Implement load-balancing mechanisms to distribute processing tasks dynamically
• H7 (Adjusting to Changes in Environmental Factors):
  • Implement continuous environment scanning to detect and adapt to real-time changes
  • Use machine learning models with active learning ability that dynamically update maps based on detected changes (FR1)
  • Implement geofencing to keep the vehicle within operational boundaries

Image is a visualization of a power system made using the package.

Developed in Python, this package abstracts the simulation of 2 different kinds of power systems, one frequently used in North America, one frequently used in Europe, into a common interface

Image is of the microcontroller used and shows the ports that were used.

In March 2023, I worked with 2 classmates for a class lab to develop a dynamic fan controller for a lab. We used an STM microcontroller to link up the fan and temperature sensor. By coding the microcontroller in C to output a PWM signal with a longer duty cycle in response to a higher sensed temperature, we were able to create a closed feedback control system.

One of the main challenges was parsing through the dense documentation (consisting of thousands of pages) to figure out which pins could be used for sensor inputs and outputs. Using STM32CubeMX and documentation, we were able to discover pin selections that would offer needed support (ex. PWM out, analog in) and not conflict with pins used by the screen or other microcontroller systems. This also required adjusting code in the configuration files to ensure everything was properly set up for our use case.

By working together and effectively subdividing tasks, we were able to achieve a perfect mark in the lab.

In March and April 2024, I worked with a classmate for a class lab to develop an application-specific instruction set processor (ASIP) to control a stepper motor. The main goal was to implement a set of Assembly instructions that could be used do the control, with different control modes possible such as full and half stepping.

First, we created Verilog code for each of the individual hardware components required to implement the ASIP. Then, we individually tested each component using Quartus Prime’s simulation tools. With each hardware component now verified, we could then design an FSM by determining the values of the signals sent to various hardware components. Then, this FSM was implemented in Verilog. With the hardware and FSM components both done, the whole system could be implemented on a Cyclone V FPGA.

BR is branch, BRZ is branch if R0 is zero, SR is set lower bits, SRH is set higher bits, MOV is move contents into a register, MOVR is move the motor by full stepping, MOVRHS is move the motor by half-stepping.

In December 2022, I individually designed a finite state machine using sequential logic to cycle a 7-segment display through my student number. I then built it with a teammate.

This was a wonderful opportunity to apply my k-mapping, state transition table, and other digital logic design skills learned in class to create an optimized design. The design takes advantage of logical gates, a decoder, and JK flip-flops. Specifically, the circuit was run through a decoder, which converted the binary representation of the number into the segments that needed to be lit up.

In addition, I learned how to debug circuits. For example, while building the circuit, I encountered an issue where a 3 was output instead of a 1. Upon further investigation, I realized that the bits responsible for both 2 and 1 were on (adding to 3). From there, I was able to backtrack and identify an error in how the inputs to the 2 bit were wired up.

Car Drawings

Report

I programmed in C on the McMaster RoboMaster Team. The McMaster RoboMaster Team allowed me to develop skills in a small team environment by programming autonomous robots. I enjoy small team environments like this one as I get to take advantage of the individual strengths of various teammates to contribute on the team. Working on a team like this to solve problems in robotics and embedded systems is something I would like to do during my career. In particular, I did the following:

• Coded a robot on an STM32 MCU in C to randomly vary spinning speed, reducing projectile impacts
• Developed efficient C code to aim a projectile launcher in real time based on computer vision output

GitHub

Developed in Java for the 2021 McMaster Engineering Competition, this platform allows a user to vote in an election to allow for online voting. Future improvements could include investing security options to ensure the platform is secure.

GitHub

This project was completed in June 2021 and coded in C#.

I also completed a logbook to document my daily progress as part of this project.