ECE597 Fall2014 Ringing Servos

Team members: Mark Morrison, Peter Olejnik,  Randy Turner

Grading Template
I'm using the following template to grade. Each slot is 10 points. 0 = Missing, 5=OK, 10=Wow!

 00 Executive Summary 00 Installation Instructions 00 User Instructions 00 Highlights 00 Theory of Operation 00 Work Breakdown 00 Future Work 00 Conclusions 00 Demo 00 Late Comments: I'm looking forward to seeing this.

Score: 10/100

(Inline Comment)

Executive Summary
 This rambles a bit. Too much history, just report on what's working. Consider using the outline given in the template. The goal of the project at this moment is to use a cape that gives the BeagleBone usage of 32 PWM ports and to attach servo motors to it. The servo motors will then drive a mechanism that will ring bells of sorts. We have successfully used the PWM cape to drive a servo to a specified position using a shell script. This was more difficult than it was originally thought, because the cape uses I2C1 on the board, which is I2C2 in software, and because there were multiple other configurations we needed to change to set up the cape. We use a JavaScript program to output I2C messages to the cape to control the servos. The servos are connected to a mechanism with two bells, and when the servo rotates the bells ring. The bells do not require a great amount of movement to ring, but need to be oriented correctly to get the best sound, so the program only moves the servo about 15 degrees away from the center in either direction. From this, we have learned that JavaScript was a poor choice for a project as time-sensitive as this. The asynchronous nature of the language has made it all-but impossible to control timing when using multiple threads. For this reason, we ported our software to C. At this point the C program can control the servers simultaneously, but we believe that we are hitting the transfer rate limit of I2C because we have to send four commands for each movement of each servo, and we send these four commands to each servo every 15 ms. Unfortunately this is not a limit that we can work around since the PWM cape is limited to I2C communication and the control signals cannot be simplified. For this reason I would not recommend the PWM cape for simultaneous control of anything that might be time-sensitive like this.

Mechanical Hardware
Two diffrent types of servos were used. These were used with simmilar results.


 * Dynam DY1008 9G Digital Servo
 * Solar Servo D220 0.11@4.8v Digital 9g Micro Servo

The following quantaties of fasterners were used as well. All were obtained from McMaster-Carr


 * X2 per Servo Mount 10-24 X 3/4" Nylon Shoulder Screw
 * X2 per Servo Mount 4-40 X 3/16" Screw
 * X5 per Servo Mount, X16 per Rack 2-56 X 1/2" Screw
 * X2 per Servo Mount 2-56 Nyloc Nut
 * X2 per Servo Mount #4 Washer

The bells used are bells provided to us by Dr. Yoder, originating from Hobby Lobby.

To build the Servo Mount, pieces were cut out from acrylic sheets. The links lead to DXF files. To download, rightclick and click save link as.


 * X2 @ 0.125 in Bell_Twist.DXF
 * X1 @ 0.125 in Servo_Connection.DXF
 * X1 @ 0.25 in Base.DXF
 * X4 @ 0.25 in and X2 @ 0.125 in Spacer.DXF

To build the Mounting Racks, pieces were cut out from acrylic sheets. The links lead to DXF files. To download, rightclick and click save link as.


 * X1 @ 0.125 in LowerRack.DXF
 * X1 @ 0.25 in TopRack.DXF
 * X16 @ 0.125 in Latch.DXF

Electrical Hardware
A BeagleBone is the bread and butter of the project, driving the entire effort. In case you dont have one, you can get one here!

To drive all these the following cape was used:


 * PWM Cape

The electrical circuitry for the detector was made a few components. Additional components may be needed if you don't want to make permanent additions to the cape.

Each detector comprises of:
 * X1 QED233
 * X1 LTR-3208E
 * X1 10K Ohm
 * X1 150 Ohm

We also created an expansion board to allow us to access the GPIO ports that would otherwise be covered by the PWM cape. It brings the I2C and enable signals to the cape and leaves the rest of the headers on the BBB open.



Servo Mount Assembly
1. Collect all the materials and tools you will use. In terms of tools, you will need a 2-56 tap, a 4-40 tap, a 10-24 tap, as well as tools to attach the screws/nuts.



2. First thing first, you need to tap the right holes. The two large holes on the Base are 10-24, the holes above and below the hole for the servo to sit in on the Base are 2-56. The hole further from the large hole on the Bell_Twist need to be tapped to 4-40. Also, depending on your horn (the thing that spins on the servo motor), you may need to widen the holes present there.



3. Ensure that the horn is vertical when the servo is at 90 degreees. After that, attach the servo, the two Bell_Twists, and the Servo_Connection to each other with the 2-56 screws and nuts as seen in the picture below. The screw and nut should hold the peices firmly together, but still allow for easy pivoting.



4. Next is to add the shoulder screw and spacers. The order which the peices should be on the screw, from the head of the screw, is the 0.125 in Spacer, the Bell_Twist, and then two 0.25 in Spacers.



5. Now comes the time to attach the servo assembly to the Base. Simply slide it in and screw in the two shoulder screws into the Base. Follow that up with adding two 2-56 screws with washers, to hold the servo down firmly.



6. The bells you select may need some prep work. The ones we recieved had tinsle and little cards on them. This needs to be removed so you only have bells.



7. The final step is to attach the bells to the bell-less servo mount. Use the two 4-40 screws to do so.



Rack Holder Assembly
1. Collect all the materials and tools you will use. In terms of tools, you will need a 2-56 tapas well as probably a screwdriver to attach the screws.



2. On the LowerRack, tap all the small holes as 2-56. There should be a total of 16.



3. Place on top of the Lower Rack the TopRack. The small holes should align over each other. Then screw in a 2-56 screw, with a latch as well. To restate this, the screw should pass, from head down, the latch, the TopRack, and then the LowerRack. The screw should be just tight enough to hamper motion of the latch, but not enough to stop it.



Rack Holder Assembly
The final assembly should look something like this. Each assembly consists of four servo mounts and a single rack. If done correctly, everything should slide sunggly into each other and hold quite respectably.



Electrical Assembly

 * Project materials are at https://github.com/randman2011/ECE597-RingingBells. Clone the repository to find a README and code to get started.
 * Use a PWM Cape to expand the PWM functionality of the Beaglebone.
 * Execute the makefile and run the RingerScript program.

Give step by step instructions on how to install your project.


 * The GitHub repository containing all of our software can be located here: https://github.com/randman2011/ECE597-RingingBells.
 * No additional configuration or setup steps are needed. Once cloned, the project is ready to be compiled.

User Instructions
 Could you give these as step-by-step instructions, showing what to type and what output to expect? Executing the makefile will create a RingerScript executable. The executable sets up separate threads automatically, so all the user has to do is execute it. The ringing of the bells is controlled by the proximity sensor LEDs. Waving a hand in front of them will trigger the board to begin ringing the associated bells. Execution continues until the SIGINT command is sent via terminal.

Highlights
'''Work in Progress. Check in later''' YouTube demo to be added soon!

Theory of Operation
 Give more detail on how the i2c command rings the bell. The main process thread spawns a number of worker threads, each of which will poll the associated GPIO pins continuously. When the input drops below the threshold, the thread sends a command via I2C to ring the associated bell.

Work Breakdown
While we all took part in all the components, each one of us took lead in a particular field:
 * Mark took lead in designing the electrical hardware. He also, took charge of coding at the end, due to his extensive experience in C.
 * Peter was the brainchild behind the mechanical aspect of the project. He is also the one who spent a considerable effort bringing up the eLinux page to a respectable state!
 * Randy was the architect of the JavaScript software that drove the bells and servos, building most of the program that later got converted into C.

Future Work

 * The current I/O being used is using an IR detector and IR LED. The detection range of our set up is not that long. It would be intresting to see an improvement on this scheme.
 * Other hardware inputs could also be looked at, from as simple as push buttons to a Rube Goldberg like contraption.
 * In addition to hardware inputs, software inputs of various type could be looked at. These weren't looked at as deeply as we would have liked to, due to the limitation of time. Potential control schemes include:
 * MIDI Inputs
 * Chrontab
 * The PWM cape supports simultaneous control of all PWM outputs. This eliminates the need for multiple threads and would also eliminate the I2C bus saturation that we are experiencing. If the application demands that all bells ring at once, this is a much better solution. The hardware addresses to control them all are as follows:
 * 250 0xFA ALL_LED_ON_L
 * 251 0xFB ALL_LED_ON_H
 * 252 0xFC ALL_LED_OFF_L
 * 253 0xFD ALL_LED_OFF_H

Conclusions
We'd also like to thank Dr. Yoder for providing us the materials and technical expertise to make this happen. We would like to also thank the Rose-Hulman Mechanical Engineering Department for supplying all the fasteners used. Also, special thanks to Ron Hofmann to cutting out all the material with the laser cutter.

We have learned that JavaScript is a poor choice for timing-critical applications. We have also learned the limits of the onboard I2C interface, making control of all 32 channels impractical. Additionally, we discovered some oddities with the setup of the BeagleBoard itself. The PWM cape uses the I2C1 headers, but is located on i2c2 in the software. Likewise i2c1 refers to the hardware I2C2 bus. The i2c0 bus is used internally and should not be accessed directly.

Technical notes of interest
Mode register of what?
 * The GitHub repository containing all of our software, as well as files CAD files, can be located here.
 * i2cdetect -y -r 2 finds address 0x40 and 0x41, which are the chip addresses on the PWM cape
 * need to set mode register (register 0x00) to come out of sleep mode to use the internal oscillator