ALEX

An upper body exoskeleton written in Python and C++ using Raspberry Pi, Arduino, ODrive, IMU, and Brushless DC Motors.

See the code

I am working with the student group UA Biomedical Technologies Development Group to design and prototype ALEX - an exoskeleton for the workplace. The purpose of our exoskeleton is to correct posture and reduce the load on the back and shoulders. The exoskeleton will be able to give users a 33% mechanical advantage, up to a full lift of 75lbs. This exoskeleton will be novel in that it will track motion and give feedback to the user to prevent repetitive and unhealthy range of motion injuries.

This project has allowed me to experience working on a project through the entire design process; from initial planning, materials requirements evaluation, choosing and setting up the software stack, documentation, electrical circuit design, prototyping, and of course writing code all along the way. As a member I worked in a highly interdisciplinary environment. From computer science to business, biology, and engineers of all types – the students on our team ranged the scholarly gambit. This meant often I had to clearly express technical computing concepts to an audience without any previous exposure to these ideas. I’m proud to say that through my efforts and dedication to the vision of the project I am now the Software Team Lead for our Control and Power Team.

The exoskeleton was previously being written exclusively in C++ using an Arduino to integrate an ODrive motor controller that we use to issue commands to our brushless DC motors. A big issue that we faced early on was the limitations innate to working with Arduinos. They certainly make learning microcontrollers easy but things such as the: limited IDE; predefined main, setup, and loop functions; and no code partitioning, meant we were in for problems in the long term. As such it was my job to find out how to get away from these restrictions and start writing custom and proper C++. I looked at many options for breaking out the Arduino compiler and bootloader while weighing which solution would be most flexible, best suit our needs, and be friendly to both - experienced CS students and newcomers to coding. We landed on the Arduino Makefile project. Our Makefile would need to allow our members to get working with the exoskeleton fast and easy regardless of their operating system and thus would need to support Linux, IOS, and Windows. I noticed issues with the Arduino Makefile project for Windows and ended up making a pull request to the project to correct their documentation and make a fix to the Makefile which drives the project (and it was accepted, yay!). I gained experience working with another products API’s while writing C++ to handle calibration of the ODrive and position encoder.

More recently we have moved to developing largely in Python. Our design now uses a Raspberry Pi to interface with the ODrive. This change allows us to utilize ROS, allowing us to perform processing for multiple joints in parallel – something that’s important when you want your two exoskeleton arms to move in sync. The Pi acts as our ROS master and runs discrete code segments as separate processes. These processes are nodes and they can publish information that a subscriber node may be dependent on. Some nodes that we have developed are the PID control, gravity compensation, and user movement monitoring for a joint. The user movement monitoring is handled by and IMU connected to an Arduino.

This was my first experience working with microcontrollers, and it provided a nice knowledge base for the work that I did implementing a softcore on a high-end FPGA; which was for a graduate students’ project on the effect of offloading select query processing components to an FPGA.

• Date: December 2018 - Present

Close Project

GLIR - Graphics LIbrary for RISC-V

GLIR is a terminal based graphics library allowing creation of graphical assembly programs.

See the code

See the documentation

In the summer of 2019, I had the fortune to work under J. Nelson Amaral where I aided in the conversion of materials for a course on Computer Architecture. A major project that I worked on during this time was the conversion of GLIM (Graphics LIbrary in MIPS) to GLIR (Graphics LIbrary in RISC-V).

GLIR is an open-source graphics library, written in RISC-V, which abstracts out the terminal escape sequences that are used to perform various functions such as changing display graphics and controlling cursor movement. GLIR was designed to enable beginner assembly programmers to include visual elements in their work by allowing production of graphical assembly programs.

Working on this project was a good experience in taking an existing project and needing to really understand it, without being able to consult anyone, in order to redevelop it. The conversion required me to understand both MIPS and RISC-V assembly – the intricacies of both ISA’s, how they were related and how they differed. While converting the instructions of GLIM I wrote extensive testing programs to be sure my work remained accurate. Using these testing programs, I discovered and debugged several issues that existed in GLIM.

My work wasn’t merely only a conversion. I expanded GLIR by reworking labels to avoid any namespacing issues that might occur during use of GLIR. I adapted standards employed by some C libraries for this. I also modified how syscalls were handled and limited use of pseudoinstructions in GLIR to allow for improved future portability. I added a structure to the repository to organize the project. I expanded the documentation of the original. This was important to ensure ease of use both for future undergrads who will be using GLIR for projects and - given the open-source nature of GLIR - for any who find the repository and wish to work with GLIR. In these ways, I kept conscious of good software practices. I hosted the documentation using Git Pages and this provided experience with writing HTML and CSS. I also added to the functionalities of GLIR by adding primitive subroutines; enabling printing of lines, triangles, and rectangles. Once the conversion of GLIR was complete, enabling use with a RISC-V simulator, I added support for using GLIR with RISC-V boards and the SiFive Freedom Studio.

• Date: May – August 2019

Close Project

RARS

I added Unicode character encoding support for the RISC-V assembly simulator RARS.

See the code

During my conversion for GLIR (listed in the portfolio section) I needed a simulator which would run the project. RARS proved to be an incredible tool, yet, it lacked Unicode support - which would be required for supporting a larger range of graphical options. I approached the developer of RARS about what would be required for him to accept a Unicode support pull request.

I added Unicode encoding handling for string storage, string writing, and file writing. My changes ended up being accepted and incorporated into RARS. Implementing these features required me to learn about and understand character encoding, the Unicode format, and error catching and handling in Java. RARS is written in Java and I had no experience working with Java before this project.

I believe that my success in this project, given my lack of experience working in Java before this, demonstrates my strong computer science fundamentals. Working with the object-oriented design and error handling felt natural. Using the Java documentation to find the methods that I needed was the bulk of the work. This was my first time working on a project of this scale. RARS is a multi file project with tens of thousands of lines of code. This project afforded me excellent debugging experience, especially in tracing bugs across files and using the IntelliJ IDEA debugger.

• Date: May – June 2019

Close Project

VIBES

A simple, attractive, and easy-to-use Android application to post, track, and share a user's moods.

See the code

Vibes was an Android app that I co-developed as part of a team of 6 for my “Introduction to Software Engineering” course (CMPUT 301). In that course, the professor acted as project sponsor with an initial request for a piece of software and it was up to my team and I to perform requirements gathering and deliver upon their request.

We developed a mobile application that allows one to post, track, and share their moods. For university students or staff that participate in using the app, this could allow a clearer picture of their experiences, perceptions, and mental well-being in the face of challenges in academic life.

The project was written using Java and the Android SDK with a Google Firebase database. I was responsible for designing the Event class, developing the add and edit mood event screens, and implementing location services. In addition, I wrote many of the project's unit and system tests.

This was one of my first projects working with teammates where our code was dependent on each other and being developed at the same time. I learned the importance of designing and implementing good interfaces early to prevent others from being blocked by missing code. This project was also excellent experience for seeing how using solid design patterns can save you a lot of headaches.

One impressive technical accomplishment for this project is that our app updates in real time – meaning that, for example, when someone you follow posts a mood update, you can see it without having to navigate between screens to refresh the app.

• Date: October 2019 - December 2019

Close Project

GAZPREA COMPILER

Co-developed the compiler for Gazprea - a language originally designed at the IBM Hardware Acceleration Laboratory in Markham, ON.

At the professor's request this code is not made publicly available but the language specification can be found here .

For the “Compiler Design” course (CMPUT 415) I, along with my team of 3 colleagues, got to build a compiler from the language specification for Gazprea. For this project we were responsible for building the entire compiler – all the way from writing the language grammar using ANTLR, to designing our abstract syntax tree, and finally to targeting the LLVM IR.

Gazprea is a procedural language and supports functional programming. The language is statically typed with Booleans, Characters, Strings, Integers, Reals, Tuples, Intervals, Vectors, and Matrices. It supports type inference, implicit promotion, explicit casting, and typedefs.

My contribution to the project was in designing the compiler passes and implementing the typedef and type resolution passes. Since types touch nearly every statement and expression in a language, this was a challenging task. I found that the design of the abstract syntax tree is crucial in avoiding an explosion of the code required for implementing the type system for a language.

From working on this project, I gained a deeper understanding of some of the considerations that go into making language design choices. In addition, I got firsthand experience in developing the infrastructure required for language compilation as well as the optimization opportunities that exist.

• Date: October 2020 - December 2020

Close Project

MEASURE WHAT MATTERS

A progressive web app used for the live recording of soccer game statistics and post-game visualization.

See the code

See the documentation

Measure What Matters (MWM) was produced for the "Software Process and Product Management" course (CMPUT 401). In this course, my group of 4 colleagues and I were responsible for producing a working piece of software for a real client. Our client came to us with a problem; it was our job to elicit their needs, negotiate deliverables, decide upon a solution and tech stack, manage our team, and implement a useable final product.

In the world of sports, data is a critical tool in informed decision making. Coaches of minor league teams have been recording game statistics with paper and pencil - equipped with only their best recall. In this manner, there is limited data collection ability.

There was the opportunity to use modern technologies to assist in those statistics gathering processes. The goal of MWM was to use technology to improve upon current means by making the process easier, more reliable, and to allow the recording of statistics that would previously have been too difficult. In addition, the information gathered is used to output detailed reports to assist in decision making.

For this project I was one of our front-end developers. My main contributions were the app wireframe mock-ups, the statistics recording screen, and some statistics visualizations. In addition, I was responsible for unit, integration, and system testing my code.

This was a challenging project as I had done very little front-end work previously. I enjoyed creating the stat recording screen because it forced me to think how I could design the interface to address the client requirements of being fast and easy to use – so that recording stats would not detract from their ability to coach their team. The recording screen was packed with so much functionality, while remaining very intuitive, and watching it come together while enabling us to record more statistics and produce more informative visualizations was very gratifying.

• Date: September 2020 - December 2020

Close Project