With the projects, I'm going to be focusing on quality more than quantity. Thus, instead of listing all that I've done, I will be listing the most memorable projects, or those which turned out to be the most interesting. Unfortunately, I may not have all the resources from previous projects due to an over-reliance on university svn, and a healthy student laziness in syncing my own version control with the university repos. In such cases, I will just write a bit about the project and what was done, and might link the last version that I have, along with a disclaimer that this was not the 'final, shipped' version.

The final results are shown below. Figure 2 shows some basic shapes rendered by the GPU. Figure 3 has the actual chip design. If you are interested and would like a more detailed/technical look, here is the final report pdf that we submitted for this project and you can have a look at the actual VHDL code (both source and mapped) on Github. Additionally, for a much more impressive demo, we rendered a rotating shape and stored the output in files that can be viewed using a java program. Download the code, and follow the one-step procedure in the README to view the demo.

In this project, I was solely responsible for the base station programming, and was handling the programmatic aspects and logic design for the microcontroller as well (sensors and communications were not handled by me). As an example, while I was not responsible for hooking up the Xbee communications (baud rate etc), I did have to make sure that the communication was 'reliable', i.e. data packets were not lost. However, in the end, I did help with PCB routing and other aspects and it turned to be a real learning experience for me. From the base station end, I used C#.net in conjunction with socket libraries and the XNA game library to communicate with the UAV, send and recieve data (and make it human-readable) and tweaking sensitivity on the Xbox 360 controller to make the UAV actually fly-able. Additionally, to reduce microprocessor load and to increase responsiveness, my base station code would pre-calculate the flight data, and directly send the requisite hex values to the microcontroller to put into the registers. Below, you will find screenshots of the GUI showing general flight data (Figure 4), and a screenshot of the main PCB design (Figure 5), omitting the powerboard which was a separate design.

Since this was a relatively large project, listing everything done here is impossible. We had to do everything from safety and environment analysis to technical analysis and present/defend our work each week. Fortunately, we had a create a website to chronicle everything hosted on Purdue's servers, and our website can now be found at the Purdue archives . It includes things like our presentations, and even our notebooks, which list the work done per week. Note that that website is not optimized for mobile viewing, and that the notebooks have lost the ECE styling after being archived, but all the content is still there. Additionally, we created a final report, user's manual and a poster at the end. The code for project (both embedded and base station) can be found on Github. We also created a video for the final demonstration, I have embedded it below for your viewing pleasure!

Being the more technically-inclined of the two, I was generally responsible for all architectural and development work while my partner opted to work on the Project Management part of things (we followed Agile Scrum + ACDM). The robot, when we got it, had ROS on it along with some python based 'capabilities' that had been programmed in by the robotics department. We had our own python module which would listen for commands on a certain port, parse those commands and convert it into lower level capabilities like "Rotate wheels for x seconds". On the other end, we had a webapp on a basic Apache tomcat server, Apache ActiveMQ for messaging, a javascript based UI and java controllers using the Struts MVC framework. The controllers would hook into the tasking system itself, allowing the user to create and execute 'tasks' remotely. These 'tasks' were larger units of works that could be placed in various combinations with one other, and internally involved capabilities strung together. One example of a task would be 'Go to room x in building y', where the tasking system had access to the map of building 'y'. Another example would be 'Go talk to advisor', which internally could include 'Go to room x in building y' along with 'Start video conference'. So, once a user had created a 'task', it could be re-used in combinations with other tasks. The overall architecture of the system is way beyond the scope of this portfolio site, but I have included the dynamic architecture in Figure 6 and static view of it in Figure 7 (click them for larger images). Additionally, an architectural document can be found here.

Since this was a multi-month project, listing everything done here is impossible. The overview above only goes over some of the technical aspect, while the technical aspect itself is only a small percentage of the project. We had to do everything including initial requirements gathering including customer sign-off and a formal SOW, architecture design including architectural experimenation, development, testing and project delivery and hand-off. Not all of the documents can be shared here, but we did have a presentation at the midpoint and the end to showcase our work to other Master's students and professors. These presentations were recorded, unfortunately those recording are only available to CMU Tartans. I was able to find my slides for these though, and the presentation for spring can be found here, while the one from summer is here. Fair warning, these aren't optimized for mobile, and are ~15MB each. The code for project (only task system, not the on-robot part) can be found on Github. We also created a video as a demo for the final presentation, along with a sample UI considering that we couldn't have the presentees follow the CoBot around the building. The code for that can be found in a separate Github repo, and I've included the video itself below (there's no sound unfortunately, as I talked over this in the presentation). Please do contact me directly if you want to know more about this project!