Mech - User contributions [en]

Ball Balancing Challenge

2008-03-21T08:23:29Z

AlexanderLeung: /* Circuit Components */

[[image:T14-project-action-08.jpg|350px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]

=== Overview ===
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

=== Mechanical Explanation ===
A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Faulhaber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

=== Other features ===
Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

=== Overview ===
The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]
=== PIC Inputs ===
The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

=== PIC Outputs ===
The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

=== Circuit Components ===

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

<b>Parts List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>[http://www.bergquistcompany.com/objects/touch_drawings/DRW_TS_400206_123rev.pdf BER237-ND]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

=== Modular Code ===

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

=== Full Code ===

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

<pre>

//Moves the motor to a pre-defined angle
void GoToAngle(int xangle,int yangle) {
while ((Encoder1 < (angleref[xangle]-100)) && (Encoder1 > (angleref[xangle]+100)) ) {
if (Encoder1<angleref[xangle]) set_pwm1_duty(78);
if (Encoder1>angleref[xangle]) set_pwm1_duty(0);
}
while ((Encoder2 > (angleref[yangle]-100)) && (Encoder2 > (angleref[yangle]+100)) ) {
if (Encoder2<angleref[yangle]) set_pwm2_duty(78);
if (Encoder2>angleref[yangle]) set_pwm2_duty(0);
}
set_pwm1_duty(39);
set_pwm2_duty(39);
}
</pre>
<pre>
int angleref[51] = {0, 91, 182, 273, 364, 455, 546, 637, 728, 819, 910, 1000, 1091, 1182, 1273, 1364, 1455, 1546, 1637, 1728, 1819, 1910,
2001, 2091, 2182, 2273, 2364, 2455, 2546, 2637, 2727, 2818, 2909, 3000, 3091, 3181, 3272, 3363, 3454, 3545, 3635, 3726,
3817, 3907, 3998, 4089, 4179, 4270, 4361, 4451, 4542};
</pre>

The first box is the function that takes a desired x-angle and a desired y-angle and tells the motor to move to that position as fast as possible. The angles passed to the function are actually a value 10 times the angle (e.g. to move the screen to 2.5 degrees on the x-axis and 3.7 on the y-axis one would type <pre>GoToAngle(25,37)</pre>). The second box is an array containing the encoder values associated with the the angle of one tenth of their index. For example, to encrease a tilt by 1.0 degrees, the encoder count would have to increase by the value of angleref[10], which is 910.

The main problem with using this method was that we were having hard times reading the encoders, and it was very difficult to manually make the screen flat before every use, as would be necessary for this to work, as there was no other way to establish a base encounter count.

Finally, the big problem we needed to tackle was a way to get a more consistent reading from the touchscreen, as this method led to a lot of false zeros. Putting a simple analog RC low pass filter did not work because the speed at which the PIC sampled the signal was too high, and the shaping of the curve would throw off the readings. A more complex analog filter might have improved this situation, but we chose to instead explore software filters. The software filters were moderately more successful, but they weren't perfect and they caused our code to severely lack resolution in the readings, as too many of the values were thrown out. The problem might be fixed mechanically if a game piece with a higher friction coefficient were used than the steel ball, such as a square slider. Alternatively, a different [http://en.wikipedia.org/wiki/Touchscreen#Technologies type of touchscreen] could be used, such as an infrared touchscreen.

Ball Balancing Challenge

2008-03-21T08:23:08Z

AlexanderLeung: /* Circuit Components */

Ball Balancing Challenge

2008-03-21T08:22:47Z

AlexanderLeung: /* Circuit Components */

Ball Balancing Challenge

2008-03-21T07:52:56Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Faulhaber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>[http://www.bergquistcompany.com/objects/touch_drawings/DRW_TS_400206_123rev.pdf BER237-ND]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results and Reflections==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

<pre>

//Moves the motor to a pre-defined angle
void GoToAngle(int xangle,int yangle) {
while ((Encoder1 < (angleref[xangle]-100)) && (Encoder1 > (angleref[xangle]+100)) ) {
if (Encoder1<angleref[xangle]) set_pwm1_duty(78);
if (Encoder1>angleref[xangle]) set_pwm1_duty(0);
}
while ((Encoder2 > (angleref[yangle]-100)) && (Encoder2 > (angleref[yangle]+100)) ) {
if (Encoder2<angleref[yangle]) set_pwm2_duty(78);
if (Encoder2>angleref[yangle]) set_pwm2_duty(0);
}
set_pwm1_duty(39);
set_pwm2_duty(39);
}
</pre>
<pre>
int angleref[51] = {0, 91, 182, 273, 364, 455, 546, 637, 728, 819, 910, 1000, 1091, 1182, 1273, 1364, 1455, 1546, 1637, 1728, 1819, 1910,
2001, 2091, 2182, 2273, 2364, 2455, 2546, 2637, 2727, 2818, 2909, 3000, 3091, 3181, 3272, 3363, 3454, 3545, 3635, 3726,
3817, 3907, 3998, 4089, 4179, 4270, 4361, 4451, 4542};
</pre>

The first box is the function that takes a desired x-angle and a desired y-angle and tells the motor to move to that position as fast as possible. The angles passed to the function are actually a value 10 times the angle (e.g. to move the screen to 2.5 degrees on the x-axis and 3.7 on the y-axis one would type <pre>GoToAngle(25,37)</pre>). The second box is an array containing the encoder values associated with the the angle of one tenth of their index. For example, to encrease a tilt by 1.0 degrees, the encoder count would have to increase by the value of angleref[10], which is 910.

The main problem with using this method was that we were having hard times reading the encoders, and it was very difficult to manually make the screen flat before every use, as would be necessary for this to work, as there was no other way to establish a base encounter count.

Finally, the big problem we needed to tackle was a way to get a more consistent reading from the touchscreen, as this method led to a lot of false zeros. Putting a simple analog RC low pass filter did not work because the speed at which the PIC sampled the signal was too high, and the shaping of the curve would throw off the readings. A more complex analog filter might have improved this situation, but we chose to instead explore software filters. The software filters were moderately more successful, but they weren't perfect and they caused our code to severely lack resolution in the readings, as too many of the values were thrown out. The problem might be fixed mechanically if a game piece with a higher friction coefficient were used than the steel ball, such as a square slider. Alternatively, a different type of touchscreen could be used, such as an [http://en.wikipedia.org/wiki/Touchscreen#Infrared infrared touchscreen].

Ball Balancing Challenge

2008-03-21T06:52:34Z

AlexanderLeung: /* Results */

Ball Balancing Challenge

2008-03-21T06:52:16Z

AlexanderLeung: /* Reflections */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Faulhaber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>[http://www.bergquistcompany.com/objects/touch_drawings/DRW_TS_400206_123rev.pdf BER237-ND]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

Ball Balancing Challenge

2008-03-21T06:49:15Z

AlexanderLeung: /* Mechanical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Faulhaber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>[http://www.bergquistcompany.com/objects/touch_drawings/DRW_TS_400206_123rev.pdf BER237-ND]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

Ball Balancing Challenge

2008-03-21T06:48:15Z

AlexanderLeung: /* Useful Resources */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>[http://www.bergquistcompany.com/objects/touch_drawings/DRW_TS_400206_123rev.pdf BER237-ND]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

Ball Balancing Challenge

2008-03-21T06:47:35Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>[http://www.bergquistcompany.com/objects/touch_drawings/DRW_TS_400206_123rev.pdf BER237-ND]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T06:46:26Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>[http://www.ti.com/lit/gpn/sn74hc04 SN74HC04]</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T06:45:32Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T06:45:05Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[javascript:openreq('http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pdf') L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T06:44:38Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>[http://www.ortodoxism.ro/datasheets/texasinstruments/l293d.pd L293D] </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T06:42:43Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|200px|right]]

==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering MS 2009
<br clear=all>

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two [http://hades.mech.northwestern.edu/wiki/index.php/Potentiometers potentiometers]) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]
Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two [http://hades.mech.northwestern.edu/wiki/index.php/Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder Falhauber motors] mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. [[Image:Coinslotopen.JPG|left|thumb|Coinslot with top off|200px]] Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via [http://hades.mech.northwestern.edu/wiki/index.php/Pulse_Width_Modulation pulse width modulation], the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors, LED "strike" array, and buzzer. The touchscreen was also an output as it was controlled by the PIC.

[[Image:TouchscreenControlpanel.JPG|left|thumb|Touch screen controls and LED display|200px]]

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

Toggle switches were added to allow easy powering on and off of our system. Also, a switch for automatic and manual control was implemented which was designed to have the purpose of switching the design from joystick control to automatic system control (self-adjusting touchscreen). The reset button was implemented to end the game at any time and end the main loop so that the motors would be inactive.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>[http://ww1.microchip.com/downloads/en/DeviceDoc/39631D.pdf PIC18F4520]</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

This project was programmed using [[CCS C]] on a PIC 18F4520. See the page on [[4520 Board use]] for more information on using the boards we used.

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

Although we got our project to the point where it worked well enough to show that we were able to create a working game, we definitely fell short of our goal of implementing a control system of not only stabilizing the ball, but also controlling its position and responding to disturbances. Listed below are our successes that greatly contributed to this project, as well as how they could be improved upon.

*A robust mechanical design that allowed for more than adequate range of screen tilting, as well as good choices of equipment and materials for not only the job at hand, but also future implementations.
**The one shortcoming in this department is we should have had a higher threading ratio in that the linear motion of the screen should be greater per motor revolution in order to have a faster response.
*We were able to have proportional control between the position of the joystick and the speed of the motors.
**For automatic control we should have the tilting of the joystick proportional to the angle of the screen instead of the speed. We got this working to an extent before we scrapped the automatic contol. It is further explained below.
*We had a successful electric design that allowed for great flexibility within the software to do what we needed, while using a minimal amount of PIC inputs.
*The source code we wrote ended up being clean, well commented, and easy to modify and experiment with. The modular approach that we took with it will be helpful to future groups who will easily be able to glean portions of the code.
**Unfortunately the code had a couple bugs in it that were only able to be ironed out after the equipment was returned, including a poorly placed delay that caused a terrible refresh rate in the touchscreen and joystick response. These bugs caused a lot of gameplay issues, but although we have not been able to test the improved code, the changes we made were definitely harmless and would have greatly improved the gameplay.
*The game ended up being fun to play, and allowed for true interaction between man and machine. We were also able to successfully use the touchscreen, adding valuable information to the wiki about a previously unused technology.
**The responses of the game were clunky, the results of the game were somewhat unpredictable, and our coin slot didn't work as seamlessly with the rest of the system as we would have liked.

===Future Action===

The main thing that would have been improved in our project if we had more time is the PIC control of the touchscreen. We put a great deal of effort into getting it working, but we simply ran out of time and had to scrap that idea not long before the project was due. Mechanically, we needed to have a better threading ratio on the bolts, and a more powerful motor would probably help as well. The rest of the work would be done on paper and in software.

On paper, the first thing we would need to figure out a PD control system to control this ball. This would consist of an equation that relates the tilting angle necessary to counteract proportionally both the position of the ball on the touchscreen as well as the velocity of the ball. Counteracting the position of the ball would be very easy, and could simply be worked in software by telling the motors to tilt the screen so that it would roll towards the center, or whatever point we tell it to go to. Counteracting the velocy would be more tricky, as we would have to calculate the momentum of the ball, and then figure out the force necessary for counteracting the momentum. The screen would then have to be tilted so that the sine of the tilting angle times the gravitational constant would equal the necessary stopping force. We drafted some code for finding the velocity of the ball:

<pre>
//Measure velocity readings for motor encoder
if (xcount>40 && ycount>40) {
xold=xnew;
xnew = (xmeasure/xcount);
yold=ynew;
ynew = (ymeasure/ycount);
xvelocity = (xnew-xold);
yvelocity = (ynew-yold);
xcount=0;
ycount=0;
xmeasure=0;
ymeasure=0;
}
</pre>

This code averages good values (not misreadings) of each axis readings and then subtracts the from the old average to get a number that corresponds to a velocity. The main problem with this is that the occurence of misreadings was generally very high because of the small contact point between the steel ball and the screen.

We also drafted some code to read the encoders and tilt the screen to the correct angle:

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T06:34:50Z

AlexanderLeung: /* Electrical Design */

Ball Balancing Challenge

2008-03-21T06:33:37Z

AlexanderLeung: /* Electrical Design */

Ball Balancing Challenge

2008-03-21T06:31:40Z

AlexanderLeung: /* Team Members */

Ball Balancing Challenge

2008-03-21T06:27:46Z

AlexanderLeung: /* Electrical Design */

Ball Balancing Challenge

2008-03-21T06:23:56Z

AlexanderLeung: /* Electrical Design */

File:TouchscreenControlpanel.JPG

2008-03-21T06:22:30Z

AlexanderLeung:

Ball Balancing Challenge

2008-03-21T06:21:12Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T06:16:29Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T06:14:48Z

AlexanderLeung: /* Overview */

Resistive Touchscreen

2008-03-21T06:05:27Z

AlexanderLeung: /* References */

== Overview ==

[[image:Bergquist hand ball balancing.jpg|[[A small Bergquist resistive touchscreen]]|right]]

Resistive touchscreens are useful for measuring the position of an object on top of them, or as an interesting user interface feature. The [http://www.bergquistcompany.com/touchscreens.cfm Bergquist] company sells them in a variety of sizes, ranging from 3.5 to 23 inches diagonal.

The 12.1 inch version was used in the [[Ball Balancing Challenge]] project. Its [http://www.bergquistcompany.com/to_technical_specs.cfm specifications] can be found on the Bergquist website. The screens are transparent and are meant to be installed over an LCD display; however, they are also useful in a horizontal orientation (as in the "Ball Balancing Challenge" project) for sensing the position of an object resting above.

According to the technical specifications, the activation force for this touch screen is 50g. From experience, activation is more reliable with a heavier weight. The area of contact may also play a role in activation; metal balls rolling on the screen produced a slightly noisy signal which needed to be filtered for reliable use in a real-time system.

<br clear=all>

== Implementation ==

A resistive touchscreen is essentially a large variable resistor. When a potential is put across two opposite sides of the touch screen, an output voltage can be read that is proportional to the touching distance between the activated sides. The Bergqist screen is a 5-wire resistive screen; its connections consist of four wires going to each of the corners (upper left, upper right, lower left, lower right) and one that goes to the surface. A potential across two opposite sides of the screen results in a gradient across the screen in that direction. When the surface is pushed in at a certain point, it forms a circuit, the output voltage of which can be read as an analog input into a PIC chip.

There are several ways to read a 5-wire resistive touchscreen. In the "Ball Balancing Challenge" project, the voltage gradient in one direction was created by placing +5 volts on two adjacent corners (for example the upper right and upper left) and grounding the other two. The position in the vertical direction was then read as proportional to the voltage on the middle (surface) wire.

Of course, this method only allows for the reading of one axis of the screen at a time. In order to read both the X and Y positions of the touchscreen, it is possible to use an interrupt service routine to switch rapidly between X and Y readings. For example, the +5V side can be switched between X and Y positions by alternating the voltage between the upper left (UL) and upper right (UR) corners and the upper left and lower left (LL) corners. Correspondingly, grounding will be switched between the lower left and lower right (LR) corners, and the upper right and lower right corners. This results in a type of square wave output on the screen wire, with its voltage representing the vertical and horizontal positions alternatively.

The voltage gradient in both the X and Y directions is linearly distributed from +5V to ground. Because the touch screens are typically rectangular, it may be necessary to multiply one of the readings by the screen's aspect ratio in order to create an equal coordinate system.

[[Image:Touchscreen.JPG|left|thumb|Touchscreen|200px]]
[[Image:Touchscreenribbon.JPG|right|thumb|Touchscreen cable for output|200px]]

<br clear=all>

== Circuit ==

The voltage switching described above must be accomplished quickly and precisely (so as to avoid a shortage). One way to accomplish this is to permanently power opposite corners with +5V and ground, and then switch the other two according to an ISR. The alternating PIC output signal is sent to one of the corners, and the other one gets its opposite signal through an inverter. The inverter ensures that only one axis of the touch screen is activated at a time.

[[Image:Touchscreen-circuit-diagram.JPG|center|thumb|Touchscreen Circuit Diagram|600px]]

== Software ==

This code will power the touchscreen and take readings of the x and y axes. It might be a good idea when reading this code to put the touchscreen reading into an interrupt service routine so the screen can be read regardless of what else is going on.

<pre>

/*
touchscreen.c
Reads the touchscreen individually as two axes.
PIC powers either the Upper Left (Y-axis reading) or the Lower Right (X-axis reading) and grounds what it doesn't power.
Output reading is the value on that axis.
Upper Left (UL) corner is PIN_C1, and Lower Left (LR) corner is always its inverse.
Upper Right (UR) corner is always high, and lower right (LL) is always ground, its inverse.
Peak voltage: Top reading voltage=4V and bottom reading voltage=1.2V
Reading is 0V when nothing is touching the screen.

*/

#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;

void main() {
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}
output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

while (TRUE) {
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}
}
}

</pre>

== External Links ==

[http://www.bergquistcompany.com/to_flexibility.cfm Bergquist Resistive Touchscreen Reference] <br>

Ball Balancing Challenge

2008-03-21T06:02:13Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T06:01:47Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T06:01:21Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T06:00:50Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T05:58:49Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T05:58:29Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T05:56:20Z

AlexanderLeung: /* Mechanical Design */

Ball Balancing Challenge

2008-03-21T05:52:37Z

AlexanderLeung: /* Mechanical Design */

[[image:T14-project-action-08.jpg|thumb|200px|right]]

<br clear=all>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

[[Image:Motorandconnection.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T05:52:16Z

AlexanderLeung: /* Mechanical Design */

[[image:T14-project-action-08.jpg|thumb|200px|right]]

<br clear=all>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

[[Image:Motorandconnection.JPG.JPG|right|thumb|Faulhaber Motor with epoxy connection to metal frame|200px]]

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

File:Motorandconnection.JPG

2008-03-21T05:49:00Z

AlexanderLeung:

File:Coinslotopen.JPG

2008-03-21T05:47:14Z

AlexanderLeung:

File:Coinslot.JPG

2008-03-21T05:45:38Z

AlexanderLeung:

Resistive Touchscreen

2008-03-21T05:42:27Z

AlexanderLeung: /* Implementation */

== Overview ==

[[image:Bergquist hand ball balancing.jpg|[[A small Bergquist resistive touchscreen]]|right]]

Resistive touchscreens are useful for measuring the position of an object on top of them, or as an interesting user interface feature. The [http://www.bergquistcompany.com/touchscreens.cfm Bergquist] company sells them in a variety of sizes, ranging from 3.5 to 23 inches diagonal.

The 12.1 inch version was used in the [[Ball Balancing Challenge]] project. Its [http://www.bergquistcompany.com/to_technical_specs.cfm specifications] can be found on the Bergquist website. The screens are transparent and are meant to be installed over an LCD display; however, they are also useful in a horizontal orientation (as in the "Ball Balancing Challenge" project) for sensing the position of an object resting above.

According to the technical specifications, the activation force for this touch screen is 50g. From experience, activation is more reliable with a heavier weight. The area of contact may also play a role in activation; metal balls rolling on the screen produced a slightly noisy signal which needed to be filtered for reliable use in a real-time system.

<br clear=all>

== Implementation ==

A resistive touchscreen is essentially a large variable resistor. When a potential is put across two opposite sides of the touch screen, an output voltage can be read that is proportional to the touching distance between the activated sides. The Bergqist screen is a 5-wire resistive screen; its connections consist of four wires going to each of the corners (upper left, upper right, lower left, lower right) and one that goes to the surface. A potential across two opposite sides of the screen results in a gradient across the screen in that direction. When the surface is pushed in at a certain point, it forms a circuit, the output voltage of which can be read as an analog input into a PIC chip.

There are several ways to read a 5-wire resistive touchscreen. In the "Ball Balancing Challenge" project, the voltage gradient in one direction was created by placing +5 volts on two adjacent corners (for example the upper right and upper left) and grounding the other two. The position in the vertical direction was then read as proportional to the voltage on the middle (surface) wire.

Of course, this method only allows for the reading of one axis of the screen at a time. In order to read both the X and Y positions of the touchscreen, it is possible to use an interrupt service routine to switch rapidly between X and Y readings. For example, the +5V side can be switched between X and Y positions by alternating the voltage between the upper left (UL) and upper right (UR) corners and the upper left and lower left (LL) corners. Correspondingly, grounding will be switched between the lower left and lower right (LR) corners, and the upper right and lower right corners. This results in a type of square wave output on the screen wire, with its voltage representing the vertical and horizontal positions alternatively.

The voltage gradient in both the X and Y directions is linearly distributed from +5V to ground. Because the touch screens are typically rectangular, it may be necessary to multiply one of the readings by the screen's aspect ratio in order to create an equal coordinate system.

[[Image:Touchscreen.JPG|left|thumb|Touchscreen|200px]]
[[Image:Touchscreenribbon.JPG|right|thumb|Touchscreen cable for output|200px]]

<br clear=all>

== Circuit ==

The voltage switching described above must be accomplished quickly and precisely (so as to avoid a shortage). One way to accomplish this is to permanently power opposite corners with +5V and ground, and then switch the other two according to an ISR. The alternating PIC output signal is sent to one of the corners, and the other one gets its opposite signal through an inverter. The inverter ensures that only one axis of the touch screen is activated at a time.

[[Image:Touchscreen-circuit-diagram.JPG|center|thumb|Touchscreen Circuit Diagram|600px]]

== Software ==

This code will power the touchscreen and take readings of the x and y axes. It might be a good idea when reading this code to put the touchscreen reading into an interrupt service routine so the screen can be read regardless of what else is going on.

<pre>

/*
touchscreen.c
Reads the touchscreen individually as two axes.
PIC powers either the Upper Left (Y-axis reading) or the Lower Right (X-axis reading) and grounds what it doesn't power.
Output reading is the value on that axis.
Upper Left (UL) corner is PIN_C1, and Lower Left (LR) corner is always its inverse.
Upper Right (UR) corner is always high, and lower right (LL) is always ground, its inverse.
Peak voltage: Top reading voltage=4V and bottom reading voltage=1.2V
Reading is 0V when nothing is touching the screen.

*/

#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;

void main() {
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}
output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

while (TRUE) {
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}
}
}

</pre>

== References ==

1. [http://en.wikipedia.org/wiki/Microphone Microphone - From Wikipedia, the free encyclopedia] <br>
2. [http://www.national.com/nationaledge/dec02/article.html Integrated Circuits for High Performance Electret Microphones] <br>

== External Links ==

[http://www.bergquistcompany.com/to_flexibility.cfm Bergquist Resistive Touchscreen Reference] <br>

File:Touchscreenribbon.JPG

2008-03-21T05:41:27Z

AlexanderLeung:

File:Touchscreen.JPG

2008-03-21T05:39:58Z

AlexanderLeung:

Ball Balancing Challenge

2008-03-21T05:34:04Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

The coin slot box was simply a ramp that would lead the dropped coin onto a conducting plate. The plate was supported by a weak spring that would bend under the weight of the coin to briefly touch another conducting plate below it before the coin rolled off. The brief contact between the two plates would send a high voltage to the PIC microcontroller.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found [http://hades.mech.northwestern.edu/wiki/index.php/Resistive_Touchscreen here].

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T05:32:12Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found here. [[Resistive Touchscreen]]

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T05:31:41Z

AlexanderLeung: /* Electrical Design */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

Information about the specifics, implementation and code that was used for the reading of the resistive touchscreen can be found here. [[Resistive Touchscreen]

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T05:28:49Z

AlexanderLeung: /* Overview */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm resistive touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

ME 333 final projects

2008-03-21T05:26:21Z

AlexanderLeung:

'''[[ME 333 end of course schedule]]'''

__TOC__

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axes, and then tracks the emitter with a laser. [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 See Spot Run.]

<br clear=all>

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This remote control robotic snake uses servo motors with a traveling sine wave motion profile to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

<br clear=all>

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic2.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

<br clear=all>

=== [[Magnetic based sample purification]] ===

<br clear=all>

=== [[Continuously Variable Transmission]] ===

[[image:CVT_setup1.jpg|thumb|200px]]

This prototype is a proof of concept model of a variable ratio transmission to be implemented in the 2008-2009 Formula SAE competition vehicle. The gear ratio is determined by the distances between the pulley halves which are controllable electronically.

<br clear=all>

=== [[Granular Flow Rotating Sphere]] ===

This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

<br clear=all>

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

<br clear=all>

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

<br clear=all>

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

<br clear=all>

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|Sweet Baseball Game|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

<br clear=all>

=== [[Ball Balancing Challenge]] ===

[[Image:Ballbalancechallenge.JPG|right|thumb|200px]]

An interactive game involving ball balancing on a touchscreen with touchscreen feedback and joystick action.

<br clear=all>

File:Ballbalancechallenge.JPG

2008-03-21T05:23:11Z

AlexanderLeung:

Ball Balancing Challenge

2008-03-21T05:04:30Z

AlexanderLeung: /* Overview */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm touchscreen] with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T05:04:18Z

AlexanderLeung: /* Overview */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

Based off an original idea of ball juggling, the purpose of our project was to test and gauge the capability of using a [http://www.bergquistcompany.com/touchscreens.cfm touchscreen]with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that would keep a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we would design a control system that would use a two-axis actuator system to move the touchscreen up and down depending on disturbances to keep the metal ball in the same place. Automatic control and manual control elements were to be implemented with the manual control element.

However, due to complications with our touchscreen readings, our group decided to focus on the essentials of our project and have it focus on both the touchscreen capabilities and try to make the project as interactive as possible. A joystick (made from two potentiometers) was used to control the two motors which would lift the table up in either axis. The game begins with a coin machine which, when a coin is slided in, would set off a contact and initiate the motor control. The design of our game was so that the player would attempt to keep the ball in a restricted region in the middle of the touchscreen, which was marked in black. The outside region of the touchscreen, marked in red, would set off LED's that would go off if the player stayed in the red region for an extended time. The player would lose after 4 LED's light up and the buzzer goes off. The player can reset the game but the motor control would cease to function and a coin is needed to reactivate the game again.

==Mechanical Design==

Our team weighed several alternatives for a mechanical system that could turn the screen in two axes. Potential solutions included a gimble system with a double-frame design and a pully-operated system that would lift up on two sides of the screen. Eventually, we decided on a system that was theoretically less precise, but much simpler and requiring less power (since one motor does not need to lift another). The system worked well under joystick control, but is only reliable for small tilting angles.

A sheet metal frame was built around the frame for protection, supported at its center of gravity by a pillar attached to the wooden base. The frame can freely tilt in two directions, allowing all possible ball movements. By raising and lowering two adjacent sides of the frame, the touch screen can be tilted in two directions. This motion is provided by two Falhauber motors mounted underneath the screen. The output shaft of the motors' gear boxes are attached to a threaded rod by couplers that we machined for the purpose. The couplers are attached to the motor shaft by a radial set screw and to the threaded rods by locking nuts. Riding on these rods are two threaded aluminum pieces, which are attached to the bottom of the frame via flexible tubing and epoxy. As the angle of the screen changes in one direction, the location of the attachment of the other motor moves slightly relative to the base of the motor. The flexible coupling allows for this motion, while providing vertical stability and transferring the up and down motion of the threaded pieces to the sides of the frame. Provided that the tilt angle remains small, its value can be approximated by the inverse tangent of the vertical motion of the threaded rod divided by 9cm (the horizontal distance from the tubing connection to the center of the frame). By controlling the speed of the motors via pulse width modulation, the tilt angles of the touch screen can be changed at a variety of speeds.

Other features include adjustable legs for stabilizing the wooden base on an uneven surface, and an upper frame above the touchscreen that prevents the ball from rolling onto the non-sensing regions at the periphery of the touchscreen. The mechanical design for this project was the simplest and most inexpensive option for this application; if a greater level of precision were required, a more complicated mechanism may have been necessary.

==Electrical Design==

The Electrical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis. This went to one of the PIC's analog inputs. The coin would simply fall on a simple switch, connecting 5V to the PIC. The touchscreen input looks like a square wave, except the two values being received correspond to the voltage from each axis. Separating these two values is done in software.

The PIC output to the motors corresponds directly to the joystick input. The PIC output goes both to the H-bridge and an inverter for each motor, so that the motor sees not a PWM signal and ground, but a PWM signal with its inverse PWM signal. As a result of this, both poles of the motor see the same thing when the high and low pulses of the signal are equal. The motors turn one way proportionally to the joystick position when the PWM has more time high than low (when that joystick potentiometer is sending a higher signal)and the other way when the PWM is more low than high.

The PIC output to the touchscreen is very simple. Although we had it go through an H-bridge to amplify the current, this is probably not necessary. Because the diagonally opposite corners of the touchscreen always have an opposite voltage going into them, we just ran the signal through an inverter so that we could control all four corners with only two PIC outputs.

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

[[media:T14-source-code.c|See full code here]]

==Results==

==Reflections==

==Useful Resources==

Ball Balancing Challenge

2008-03-21T00:41:10Z

AlexanderLeung: /* Overview */

[[image:T14-project-action-08.jpg|400px|right]]

<br>
<br>
==Team Members==
[[Image:T14-project-group-08.jpg|right|Left to right: JJ Darling, Alex Leung, Ben Schriesheim|thumb|200px]]

*JJ Darling - Electrical Engineering Class of 2009
*Ben Schriesheim - Manufacturing Engineering Class of 2008
*Alex Leung - Biomedical Engineering Graduate Student

==Overview==

The purpose of our project was to test and gauge the ability of using a touchscreen with a PIC Microcontroller. Our original projected means for testing the touchscreen for our project was to attempt to design and implement a system that keeps a round metal ball in the center of the touchscreen. Using the touchscreen's analog outputs of position, we could use a two-axis actuator system to to keep the ball stable. It will respond to disturbances to keep a metal ball in the same place.

Our project is to use an infrared touch-screen to balance and move a ball in a controlled manner. The ball will be balanced on top of the horizontally oriented screen and will be moved by tilting the screen in two axes.

To operate the device, a user would select a point on the screen (likely by touching it), and then would place a ball on the screen’s surface. The ball’s position would be continually tracked by the touch screen’s infrared intersection array. This information would be sent to a processor, which would control two motors and tilt the screen in order to move the ball to the selected location as quickly as possible.

The purpose of our project is to undertake the design and fabrication of a computer mouse that controls the on-computer cursor with hand movements in two dimensions -- roll and pitch (in the style of the WiiMote). We will accomplish this through the use of a two-axis accelerometer to determine the angle (x and y) of the remote relative to a preset (0, 0) and a XBee module for communication between the device and the computer. One of our primary goals will be to optimize the user’s experience by creating a device of reasonable size and weight, and focusing on an intuitive interface, in terms of cursor resolution and a tracking (cursor hold) button that is analogous to lifting a traditional mouse off a surface and relocating it.

We built a horizontal circular platform that is actuated from underneath by three speakers placed in an equilateral triangle. The vibration of the platform causes a small object (e.g., an IC socket or a coin) to act as an hour "hand" on top of the platform. The object slides around the circular platform, impelled by friction forces due to the vibration. By placing the speakers at different phases and amplitudes, we got the objects to move to desired positions. Due to the nodes created by the speaker vibrations, the object will move back to the correct hour if it is moved away. Our project was given to us by Professor Colgate and was based upon the research of Professor Lynch.

==Mechanical Design==

The Vibratory clock consists of a wooden base, held up by adjustable legs, three speakers, and a circular platform. The following material were used to create the design:

''Base:''
*wood: 16" diameter, 0.75" thick
*holes: 6" diameter (3 total)
*adjustable legs: 3 rods: 3/8"-16; 4" long; 6 nuts total

[[Image:speaker_supports.jpg|right|thumb|200px]]

''Speakers:''
*3 Pyramid Power PW677X: 300W, 4 Ohms, 6.5" Chrome Subwoofer
**previously adapted speakers replaced center of speaker with attachments 3" in height and 1/2" hole on top
**1/2" diameter PVC used to attach previous attachment to platform with a screw
***held in place by 2 set screws each
**centers placed 7.125" apart

''Circular Platform''
*PVC/Acrylic: 11.75" diameter, 0.25" thick
**machined on the LaserJet
**screw holes counter-sunk at 7.125" apart
*2.875" above wooden base
*Silver Sharpie used for numbers

'''Reasoning for Geometry of Design'''

''Equilateral Triangle:''
By having the speakers equidistant from each other, we were able to create symmetry in our design, which made programming the various nodes much easier. For example, we were able to use the same theory to find the node at 12 o'clock, 4 o'clock, and 8 o'clock. If the speakers were not placed equidistant from each other, two speakers placed at equal amplitudes and opposite phases would not have created a sink in the exact middle of the two speakers.

''Adjustable Legs:''

We needed to make the legs adjustable since it is essential that the platform be perfectly level in order for the objects placed on the platform to move in expected patterns. For example, if one leg is slightly shorter than the other two, the objects placed on the platform would tend to move towards that leg and we could no longer rely on symmetry to program the various nodes due to the effects of gravity.

''Height of Platform:''

Through our own experimentation and from [http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm Professor Lynch's research], we found that we needed to have the pivot point (i.e. the speaker diaphragm) significantly below the platform in order to create sinks. At one point in the design process, we attempted to create a different pivot point by replacing the PVC with 1/2" outer diameter, 1/4" inner diameter Tygon 2001 tubing that only was able to bend in one point since it had stand-offs and screws inside the tube. However, this replacement in a sense created two pivot points (the speaker diaphragm and the Tygon), causing the platform to only create sources and not sinks. In addition, the different height of the pivot point may have also led to the plate acting differently.

==Electrical Design==

The Electical Design was fairly simple for this project. The inputs to the PIC were the joystick, coin slot, and the touchscreen. The outputs were the motors and the LED "strike" array. The touchscreen was also an output as it was controlled by the PIC.

The user would control the joystick that was simply two potentiometers that would output a value between 0V and 5V, corresponding to both the x-axis and the y-axis.

[[Image:T14-electronics-photo-closeup.JPG|right|thumb|Circuit Board|200px]]

<b>Component List:</b>
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th><th>Vendor</th><th>Price (Total)</th></tr>
<tr><td>Microchip 8-bit PIC Microcontroller (U1)</td><td>PIC18F4520</td><td>1</td><td>N/A</td><td>N/A</td></tr>
<tr><td>Quadruple Half-H Drivers</td><td>L293D </td><td>2</td><td>[http://www.digikey.com Digi-Key]</td><td>$1.93</td></tr>
<tr><td>Hex Inverter</td><td>SN74HC04</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$0.47</td></tr>
<tr><td>Touchscreen</td><td>BER237-ND</td><td>1</td><td>[http://www.digikey.com Digi-Key]</td><td>$62.00</td></tr>
<tr><td>Joystick</td><td>N/A</td><td>1</td><td>N/A</td><td>N/A</td></tr>
</table>

<b>Circuit Diagram:</b>

[[Image:T14-schematic 1.JPG|center|thumb|Ball Balancing Circuit Diagram|600px]]

==Software Design==

The opening lines are necessary for establishing that we are using a PIC 18F4520, analog inputs, a clock, connecting with an ICD, and that we are using pin 36 instead of 16 for the second PWM output. This is also where we establish all of our variables and functions.

<pre>
#include <18f4520.h>
#DEVICE ADC=8 // set ADC to 8 bit accuracy
#fuses HS,NOLVP,NOWDT,NOPROTECT, CCP2B3 // CCP2B3 moves PWM2 output to pin 36 (RB3) rather than pin 16 (RC1)
#device icd=true
#use delay(clock=20000000)

int yread,xread,m,j=0;
int read1pwm,read2pwm=0;
int read1,read2=0;
int coin,strike,ball=0;
signed int16 counter=0;

void buzz();
</pre>

The main function starts with setting the correct initial values to the variables, and setting up the timers and analog ports.

<pre>
void main() {
//Flash 3 times to let us know we're running
for (j=0;j<3;j++){
output_d(0b11111111);
delay_ms(250);
output_d(0);
delay_ms(250);
}

coin=0;
strike=0;
ball=0;
counter=0;

output_high(PIN_C1); //Start with UL high, LR low ***THESE WILL CHANGE***
output_high(PIN_C0); //This is the pin for UR. It will be run through an inverter for LL
//the bottom left corner. ***THESE ARE PERMANENT***

setup_adc_ports(AN0_TO_AN2); // Enable analog inputs; choices run from just AN0, up to AN0_TO_AN11
setup_adc(ADC_CLOCK_INTERNAL); // the range selected has to start with AN0

setup_timer_2(T2_DIV_BY_4, 77, 16); // clock at 16KHz, interrupt every 4*50nS * 4 * (155+1) * 16 = 2.00mS

enable_interrupts(INT_TIMER2);
enable_interrupts(GLOBAL);

setup_ccp1(CCP_PWM); // PWM output on CCP1/RC2, pin 17 this goes to y-axis motor
setup_ccp2(CCP_PWM); // PWM output on CCP2/RB3, pin 36 this goes to x-axis motor

set_pwm1_duty(39);
set_pwm2_duty(39);

</pre>

The following portion of code shows what happens when the game is continuously played. First the game waits for a coin, then it plays the game until the user strikes out, then it stops the motors from spinning and again waits for a coin.

<pre>
while (TRUE) {

set_pwm1_duty(39);
set_pwm2_duty(39);

//Wait for coin to be inserted
while (coin==0) {
if (input(PIN_E1)) coin=1;
else delay_ms(100);
}

//Gameplay begins. Controls go dead when strikes go too high;
while (coin==1) {
</pre>

The touchscreen is read by having the PIC send alternating signals to 2 of the corners that are diagonal to each other while keeping the other two signals constant. This allows the touchscreen to read both axes each run through, and then display them in a manner where the x-axis reading corresponds to PIC LED outputs D0-D3, and the y-axis reading corresponds to outputs D4-D7. Although this gives visually a very poor resolution on the reading, it serves well enough as a debugging tool to make sure the reading is working.
<pre>
//Touchscreen reading, looks at the touchscreen readings
if (m==0) {
output_high(PIN_C1); //UL goes high, thus LR goes low; y-axis can be read
set_adc_channel(0);
delay_us(10);
yread = read_adc(); //Read y axis
m++;
}
else {
output_low(PIN_C1); //UL goes low, thus LR goes high; x-axis can be read
set_adc_channel(0);
delay_us(10);
xread = read_adc(); //Read x axis
m=0;
}

//LED readings for XY locations of the touchscreen
if (xread<75) {
output_low(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<110) {
output_high(PIN_D0);
output_low(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<145) {
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_D3);
}
else if (xread<180) {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_low(PIN_D3);
}
else {
output_high(PIN_D0);
output_high(PIN_D1);
output_high(PIN_D2);
output_high(PIN_D3);
}
if (yread<75) {
output_low(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<110) {
output_high(PIN_D4);
output_low(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<145) {
output_high(PIN_D4);
output_high(PIN_D5);
output_low(PIN_D6);
output_low(PIN_D7);
}
else if (yread<180) {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_low(PIN_D7);
}
else {
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
}
</pre>

To find the "winning" ranges of the black area on the touchscreen, we measured the voltage output on each axis on each boundary line, and converted it from the 0V to 5V scale to the quantized 8 bit (0 to 255) scale. Our code then checks to see if the ball is not in this zone before assigning a strike to the user. The counter variable is to ensure that the ball is outside the range enough times in a row, and a low reading is not simply the result of inconsistencies in the touchscreen reading.
To stop the machine from simply running up the strikes while the ball is in the red, the code ensures that a "strike" cannot be assigned until a "ball" is assigned before hand.

For each strike, a corresponding LED is lit up, and upon the last strike, the buzz function is set off.

<pre>
//Check to see if the Ball is outide the allowed range of values to be "in the black" of the touchscreen
if ((yread< 90) | (yread >150) | (xread <90) | (xread > 150)) {
counter++;
if ((counter==3) && (strike==ball)) {
strike++; //If ball is "in the red" for a sufficiently long time, a strike is added.
}
}
else {
counter--;
//Check to see if the ball has returned from being "in the red."
if ((counter==-1) && (strike>ball)) {
ball++;
}
}

if ((counter==3) | (counter == -2)) counter=0;

if (strike==2) {
output_high(PIN_A3);
}
if (strike==3) {
output_high(PIN_A4);
}
if (strike==4) {
output_high(PIN_A5);
}
if (strike==5) {
output_high(PIN_E2);
set_pwm1_duty(39);
set_pwm2_duty(39);
buzz();
}

</pre>

The PIC reads the joystick and quantizes the input from the analog 0V to 5V to the 8 bit quantized 0 to 255. It then scales that number to be between 0 and 78, the PWM extremes.
<pre>
//Joystick Control
if (input(PIN_C7) != 0) { // toggle switch that switches between Joystick control system and Touchscreen control system
set_adc_channel(2); // there's only one ADC so select which input to connect to it; here pin AN1
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read1 = read_adc(); //x-axis
if (read1<145 && read1>115) read1pwm=39;
else read1pwm=(read1*.3);
set_pwm1_duty(read1pwm);

set_adc_channel(1); // there's only one ADC so select which input to connect to it; here pin AN2
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
read2 = read_adc(); //y-axis
if (read2<145 && read2>115) read2pwm=39;
else read2pwm=(read2*.3);
set_pwm2_duty(read2pwm);
}
else {
output_d(0);
set_pwm1_duty(39);
set_pwm2_duty(39);
}
}
}
}
</pre>

The buzz() function resets the counting variables to zero and sets the buzzer off by oscillating a PIC output into a basic buzzer speaker at an audible frequency.

<pre>
void buzz() {

coin=0;
strike=0;
ball=0;
counter = 0;
output_low(PIN_A3);
output_low(PIN_A4);
output_low(PIN_A5);
output_low(PIN_E2);

while (input(PIN_C6)==0) {
output_high(PIN_C4);
delay_us(100);
output_low(PIN_C4);
delay_us(100);
}
}

</pre>

==Results==
[[Image:VibratoryClock.jpg|right|thumb|300px]]

We were able to get our project working so that the plate moves an object placed anywhere on the plate to the correct time and then moves the objects around the clock face, acting as the hour "hand" of a clock. However, we increased the speed so that it takes about 2 minutes for objects placed on the clock to move around so that it is easy to demonstrate. Check out the working Vibratory Clock [http://www.youtube.com/watch?v=KhgTNCfdwZw here].

==Reflections==

==Useful Resources==

[http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm Vibration-Induced Frictional Force Fields for Part Manipulation]

[http://www.cs.berkeley.edu/~jfc/dreznik/UPM2000/index.html Universal Planar Manipulator]

Ball Balancing Challenge

2008-03-20T23:54:08Z

AlexanderLeung: /* Overview */

Microphones

2008-02-19T23:45:01Z

AlexanderLeung: /* Overview */

== Original Assignment ==

This project is to demonstrate a "clapper" device using an electret microphone (e.g., the 423-1024-ND from digikey). Build an appropriate circuit and write a program to continuously display the volume of the sound it receives as a "light bar" on the PIC board LEDs.

== Overview ==

A "clapper" device was built using a PIC 18F4520 and an [http://en.wikipedia.org/wiki/Electret_microphone electret condenser microphone] (in this case, the [http://www.knowles.com/search/prods_pdf/MD9745APA-1.pdf 423-1024-ND] from digikey) as an analog input. The device operates on the principle that the microphone will convert the sound into an analog input to the PIC and, as the sound increases in volume, the analog input's amplitude will increase. This input is then converted into an output on the set of LEDs soldered onto the PIC's circuit board. This output works as a light bar; it displays the minimum one LED for quiet sound levels and activates additional LEDs as the sound becomes louder -- up to a maximum of eight. The sensitivity of the microphone is adjustable through a gain potentiometer.

[[image:ElectretMicrophone.gif|thumb|300px|[[Interior of Electret Microphone]]|right]]
[[image:Electret_condenser_microphone_capsules.jpg|thumb|350px|[[Electret condenser microphone capsules]]|left]]

The most commonly used microphones for audio use capacitance charge (condenser microphones), electromagnetic generation (dynamic microphones), or piezoelectric generation. In a [http://en.wikipedia.org/wiki/Condenser_microphone#Condenser.2C_capacitor_or_electrostatic_microphones condenser microphone], a thin membrane of the microphone acts as one plate of a capacitor and a nearly constant charge is maintained on the capacitor. The voltage maintained across the capacitor plates changes with the vibrations in the air, according to the capacitance equation:
:<math>Q = C \cdot V</math> where Q = charge in coulombs, C = capacitance in farads and V = potential difference in volts, resulting in a change in output voltage. Power is necessary for establishing the capacitor plate voltage, and is also needed for internal amplification of the signal to a useful output level. Electret microphones, a type of condenser microphone, replace the externally-applied charge with a permanently fixed-charged material. The electret is a stable dielectric material with a permanently-embedded static charge. Electret microphones require no polarizing voltage but, due to their integrated pre-amplifier, require a small amount of power either from microphone inputs as phantom power or from a small battery. Due to mass-production of these devices, electret microphones lack the precision needed for high-quality microphones.

Due to the variable nature of ambient noise, a calibration "reset" button was included that would reset the output LEDs based on the environment's baseline noise level. This calibration was done via software averaging of the ambient volume level. The device that is built currently follows the principles of the clapper device in that the higher the analog input is received, the more LEDs will be shown. However, due to the brevity of the audio input peak for shorter signals such as a clap, it is sometimes difficult to see the correspondingly brief output. A further step would be to install a software switch that would detect the characteristic sound pattern of a clap and activate a digital output upon recognition.

Of the three microphones tested for the clapper device (Electret Microphone, [http://www.sonystyle.com/webapp/wcs/stores/servlet/ProductDisplay?catalogId=10551&storeId=10151&langId=-1&productId=11037550 Sony F-V100], and a small dynamic microphone), the electret microphone showed the greatest sensitivity to varying noise levels.

== Circuit ==

The circuit built for this example uses an electret microphone to listen to external sound and displays the volume level as a light bar on the PIC board LEDs. The microphone uses a single analog input pin of the PIC.

Optional features present in the shown circuit diagram include a potentiometer gain knob for adjusting the microphone's sensitivity and a calibration button for setting the baseline ambient noise level. The code governing the operation of the calibration button is included below; the button itself is wired into a digital input of the PIC. Refer to the photo and diagram for details.

[[image:400px-Microphone_circuit.JPG|thumb|400px|[[Microphone Circuit and PIC photo]]|right]] [[image:Mic_circuit_diagram4.JPG|thumb|400px|[[Microphone Circuit and PIC diagram]]|left]]

<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>

== Code ==
<pre>

/*
microphone.c by JJ Darling, Alex Leung, Ben Schriesheim
This code will take an analog microphone input and display the power of the single
as an easily read LED array. One light on means the input matches the ambient noise,
and all eight lights on means the microphone is receiving a loud noise.

The reset button can be used to match the lowest output to the ambient noise.

This code was derived off of the analog input code written by Prof. Michael Peshkin, which
can be found in the source code repository on this wiki.
*/

#include <18f4520.h>

#DEVICE ADC=8 // set ADC to 8 bit accuracy.

#fuses HS,NOLVP,NOWDT,NOPROTECT
#use delay(clock=20000000)

signed int16 value;
int16 valueinit=0;
int k=0;
void initialize();

void main() {

setup_adc_ports(AN0); // Enable analog inputs AN0;
setup_adc(ADC_CLOCK_INTERNAL);
initialize();

while (TRUE) {

set_adc_channel(0); // there's only one ADC so select which input to connect to it; here pin AN0
delay_us(10); // wait 10uS for ADC to settle to a newly selected input

if (input(PIN_C0)>0) initialize(); //Initialize the base output to match ambient noise

value = read_adc(); // now you can read ADC as frequently as you like

//Create a gain to dramatically differentiate the input level from ambient noise
if ((value-valueinit)<0) value=0;
value=(value-valueinit)*20;

if (value<32) //Easy to read volume meter
output_d(0b1);
else if (value<64)
output_d(0b11);
else if (value<96)
output_d(0b111);
else if (value<128)
output_d(0b1111);
else if (value<160)
output_d(0b11111);
else if (value<192)
output_d(0b111111);
else if (value<224)
output_d(0b1111111);
else
output_d(0b11111111);

if (value>128) delay_ms(200);
}
}

//Take samples to establish an initial value to 'tare' the ambient noise.
void initialize() {

delay_ms(1000); //Give enough time for the user to release the "reset" button

valueinit=0;

//Read 100 input levels and take their average. This a measure of the ambient noise
for (k=0;k<100;k++)
{
set_adc_channel(0); // there's only one ADC so select which input to connect to it; here pin AN0
delay_us(10); // wait 10uS for ADC to settle to a newly selected input
valueinit+=read_adc();
}

valueinit = (valueinit/100);

}

</pre>

== References ==

1. [http://en.wikipedia.org/wiki/Microphone Microphone - From Wikipedia, the free encyclopedia] <br>
2. [http://www.national.com/nationaledge/dec02/article.html Integrated Circuits for High Performance Electret Microphones] <br>

== External Links ==

[http://www.hosiden.co.jp/web/english/web/products/pdf/e_on06_mic.pdf Guide for Electret Condenser Microphones] <br>
[http://www.soundonsound.com/sos/1995_articles/jun95/microphones.html CHOOSING A MICROPHONE: Microphone types and uses] <br>