Pinball Machine

EGGN 383 Final Project

May 6, 2013

Mei Li and Caleb Whitehead

1

Introduction

The objective of our project was to design and implement a small-scale pinball machine. To make

the project feasible given the allotted time we had, the operations of our pinball machine were limited.

Two servo motors drive two separate paddles. User input via a pushbutton activates the paddles to strike

the pinball, which then travels around the playing base. If the pinball enters the score region, it will be

detected by infrared (IR) break-beam sensors and the machine will update the score on the liquid crystal

display (LCD). If the pinball enters the escape region the machine will decrement the number of escapes

remaining. Game is over when the pinball escapes three times; the goal is to enter the score region as

many times as possible.

Project specifications were met with two software steps. First, we initialized all necessary

components such as the LCD and the PWM system, which controlled the servo motors. Second, we used

a polling technique to read input from the pushbuttons and drive the paddles accordingly, as well as to

read the input from the break beam sensors and adjust the scores on the LCD accordingly.

Hardware Overview

As shown in the hardware diagram in Figure 1, the main electrical components for this project are

the servo motors, pushbuttons, IR break-beam sensors, and LCD. The mechanical aspects of this project

consisted of the playing base, the paddles, and how they are mounted together with the electrical

components. We used two servo motors, rated at 6V, to swing the paddles to 60 degrees. The motors were

mounted on the bottom of the playing base, and as the pinball fell, the pushbuttons could activate the

motors. Two IR break-beam sensors were installed around the center of the playing base. The gap

between the emitter and the receiver served as the scoring region, and as the pinball travelled through the

gap, the beam was broken and the LCD updated the scoring. A similar principle applied to the IR break-

beam sensor installed at the bottom of playing base, and the difference was that this sensor served as the

escape region.

The picture in Figure 2 shows our implementation of the conceptual design in Figure 1. We used

wooden materials for the playing base and the paddles. Cardboard material was considered in our original

design but it was too fragile and did not offer a smooth playing field for the pinball. However, we used

cardboard material to make the edges and obstacles on the playing base.

2

Figure 1: Hardware Diagram

Figure 2: Hardware Implementation

3

Circuit Description

The circuit we used to construct the pinball machine consisted of two parts: the primary control

circuit and the 555 timer circuit. The first, shown in Figure 3, included the wiring between the HCS12

microcontroller and all of the major components involved in mechanical controls and data transfer. This

circuit can be further divided into three primary functions: The LCD was wired to PortAD, which was

used for this project as nothing more than a simple input/output port. PortT monitors the pushbutton

signal inputs and adjusts the servo motor outputs accordingly. Finally, the IR sensor outputs were

captured using 3 different pins on PortM.

The LCD used for this project was the same device used in Lab 7; the wiring method remained

unchanged from what we used previously, but because PortAD pins 0 and 1 were hardwired to other

components, all pins used were shifted up by two pins from those used on PortT. The IR sensor outputs

were sent to PortM, pins 2 through 4, which were configured as inputs to read the signals.

The wiring on PortT is somewhat convoluted for a couple of design reasons. The servo motors

require a PWM signal to control them properly; changing the duty cycle adjusts the device position.

PWM signals can be transferred from the PWM system to PortT using the MODRR register; however,

they can only be transferred to pins 0 through 4. However, the servo motor outputs, J3 and J6, are

hardwired to PortT pins 4 and 5. As a result, the PWM signals were sent to pins 3 and 4, and then the

signal on pin 3 was hardwired to pin 5 on the header board. All of this wiring is shown in Figure 3. The

pushbutton inputs used a simple pull-up resistor control scheme, and are sent to pins 0 and 2 on PortT,

which are configured as inputs.

Figure 3: Primary HCS12 control schematic

4

The second part of the circuit, shown in Figure 4, was the 555 timer circuit. Although the 555

timer was driven by the power supply from the SSMI board, this was an entirely separate circuit and used

only to produce the 38 kHz signal necessary for operating the IR LED outputs to the break beam sensors.

To achieve the desired square wave output, the 555 timer was configured in Astable mode, as depicted

below. A variable resistor was used to fine tune the signal output for the IR devices used. The output from

the timer was sent through a series resistor-IR LED circuit that transmitted a continuous beam to the IR

sensors in Figure 3.

Figure 4: 555CN IC Timer schematic

Software Design

As formerly mentioned, the software we used to control this device consisted of two primary

tasks within the main function. The first was an initialization phase, and the second, within the infinite

loop, was code that would continuously poll and respond to inputs on the pushbuttons and IR sensors.

Pseudocode for the software is shown in Figure 5, whereas Appendix A3 details the actual main function

in C used to implement the design.

Initialize

LCD (on PortAD)

PWM system (on PortT)

IR sensors (already set as inputs on PortM)

Set score to zero

Set number of escapes left to three

While(true)

Drive motor forward if button depressed

Drive motor back if button released

Waiting = 1 if score sensor detects ball

Increase score, waiting = 0 if score sensor doesn't detect ball and waiting = 1

If escape sensor detects ball, wait until escape sensor doesn't detect ball, then decrease escapes

left

Update counters on the LCD

Display "Game Over" if no escapes left

While (Game Over) enter infinite loop to disable game

Figure 5: Pinball Machine Pseudocode

5

In the initialization phase, all DDRx registers were set to appropriate values so that the pins were

configured as input or output, and the score counters were initialized to 0, for the score, and 3, for the

number of escapes allowed. All functions required to initialize the LCD are in Appendix A2; essentially,

this required clearing the display, configuring the cursors, and preparing it to show characters as desired.

In the polling phase, the motor functions were very simple. IF statements determined if the

pushbuttons were currently depressed or not, and changed the duty cycle of the PWM signal to the servo

motor accordingly. Polling the IR sensors required first evaluating whether or not any IR beams were

broken and then using that information to update the LCD display. The pseudocode shows redundancies

that were put in place to prevent unbounded scoring increases should the ball become lodged between

sensors. When the escape counter reached zero the “Game Over” state was implemented by entering a

second, nested loop that prevented the program from operating until the reset button was pushed.

Verification

Since this project consisted of different hardware components, we developed the testing

procedure for one component at a time. We started the implementation of the project by verifying that we

could adapt the LCD code and schematic from previous labs to be used on PortAD. After testing the

LCD, we moved on to experiment with different types of motors. Initially, we were not sure which type

of motor would be ideal to swing a paddle. The DC motor we had in the lab was not accessible as it was

built into a wheel system architecture, and would also have created error with continuous forward and

reverse motion. Furthermore, the stepper motor was designed for applications required accurate

positioning but could not provide torque adequate for our project, so we opted to use the servo motor.

Servo motors require a PWM signal to control their position. Having set-up the push-buttons to

control the PWM duty cycle for their corresponding motors, we used an oscilloscope to measure the

output signal being used. As Figure 6 shows, the steady position for each motor required a different duty

cycle, as they are positioned in mirror locations from each other.

Figure 6: PWM signal used to place each servo motor in initial, steady position

6

The next task was to implement the IR break-beam sensors. To make the pinball machine

portable, we decided to use a 555 Timer instead of a function generator to modulate the frequency

required for the IR emitter. In this process, we experimented with the potentiometer and the trimpot for

the variable resistor. As Figure 7 shows, the modulated signal for the emitter was not exactly 38 kHz. It

was important for us to maintain the 36.6 kHz signal in order for all the break-beam sensors to work

properly. Through experimentation, we found out that trimpot gave us more stabilized signals.

Figure 7: Modulated signal for IR emitters

After verifying the 555 timer, we tested the IR sensors. As expected, when an object was in

between the emitter and the receiver, the beam was broken. Figure 8 shows this instance while Figure 9

shows when there was nothing in between the emitter and the receiver. After testing the IR sensors we

mounted them on the board and soldered their terminals to wires for connection to the SSMI board.

7

Figure 8: Oscilloscope trace when an object breaks the IR sensor beam

Figure 9: Oscilloscope trace when there is no IR detection

8

Conclusion

Given the scope of the project specifications from the beginning, which proposed a simplified

version of a pinball game, this project was successful. After adding a second, external power supply we

were able to drive both servo motor paddles with precision, and the IR sensor system was successful in

detecting the presence of the ball and appropriately adjusting the score. Use of servo motors allowed the

position of the paddles to be controlled with every button press, which eliminated positioning errors that

may have been introduced by other motors. Also, the use of a 555 timer chip allowed us to make the game

more compact and portable, while still providing adequate control over the output signal.

While designing this project we faced three primary challenges that consumed a great deal of

time. The first challenge dealt with capturing the signal from the pushbuttons; initially we planned to use

input capture on PortT, but we discovered that the initial bouncing from the pushbutton produced

occasional false triggers that caused this method to be unreliable. We resolved this problem by polling the

state of the pushbuttons in the main function, rather than responding to the state transitions only.

The second problem was caused by the HCS12’s power limitations. When we attached both servo

motors simultaneously we observed erratic behavior when controlling them with the pushbuttons. This

included false triggers on both motors, continued, random oscillatory behavior after the pushbuttons were

no longer being operated, and failure to operate at all. This problem was resolved by powering the second

motor with an external 5V DC power supply, but still using the PWM signal from the HCS12 for control.

This system allowed us to retain both paddles in our design. Although we were able to use both motors,

we were required to use slower motors provided in lab rather than higher speed servos, as the parts we

ordered did not arrive on time.

The final difficulty we faced was tied to the IR sensors. We found there to be some slight

variation in the signal frequency that each IR sensor would detect, so there was a substantial amount of

trial and error involved in configuring the 555 timer to output exactly the right signal so that high and low

signals were consistent.

We were pleased with the successful implementation of our design. We learned a great deal about

the power dependency of the HCS12 microcontroller, and were able to expand our knowledge about using

the various ports available.

9

Appendix

A1: Microsecond Delay Function (delays number of microseconds input x10)

void DelayuSec(unsigned int t) { if (t !=0){

t*=10; __asm { ; Main loop is 24 cycles, or 1 usec ldx t ; 3 additional cycles here loop: psha ; 2 E cycles pula ; 3 E cycles psha ; 2 E cycles pula ; 3 E cycles psha ; 2 E cycles pula ; 3 E cycles psha ; 2 E cycles pula ; 3 E cycles nop ; 1 E cycle dbne x,loop ; 3 E cycles } } }

A2: LCD Functions (writeNibbleToLCD, writeByteToLCD, InitializeLCD, printLCD)

void writeNibbleToLCD(char n, char rs, int t) { rs <<=5; PTAD = (rs|0x10|(0x0f & n))<<2; //PTAD <<= 2; DelayuSec(1); PTAD &= ~0x40; DelayuSec(t); }

void writeByteToLCD(char b, char rs, int t) { char temp = b>>4; writeNibbleToLCD(temp, rs, 1); // for high nibble, shift left 4 // bits writeNibbleToLCD(b, rs, 1); // for low nibble, nibble function // will take care of masking b DelayuSec(t); }

void InitializeLCD(void) { int i; for (i=0; i<100; i++) { // delay 100ms to allow LCD powerup DelayuSec(1000); }

10

// The first parameter in each call is the nibble to be sent, // the second parameter is the rs value (rs=0 indicates an // instruction), and the third parameter is the time to delay // after sending (in units of us). writeNibbleToLCD(0x03, 0, 5000); //delay at least 4 ms = 4000 us writeNibbleToLCD(0x03, 0, 5000); writeNibbleToLCD(0x03, 0, 5000); writeNibbleToLCD(0x02, 0, 5000); // The first parameter in each call is the byte to be sent (as // two nibbles), the second parameter is the rs value (rs=0 // indicates an instruction), and the 3rd parameter is the time // to delay after sending both nibbles (usec). // These commands are all fast (~40 us) except for "clear // display" (2 ms) writeByteToLCD(0x28,0,50); // 2 lines, 5x8 dots writeByteToLCD(0x0c,0,50); // display on, no cursor, no blinking writeByteToLCD(0x14,0,50); // shift cursor right writeByteToLCD(0x01,0,2000); // clear display and cursor home }

void printLCD(char mystr[]) {

int i; char strChar;

writeByteToLCD(0x01,0,2000); // clear the display

for(i = 0; i<80; i++) { strChar = mystr[i]; if(strChar == 0) break; writeByteToLCD(strChar, 1, 50); } }

A3: Main Function (with include statements)

#include <hidef.h> /* common defines and macros */ #include "derivative.h" /* derivative-specific definitions */ #include <stdio.h>

void main(void) { /* initialize variables for LCD */ char toLCD[80]; // Stores the value to be displayed int file_number = 0; // Unused variable used to call sprintf int score = 0; // Score count int escapes = 3; // Number of escapes remaining char waiting, update; // Used in the IR polling function

// initialize PAD pins for LCD DDRAD = 0xfc;

11

// Set up PWM System to drive the Servo motor(s) on PT3-PT4 PWMCLK = 0x18; // Select clock SA/SB as the clock source PWMPRCLK = 0x66; // Set clock prescalar to 64 on A and B PWMSCLA = 15; // Divider for clock SA PWMSCLB = 15; // Divider for clock SB PWMPOL = 0x18; // PWM3/PWM4 output high at the start of period PWMPER4 = 250; // Period = 250 ticks PWMPER3 = 250; PWMDTY4 = 14; // Duty = 12 ticks, which is about 1 ms PWMDTY3 = 22; PWME = 0x18; // Enable PWM3/PWM4 MODRR = 0x18; // Route PWM to PortT PT3/PT4

// Set up PT3/PT4 for output to the motors DDRT = 0x18;

InitializeLCD();

EnableInterrupts;

waiting = 0; // Initialize IR sensors with no ball detectio

// Initialize score display to starting values file_number = sprintf(toLCD, "Score: %d \n\n Escapes Remaining: %d", score, escapes); printLCD(toLCD);

for(;;) {

/* * * * * POLL PUSHBUTTONS * * * * */ //"Outside" pushbutton controls J3, treats it as left paddle //"Inside" pushbutton controls J6, treats it as right paddle //PWM Duty cycles for forward and reverse positions are opposite //for left and right paddles if (!(PTT &0x01))//PT0 is low; Left Motor forward PWMDTY3 = 14; else PWMDTY3 = 22;

if (!(PTT &0x04))//PT2 is low; Right Motor forward PWMDTY4 = 22; else PWMDTY4 = 14;

/* * * * * POLL IR SENSORS * * * * * */ if (PTM & 0x18){ //check if ball is in a score region score++; //if present, increase score counter update=1; //”update” tells the LCD to refresh }

12

if (PTM & 0x04) { while (PTM & 0x04);//if ball enters escape region, wait for //user to remove it escapes--; update = 1; //”update” tells the LCD to refresh } if (escapes>0){ file_number = sprintf(toLCD, "Score: %d \n Escapes Remaining: %d", score, escapes);

if (update){ //Takes time, so only refresh if scores change printLCD(toLCD); update =0; } } if (escapes ==0) { printLCD("Game Over"); for(;;); //infinite loop prevents further gameplay at “Game //Over” until Reset button pressed }

_FEED_COP(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }