Projects

This is a directory for all the projects I have worked on, or am currently working on. They are categorized by who the project is for.

Personal Projects

This section is empty, but I swear Im working to fill it with content!

Case for Pocket C.H.I.P

I'm a big fan of one of my newest gadgets, the Pocket C.H.I.P. (P CHIP). And I've learned that anything I like needs to have a case, otherwise it's going to get scratched. So, with most things like this I asked my wife to make a case for it. But then I decided that perhaps it was finally time for me to try and make it (with her walking me through it of course). So here is how it's done:

First we cut out the fabric. These are two cuts of fabric that we had sitting around from previous cases. The red cloth is very soft and slick and will be the inside. The blue cloth has a pretty thick padding in it, to protect from most minor cases of rumble and tumble. The fabric was cut by eye, such that it will be able to fold snuggly over the P CHIP.


Eye-ball cutting the material to fit the P CHIP

Next I got to learn how to thread the sewing machine. I admire the work that the engineers at Brother put into making it very simple to thread this, with extruded numbers at each step showing where to thread next. 


Threading the needle

 Since this fabric is pretty thick, my wife recommended we use a walking foot (pictured below)


The walking foot

 I started out on the bottom corner near the fold of cloth. I did about a quarter inch backstitch, then a forward stitch to make sure things don't unravel on me. Once I got to the corner, I left the needle down, and turned the case around that point to keep a continuous thread.


The outer fabric pocket

 Since the outer material is so thick, I had to cut the corners. Otherwise the corners would be to bulky and things might not fit right.


"Cutting corners"

Next I sewed the inner material together. During my first attempt, I accidently had the material folded imperfectly, and would have been too tight of a fit. So we had to rip some stitches and restart. This time  we pinned it together well. You also have to becareful with the slippery cloth, because (due to the mechanism that feeds the cloth in) it can cause the top of the fold to travel faster than the bottom, misaligning things.


Pinning up the inner fabric

 Next I stuff the inner pocket material into the outer pocket. Note that I am stuffing it such that both the seams are not on the same edge, otherwise things might fit awkwardly.


Stuffing the two pockets together

I pushed the P. Chip in to make sure everything was going to fit well 


A little test fit

Next I folded the excess of the inner fabric in half, then rolled it over the side of the outer fabric. I used a lot of clips to make sure things stayed where I want them 


Folding the brim of the bag


I got caught in the act of sewing something

I had planned on stopping at this point. But I thought it needed a bit more, so we decided to give it a loop and button. The button is a custom 3D Printed button with the C.H.I.P. symbol on it. Sewing the button was pretty strait forward. I just had to turn off of the feeding mechanism, and then set it to a diagonal stitch with an appropriate distance set. I did the first stich very slowly (using the hand wheel) to make sure that things would work well with the current settings


The button and loop

And there it is, the Pocket C.H.I.P. fits happily in this little case, now I can put it in my backpack and not have to worry about any annoying scratches! 


It fits snuggly!

Also as a minor digression, I had a bit of trouble printing out my button. The quality was jut not what I wanted. I was also using some new PLA. I solved this issue by dialing back the extrusion multiplier. I could tell just by looking at it, that the printer was smearing the excess material around. The SCAD model for the button is attached below. 


The three print iterations with a dialed down extrusion multiplier (I also changed the hole size)

Click here for the Pocket C.H.I.P. button design files!

Custom Built Workbench

One thing I need when working on a project is a lot of desk space. The moment I feel cramped, I start to shut down. Previous to this project I had only been working off of a small hand-me-down desk from Walmart, and once I put an oscilloscope and multimeter on the desk, I barely had room to set a book down. So while I was house-setting for a friend who had a fully-stocked wood shop, I decided I should utilize it to build myself a big desk (as cheaply as possible). I started by designing a model in SketchUp 2015.

Desk Design 3D Model

It's very simple to look up what's available at your local Home Depot, and model 2x4s, plywood et cetera. I took some measurements on myself and found the ideal location for the bottom braces (because I like to rest my feet on them). Then I took measurements on all of the important things that needed to fit on my desk like books, the oscilloscope, my old CRT TV, and made sure they would all fit together.

Desk Populated with objects

Once I was happy with the model, I purchased all of the 2x4s. You can get 2x4s at a very low price, which kept the price of this project down. I added up all the lengths of the 2x4s from the model to get my estimate. When I started cutting all of the boards, it was important to cut all of my long boards first, because some of the remnants could be used as short pieces (IE the shelf supports). Keep in mind that I was doing all of the cutting at a friends house,l and would have to take them back to my house where I would not be able to make any adjustments. So I pieced the frame parts together to make sure everything fit as expected.

Once I was done house setting, purchased some screws and began assembling the desk frame. I had to get creative doing this part alone, by using some scrap blocks to hold parts at heights I needed, etc. Once the frame was done I purchased some oak plywood. It was a little expensive, but it's going to be a lot more resistant than particle board, and better to write on than OSB. The plywood was delivered by my father (couldn't fit this wood in my Jeep! Thanks Dad!) and cut with a skill-saw. The rest of the desk was screwed together with no issues.

The Finished Desk (Yes that is a lava lamp)

The only thing I would have done different is pre-drill all of my holes on the edges of 2x4s. Not doing this resulted in a lot of splits. Later on I purchased a nice swivel chair with no arm rests (they'd get in the way). Still very happy with this desk! If you have any questions or would like a copy of my model, I'd be happy to help, leave a comment below!

Custom Electric Motor

I think it was my sophomore year in high school, I decided I wanted to build a generator. I knew the basic princple that I needed to move a magnet through a coil of wire, and that is about it. So I took a cardboard toilet paper roll, wrapped some rubber coated wire around it once, and made a rig to hold a ceramic magnet that I could fasten to a drill motor. After fussing with it for about an hour, I gave up and did something else.

Now a few years later, I have about finished my bachelors of electrical engineering degree, and I understand the design a little better. I was reading through a book I had recently acquired "The Inventions, Researches, and Writings of Nikola Tesla," and some of the first sketches of an AC motor inspired me of my short lived high school ambition. Now of course at this point, I realize that an electric motor and generator are in fact one in the same.

Tesla's patent sketches of the AC Motor (Photo credit Wikipedia.org)

So I decided it would be a fun weekend project to try and make my version of the electric machine! I wanted it to be as simple as possible in terms of construction, and also as cheap as possible. So I decided the frame should be 3D printed (as if I would have chosen any other option), and the cores of the coils would be roofing nails that I had sitting around. The magnets were picked up for $6.00 at a local craft store, they are neodymium and measure 2561 Gauss. Most of these dimensions were arbitrarily designed as this was more of a hobbyist weekend project than a technical engineering project. The motor stator and rotor was designed in SketchUp 2015. I designed for the bearing (a skateboard bearing I keep on stock) to be press fit, knowing that once it was 3D printed, it would fit tight, and could be sanded down.

The designed 3D Model of the motor

 

I printed the rotor first, and it turned out well. The magnets press fit into the slots well; this is a handy feature for later experimentation (plus glue is messy, so I like to avoid it). I printed with 40% in-fill, and it feels pretty sturdy. My only mistake was making the hole too big for the screw, because it caused difficulty when lining everything up.

The motor rotor

 

Next, the stator body was printed. I designed it with mounting holes so it could potentially be fastened to a piece of wood, along with the control electronics. It should be noted that I purposefully left the motor open faced, because it serves as a good motor demonstration piece. I had to sand our the bearing socket with my Dremel on the lowest setting, and then lightly hammered it in with a block of wood.

The motor stator body

 

Next I cut the ends off of my roofing nails, and began winding my magnet wire. I wound them by hand, and did not wind to a precise value. I stopped winding when the coil was about as wide as the nail head. The first stator body was broken when I tried to press one of the coils into the stator hole. I quickly printed another body, and drilled out the holes a bit. This time I went a little to big, and had to wrap some of the nails in Teflon tape, to get a tight fit. Once the coils were all installed, I lined up the rotor by eye, and fastened everything together.

The finished motor

 

Now I have not started designing a controller for this motor yet, so I have no information on it running in motor mode. However, I did hook up some of the coils to my oscilloscope, and did some testing in generator mode. Just spinning the motor by hand, I got about a 5 mV peak output.

The output from a single coil on the motor

As usual, if you want any of the models, or have any questions or comments, please comment below, I'd be happy to talk to you about the design!

Custom Linear Actuator (XY Table)

There was a point in time when I wanted to build an XY table with 3D printed components, wood, and hardware only. I wanted to utilize some cheap steppers found on Amazon. This XY table was going to be used for the ACAPP Project, a machine used for createting simple printed circuit boards. The design has flaws, but some of the parts work very well on their own! With some work, the whole system might work, but that's a project I have to save for the summer.

I started by designing a gear that would fit over the output shaft of the stepper. I found a model of the 28BYJ-48 5V stepper on Thingiverse from user "siderits." I took some measurements on the physical motor, and double checked the dimensions. From that point, I designed a gear or "pinion," and made a simple rack just to test the fit. I had to use an Exact-O to cut away some of the inner hole of the pinion once it was printed, so it would fit well on the motor shaft.

Once I verified the basic principle was going to work, I designed the rest of the axis, or the linear actuator. Now my Printrbot Simple only has a print volume of 4"x4"x4", which can be a large constraint for projects like this. I've experimented a lot with dovetails, and have not found one that has worked perfectly, but I've found some that work good enough for my application. The complete axis can be seen below.

Some images of the designed linear actuator

The axis is designed in 6 parts (4 unique parts) and designed such that it can be printed with no support, or any other assistive measures. These parts were printed, and worked very well. I had taken a soldering iron at a low temperature to "smooth" out the dovetail joints. With a little pressure and patience, they go together well. The ends of the axis are made to have small limit switches tied to them for end stops. I wrote a basic assembly program to control the stepper back and forth on the axis.

I wrote the code for an end of life processor that I can't seem to let go of, the Parallax SX28. I've got a whole bunch of them, and have a sentimental attachment to the processor (The first microprocessor that I've ever used)

;-------------------------- DEVICE DIRECTIVES --------------------------

        DEVICE        SX28,OSC1MHZ,TURBO

IFDEF    __SASM  ;SASM Directives
        DEVICE        STACKX,OPTIONX
        IRC_CAL        IRC_SLOW
        
ELSE        ;Parallax Assember Directives
        DEVICE        STACKX_OPTIONX
ENDIF

        RESET        Initialize

;------------------------------ VARIABLES ------------------------------
            
        Count1    EQU    $08
        Count2    EQU    $09
        Count3    EQU    $0A

;---------------------------- DEBUG SETTINGS ---------------------------

        FREQ     20000
    
        WATCH    Count1,16,UDEC

;------------------------ INITIALIZATION ROUTINE -----------------------

Initialize
        ;Configure port settings
        

        mov    W,#$1E            ;Allow Pull-Up Resistor configuration
        mov    M,W                
        mov    !ra,#%0000        ;Set entire 4-bit port A to have pull-up resistors

        mov    W,#$1F            ;Allow Direction configuration
        mov    M,W                
        mov    !ra,#%1111        ;Set port A bits 0-3 to input direction

        mov    rb, #%00000000        ;Port a output zero
        mov    !rb,#%00000000        ;Port a.bit7 output dir.

;---------------------------- MAIN PROGRAM -----------------------------

Main

    
        mov    RB, #%00110011
        call delay
    
        mov    RB, #%00100001
        call delay
    
        mov    RB, #%01101001
        call delay
    
        mov    RB, #%01001000
        call delay

        mov    RB, #%11001100
        call delay
    
        mov    RB, #%10000100
        call delay
    
        mov    RB, #%10010110
        call delay
    
        mov    RB, #%00010010
        call delay

        csne    RA, #$0E
        jmp    NotMain
            
            
        jmp    Main            ;goto main

NotMain
    
        mov    RB, #%00010010
        call delay
    
        mov    RB, #%10010110
        call delay
    
        mov    RB, #%10000100
        call delay
    
        mov    RB, #%11001100
        call delay

        mov    RB, #%01001000
        call delay
    
        mov    RB, #%01101001
        call delay
    
        mov    RB, #%00100001
        call delay
    
        mov    RB, #%00110011
        call delay
        
        
        csne    RA, #$0D
        jmp    Main
                
        jmp    NotMain            ;goto main
                

Delay        clr    Count1          ;Initialize Count1, Count2                                    

Loop        djnz    Count1,loop        ;Decrement until all are zero                                    
        ret                ;then return          
     

Next I designed the rest of the table. Once again, I designed it such that it could be printed off flat with no supports.

A picture of the entire system model

After printing off all of the parts, cutting some wood, and picking up some hardware, here is my finished product.

A picture of the finished machine

The suspended axis is designed such that a different carrier can be put onto the motor so different tools can be used on the table. The issue was my 3D printed linear bearing design. It did not slide smooth enough, and prevented the lower axis from moving properly. This could be fixed by using a standard linear bearing and rod. Overall this project was a fun experience to try and see how effectively I could design for 3D printing, and working on a whole system. Leave a comment below if you have any questions, or would like some models!

Making a Replacement Chair Foot

I have recently moved to be close to Michigan Tech. And so far the process has gone great. Except for this chair. It's always been fine on the carpet in our old apartment, but now that we have hardwood floors, it needs to be dealt with. The chair is missing a plastic cap on it's foot, which makes it impossible to apply a scratch-preventative felt pad. Luckily, to a man with a 3D printer, everything needs to be printed.

A nice chair with a slight wobble.
A nice chair with a slight wobble.

First I get a good look at the empty foot of the chair, and take some measurements on both the cavity, as well as the existing plastic feet.

This leg of the chair is missing a plastic foot
This leg of the chair is missing a plastic foot

Then I design the simple plug in sketchup. 

The designed chair foot
The designed chair foot

I beefed up the wall thickness up to 5 rather than 3, and kept the fill density at 40%; These settings will make the part more than strong enough.

The final part, freshly printed
The final part, freshly printed

With a little persuasion (hitting with a hammer) the part fit in perfectly, allowing me to finally place a felt pad on this leg of the chair. Another win for 3D printing!

The 3D printed foot applied to the chair
The 3D printed foot applied to the chair

 

Video: Making a PCB Milling Fixture

A brief video on making a simple wood fixture to hold PCB raw materials, so they can be milled into their finished product. I use my G-Code Procedure Array to make it:

School Projects

This project book is a collection of things that I either helped on or personally did at Saginaw Valley State University. They include class projects, research projects, and projects for the FSAE race team, Cardinal Formula Racing (CFR).

A Novel Design of a McCulloch-Pitts Neuron in CMOS VLSI

What follows is a paper that I and my advisor, Dr. Rajani have submitted for the American Society of Engineering Educators (ASEE). Hopefully it will get accepted and be one of my first publications.

Department of Electrical and Computer Engineering
Saginaw Valley State University
7400 Bay Road, University Center, MI, 48710

Abstract

Due to the advancement in recent hardware technology and vast information availability, a growing need for efficient and adaptable processing has become a necessity. Artificial neural network (ANN) mimics the functionality of human brain and can be applied to solve many complex engineering problems such as pattern recognition, control, time series modeling, and optimization. The capability of ANN is limited due to current microprocessing systems, and thus need specialized digital logic. In this paper, a neuron for a multilayer perceptron (MLP) using back-propagation is applied using digital logic methods, which is implemented using CMOS very large system integration (VLSI) for high speed and energy efficiency is proposed. The key feature, massive parallel processing is made possible using the proposed ANN approach and as proof-of-concept. 

Introduction

Artificial Neural Networks (ANNs) mimic the function of a biological neural network. When considering the biological neural network at a very summarized view point, their function is pattern recognition. Humans use their brains to recognize patterns in all sorts of things, from mathematics, to weather, survival, etc. Now as expected, ANNs attempt to mimic this activity, and can therefore be used for similar tasks, such as pattern recognition, prediction, controls, outlier detection, etc. These basic categories encompass many engineering situations that would otherwise require complex mathematics, very specialized programming, or the ``human touch''.

If implemented properly the Programmable Artificial Neural Chip Acquires Knowledge by Experience (PANCAKE) could have many potential uses. It's main advantage is that it can be implemented as a control system that operates on a large amount of variables. One potential application is increasing the accuracy of readings from nerve endings for motor enhanced prosthetics. The propagation of nerve signals can be effected by both internal and external factors1. Do to this variance, the quality of motor controllers will vary. Implementing PANCAKE with appropriate sensors (IE Body temp, Heart rate, Barometric Pressure) will allow for the signal to be automatically compensated, and therefore will increase the quality of control.

Another potential application for PANCAKE would be implementation in prediction systems. For example PANCAKE could monitor a large variety of environmental weather conditions, and from that data, it could begin to make localized weather prediction on rain fall, humidity, et cetera. PANCAKE can also use it's large amount of inputs for tasks such as pattern recognition which might be geared for industrial quality detection, character detection, and so on.

The key component of ANNs are the neurons themselves. A typically accepted neuron structure is the McCulloch-Pitts neuron(MPN)1. The MPN consists of weights, a summation, and an activation function as seen in Figure 1. The MPN applies weights to incoming signals, and sums the weighted signals. That summation is fed into an activation function $\phi$, which is commonly assigned the sigmoid logistics function in Equation 1 where $v_j$ is defined as the output of the summing function.

Figure 1: The McCulloch-Pitts neuron
Figure 1: The McCulloch-Pitts neuron

 

$$  \phi_j=\frac{1}{1+e^{-v_j}} $$

Using a learning algorithm such as back-propagation, a network of MPNs can be taught to handle sets of data, and make predictions or choices based on past experience. The individual neurons "learn" by adjusting their attached weights according to feedback from the learning algorithm.

The proposed neuron is a single piece in an integrated circuit containing a discrete artificial neural network capable of multiple different machine learning tasks. Since PANCAKE implements a neural network in hardware form, it will be capable of multiple different machine learning tasks, and capable of handling assigned tasks in a true parallel nature.

Methodology

MLP consist of three parts as shown in Figure 2, Weights, Summing Compression Adder (SCA), and the Sigmoid Function Block (SFB). The topology of these functional blocks will be described in this section.

Figure 2: A discrete block diagram of the McCulloch-Pitts neuron

The system is discrete, and requires the SFB to quantize the continuous data into 32 states as shown in Figure 3.

Figure 3: A table and graph displaying the discrete and continuous sigmoid function

Binary values are assigned to defined points on the input axis, as well as the output axis. The input is cut into the signed binary value $00000000$ to $11111111$, or more simply an 8 bit input. The output is defined as a 5 bit output. From these assigned values, Karnaugh maps can be made to find the boolean relation4. These functions are later translated into a NAND-NOR system and then further translated into a VLSI Block. Functions 2 to 6 are defined assuming the most significant bit of the input is A and the least significant bit is H.

An image of the boolean expressions governing the SFB

Next, the SCA is considered. One of the issues presented in PANCAKE is that the network is defined to be 32 x 32 neurons; implying that each neuron will have 32 connections. This also implies that the summation node of the neuron will have to sum 32 8 bit numbers in a parallel fashion. Though this is entirely achievable the output of the adder would be a 13 bit number, and would require more inputs to be considered in the SFB. Also the adder circuit as well as the SFB will be larger and will hinder the goal of 32x32 neurons. Therefore the following design is proposed in Figure 4. The concept is to use an 8 bit full adder to add two 8 bit numbers, and ignore the LSB. Instead the carry bit is treated as the MSB of the output byte, in essence shifting each bit down one binary value. This method can be cascaded to handle any amount of inputs and compress it into an 8 bit output.

Figure 4: A block diagram of a four 8 bit input, single 8 bit output Summing Compression Adder

It should be noted that if an SCA is not utilized to full capacity, there will be a more significant round off error (IE an SCA is build to handle 10 inputs, but only 5 are used). If this case is not avoidable, then selector logic must be used to take intermediate sums from the SCA to reduce error.

Lastly, the Weight block will be discussed. A typical weight in an ANN operates as a gain, or "multiplier" to it's input data. Conventional multiplication will not work well within the bounds of the discrete domain defined for the designed neuron. The weight block is instead designed to operate on a shift-and-add system. The back-propagation learning algorithm will have to be modified to generate two values, one that specifies how many bits the value will have to shift and in what direction. The second value will be a "fine tune" adjustment to specify a value to add or subtract from the shifted input.

Figure 5: A block diagram of the weight node

Results and Analysis

All of the systems proposed are within the realm of possibility to implement, however their success depends on the implementation of optimal learning algorithm. The SFB is designed in Electric VLSI using the sea of gates layout method3. The speed of the largest gate in the SFB is measured in a SPICE simulation, and is found to be a 19.2 nS Transition, or alternatively, it is capable of switching at 51 MHz when used alone. The dimensions of the SFB are measured to be 1320 nM by 1120 nM.

Figure 6: A section of the SFB

Conclusion and Future Work

PANCAKE is modeled based on the state-of-the art methods tailored to solve real-world constraints. The proposed architecture is feasible, and require testing on benchmark problems such as weather prediction, which will be discussed in future research. 

References

[1] M Dhavalikar, A.Narkeesh, N. Gupta Effect of Skin Temperature on Nerve Conduction Velocity and Reliability of Temperature Correction Formula in Indian Females. Journal of Exercise Science and Physiotherapy,2009. [2] Simon Haykin. Neural Networks. A Comprehensive Foundation. Prentice Hall, Upper Saddle River NJ, 1999. [3] Neil H. E. Weste, Kamran Eshraghian. Principles of CMOS VLSI Design. A Systems Perspective. Addison-Wesley, Reading MA, 1993. [4] M. Morris Mano, Michael D. Ciletti. Digital Design. Prentice Hall, Upper Saddle River NJ, 2007.

 

Automated Copper Applicator for PCB Prototyping (A.C.A.P.P.)

Pre-Introduction

The Automated Copper Applicator for PCB Prototyping (ACAPP) is a project I am working on, in part through SVSU's faculty lead research grant. Below is a submitted report on the progress of the project so far.

Introduction

The goal of this project is to create a machine capable of manufacturing printed circuit boards (PCB) in an efficient and ”green” way. There are many methods which could be used, but it was decided that the best method to use would be a unique copper tape applicator. Because of this, the machine is named Automated Copper Applicator for PCB Prototyping (ACAPP). ACAPP is still a work in progress, but all of the methodology is planned and is within the range of execution. In this report I will discuss how processes are selected, as well as the finer details of execution.

Method Selection

There are many methods for making PCBs, but among the most common are milling and photo-etching. Milling involves a sheet of copper glued to a sheet to epoxy-glass, where the unneeded copper material is milled away by a small radius end-mill. The second process mentioned, photo-etching, involves the same sheet of copper and epoxy-glass. In this process, a negative image of the circuit board is printed onto a sheet of transparent plastic, and is then taped to the copper sheet. They are then placed in Ferric Chloride, and light will cause a reaction, etching away unneeded copper areas. Both of these processes are ”subtractive,” meaning that there is a waste byproduct. Not to mention the hazards in storing or processing chemical waste from photo-etching.

It was decided to seek out a method which involved an additive process. The first method considered was a relatively new technology called ”Conductive Ink.” It is a silver compound in a paint marker like device. This method would prove very easy to implement on a standard gantry-styled machine, however, the ink is expensive, susceptible to smearing, and most importantly, the resistivity of the material is relatively high (up to 10 Ω per Cm). This is where the copper application comes into play. 3M makes thin copper tape used for electrically shielding devices and cables. The tape is flexible, and is pure copper, giving it a very low resistance (0.05 Ω per Cm). The tape can be applied in any shape or design within the limits of the materials width (3mm). This process is purely additive, efficient and inexpensive. Moreover, this method can be used to print on any material, from wood, to cardboard, cloth, or fiberglass. 

Mechanical Hardware Design and Build

The first mechanical task undertook was a feasibility study to check if the copper application was possible. The applicator is the key part of this mechanical design, and the most complex. That said, its basic concepts can be viewed in the sketch in Figure 1. The basic process detailed in the sketch is this: Tape is spooled out and is gripped by a set of rubber wheels. On the outlet of the rubber wheels, the tape is peeled from it’s wax paper backing. The tape is deflected down to a tensioner which will roll the tape onto the PCB surface. A cutter is also positioned to end a line of tape.

Figure 1: A concept sketch detailing the mechanics of the tooling head

The tooling head must be on an automated positioning system. In this design, a gantry styled automaton system is designed. Construction materials chosen involve 1 inch square aluminum tubing, joined together by custom designed 3D printed parts. Tensioners are built from aluminum bar and and skate-board ball bearings, and can be viewed in Figure 3. Moving components are belt driven, and ride on linear bearings.

Figure 2: A comparison between the designed and built machine

 

Figure 3: The implementation of one of the three belt tensioners

It is necessary for the printing table to rotate at least 90◦ , because the copper applicator is only capable of laying in one direction. The table is set on a ball bearing taken out of the differential of the formula race car. The table base is designed such that it can be rotated by a motor driven belt.

User Interface Software Design

Typically, PCBs are designed and exported as a file type called the Gerber file. It was decided that a Gerber file, though universally excepted by the industry, was too complex for this application. Instead, a software has been designed where custom PCB layouts can be designed, and saved in a simple .txt format. The data structure is simple: If you look at the PCB as a 2 dimensional plane, then a set of Cartesian coordinates can be applied. Each line in the design has both a start point and end point, of which can relate to the coordinate plane of the PCB. These coordinates are saved in an array, and eventually to a .txt file. The current interface design can be viewed in Figure 4.

Figure 4: A comparison of user interface concept vs actual design

 

The software is designed in QTCreator, a free C++ development environment. It was chosen because of its QtPainter library, which is used to render the circuit board during the design phase, and its QtSerialPort library, which enables COM port access and control. The software is designed such that all necessary functions can be performed on a single screen. There is a function for designing the board, as well as saving and loading files. On the right side of the interface is a manual jog control, to move the machine for troubleshooting purposes. And finally there is a command console used for advanced debug.

The software will be designed to handle all translation from the designed coordinates to machine motions. This choice is significant, because computation will be done much quicker on the PC compared to on the microcontroller. The serial communication structure between the software and microcontroller are discussed in the next section.

System Firmware Design

The firmware, by design, is relatively simple. Programmed on the Texas Instruments MSP-EXP432P401R microcontoller, its main function is to interpret serial signals, and relay information to motor drivers. The firmware is designed to interpret byte-wise serial data. The bytes received by the controller will carry data identifying the byte address, and then will either contain information about the step count or motor control information. In all control bytes, the 3 most significant bits are reserved for the address, which will allow for a maximum of 8 addressable bytes ($2^3 = 8$). The 5 bits left in the byte are used for data. For the step count byte in Figure 5, the 5 bits are part of a 15 bit signal, used for telling the motors how many steps they should make in their current configuration. Because the step data is a 15 bit number, it uses 3 serial bytes. The motor data byte in Figure 6 has 4 used data bits: MS1 and MS2 which are used to control the step size, DIR, which specifies rotational direction, and STP, which tells the motor if it is directed to move or not. Each motor operates off of a uniquely defined serial byte. These serial signals are received by the microcontroller, decoded, and then sent to their appropriate motor drivers or internal control variables.

Figure 5: An example of the serial byte structure for step data

 

Figure 6: An example of the serial byte structure for motor data

 

Electrical Hardware Design and Build

Taking a cue from industry standards the positioning motors were chosen to be stepper motors. This choice is because of their open loop controllability, as well as their availability and inexpensive price. The 4 positioning motors are each driven by a SparkFun EasyDriver. These driver boards receive binary data from the TI microcontroller. All of the control circuity is connected together on a piece of perf-board, and interfaces with motors through screw termination. The finished board can be seen in Figure 8.

Figure 7: A simplified electronic schematic of ACAPP

 

Figure 8: The control circuit board for ACAPP

Product Testing

ACAPP is not complete, however, multiple parts of the machine have been tested. After extensive debugging, the communication between user interface and microcontroller works flawlessly. The circuit board has also been tested, and appears to be free of problems. Motors were hooked to the board, and position control was tested and verified. At the time of writing, there are currently 2 axes finished and operational. The rotational axis of the table does have some issues that need to be remedied, namely belt slippage. This issues is temporarily fixed by tensioner bolstering using safety wire.

Plan to Finish Implementation

There is still a fair amount of work to be done to finish ACAPP. We are working to finish movement in all 3 axes first. This involves the completion of some mechanical build and testing. Once movement is working, there will be extensive testing for 3 dimensional position control. The final step is to build the copper applicator, and fixture it to the machine. Once again, the machine will have to go under extensive testing and calibration. Once this step is completed, the design will be assessed, and the continual refinement process will begin.

Conclusion

Building ACAPP has had a significant impact on my life. Since the design entails so many things from mechanical, to electrical, software, and manual construction, I have gained a strong consciousness of how an entire system works together. I have truly gained a strong understanding of system design. My C++ skills have increased, specifically working with bit-wise operations, because the programing was so logically intensive. I have also gained a proficiency in mechanical modeling; an ability I did not have going into this project. Another key thing learned during this project was market assessment, and benchmarking. I had to understand what was on the market for PCB manufacturing, what was good and bad about each option, and then try to improve on it. I feel that ACAPP has a true potential to become an actual consumer project, given enough refinement.

I am grateful for this opportunity to research along side Dr. Zou, as well as being granted the F-Led Research Grant. This experience will certainly aid me in my future endeavors, especially as I apply for graduate school

 

Formula Race Car

The Formula Race Cars are some of the best projects I have ever worked on. When I started out. I knew nothing about cars. Now I'd say I know a considerable amount about how they work, and how to make them. Not only is the project great, but all of the engineering students on the team are great people, and I consider them to be some of my best friends. This project is advised by Dr. Brooks Byam (of SVSU) and Erich Heuschele, lead engineer at Chrysler SRT. To this date, I have worked on 3 cars which have competed in world-wide competitions.

The 71 Car
The 71 car
  • Car 71 (2013): Overall 51/104
The 50 car
The 50 car
  • Car 50 (2014): Overall 36/109 (first in the acceleration event)
The 73 Car
The 73 Car
  • Car 73 (2015): Overall 26/110
Yes, I have driven the car before
Me in the car

Formula Race Car Data Acquisition System

The race car's data acquisition system (DAQ) was a two birds with one stone project. The project was for an elective class at SVSU (ECE490), but it also provided a DAQ for the race car. It implemented an Arduino, with some daughter-boards for GPS and data logging capabilities. The DAQ was capable of logging:

  • All GPS Data (Speed, position, elevation, time, etc..)
  • Suspension position (all four wheels)
  • Axial acceleration (XYZ axes)
  • Steering wheel position
  • Brake pedal position
  • Throttle Position

My tasks with this project included hardware design and building, and assistance with programming the Arduino. I was also responsible for programming a LabVIEW interface to load in data files and display them in a comprehendible manner. The timeline of this project was about 3 months. This project was done with my partner Samuel Nelson.

An image of the DAQ Harness with sensors attached
An image of the DAQ Harness with sensors attached
Custom Designed and 3D printed Enclosures for DAQ electronics
Custom Designed and 3D printed Enclosures for DAQ electronics
The LabVIEW VI for handling data files
The LabVIEW VI for handling data files

Open Source Low Cost Power Measurement System for Solar Energy

This is a project I am currently working on for TED speaker Marcin Jakubowski. The project is for my EE5490 class at MTU: Solar Photovoltaic Science and Engineering, taught by Dr. PearceIt is a multi-channel power monitoring system for a home powered completely by alternative methods. It will be completely open source (as all of Marcin's Open Source Ecology projects are). The project is currently in the design phase, and the notes can be seen below:

Some other relevant links:

Power Inverter PCB

The power inverter (DC to AC converter) is a project I've been working on with Dr. Zou from SVSU. Dr. Zou and some of his graduate school counterparts were responsible for designing the circuit. I was given the responsibility of designing a printed circuit board for the system. I can't say much about the intricacies of the board (Since the research and ideas are the universities property, however Dr. Zou is allowing me to share this with you), but this is what I can share:

The power inverter can be used for many different power electronics applications, of which the most relevant are:

  • Motor Control: Given a DC Bus, using the PWM method, the inverter will be capable of modulating the motor's speed
  • Power Conversation: Given a DC Bus (Say from a solar panel), the inverter can convert the DC into a form of AC usable by consumer electronics.
An image of the circuit board in progress

The circuit board was designed in NI Ultiboard, it uses only two layers. The soldering and testing is currently underway by two other students at SVSU.

Race Car Harness

One of the most important things for me to focus on when working on the race car was designing and manufacturing the electrical harness. I made efforts to streamline the process, by mimicking industry standards. This involved designing comprehensive schematics in AutoCAD, dimensioning the harness in Solidworks, and making a "pegboard" so the harness could be made off of the car. The harness uses 18 and 20 AWG wire with PVC coating for flexibility and small cross-sectional width. The harness is covered with heat-shrinkable cloth tubing, and its ends are covered with adhesive lined shrink-tube. The connectors are either determined by the device they are connecting to, or when possible, compact military-spec connectors are used.

The harness in construction on the peg board
The harness laid out on the pegboard