Team 7 Flappy Bird Hardware

Schematic

Our project consisted of the following hardware parts: the Xmega-A3BU microcontroller, an Arduino Uno, a thumb stick, a lcd screen from a Nokia 5110 and basic push button. The Arduino ran our game code and controlled the lcd screen, while the A3BU revived inputs form our controller. The A3BU and Arduino communicated via serial.

During our project we discovered that our thumb stick was not functioning properly. We believe the potentiometers were to blame for this. Due to this and limited time to order a new one, we decided not to have one.

Fall 15 Team 2 Schematics: Making the hammer

 

ThorSchematicElectromagnet

Our first attempt of making an electromagnet was with an iron spike and copper wire. Unfortunately, the magnet was not strong enough. Instead, we used the transformer from an old microwave, as seen above. In order to power the hammer, the A3BU is powered by a 9V battery, and the magnet is powered by 4 AA batteries that supply 1.5V each. These are hooked up in series, as shown in the diagram above, which outlines how each element of our design is powered.

 

FirstBuild

The case of the hammer was made at the FirstBuild workshop, which is on the far corner of campus. Inside is the hammer will be the electromagnet, as well as the A3BU board, which will turn on / off the magnet via a button press. In concept, the magnet would prevent the hammer from being lifted if it were resting on a metal surface.

Schematic: Team 4.1’s U-box

The schematic for Team 4.1’s U-Box seems complicated but is actually fairly straightforward. There is essentially a circuit for the LED and LCD screen, and a second circuit for the servo motor. From the A3BU, 3.3V runs through a 330 Ohm resistor to a red LED and back to ground. A switch completes the loop so that the LED will only light up when the switch is flipped. The other side of the switch runs back to an input pin on the A3BU that just lets the micro-controller know which position the switch is in. This is necessary so that our LCD screen knows when to show the different faces.

Unfortunately, the 3.3V from the A3BU were not enough to power the 5V servo, so a second part of the schematic is designed to run this servo. When the switch is flipped, the A3BU tells an Arduino to run its code, and the Arduino outputs the 5V necessary to turn the servo 35 degrees. The servo will rotate and hit the switch back into the off position, causing the LED to turn back off.

Team 1.2 – Schematics

3x4_Matrix_CircuitAbove is the main schematic we used for our project which helped us figure out what pins corresponded to which row and column as well as how a specific keys location was relayed to the board. The schematic details the conductors associated with each row and each column. The keypad we used for our project has 4 rows and 3 columns for 12 total buttons, but only 7 data pins. To read which button was pressed at any given time, we energized the voltage on each row while checking for a column inputs.

Here is a diagram of how each row and column was wired to the A3BU:keypad_hardware_schematic (1)

Team In Progress: Color Sensing Motor Control – Schematics

Driving a DC Motor

Capture

Our team implemented a DC motor into our project using the circuit shown above. We used the SDA pin on the J1 header of the A3BU Xplained board to provide the signal, and we used 4 AA batteries as our power supply. The diode, wired in parallel with the motor, protects the transistor and the A3BU from possible reverse current. (Reverse current occurs when power is removed from the motor.) The diode does not affect the circuit when the power supply is on because, in this case, the diode is reverse-biased (meaning that it blocks current) and all the current flows through the motor. The transistor is used as an amplifier. The transistor has three pins (Collector, Emitter, and Base). The motor is connected to the Collector and the A3BU is connected to the Base. The Emitter is connected to ground. The A3BU cannot supply enough current for the motor to start turning, so the A3BU is connected to the transistor’s base, supplying the base current. The base current is multiplied by the gain of the transistor, and this current (the collector current) is supplied to the motor. The resistor is added to the circuit to create this base current. The high value (2.2 kΩ) of the resistor is used to limit the current going into the base since base currents are typically very small.

Golden Monkeys On Duty! (The Build)

The Beginning:

2015040795150030
It all starts with the base! This is where our 8x8x8 LED cube will sit on so that we can keep it as neat as possible when wiring. The wooden cube was manufactured by our team member, Tayce, and allowed us to keep all of the components snug.

2015032595220719

Starting out we had to create our individual layers. Since we created an 8x8x8 LED cube we had to create 8 layers of 64 LEDS with half an inch gape between each LED.

2015033195173430

After we completed soldering all 8 layers we then proceeded to solder the layers on top of each other with half an inch spacing. This required 2 people to accomplish: one to hold the new layer being soldered, and the other soldering the next layer.

2015042095180649


This is the completed 8x8x8 LED cube which resulted in 1024 solder joints, which does not include the soldering done on the board, and the wires that hook up the board to the cube. In total this build took about six weeks to accomplish.

20150414951833002015042095203508This is the board that is hooked up to the LED cube. The ones marked with numbers are the 74HC574 which are our LED drivers, and the two in the middle are our decoders 74HC138E. The decoders basically send a clock a signal to the LED drivers which in turn control which LED will get turned on. This works by giving the programmer the ability to control the LEDS in the X, Y, and Z direction.

Putting the two together, the LED CUBE and the circuit board, the completed project looks like this:2015042095152751 2015042395165003

2015042095180718 2015042095153625

Team DND – The Final Product

team logo

 

Once we had our housing printed and a working circuit we were ready to begin the assembly process.  Then we realized we missed something, the use of the A3BU microcontroller.  We were not entirely sure if the project needed to incorporate the A3BU but we decided to use it just to be safe.  The sole purpose of the A3BU in this project is to act as a button.

Implementing the A3BU:

On the Saturday night before the project was due Marcus and David began the process of adding the A3BU to our project.  We started by trying to write a program that would output a high voltage from a pin on the A3BU to be read by the Arduino to start the sounds and lights routine.  Soon it was clear that we were not going to get this method to work without the ICE-3, which we conveniently left in the ECE lab and didn’t have with us at the First Build facility.  The next option was to bypass the software of the A3BU all together.

We noticed on some of the A3BU schematics that when a 5v source was connect to the power in of the A3BU the buttons on the chip became active.  In particular, there was one button that exposed its output on the back of the board.  We tested this by using a multimeter with one end on the ground and the other on the TP304 (see below) plate.  When the button was pressed the TP304 plate would drop to 0.0v from the steady 3.3v it was at.  This means that we could use this A3BU button without any software at all.

 

A3BU Hack diagram

 

Diagram of the A3BU button we hacked.

We soldered a wire to the back of the A3BU board and lead it to a digital input pin on the Arduino to trigger the routines we wanted.  At this point we had the Arduino powered by a battery but the A3BU still needed to be connected to a computer for power.  We wanted to eliminate this connection to the computer.  This is where we got really fancy.

Again, we used a multimeter to check where the 5v from the power source was leaving the usb connection to the voltage regulator on the A3BU chip.  We discovered the one of the legs connecting the mini-usb port to the board was carrying 5v when power was connected.  We used a continuity test with that leg and the TP304 plate and discovered thats how the 5v travels to the rest of the chip. With this new knowledge we were able to solder a wire from the 5v output on the Arduino to the leg on the A3BU that distributes the power on the A3BU.  We were able to successfully power both microcontrollers with a single 9v battery connected to the Arduino.

In the code we used an interrupt to set a variable to either “on” or “off” when the button on the A3BU was pressed.  Essentially, we created the most complicated button of all time.

How it looks:

To make the components fit into the housing better we ditched the large bread board for a small piece of protoboard.  Once we had the entire project working exactly how we wanted, we soldered the pieces to the protoboard permanently.  We used the ground and the 5v source from the Arduino to create hot and ground rails on the protoboard.  Once the entire circuit was contained on the protoboard we started the difficult and delicate process of stuffing the components into the housing.  After a lot of concentration the below picture shows the final result of the component compartment:

11125478_10205078254768678_625303218_n

The only thing hanging out of the housing is the battery supply cord so we can turn the entire project on or off easily.

When the project is first powered on it is in a standby mode.  The LED array “breathes” and changes colors as time goes by.  Once the button on the A3BU (which is accessed from the components compartment opening) is pressed the A3BU sends an interrupt and starts the music and lights routine.  A tone will begin to play and a certain number of LEDs will light up on the array.  As the knob is turned the tone changes pitch and the amount of LEDs that are lit up change.  The LEDs change color as more LEDs are lit.  For example the left most LED column is all green, the middle few are yellow, then orange, and the right most are red.  See the video below for a short demo:

Conclusion:

This project was an overall success.  The device works exactly how we envisioned it from the start.  The team was exposed to many new electrical and programatic challenges along the way but we were able to work together to overcome the obstacles.  We were also introduced to the First Build community from spending so much time there, we now all feel comfortable with using their resources more ofter.

We think that the use of an Arduino allowed us to push the limits of what this project was capable of.  The ease of use allowed us to rapidly prototype and trouble shoot without wasting a lot of time fighting with a more robust microcontroller.  Although we did not use the A3BU extensively in this project I think we gained a new understanding for it by using its internal hardware against itself to supply us with a button without the use of software.  We think that future projects in this course will benefit from using a more popular microcontroller like the Arduino Uno.  This is mainly because students will not have to spend their time setting up a project and getting familiar to the complicated environment of Atmel Studio and just dive right in to reading digital input or pushing a desired voltage to external components.

We are very happy with our end result and are extremely proud of it.  The 3D printed housing give the project the esthetic component we were looking for from the start.

Nokia’s LCD display

For our project, we decided to purchase and use a Nokia Graphic LCD display to have a bigger display. At first it seemed easy to just plug the right wires in and make the LCD to work. Here’s a graphical representation of what the LCD looks like connected to an Arduino.

We hooked up the A3BU accordingly. When it came to converting the code for Arduino to a code that’d work with A3BU, we noticed we would need to write a driver from scratch for the Philips PCD8544 display controller to work with A3BU.

We started developing a simple driver for the PCD8544 display. Upon more research we realized that the LCD protocol is 9-bit SPI verses the AVR microcontroller series only support 8-bit mode. The LCD display could work with the 8-bit AVR microcontroller but we would need to implement additional software SPI output for it. Since the project scope doesn’t allow us to spend more time on it, we decided to go back to the good old LCD display for the A3BU which it’d make things much easier since we’re familiar with ST7565R LCD controller :).

(See Fall 2015 flappy bird project for a creative workaround to using the Nokia LCD with the A3BU!)