Summary of processes and experiences.
Project group members: Alexandru Antohe [Manager], Noel Altali [Administrator 1], Mohammad Mahdi Mahboob [Administrator 2], Liam Walker [Coordinator], Alvin Qian [Coordinator].
Figure 1. Team Portrait.
This project aimed at creating two components of an integrated system designed to sort and dispose of various beverage containers accurately. This system serves as a proof-of-concept for recycling and waste sorting stations, demonstrating a solution that is consistent and is able to handle systemic and random error correctly. The group focused on two sub-systems: the sorting and transportation system, designed by the Computation sub-team; and the operation of a container depositing device that held containers during transportation, designed by the Modelling sub-team. I worked in the Computation sub-team alongside Liam Walker and Alvin Qian.
The Computation sub-team first identified necessary objectives and constraints that outlined the program’s characteristics and allowed the program to carry out its intended function correctly. Flowcharts and high-level pseudocode of the necessary tasks required to fulfil the program requirements were first created; these were then used to form the program in Python. The program was written on a Raspberry Pi, and interfaces with a virtual simulation environment run on Quanser Interactive Labs. The environment consisted of a robotic Q-Arm, a bottle-dispensing turntable, a Q-Bot with a simulated depositing device, and the overall path and bin locations for the waste management system. The system uses ultrasonic sensors to determine the Q-Bot’s location with respect to the target location, and used modified infrared sensors to follow a given loop. The code created for the virtual environment can be modified for real-world use, and a modified code was created for the bonus portion of the project. However, the group was unable to attempt the bonus. Project process was tracked using Git VCS and GitHub, and the link to the repository can be found on the project main page.
Figure 2. Q-Bot Container Depositing Function in Virtual Environment.
Having had considerable programming experience in the past, I found my role on the Computation sub-team a comfortable one. Nevertheless, using the virtual system was a new experience for me, as I did not have much experience working with robotic systems, let alone a simulation of one. Most of my experience came from competitive programming, which differs vastly from software development for processes such as the one designed for this project. I learned many new conventions and practices for software development, especially for abstracted embedded systems. One of the main practices I learned was system testing, as the program was continuously tested and refined to ensure it was accurate. This project was also the first project where I used Git VCS and GitHub properly, so it gave me an opportunity to become familiar with Git CLI and using GitHub for repositories.
Figure 3. Q-Arm Bottle Sorting System.
Developing software for hardware systems is vastly different from competitive programming. While competitive programming focuses on problem-solving skills, computer science algorithms, and developing an efficient solution quickly, this type of development project focused much more on code readability and structure, sensor reading and analysis, and testing. The Q-Bot sensors were a unique obstacle to handle, especially in the virtual environment. Though I had some experience with sensors in Arduino, the sensors on the Q-Bot worked differently from what was expected of a sensor in the real world, and so accounting for that proved to be quite a challenge. The ultrasonic sensor returned the distance of the nearest object from any point on the circumference of the robot, which yielded different results from ultrasonic sensors mounted on the Q-Bot in a physical environment. Accounting for this proved to be challenging, but I was able to collaborate with my sub-team members to find an accurate solution.
Figure 4. Q-Bot Ultrasonic Sensor Adjustments Allow for Accurate Dispensing of Containers.
Another challenging sensor-related issue the group faced was dealing with the line-following sensors. We recognized the importance of accuracy in the transportation process, especially when the Q-Bot was traversing through curves. We concluded that a calculation-based system for wheel speeds in response to sensor readings would provide a more instantaneous reaction from the Q-Bot, as well as increase the number of readings that were conducted on average, in comparison to using if statements. This is because the calculation reduced branching when compiled, creating less delay between leading and execution. Developing an accurate calculation method that reduced branching was difficult, but my previous competitive programming experience and mathematical knowledge helped in determining a solution.
Figure 5. Q-Bot Adjustment for Accurate Home Position Returns.
Like Project 2, this project had an interview component in it, where we were asked different questions about our design as well as our competency in different concepts in our given sub-teams. I demonstrated confidence in my understanding of the code I designed and fundamental computing skills. This was an excellent opportunity for me to sharpen my communication skills, as demonstrating solutions to clients or other members of a team is crucial as an engineer.
In this project, I took the role of administrator, which again was a new role. This gave me another perspective on team dynamics, as this job was more about tracking project progress and ensuring tasks were being completed by all team members. I used much of the skills I acquired as a coordinator to still take notes throughout the design process, but I was also shouldering more responsibility for the Computation sub-team and acted as a leader for them. I delegated tasks to my teammates and ensured that they were completing the tasks along with getting my work done. I also helped my teammates in any way I could, which helped me understand all of the code we wrote. This also let me assess strengths of my teammates and delegate tasks accordingly so that the team was able to complete the project on time with minimal issues.