Member interactive website for Wolfgang A Cappella

Last major work: 2011

Coded using HTML, CSS, Javascript, PHP, mySQL

Previous iterations of the site required manually updating information on each page and manual creation of member pages. No longer an active (singing) member of the group, I needed a way to make it easier for someone less skilled with web design to manage and update the site. I moved most of the content to databases and created a login system so that specific members could update as administrators, and other members could simply update their own profile page.

In mid 2012, a new member took over the site and re-made it without any of the material I created, so now I host my own copy of the version I created at wolfgang.dahners.com

ECE522 Spring 2013: Sleep Monitoring using an Electrooculogram (EOG)

Language: C

This group course project assigment required the group to come up with a medical device to design and implement. The group selected a topic of sleep monitoring and investigated several options. An important part of sleep monitoring is capturing REM sleep accurately, which the EOG does well and therefore became the design project.

I brought up the MSP430G2553 microcontroller early on in the semester and designed the software to acquire the signals and pass it on via UART over USB. Once this was complete, I helped design the analog circuit in OrCad Allegro using an instrumentation amplifier as the first stage, followed by filtering op-amps before the signal is sent on to the microcontroller.

Once the analog design was breadboarded and prototyped on a perfboard with some sleep testing, I designed a primarily surface mount PCB using DipTrace.

ECE786 Spring 2013: GPU CUDA Application Techniques

Language: C++ and CUDA

Implemented using CUDA SDK 2.3 and its built in emulator

Group course project, based on: Stratton, John A et al. "Algorithm and Data Optimization Techniques for Scaling to Massively Threaded Systems." Computer 45.8 (2012): 26-32. The group developed examples for each technique to demonstrate how the technique could be applied and the resulting improvement. I focused on the technqiues called Compaction and Regularization and made an example from SpMV.

ECE786 Spring 2013: Matrix Convolution in CUDA

Language: C++ and CUDA

Implemented using CUDA SDK 2.3 and its built in emulator

Two part project involving first writing matrix convultion in CUDA, then optimizing it using tiling in shared memory

ECE785 Fall 2012: N-Body Gravitational algorithm speed improvements

Language: C and ARMv7 assembly

Implemented on a Beaglebone, which uses an ARM Cortex-A8 (ARMv7), allowing for speed improvements using the Neon coprocessor

Optimzations implemented via: compilation flags, code modifications, SIMD intrinsics, and SIMD assembly

MBA514 Spring 2012: Presentation highlighting the function Trade Secrets play and whether or not Reverse Engineering should be illegal

Presentation

ECE520 Spring 2012: Verilog RTL design of a packet forwarding engine

Language: Verilog

Based on "Novel Hardware Architecture for Fast Address Lookups" by Pronita Mehrotra and Paul D. Franzon which involves the use of a trie data structure to compact the routing table

ECE521 Fall 2011: Superscalar out-of-order pipeline simulator based on Tomasulo's algorithm

Language: C++

A simulator for an out-of-order superscalar processor based on Tomasulo's algorithm that fetches, dispatches, and issues N instructions per cycle.

ECE521 Fall 2011: Branch predictor (Gshare, Yeh/Patt, and Hybrid) simulator

Language: C++

Branch prediction has become rather integral to pipelined processor performance. When a branch instruction is fectched, the pipeline likely has several stages to go before the information needed to make the branch decision is available. Therefore, the processor will have to make a choice if it's not going to stall. Of course, if it chooses incorrectly, this can be just as bad or worse, since the pipeline will get filled with instructions performing the wrong operations, and now the processor will need to restore it's state back to when the branch occurred.

This project is a few branch prediction models rolled into one simulator allowing selection of which model to use on the input. It collects some statistics, such as accesses to the predictor, mispredictions, and misprediction rate.

ECE521 Fall 2011: L1 and L2 data cache simulator with Markov chain pre-fetcher

Language: C++

This project was designed in two stages. Part A involved the creation of a generic cache simulator, which could be used to simulate any level cache in the hierarchy. It takes read/write requests as input and optionally generates appropriate read/write request for the next level of memory hierarchy. For part A, therefore, it need only simulate a level one cache, between the processor and main memory. The cache is configurable in terms of supporting any cache size, associativity, and block size, specified at the beginning of simulation. The simulator also supports replacement policies: Least Recently Used (LRU), and Least Frequently Used (LFU), as well as write policies: Write Back Write Allocate (WBWA), and Write Through No Allocate (WTNA). The simulator also collects statistics, most importantly Average Access Time.

For part B, the cache simulator had to expand to allow the simulation of an L1 and L2 cache, along with a victim cache. Having implemented the generic cache as an object now came in handy. Additionally, special index functions were required: bitwise XOR mapping, and prime modulo mapping.

MBA554 Summer 2011: Given a project, the goal was to crash the schedule while staying within budget

The project as given should take 98 days and cost $44,160. The goal is 55 days and $50,000. As it would turn out, the goal was unobtainable (the professor varied the constraints each semester and unintentionally made this project impossible). As part of my report, I included solutions to meet one goal or the other; 56.853 days for $49,999.04, or 54.965 days for $50543.50.

ECE561 Spring 2011: Design a method to accept messages on one serial port and send them out the other serial port with digital signatures added

QSK62P (RENESAS M16C processor), programmed in C, using uC/OS-II RTOS

The signature generator includes 5 signature types: repeated key, byte addition + key, byte multiplication + key, CRC-32 as described here, and ASCII vowel count.

ECE561 Spring 2011: Simulate a device which calculates and displays the lateral drift rate of a vehicle (aircraft, car, boat) where the lateral drift would be due to crosswinds, currents, skidding, etc.

QSK62P (RENESAS M16C processor), programmed in C, coordinating with a partner to use one board as the GPS output over UART, and the other board as the drift calculator

Simluated a compass onboard the craft via the onboard potentiometer and ADC. Using this information, plus the GPS data, calculated four values: heading, speed, track, and drift rate. GPS information was transmitted via UART in NMEA format.

Time was measured starting when the last character in the NMEA-0183 sentence is received, finishing once the drift calculation was complete. Optimized the calculation time using several techniques, including: minimizing use of double precision math functions where not needed, changing the distance calculation to use the Pythagorean Theorem, defining numbers as constants, replacing division with multiplication, removed redundant calculations, and compilation flags.

ECE506 Fall 2010: MSI, MESI, MOESI, and independent cache coherency simulators

Language: C++

Using the state transition diagrams, created a cache coherency simulator which collected statistics about the caches' performance. Statistics included reads, writes, read misses, write misses, interventions, invalidations, write backs, and flushes. Once the simulator functioned to simulate MSI, MESI, and MOESI, we had to implement a cache coherency model of our own design. I expanded on MOESI by adding a state I called "Common ownership" which allows the "Owner" state to reflect that it's copy has been modified while "Common ownership" indicates multiple caches can have copies of the cleanest copy of that data.

ECE506 Fall 2010: Three part project involving several parallelization techniques to improve performance

Language: C++ with OpenMP

Part One: Improving a given Gaussian Elimination algorithm by implementing parallelization using OpenMP

Part Two: Parallelizing a Histogram calculation using an array of locks, atomic operations, and code reduction

Part Three: The goal of this problem was to parallelize the insertion and deletion operations of a doubly-linked list

ECE306 Fall 2011: A vehicle which uses infrared light to track a black line on the ground.

QSK62P (RENESAS M16C processor), programmed in C, built H-bridge, buck boost, GPS circuits, using SMD components.

This project was an incremental, semester long project. The inital projects (and homeworks) required researching the manual and implementing the basics on the QSK62P. Building on these lessons, the projects built from soldering a board containing the full H-bridge, power circuit (buck boost), and later a GPS, to assembling a vehicle and having it drive itself in specified shapes, to having the vehicle register and follow a line.

Probably the most interesting projects were the line tracking, and the GPS project. The line tracking was performed by shining an IR LED onto a dark line, then having two IR collectors spaced appropriately such that they could register the light bouncing off a white background outside the line. This data was tracked and used to decide the speed of each of the driving wheels. The GPS project was more an attempt to accurately capture the output stream of the GPS chip. Here I chose to use the GPS chip in SiRF mode, where the error correction provided allowed me to double check the string received (we had the option to set up using NMEA which was "easier" but more prone to error depending on if the baud was off).

ECE209 Spring 2010: This program solves deterministic sudoku puzzles.

Programmed in C. Simple ASCII display in a console window.

Designed to solve Sudoku puzzles that have only one solution. Specification defined the protocol for user interaction and error reporting.

Senior Design Spring 2007: A program which assigns parking spaces based on availability and desired end location.

Programmed in Java.

Three person team. For demonstration purposes, the parking lot of a nearby shopping center was used as the parking lot/shopping location basis. A backend randomized fictional cars entering and exiting the parking area during the operation of the user interactive parking area entry touch screen, thus, to demonstrate, a user could select a store and would be given a space in which to park. The backend included a depiction of the parking lot and its current occupation.

ECE 492X Fall 2006: A vehicle which can set a speed and then maintain it on an incline.

Programmed in BasicX. Re-purposed an RC car for the body.

Mounted a BASICX-24 into the RC car and programmed it to read an encoder added to one wheel. Once I completed the basic requirements, I opted to re-integrate the original RC board so that I could maintain the remote control steering functionality and I re-assigned other functions to set the cruising speed and cancel cruise control.