Maintenance and Broken Things

buildscc | 09 Nov 2011 | | maintenance

There are many things which break during projects, by accident, or for no reason what-so-ever. Since functional tools are much preferred to broken ones when people are working on projects the broken things should be fixed, and/or improved. This wiki page can be added to by any and all members of BUILDs and is not limited to broken things, but also any additions we want to make to the infrastructure of BUILDS, for example, infrastructure based projects. Also this page can be used to request changes and report issues.

If you are interested in helping please join the builds-tech-list mailing list.

  • We need a better way of reporting errors maybe a bug tracking system of some sort. Might be interesting to build one that was a wiki plugin (or a wordpress plug-in) that might be interesting…

Projects with Broken Things

  • Arduino Mega

Community Tools/Issues

  • Some way of tracking tools and keeping the room organized

Random Things We Have

  • Baby Monitor, Barcode reader pencils (2), Old Broken Ipods, Tone generators (4), Computer Speakers (5), Purple fan w/ coil, Fire alarm, Emergency phone, Microwave antenna..

Light Speakers

buildscc | 09 Nov 2011 | | projects


Light Speakers receive an audio input and toggles a SSR (Solid State Relay) with the “beat”. The light speaker accomplishes this by amplifying the incoming sound, filtering the sound with a bandpass filter for the desired band and then putting the output of the filter through a “peak” detector which will turn on the relay for a longer period of time when something gets through the filter.


Schematic and PCB files are available on [ github].

Block Diagram


The two audio channels (left and right) need to be isolated from one another before they can be summed together. Using a basic unity gain buffer will do this perfectly. It allows fro the current and voltage changes to be transmitted through the buffer, but for no current to be drawn from the source of the signals.


Band Pass Filter

Peak Detector


[[Image:LightspeakersV1Final.jpg|thumb|center|400px|LightSpeaker Rev. A Schematic. Made with EAGLE]]

PCB Layout

[[Image:Lightspeakers_pcbV1Final.jpg|thumb|center|400px|LightSpeaker Rev. A PCB Layout. Made with EAGLE]

Bill of Materials (aka Parts List)

{| | | | | | | | | | |---- |Part |Value |Distributor |Distributor Number |Manufacturer |Manufacturer Number |Unit Price |Qty |Total Price |---- |C1,C8, C9 |10uF Electrolytic |Digikey |P5148-ND | | |0.2 |3 |0.6 |---- |C2 |.01uF 603 |Digikey |490-1512-1-ND | | |0.023 |1 |0.023 |---- |C3 |100uF Electrolytic |Digikey |P5152-ND | | |0.25 |1 |0.25 |---- |C4, C6 |.1uF 603 |Digikey |490-1532-1-ND | | |0.023 |2 |0.046 |---- |C5 |.047uF 603 |Digikey |490-1567-1-ND | | |0.041 |1 |0.041 |---- |D1 |1N4001 |Digikey |1N4001-E3/54GICT-ND |Vishay |1N4001-E3/54 |0.43 |1 |0.43 |---- |IC1 |LM1117 5V Regulator |Digikey |LM1117MPX-5.0CT-ND |National |LM1117MPX-5.0/NOPB |1.16 |1 |1.16 |---- |IC2 |LM324 SOIC14 |Digikey |296-1390-5-ND |TI | |0.31 |1 |0.31 |---- |J1 |Power Jack |Digikey |CP-202A-ND |CUI Inc |PJ-202A |0.092 |1 |0.092 |---- |J2 |Terminal Block (2x) |Digikey |ED1623-ND | | |0.59 |1 |0.59 |---- |JP2 |.1” Headers |stock |stock |stock |stock |0 |1 |0 |---- |JP3 |.1” Headers |stock |stock |stock |stock |0 |1 |0 |---- |LED1 |LED BLUE 603 |Digikey |475-2816-1-ND | | |0.21 |1 |0.21 |---- |LED2 |LED RED 603 |Digikey |475-2816-1-ND | | |0.21 |1 |0.21 |---- |Q1 |2n2222 TO-92 |Digikey |P2N2222AGOS-ND |ON Semiconductor |P2N2222AG |0.36 |1 |0.36 |---- |R1 |150 603 |Digikey |RMCF0603JT150RCT-ND |Stackpole | |0.02 |1 |0.02 |---- |R2, R15 |470 603 |Digikey |RMCF0603JT470RCT-ND |Stackpole | |0.02 |2 |0.04 |---- |R3, R13 |2.2k 603 |Digikey |RMCF0603JT2K20TR-ND |Stackpole | |0.02 |2 |0.04 |---- |R6,R12 |47k 603 |Digikey |RMCF0603JT47K0TR-ND |Stackpole | |0.02 |2 |0.04 |---- |R7 |33k 603 |Digikey |RMCF0603JT33K0TR-ND |Stackpole | |0.02 |1 |0.02 |---- |R8, R9, R14 |100k 603 |Digikey |RMCF0603JT100kTR-ND |Stackpole | |0.02 |3 |0.06 |---- |R10, R11 |1M 603 |Digikey |RMCF0603JT1M00TR-ND |Stackpole | |0.02 |2 |0.04 |---- |S1 |SWITCH-SPSTSMD2 |Digikey |450-1635-ND |TE |SSJ12R04 |0.79 |1 |0.79 |---- |SV1 |.1” Headers Male Right Angle |stock |stock | | |0 |1 |0 |---- |SV2 |.1” Headers Female Right Angle |Digikey |S5439-ND | | |0.65 |1 |0.65 |---- |U$1 |10k Pot 3362U |Digikey |3362U-103LF-ND |Bourns Inc. |3362U-1-103LF |1.05 |1 |1.05 |---- |U1 |SSR S108T02 |Digikey |425-2396-5-ND |Sharp Micro |S108T02F |5.01 |1 |5.01 |---- |U2 |3.5mm Audio Jack |Digikey |CP1-3524NG-ND |CUI Inc |SJ1-3524NG |0.85 |1 |0.85 |---- |F1 |FUSEHOLDER OPEN 5X20MM PC MNT |Digikey |WK0011-ND |Littelfuse Inc |64900001039 |0.38 |1 |0.38 |---- | | | | | | | | | |---- | | | | | | | | | |---- |Total Cost |13.312 | | | | | | | |---- |}

Cost Reductions

Change all Resistors to Stackpole resistors (eg 150 ohm 603 Resistor RMCF0603JT150KCT-ND costs $.02 per instead of $.1 per): Approx Savings $1.04

Change LED1 and LED2 to OSRAM CHIPLED (example LB Q39G-L2N2-35-1 OSRAM Opto Semiconductors Inc 475-2816-1-ND).From $.5 per to $.2 per: Approx Savings: $.6

LM385 -> LM324 (quad opamps with buffering): LM324D Texas Instruments 296-1390-5-ND $.31 : Approx Savings: $.45


Version 004

Semi Complete May 24, with Solid State Relay. BOM coming soon along with PCB board and a finalized schematic. [[Image:Lightspeakers.jpg|thumb|800px|center]]

Version 003

Completed 12 May 2012 [[Image:LightspeakerVersion3.png|thumb|800px|center]] This time the LED is replaced with a relay switch which AC powered lights can be plugged into.

Version 002

Completed 12 May 2012 [[Image:LightspeakerVersion2.png|thumb|800px|center]] This version still only lights up an LED, but it also does a better job of filtering out noise so that the on and off is much crisper.

Version 001

Completed 12 May 2012 [[Image:LightspeakerVersion1.png|thumb|800px|center]] This circuit passes the signal from a audio jack into an LED based on the amplitude of the signal alone. It works. The potentiometer determines how low the bass must be to be let through.


  • Chris Woodall
  • Rusty Shomberg
  • Patrick Ehrlicher
  • Tom


buildscc | 09 Nov 2011 | | projects


BUILDS Bot will be circular, autonomous, wheeled robot designed with the future in mind. It will consist of a base disk module,12 inches in diameter, which is driven by two DC motors attached to wheels with a smaller, free moving wheel allowing for full rotation in place.

Eight IR sensors, 45 degrees apart, will be placed around the circumference of the disk. The motors and sensors wil be controlled from an Arduino board that will also be responsible for simple robot behaviors. For more complex behaviors, the base will mount an mini-ITX motherboard with an Intel x86 CPU.

Future projects will be able to use the robot for their own purposes by stacking further disks on top of the base module. The project will generate open source software libraries that will allow other teams outside of BUILDS to program their own BUILDS bot.

Progress Reports

April 10, 2012

  • Talked about DARPA Grand Challenge for a humanoid robot DARPA Grand Challenge.
  • Parts orders put in for McMaster-Carr (Polycarbonate), HobbyKing (Battery) and Pololu.
  • Discussed plans for motor mounting brackets. Patrick and Rusty will make these and the polycarbonate chasis. The machine shops are packed right now, but they should be able to get ahold of the proper equipment.
  • Chris has finished the schematic and he needs to finish doing the PCB layout and send a parts order and PCB order. If the PCB is not done we can rig together a system that will work decently well from what we have for the showcase. Similar to what we currently have. Should work out fine actually.
  • Watched propaganda and formed the [[BU Propaganda Enthusiast Society]] (BUPES, pronounced Boops).

April 9, 2012

Put in a parts order to Leo. Needs to be OKed then sent to Theresa.

Supplier Part# Description Qty Price/Part McMaster-Carr 8574K55 Clear Polycarbonate to craft our chasis from.

  • 1 $39.36 HobbyKing 601Ax5 XT60 connectors for the battery.
  • 1 $2.44 HobbyKing ECO6 Charger for Battery.
  • 1 $17.99 HobbyKing Z22003S20C ZIPPY Flightmax 2200mAh 3S1P 20C
  • 1 $8.99 Pololu 1930 Female Crimp Pins for 0.1” Housings 100-Pack
  • 1 $5.95 Pololu 1902 0.1” (2.54mm) Crimp Connector Housing: 1x3-Pin 25-Pack
  • 1 $0.79 Pololu 965 0.100” (2.54 mm) Breakaway Male Header: 1x40-Pin, Straight
  • 4 $0.99 Pololu 2440 Screw Terminal Block:
  • 2-Pin, 5 mm Pitch, Side Entry (4-Pack) 2 $1.50
  • Total Cost: $82.48

April 3, 2012

Mechanical CAD design is nearing completion. We will be using polycarbonate and Rusty and Patrick will be doing the CNCing. They may also be CNCing wheels which fit nicer for our design. We will be purchasing part number 8574K55 from McMaster Carr (24” by 24” by 1/4” clear polycarbonate. The cost is $39.36 and will give us enough polycarbonate for later (for possible wheels or an additional layer or two. Battery will be picked up from Radioshack. They have some pretty nice batteries we can use for 2 Liter Electronics schematic is almost complete. The PCB board should be done soon. Chris plan on sending it out to review to Eric Hazen and Dan Gastler to reduce the number of errors and problems. Coding is at a stand still until the Gyros come in and the electronics board is done.

Task Allocation

  • [[Russell Shomberg]] and [[Patrick Ehrlicher]] will be finishing up the CAD designs, most notably for two mounting brackets for our motors.
  • [[Christopher Woodall]] needs to put in a part order for the polycarbonate so that the chasis can be made.
  • [[ Christopher Woodall]] needs to complete the electronics layout in KiCAD. Schematic then PCB layout (~1 weeks worth of work, bug him about it).
  • [[Allan Wirth]] has no particular duties this week except to be ultra productive on other projects.

12 Ounce Update

12 Ounce is a smaller robotic platform and has recently received eyes. We work on 12 Ounce from time to time to test ideas and get hands on experience with certain components. Here is a video of 12 Ounce working: [ 12 Ounce working]

March 27, 2012

Revised and defined our design goals:

  • Modularity in the mechanical design (and electronic design using the I2C bus)
  • Ability to navigate BUILDS with minimal collisions
  • Basic mapping abilities should be present. Defined our CAD design parameters:
  • 12” diameter 1/4” thickness polycarbonate disk (possible change) ** Should have places to mount the IR sensors
  • 2 mounting brackets for the motors
  • 5” x 4” PCB board (possibly will change), mounted above board with standoffs
  • Holes for threaded rod (modularity)

We are also going to replace our wheels, with new wheels that fit better and are more durable. We are waiting for a finished CAD design to choose the exact wheels. [ Possibility for our new wheels]

Need to figure out an easy way to share electronics between modular layers… (Ribbon cables?)

Thoughts about updating our microcontroller. Currently we are using an ATMega328 on an Arduino development board (only using Arduino language for rapid testing of electrical components). However, there are plans to put a beefier microcontroller into our future PCB board. One option was to go with an ARM chip, possibly something in the [ LPC2131 family] or the [ LPC1311 family].

These chips offer higher processing speeds, a built-in USB interface, More GPIOs, I2C bus (which we currently have). GPIOs which are not used for main board purposes should be broken out and accessible to future boards via ribbon cable or “shields”. The disadvantages of using an ARM chip are that we would likely need a RTOS to manage the processes, so that we can properly thread and manage our processes.

Also there is an increased complexity in programming for an ARM chip versus an 8-bit microcontroller like an ATMega32u4 which is another option (ATMega chip which provides on board USB support). Also planning on using this PCB Manufacture [ Advanced Circuits] with their Barebone PCB 1 day turnaround prototyping option. We will also likely put in a massive Digikey order for our parts (also order extras of those parts).

Task Allocation

  • Russell Shomberg and Patrick Ehrlicher are on CAD layout duty for the mechanical design.
  • Chris Woodall is on Electronics EDA/CAD design for the schematic and PCB board. Allan Wirth is helping him pick out a new processor.
  • Allan Wirth is going to work with our current 2 Liter prototype and bring him to a semi functional level [[Image:2Liter_IRSensor_3272012.jpg thumb 2 Liter with IR Sensor]]

Progress Report

[ 2 Liter can move and detect walls… Kind of… Has a little bit of an issue rolling straight (likely a wheel alignment issue)]

March 20, 2012

[[Image:2_Liter_Bottom_32012.jpg|thumb|left|Bottom of 2 Liter, displaying the mounting]]

We did a lot of work today. We mounted the motors onto our new semi-circle chasis. To do this we used:

  • 4 rubber chair stoppers that were the same radius as our motor
  • 4 U brackets of appropriate radius

This mounting method is somewhat non-traditional, but it works and holds the motors in solid. It is also non-permanent. If the appropriate mounting brackets are purchase they can easily be put in place of our current mounting solution. The motor controller was relocated to a tiny breadboard that could be easily mounted to our chasis.

All electronics were mounted using removable velcro tape, which allows for a removable platform that we can be changed during the prototyping stages. Rapid prototyping is essential for the success of this project because it is a great way to learn about and change your methods with limited consequences. The basic schematic used for our motor controller is pictured [[#Motor Controller below]].

The pin mapping is stated in the code snippet. Our current electronic set up allows for tethered movement. 2 Liter needs a power supply for the Arduino and a power supply for the motors. We have been using the USB link to program and power the Arduino and our new Bench Power Supply as an adjustable voltage source for 2 Liter’s motors.

Currently we are researching battery solutions and they should be ordered at the next meeting. [[Image:2_Liter_Electronics_2_32012.jpg thumb right Electronics for 2 Liter (Motor Controller and Arduino)]]
/* Buildsbot 2 Liter Test Code
 * March 20, 2012
 * Written By Christopher Woodall
 * Makes 2 Liter do a little dance. Developed using the Arduino language and IDE.
 * Pin Setup
 * Left Motor
 * 11 - Enable
 * 12 - A
 * 13 - B
 * Right Motor
 * 10 - Enable
 * 9 - A
 * 8 - B

void setup() {
	pinMode(13, OUTPUT);
	pinMode(12, OUTPUT);
	pinMode(11, OUTPUT);
	pinMode(10, OUTPUT);
	pinMode(9, OUTPUT);
	pinMode(8, OUTPUT);

void loop() {

void backward() {
	digitalWrite(13, LOW);
	digitalWrite(12, HIGH);
	digitalWrite(11, HIGH);
	digitalWrite(10, HIGH);
	digitalWrite(9, LOW);
	digitalWrite(8, HIGH);

void forward() {
	digitalWrite(13, HIGH);
	digitalWrite(12, LOW);
	digitalWrite(11, HIGH);
	digitalWrite(10, HIGH);
	digitalWrite(9, HIGH);
	digitalWrite(8, LOW);

void turnLeft() {
	// L digitalWrite(13, LOW);
	digitalWrite(12, HIGH);
	digitalWrite(11, HIGH);
	// R digitalWrite(10, HIGH);
	digitalWrite(9, HIGH);
	digitalWrite(8, LOW);

void turnRight() {
	// L digitalWrite(13, HIGH);
	digitalWrite(12, LOW);
	digitalWrite(11, HIGH);
	// R digitalWrite(10, HIGH);
	digitalWrite(9, LOW);
	digitalWrite(8, HIGH);

void stopBot() {
	digitalWrite(11, LOW);
	digitalWrite(10, LOW);

Video of 2 Liter working: [ BUILDSbot 2 Liter taking a stroll] ‘‘Note: Gather price information and part information’’

March 7, 2012

My minions (You know… Chris, Allan, and Rusty) have been hard at work this past month honing their crafts for the eventually creation of this unholy machine.

We’ve managed to setup an I2C bus between the accelerometer,gyroscope, and ADC, and we’ve discovered that our gyroscope was defective. More parts have arrived too, heralding a new rush of activity involving wheels and IR sensors. Among the new parts, we’ve purchased some new motor controllers that integrate diodes that protect against motor feedback.

Soon we’ll have a robot platform to play with not a miscellaneous collection of parts. Rusty will be machining custom motor brackets for the now semi-circle shaped body. Chris will be working on a PCB layout so all of our sensors can be mounted together, and Allan has created a bunch of nice code for integrating everything all together.

-Z Parts List (80x10mm Red) (Wheels) (2) (.75 inch) (Caster) (1) (Mounting Adapters for Wheels) (1) (Harnesses for IR Sensors) (8) (Motor Controller Chips) (2)

Febuary 14, 2012

Parts,Parts,Parts! We have parts! Today I’m proud to report that our ADC and motor controllers came in today. Additionally, the motors themselves will arrive Thursday by the end of the day, with the IR sensors coming in sometime next week. In the meantime, we’ve decided to build a mini-robot using some parts Chris had knocking around, so go check that out over on the [[BUILDSbot Diet Coke|project]] page.

A hackathon has been scheduled this Saturday, February 18th, starting in the early afternoon, so make sure to come by and hack away on the thing! We’ve also chosen code names for both robots, please inquire to team member Allan towards there significances…As always, more to come later. -Z

January 26, 2012

Another day, another intensively productive meeting. Below lays before you the final list of parts we’ll need to get this project off the ground. You’ll notice a few more playthings than last we met. Namely, the 12-bit, 8 channel ADC (We need more of them!), and the motors with encoders (something whats other she said,yeah, we’ve decided to get new motors). Having motors that can tell us their revolutions per minute is great for things like feedback, which is rad code speak for deducing where the robot really is versus where we think it is after we moved it.

Yes, I really did coin the phrase “rad code speak”, please address a stamped envelope to yours truly with 2 cents inside for all utterances of this phrase in every day conversation. You may also keenly notice that we’ve changed out Accelerometer out for a more resolute model that runs on an I2C bus. Moods are high, and we’re all very excited to get parts in from which to tinker and build with. Until next time. -Z

Tentative Parts List

  • 8 x Sharp IR sensors [ Datasheet]
  • $8.80 4 x Motor Controllers [ Datasheet]
  • $11.40 1 x Accelerometer [ Datasheet]
  • $27.95 1 x Gyroscope [ Datasheet]
  • $49.95 2 x DC Motors w/encoders [ Datasheet]- $115.08 1 x ADC Converter [ Datasheet]
  • $19.99 Total: $313.17

January 21, 2012

Today we finalized the what the processor for the robot will look like, namely that we’ll have an Arduino control the low level stuff such as sensors and motors, and that we’ll have the higher level behavior be controlled by drumroll an onboard x86 Intel processor. We plan to go with an mini ITX board running Linux (Most likely Arch), with communication to the Arduino going through a serial port.

We’ve rediscover two [ First Robotics motors] that we intend to use, there very torquey and should let us have a robot that weighs in around 30 pounds. Sensors were discussed, and we decided to go with an accelerometer and 8 Sharp IR sensors recessed 4 inches (there minimum range) onto the frame as to avoid junk data. A initial list of parts we need to order was also created for the project

  • 8 x Sharp GP2Y0A21YKOF IR sensors
  • 1 x Accelerometer
  • 2 x [ L6202 Motor Controllers]

Gears and wheels may or may not be added to this initial order, we’d like to prototype everything first and get used to programming the Arduino, which, on a side note, we’ve also rediscovered laying around. Regarding some administrative details, we also decide to start meeting twice weekly on Tuesday and Thursday nights, 6 to 8. Anyways, we’re all super excited to get the project underway, and I hope you stop on by! So. You know. Go ahead and do that. See you space cowboy. -Z


Mechanical Design

[[Image:BUILDSbot_ChasisPlate_RevA.jpg|thumb|center|First draft of our CAD layout for the 2 Liter Chasis. Done by [[Patrick Ehrlicher]]]]

Electronics Design

Microcontroller Selection

Alright, this is all getting a little complicated. So lets break it down by order of boards, revisions and ideas:

1) Original/Prototyping — Arduino Duemillanove with ATMega328 2) Board rev A (Never ordered) — ATMega32u4 3) Board rev B — Move to a 32-bit ARM (Cortex-M3 or Cortex-M4).

Likely STM32F4 Currently [[Chris W]] is working on rev B, but needs to select an ARM processor to go on that board. The current battle is between the LPC1768 or the STM32F4. The dev equipment for the STM32 is much cheaper and the chip has more features and is generally a better idea… We will go with the STM32F4 :) [[ STM32F4 devboard + programmer]]



For the IR Sensors we need to add some .1” spacing pins. These can be hand made for cheap. Also, we will have extra around (this is good).

  • [ JST to Crimp pins for .1” spacing]
  • [ Crimp Pins for .1” spacing]
  • [ .1” Crimp pin housings] This means all external things, thus far, will use .1” spacing (100 thou), which makes [[Chis Woodall]] happy (easier layout).

In general we need lots of .1” spaced headers. This we should buy these [ .1” Male Headers] Also Terminal Blocks! [ Terminal Blocks!] Some of these for the battery: [ XT60 Connectors] Oh and 12 Gauge wire.

Thanks for Pololu being easy to use compared to digikey when it comes to connectors.

Power Supply

We are picking the [ Zippy Flightmax 2200mAh 3S 20C] Lithium Polymer battery with the [ Hobbyking ECO6] Battery Charger.

Replace XT60 Connectors with the easier to use T-Connectors

Power Needs

  • The battery
  • Appropriate off bot charger.
  • DC-to-DC converter for the mini-ITX board.
  • Other voltage regulators to provide 5V DC, 3.3V DC (on board on most Arduinos) and 12V DC. For the uC, sensors and motors. ** 5V Linear LDO Regulator (which can provide decently high currents 500mA-1A should be ok). ** 3V3 Linear LDO Regulator (possibly on Arduino, current provisions are less of a concern). ** 12V Linear LDO Regulator (which can provide high currents, might be hard to find, but a preference on something close or above to 1.5A with heatsinks)
  • Heat sinks for the Regulators.
  • Some form of low battery detection circuitry with a low power draw. We will need a battery to power the miniITX board, the motors and the microcontroller. We will also need some [ DC to DC Converters].

How to Pick a Lithium Polymer Battery

Voltage: You want something with at least as much voltage as you need out of it. You can regulate your voltage to a lower level if need be. One could also use something of lower voltage to power certain things.

C rating: C rating specifies how much current it is safe to draw at any given point in time. This is only related to the other capacity rating (which is in mAh). Basically it is safe to draw the following:

(Capacity)*(C rating)=(Max Current Draw)

Capacity/mAh/Watt-Hours: Defines how long a charge of battery will last (how much current the battery can provide over what period of time).

’'’Example’’’: The Turnigy 5000mAh 20C 14.8V battery can draw a maximum of 5 * 20 = 100A.

That would allow us to provide a MAXIMUM of 14.8V * 100A = 1480W.

All of that said, that would drain our battery in minutes, maybe less. Assuming we want to run for about an hour we can draw up to 5A * 14.8V = 74W.

This provides a minor problem considering that the mini-ITX boards power usage can range from 25-150W and the motors are also going to be drawing a lot of power. Furthermore, running near the max power draw is not suggested for various reasons, namely LiPolys can explode.

(NOTE: These power calculations do not take into consideration Power factors, but give a reasonable approximation of the maximum power that can be drawn from the LiPoly)

Motor Controller

[[Image:BUILDSbot2Liter_MotorController.jpg|thumb|500px|center|Motor controller schematic]]

We changed motor controllers to the [[SN754410]], which is a quadrupel Half-H bridge, with protection diodes. We are using the [[SN754410]] as a double full-H bridge driver to drive our motors both forwards and backwards. We currently have our motor controller functioning with the schematic shown above.

The [[SN754410]] includes protection diodes and has a somewhat smaller package than the [[L293]]. The [[SN754410]] has been tested running at 12V for a few minutes and nothing bad happened to the IC and the heat gains were not bad. Also the motors are operating within operating range for the [[SN754410]]. We should be fine!

  • [ SN754410 Datasheet]

Old Motor Controller

Previous suggestion included the [[L6202]] and the [[L293]]. Given some more research using the [ L293] may be a better option. Care must be taken not to order the L293D which can only handle 600mA, where the [[L293]] can handle 1A with a maximum current of 2A. They will function on voltages from 4.5V to 55V and include four half h-bridges (aka 2 full h-bridges).

Furthermore, they are significantly cheaper than the L6202, but they do not have current sense pins and a few other of the “nicer” features of the L6202 (which quite honestly I am not 100% sure on how to use appropriately).

:Problem :: We accidentally ordered the L293E instead of the L293, which needs protection diodes… Which are not bad, but slightly inconvenient for us. Since we had a wait time we decided to change to the [[ SN754410]]

  • [ Digikey Link]
  • [ A L293 in use]

Software Design

System Bus

Polling Rate Calculation

I2C Bit Rate (Fast Mode) = 400 kbit/s

  • I2C Frame ** 1 start bit ** 7 bit address ** 1 bit r/w mode ** 1 ack bit (from slave) ** data (1 ack bit per byte) ** 1 stop bit
  • Total: 11 bits overhead ** ADC Write data ** 8 bit ‘command byte’ ** ADC Read data ** 16 bit ‘output’ ** 1 ADC Sensor Read *** (2 * 11) + 8 + 16 = 46 bits of overhead per read.
  • With 8 IR sensors: * 400 kb/s / (8 * 46 bits)=1.11304348 kHz (or how fast we can poll our IR sensors)


  • Code for the robot:
  • Code for the client:
  • Software and Hardware Repo is here:



  • Milestone 1: Working Prototype of 2 Liter using the Arduino Board

This was a partial prototype.

  • 2 Liter was a semi circle (final will be a full circle).

[Active] Milestone 2:

Complete CAD Layout (both Electronic and Mechanical)

Milestone 3: Construction of Mechanical CAD and Electronic Parts

Milestone 4: Semi Functioning Robot

Milestone 5: Nice Library and Functioning Robot

End Goal: World Domination

Offshoots and Minions

BUILDSbot 12 Ounce Line Follower and Development Platform

[[BUILDSbot 12 Ounce]] will be made up of some parts which are coming in and that we have laying around. [[BUILDSbot 12 Ounce]] is spec-ed to be a line follower and the main focus will be on controllable motor movements and issuing commands directly too it over a tethered USB interface (may add a small radio eventually). [[BUILDSbot 12 Ounce]] is in a complete and mostly functioning state. Code being cleaned and documentation being completed. Possibility of making a PCB layout, but not a necessity.

BUILDSbot Droplet Swarm

[[BUILDSbot Droplet]] is a swarm of tiny wirelessly controlled robots. Extremely simple logic, with basic collision detection. Possibly addition of minimal accelerometers and gyroscope.

BUILDSbot Kiwi Drive

A future possibility. A 3 wheeled Omni Wheel Vector (Kiwi) drive Robot.

[ Affordable OmniWheels] [ Some information from Society of Robots]


  • Christopher Woodall (Project Leader/Resident SparkE)
  • Russell Shomberg (MechE 2)
  • Patrick Ehrlicher (MechE 1)
  • Allan Wirth (Coder General)
  • Anthony Inzero


Team Meetings: Tuesday/Thursday 6pm-8pm @ BUILDS | Please come by if your interested!

Mailing List: [ Information on how to subscribe]

Open 7400 Drum Machine

buildscc | 01 Nov 2011 | | projects


This is a basic 4 stage, 4 tone, drum machine built from 7400 Logic ICs and other discrete components and ICs for Dangerous Prototypes Open 7400 Competition ( I started brainstorming and designing the project on October 7, 2011 and submitted the project on October 20, 2011.

The idea for building a drum machine came from a discussion I had with my roommates in which we were talking about the popularity of drum machines as simple web applications. I decided to try to implement one, but using 7400 Logic Chips. The design was rather simple and is based mostly around utilizing sequential logic devices in order to count, step through and play different tones.

Here is a video describing and demoing the final product:


Current version is 1.0 (Bleeping Tilde)

Parts List

  • 8 x 74LS74 (dual D-type Flip-Flops)
  • 4 x 74LS14 (Hex Schmitt Trigger Inverters. You could minimize this to 3 if you want, but I preferred to have one IC per stage)
  • 1 x 555 Timer (could have more for generating different frequencies)
  • 2 x 74LS253 (dual 4x1 multiplexers)
  • 1 x 74LS107 (dual JK-flip-flops)
  • 24 x 0.1 uF Ceramic Capacitors (You may need more, but you need one on every 7400 IC and for debouncing)
  • 22 x 1k Resistors
  • 2 x10k Resistors
  • 1 x 100k Potentiometer
  • 4 x Piezo Buzzers (should have 4 Piezo Buzzers… One for each tone, but I used two to demonstrate functionality)
  • 1 x 10uF Electrolytic Capacitor
  • 1 x Switch (for power)
  • Some power source which provides 5V and GND(I used my Arduino for a rather stable 5V and GND)
  • Some array of 16 Buttons and 16 LEDs for input. I used a panel which Valerie Young found. It has 24 pushbuttons with 25 LEDs and one RESET button (currently unused). I made a little “breakout” board of sorts with headers and used this board. Explanation below.
  • 3 x Breadboards (I used 3 breadboards and one protoboard, but this board can likely be made better)
  • 6 x LEDs for monitoring

Notes: I used all LS TTL based logic instead of CMOS logic. This was quite fun to use and was cost effective because I had access to free surplus parts.

The Heart: Clock and Binary Counter

The first step was to get a stable and working clock, which could then be put through a 2-bit binary counter, which will select between the 4 stages. Once the stage is determined the 2-bit code which designates one of the 4 stages can then be put through a multiplexer and a tone associated with that multiplexer can then be played. To accomplish the task I broke down the logic into three basic parts: the clock, the counter and the mux.

The clock was created using a 555 timer with a 10 uF electrolytic capacitor a 100k Potentiometer and a 10k resistor. This give a frequency of about .68 Hz or ~41 cycles per minute, which is on the order of 60 beats per minute and can be adjusted upwards to rather high speed using the 100k Potentiometer. More theory on the 555 timer can be found at kspec:, they do a really good job at explaining the operations of the 555 timer.

The output of this clock is then feed through a 2-bit Binary Counter created using two J-K Flip Flops in a 74LS107 IC. These J-K Flip Flops are setup to basically switch on different signals and they way J-K’s toggle, if set up correctly, means that they change delayed cycle. The 2-bit Binary Counter creates a repeated count of 00, 01, 10, 11.

Here is the clock and multiplexer at work: Video of Clock and Mux

The Brain: Multiplexer

Here is the multiplexer part of the circuit. I used two 74LS253 ICs with dual 4x1 Multiplexers on it. The 2-bit binary counters is feed into the 4 different multiplexers and they then loop through there 4 stages in order. Each mux has an output which is associated with some sort of sound which will be produced when that stage is triggered. The Mux reads if a 0 or 1 is sitting at the selected input and then feeds that state to its output which then sends a signal to the sound production devices (in this case LEDs for monitoring and Piezos). The inputs are provided by the D-type Flip-Flops which store and toggle state feed into them by the pushbutton array.

The circuit so far

The Interactive Surface: The Button Panel

The cool looking LED/Pushbutton Array I used.

This is the most tedious part of the whole project if you are not ready to solder tons of wires and make them look neat. In fact, sort of using ribbon cables and similar cable types your circuit will start to look like a mess of cables right about here. This is thanks to the fact that you have to run 2 bundles of 16 wires from your LED/Button Array to your actual board and then another 16 from your Flip-Flops to your Multiplexers. Besides being the easiest theoretically this part ended up taking the longest, costing the most and creating the most errors in the system as a whole.

The circuit here is simple, you need to take your pushbutton signal and debounce it using a capacitor and a Schmidt Trigger Inverter (74LS14). The Schmidt Trigger has hysteresis, which prevents small changes in making changes to the system and as such allows you to have a nice sharp switch in logic levels instead of the smooth switch which just a capacitor would create. You will need to debounce your buttons pretty much regardless of your types of switches you use. I used pushbuttons then stored and toggled their value using D-type Flip Flops.

The actual debounced pushbutton signal is used as the Clock/Enable input into the D-type Flip Flops and the negated output is put into the input. This means that the state of the flip-flop will toggle as you press on the push button.

Tips and Tricks

  • Make sure you ground all the unused inputs on your 74LS14 Schmidt Triggers, if you don’t weird things will happen.
  • I highly suggest trying to find a button array with a sensible pin out (like the one I found). Sparkfun has a pretty interesting looking button array.
  • If you need to make your own try to get pushbuttons with LEDs built-in. They look nice and simplify your protoboard layout.
  • You will need to use a protoboard for the array, but you can put your ICs wherever you want.

Current State of the Project

Currently done and ready for submission, but I need better noises and more piezo elements or just a better way to make noises. Possibilities include: motors to hit/vibrate things (very possibly with BJT transistors), 555 timers to oscillate at different tones. The current setup is made mostly to show off the fact that it works.

Other problems:

  • Noise in the Vcc and Ground lines causing jumping bits in my d-flip-flop array which stores state for the pushbuttons and allow them to toggle. All attempts thus far have failed at removing this side effect.
  • Better tempo adjustment and user interfacing.

The Path Forward

  • Make sounds that sound good
  • Make those good sounding sounds adjustable
  • Make the clock a little more stable and usable as a DRUM machine
  • Debug the inputs… Possibly change input styles to a 4 button input with 1 button to toggle between 4 different instrument states (or 4 buttons). this would reduce the number of buttons and thus the number of ICs needed (by about 6 ICs).
  • Maybe involve a basic microprocessor to implement MIDI type controls.

Licensing and Credits

Licensed under CERN OHL v.1.1 or later

This project was previously under the MIT License, but as of November 1st is being moved to the CERN Open Hardware License.


Designed and Implemented by by Christopher Woodall

Thanks to Dan Gastler, Valerie Young and Eric Hazen for help, parts and support.


Musical Gloves

buildscc | 01 Nov 2011 | | projects

Playing music with gloves

Status Report

Currently developing a basic schematic to develop the basics of the project. The glove part is on hold, so we are making a Musical right now :D

Some Tips on Using These Files

  • The schematic files are all made in EAGLE and so will the PCB Board
  • The source code will be written for the Arduino and possibly TI Launchpad. This is for now and up to change, for example, ATtiny’s might be used on each hand to do some basic signal processing before sending the signals to the Arduino.

Schematic/PCB/Source Code

All of the Schematics, PCB and Source Code files are hosted on github at

Hack an Orchestra

buildscc | 01 Nov 2011 | | projects


The Hack an Orchestra project will build an array of bizarre instruments.

More Information Coming

Current Instruments

  • Open 7400 Drum Machine: Drum Machine + 7400 Digital Logic ICs

Projects on Hold

  • Musical Gloves: Play music with gloves!

Mailing List

Wanna be on it? Email cwoodall


  • Christopher Woodall (Project Leader)
  • Darian
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25