Pinball Chip Packer
In 2013, during a 4 month design course, my team and I built a backgammon chip packing machine, which we called the Pinball Chip Packer. We competed amongst Engineering Science students, and we were very proud when we came in 2nd Place.
We received an RFP which asked us to "Design and manufacture the proof-of-concept prototype of a machine that can package Backgammon chips in two colors, amber and camel, in cylindrical plastic containers in a variety of combinations reliably and quickly, according to the operator’s keyed-in requests".
The user had to fill the two reservoirs in the machine with amber and camel colored chips, and enter two numbers corresponding to different packaging patterns, as shown below.
The machine was expected to pack 2 containers of 10 chips accordingly, in less than 2 minutes, and close the lids. Upon termination, the number of remaining chips in both the camel and the amber reservoirs had to be displayed, as well as the time taken for the operation. The machine had to be less than 6 kg, fit within a 50 cm x 50 cm x 50 cm cube, and cost less than $230 CDN. The rest of the requirements can be found here.
The first step, as of any other design projects, is research. So we looked at existing products, reference designs, and the packaging industry as a whole. Below are two pages of our team's proposal. If you'd like to see the full proposal, please contact me.
We went to a group study room in one of the libraries on campus, we stayed there for hours, and came up with as many ideas as we possibly could; some very unusual perhaps! Once we finished brainstorming, we summarized the ideas in our notebooks, so that we could come back to them during our next meeting.
Below are three of the designs we came up with for the unloading mechanism (emptying the reservoirs) which we called the rotating disk tower, the coin ramp, and the chip shooter with ramp.
Below are three of the designs we came up with for the packing mechanism (filling the containers) which we called the rotating container platform, the rope-pulley system, and the conveyor belt.
3. Approach Selection
Since all three of us were a fan of simplicity, we chose the chip shooter with ramp design. For the packing mechanism, we came up with a clever alternative were a little piece of glass changed the path of the chips from one container to the other, so we didn't have to move the containers themselves. We called this piece of glass the pinball arm, and that is why we named our robot the Pinball Chip Packer.
We also created a qualitative comparison table between different alternatives, in order to confirm the results. We followed the exact same procedure for choosing the lid closing mechanism, as well as the method of counting the remaining chips in the reservoirs.
Next, we spent nearly 2 hours to make a low fidelity prototype, using pieces of wood, two plastic funnels, ketchup and mustard containers, and two motors. This was a great investment of time, because it gave us some useful insight about our design. After doing some test runs, we realized that we had to slow down the motors in order to have more control; we decided to write a PWM code to do so. Also, we needed to either use a stepper motor or micro-switches to stop the motors after a 360 degree rotation. In this case, we decided to go with the second option.
5. Iteration and Planning
Once we had a clear understanding of what we wanted to build, we created SolidWorks models, circuit diagrams, and algorithm flow charts, to help us with the construction.
During the construction phase of the project, we decided to split up the work into three main sections: micro-controller, electrical, and electromechanical. We each took on a task and started working individually for about two to three weeks. This separation helped us get started, but after that short period, we came together and worked on all the subsections as a team.
I was the micro-controller member of the team, and I used PIC16F877 and coded with Assembly. Since I didn’t necessarily have to code during the lab hours, I managed to finish the code early on. So, I joined Theo, and we continued building the circuits together. Below are some of the circuits that we built .
After two or three weeks we came back and started integrating the subsections. This is where we spent most of our time: integration, debugging, and calibration.
And after many sleepless nights … we finally got things to work together!
7. Admitting Mistakes
Along the way, we learned to admit failure, and use that as an opportunity to improve. One of the requirements stated in the RFP was to count the number of chips left in each reservoir after termination. To do so, we did some research on how machines in the industry perform such tasks, and we were introduced to the concept of sensor arrays. The idea is to have one emitter and one receiver for each chip, and use those readings to determine how many chips are left in each column. Since initially each reservoir could have had a maximum of 15 chips, and after one complete cycle at least 5 chips from a given reservoir would have been dispensed, we created an array of 10 sensors.
Up until 2 weeks before the competition we continued on with this sensor array, and we encountered many problems. First, we had a limited number of I/O pins on our PIC16, a port assignment diagram is shown on the right. In order to allow all the sensor data to pass through, we had to use a 16 bit shift register to feed the data into the PIC one at a time. Secondly, debugging was a nightmare, once one of the sensors broke, we had to debug the entire array to find out which one we had to replace. Another, issue was alignment, we had to make sure the transmitter and the receiver were directly in front of one another, to avoid interference. So, about a month before the competition we all knew that a sensor array was a bad idea, but we refused to admit that we were wrong, and we continued working with that design.
We spent endless hours on only that part of the machine, and finally we agreed that we made a mistake and we had to go back and make changes. Below, the picture on the left shows our sensor array, and the picture on the right shows the design we replaced it with.
We went back to the brainstorming stage and started thinking about other design alternatives. The first question we tried to answer was “are all these sensors necessary!?". turned out, they weren’t. After thinking for a bit we realized all we really needed was 2 sensors on each column. As the micro-controller member I came up with an algorithm that allowed us to replace 10 sensors with only 2. Below is the code that I wrote, along with the algorithm. On each column there was a sensor placed on the 5th chip, and one on the 10th chip, which I called sensor5 and sensor10 respectively.
;;;;;;;;;;;;;;;;;;; AMBER SENSOR ;;;;;;;;;;;;;;;;;;;;;;;
bcf PORTC, 7 ; switch to sensor
call relaydelay ; wait
btfsc amber_01, 0
btfss PORTC, 6
; if sensor 5 doesnt have a chip
btfss PORTC, 5
; if sensor 10 doesnt have a chip
bsf PORTC, 7 ; switch to motor
call relaydelay ; wait
What we learned from this experienced is that things will go wrong, and there is nothing wrong with making mistakes along the way, as long as we admit them and try to find a solution before it’s too late.
Finally we got everything working, and on the day of the competition we realized that our design was quite unique. Every other team had their cylindrical containers either rotating or sliding at some point. I believe the pinball arm helped us do well in the competition, because most of the groups experienced problems while moving the heavy cylinders or when aligning them so that the chips would fall exactly in the cylinders. If you would like to see the final report, the code, or any other relevant documents, feel free to contact me.
In the picture below, from left to right:
- Theofilos Sotiropoulos-Michalakakos: Circuits
- Denis Burkov: Electromechanical
- Parastoo Abtahi: Micro-controller
One year after the competition, our team was asked to do a 50 minute presentation, for the new class, sharing our story and providing them with tips and tricks that we learned along the way.