The sanitary pipe inspection project involves developing a robot to traverse, inspect and perform measurements inside a sanitary sewer system. The purpose for this project is to give municipalities the ability to measure the flow rate of groundwater infiltration and quantify the benefits of excavation and repair in an attempt to reduce the increasing water volume and treatment/pumping costs.

Our group consists of 4 mechatronics engineers working on creating a lightweight and space efficient inspection platform that can traverse through 20cm diameter pipes and perform measurements directly in the flow stream. The mechanical, electrical and software design of the inspection platform is all designed and built completely from scratch and is aimed to be completed by the end of April 2015. I'm primarily the mechanical lead for powertrain design, manufacture and waterproofing. This is an ongoing project taking up the bulk of our time, please contact for more information.

Limited updates will be posted from time to time of the progress.

After commuting between Waterloo and Woodstock every day during the summer term I noticed that my car was quickly burning through a massive amount of oil, about 1 litre every 2-3 weeks (almost half the total capacity). There was also a nasty looking oil spot underneath my car in the parking garage which motivated this project. This was my first major engine repair job and definitely a huge learning curve.

The engine block was immediately brown and wet from the cylinder head interface and downwards. This led me to believe that there may have been a blown head gasket (among other worn seals) which was very likely since the car is 20 years old.

Accessing the cylinder heads meant that a lot of components needed to be removed. For this reason I thoroughly cleaned the engine block and replaced any necessary seals and critical components. The cylinder heads were also machined back to a perfectly flat surface.

Starting out, I had to flush the fuel lines, disconnect the battery and fuel pump relay and remove the fuel lines and spark plug wiring. Next, there was a big mess of wiring, vacuum hoses and plastic covers encompassing the fuel injection, cruise control and air intake systems that had to be removed. The picture below shows what the engine looked like at the very beginning.

The air intake manifold (giant block in the center) was the first major component to be removed and revealed a much dirtier engine underneath.

The most difficult part about this project was removing the timing belt and ensuring that the camshafts and crankshafts both remained at the TDC position even after I removed the cylinder heads. I later realized that this wasn't possible because the cams needed to be rotated to close the valves in order to machine the surface once separated from the engine. I would also find out later after removal that the crankshaft also needed to be rotated to place each piston at the top most position so that I could clean the pistons without the possibility of damaging the combustion chamber.

Thus, I removed all the covers and hoses in my way, released the tensioner and timing belt and also popped off the cam sprockets. Finally, I only had to remove the cylinder head bolts and exhaust manifold to catalytic converter bolts to remove the heads.

All the pistons were rotated to the top position so that I could gently scrub off the 20 years worth of carbon buildup without damaging the combustion chamber. Additionally, all the bolts were soaked in an anti-rust solution, each component was thoroughly brushed clean and the baked on oil which turned the engine block black was also chiseled away to reveal the true colour underneath. A comparison shot can be seen below of both before and after the cleanup. Notice the colour of the engine block is completely black between the valley pan cover and the head gasket or also at the engine to transmission interface. This took days to clean but was definitely a necessity so that I could tell in the future if a leak in this area still existed or not.

The cylinder heads were in good condition once I finally got them removed. Yet if you compare the surface finish before and after the machining, there is no comparison to the end result as the heads were immaculate once completed.

The engine block at the cylinder head interface had a large buildup of carbon and I very cautiously scrubbed this off with a weak material to ensure that no damage was caused to the surface finish of the block.

Once the cylinder heads were removed and the gaskets were accessible, it could be clearly seen that there was cross contamination of oil and also likely coolant in the combustion chamber based on the brown stains across the rings. The orange seal surrounding the edge of the gasket was also completely burned away in certain sections. Granted, the gaskets are designed to be heavily torqued to over 110 N.m, however there is almost no trace of the orange seal left in some areas of the gasket. A comparison shot of the old vs. the new gasket can be seen below.

The cylinder head bolts are the most critical component in the engine to securely fasten the engine block to the heads, without proper tightening there will be a mess of problems in the combustion chamber. Even minor coolant leaking into the combustion chamber will destroy the engine over time due to the 50/50 water to coolant ratio. The water will eventually rust the engine from the inside out. So of course the old head bolts couldn't be reused. They are subjected to such high stress that they experience plastic deformation and cannot be used again. The new head bolts had an unusual modified looking female spline bit type which ending up being a special dealer tool and huge pain to find, but luckily I was able to find one.

Finally, the picture below shows the engine after the long process of carefully cleaning and assembling the critical components back to the original positioning just prior to head bolt re-assembly.

A total list of the components that were replaced throughout the process including all filters, seals and bolts include:

Air filter
Fuel filter
Oil filter
Engine oil
Power steering fluid
Coolant
Thermostat
Cylinder head bolts
Cylinder heads re-surfaced
Valve seals verified functional
Head gaskets
Exhaust manifold gaskets
Head air intake gaskets
Intake manifold gasket
Intake throttle gasket
EGR valve seal
Valve cover seal
Camshaft front and rear seals
Valley pan seal
Water pump coolant pipe o-ring
Spark plugs
All rusted bolts restored

This was a huge learning experience and I am definitely looking forward to more complex repairs and the possibility of a classic car restoration someday in the future as a hobby. Thanks for taking the time to look!

This word clock was a fun side project to work on during the school term. The clock consists of a grid array of 12x12 letters to display all the combinations of words to represent the time in 5 minute increments. The LED design however, is composed of an array of 12x6 LEDs, mainly because the light behind the letters are diffused by a translucent plexiglass sheet anyway, so the use of an LED per letter is a bit overbearing.

The brain of the hardware is composed of the ATMega 328p microcontroller, three 8-bit bidirectional flip flops and a low frequency oscillator operating at 32.768 Khz to accurately keep track of the time. The user is also able to update the time by the use of two push buttons to adjust both the hours and the minutes.

The 8-bit data inputs for all the flip flops are tied together to an 8-bit I/O port on the microcontroller. The flip flop clock signals are also individually tied to 3 different I/O bits and the output enables are tied together to a single I/O bit on the microcontroller. To select a row or column, the output enable is first turned off, then data is written to the flip flop data inputs, a clock signal then activates the correct flip flop and finally the output enable is then activated to enable the flip flop outputs. This has to be done for both a row and a column to turn on the correct word. Note: I accidentally soldered 6 resistors between the outputs of the flip flop for the anode legs which is uneccessary given that 0V activates the columns. The traces were shorted underneath the board to get rid of them.

The pictures below show what the completed circuit looks like. With careful planning I was able to fit everything onto one board. As my own personal rule, I don't route any wires over top of traces, components or other wires unless absolutely necessary. This gives me the opportunity to easily repair any poor solder joints or misplaced connections without having to desolder any wires.

The LED grid is soldered by connecting all the cathodes in columns and the anodes into rows. To turn on an individual LED, the row is activated by turning on +5V to the anode and the column is activated by writing 0V to the cathode. With this configuration, a single row will be selected at a time while multiple columns will be selected at a time in order to write an entire word. The 12 rows are connected with 8-bits on the first flip flop and 4-bits on the second flip flop. While the 6 columns are connected via 6-bits on the third flip flop. The data that is output from the microcontroller to the flip flops is written using hexadecimal where the binary number represents which bits need to be turned on/off for each row or column.

The rows and columns are connected to the board using ribbon cable which I prefer to size, cut and crimp myself. The female headers in the below picture connect directly from the ribbon cable to the flip flop outputs. This gives a nice and sturdy connection with a custom length to properly route the wiring without interference with other components and also avoids any harsh pinches or folds.

Here is a small section of code that shows the setup for the 1 second timer interrupt, port configuration and fundamental design. The timer2 register on the 328p is intended for a watch crystal and contains an 8-bit register, which can only count up to 256 before it overflows. I used a prescaler of 128 to trim the clock from 32,768 cycles/second to measure at 32,768 / 128 = 256 cycles/second. The timer compare register OCCR2A compares it's value with the timer register and will trigger an interrupt and clear the counter register once it is true. So at 256 cycles/second and counting up to 256 (actually 255 in code since counting starts at 0), an interrupt will trigger every second which will increment the seconds counter.

The 328p operates on the interal oscillator at 8.0 Mhz and another interrupt service routine was setup to trigger every 0.4 ms. I found that this was the best refresh rate for the LEDs with a balance between blinking vs. dim words. When the interrupt is triggered it sets a bit which allows the program to call a function only once to write one of the words to be output. Because there are multiple words in each time string, a counter is used and incremented to keep track of the next word which needs to be written. This word will remain activated and the next word won't be written until the interrupt is triggered again. There are also a varying number of words to be displayed in each time string. To circumvent this, there is a check which ensures that the next set of hexadecimal values to be written to display the next word are not at the preset default 0x00 value. This ensures that the next word to be written is a real word. Each word is saved in a two dimensional array of hexadecimal numbers to select the appropriate row and column and called in the write_word() function.

The lettering was designed using Adobe Illustrator. The font had to be adjusted to account for enclosed letters such as the letters "O" or "P". The centers of these letters would have no support material and would be cut out if the board was laser cut. These letters were adjusted by redesigning the lines to prevent complete enclosure. The file was then sent to a laser cutting service to cut the wood. Translucent plexiglass was gathered, measured and cut to size in the UW machine shop and then glued to the corresponding words. This provided a nice evenly distributed lighting to each word. Since I didn't have any woodworking tools available at the time, I had to use a mill in the machine shop to cut slots in the wood to hold the lettering stencil and backboard plexiglass in place.

To separate the words and prevent light leakage, I cut popsicle sticks down to size and placed between the plexiglass sheets using superglue and a putty to seal the cracks as can be seen below.

All in all this was a simple project and only took about a week or two to complete. Throughout the process I also stumbled across a very nice local specialty project wood shop which will be great for future woodworking.

The purpose of this project was to create a controller which could individually control each of the 512 LEDs in the cube with a reduced number of I/O ports required at the microcontroller.

The wiring for the LEDs is a similar concept to that of the word clock with an added third dimension. The anodes in each pillar of the cube are connected through the layers from the top downwards. The cathodes of each leg of the LEDs are connected across the entire layer to sink the current. With this configuration there are 64 positive legs that go through the bottom of the wooden base and 8 legs that stem off of the 1st to the 8th layer of the cube. A total of 72 I/O pins was needed for the microcontroller which was still too high!

To further break down the hardware, I separated the 64 pins into 8 separate 8-bit flip flops and tied together all the flip flop inputs to one 8-bit port on the microcontroller. To sink the current at each layer, I also needed a transistor which could handle the current capacity from a total of 64 LEDs. So I used 8 transistors where the base of each transistor is tied to another 8-bit port on the microcontroller. To clock the data into the flip flops, the clock signals had to be separated and wired to the microcontroller. To do this, another 8-bit port was used to address each of the flip flops. Finally, an additional output enable I/O pin is required to turn on/off the outputs of the flip flops.

All of these combined left me with 25 total I/O pins required to control 512 LEDs. The data input bits to the flip flops represent the x-direction, the clock signal bits to select the appropriate flip flop represent the y-direction, while the transistor bits to select the layer represent the z-direction.

With a little bit of difficulty for spacing on the largest protoboard I could find, I was finally able to organize everything and solder it together. In the first configuration I used a 3:8 multiplexer to further reduce the pins to drive the clock signal high on the appropriate flip flop. This was unneccesary though because I had already chosen a microcontroller which had enough I/O pins to support my requirements. I was able to power on the circuit and start programming the cube right away, although I experienced some difficulties when selecting a couple different rows. Certain rows caused other rows to flicker or remain dimly light. The controller was unreliable and inconsistent when programming certain rows and because there were a lot of potential failures modes, I decided to print a more reliable PCB instead. Currently, I'm working on redesigning the circuit schematic in KiCAD and defining the attributes and spacing for each surface pad location. Once completed, the file will be submitted to the UW print shop.

The picture below shows the layout I have for the circuit schematic so far. It's still a work in progress and is missing the header banks and also some I/O connections.

The software design is centered around the interrupt service routine similar to that of the word clock. When an ISR is triggered, a layer of LEDs is written at a time. The output enable is first driven high (active low output enable), data is then written to the flip flops and clocked in sequentially for all eight flip flops, the output enable is then driven low and finally the transistor for the desired layer is then activated to sink the current for the entire layer. With this design, data can be written for the next layer while the previous layer is visibly activated. This gives each layer of 64 LEDs a duty cycle of 12.5% as opposed to controlling an individual LED with a duty cycle of 0.195%. This gives a much brighter end result and much better control over the transitions for each layer.

The software and hardware is still in development right now, but stay tuned for future updates!

For our third year design project course, we were required to work in a group of five to create an autonomous boat which could traverse counterclockwise around a pool and remain within a certain distance from the side wall without making any contact. Any method for propulsion, wall detection, hull design or orientation measurement could be used as long as the constraints of the project were satisfied. For every instance that the boat made contact with the wall or strayed across the center of the pool, 5% overall would be lost in the course.

The boat for each group was ranked comparatively based upon both the weight of the boat and speed of traversal. A design index was generated based on these two parameters and overall marks were distributed according to the rankings.

While most groups typically constructed their boats entirely out of foam and molded their boats as they progressed, we wanted a clean design where the positioning for each component and routing for the wires was defined with purpose prior to the build. With this mentality, the mechanical design was completed in Solidworks and 3D printed. We knew that 3D printing was also not a watertight method due to the low resolution of the fused deposition method, so we used acetone which is a plastic eating volatile chemical to melt the outer layer of the plastic. When the boat was finally placed in the water, the buoyancy was lower than expected. The water level sat only a couple of centimeters below the edge of the rear wall so we needed to add sections of foam to redistribute the tilt and increase the buoyancy of the boat.

The pontoons we used were also a hollow 3D printed shell and connected to the center hull through the use of hollow aluminum tubes. This allowed us to route the wiring for the IR sensor from the pontoon, through the hollow shaft and out into the center hull.

As the electrical lead for our group, I was responsible for designing and creating the controller for the boat. We had 5 I/O components total which included three IR sensors, a DC motor and a servo for control. The front IR sensor was long range and searched for any walls straight ahead and turned the boat accordingly, while the remaining two side IR sensors were short range and responsible for determining the orientation of the boat. The DC motor propelled the boat while the servo and a kinematic linkage was used for rudder control.

All groups were originally given an Arduino Uno for control, however, we wanted a smaller, more lightweight controller which we could plug each component into without having a mess of wires connected to a breadboard. So instead we pulled the 328p from the Uno and soldered our own protoboard given our basic requirements. With this new controller we were able to snugly fit all of our components into the boat with a width of about 4 cm in the center hull.

The boat was programmed based off of the given assumption that it would always be traversing counterclockwise in the pool. The front IR sensor was given priority over the side sensors for rudder control. Whenenever a wall was within a manually calibrated range, the speed would slow down and the servo would adjust the rudder and turn the boat left until a wall was no longer within the critical region. The side sensors were more tricky.

These short range IR sensors that we used did not have a linear profile for voltage to distance mapping. Additionally, the most troubling part about this that we didn't realize during the mechanical design phase was that the side sensors were not directly in line with each other. To map the profile of the sensors we used the least squares method to linearize the mapping and then calibrate an additional offset to align the side sensors. From this information, we could then tell what the distance was from the wall as well as the orientation of the boat by comparing the distances measured from both sensors.

With just basic rudder control we soon realized after testing that the boat was oscillating back and forth on the straight sections. We wanted to implement a PD controller at the very least to give us reliable stabilization in the water but we were too short on time to properly model the boat/fluid system and develop a frequency response which we could analyze. Instead, we manually calibrated the magnitude of the rudder change given the two parameters: the boat distance from the wall and the orientation of the boat.

Knowing what we know now, we definitely could have made some improvements in the end result such as aligning the IR sensors, using ultrasonic sensors instead or even implementing a gyroscope for accurate orientation measurement. We were still happy with the end result though and refrained from hitting any walls during the competition!