Brian Woytowich, 5/12/04

"Baby, You Can Drive My Car"

For the final project our group wanted to create a musical instrument that was fun to play, and at the same time was familiar so that anyone could play it with ease. Also, we wanted to create an instrument that was based mostly on a physical interface rather than a more elaborate backend of complex programming, since no one in our group is very experienced at programming in MAX. For this reason, we decided to use a car interface to generate MIDI data, which in turn would manipulate a particular sequence in Reason. Each aspect of driving a car would be taken into account, and would be used to change a particular parameter of the music. Although some of our original intentions did not survive to see the final product, the basic concept remains the same, as detailed in the following account of the project.

The primary design for our "musical car" included a steering wheel attached to a turn potentiometer, a shifter based on a slide potentiometer, a blinker and windshield wiper switch using toggle switches, and a gas and break pedal that would each be hooked into turn potentiometers. Each physical control was originally meant play a relative sound that would be used in combinations with other sounds to build a song. For example, a horn would make a honking sound, the brake pedal would produce screeches, and pressing the gas pedal would result in a revving engine sound. The ideal goal for this setup would have been to have a program that would let you toggle a switch to record a particular sound, and then loop it. Then, you could record more sounds over that loop, and keep on repeating, and in effect build a song just using car sounds. This idea, however, was quickly abandoned because the programming involved was beyond anyone’s capabilities in the group. Although, we were able to do the next best thing, which is to create a sequence in Reason using both car samples and conventional instruments, and then add the capability of controlling each of these sounds in the sequence in real time.

After the first step of brainstorming on design ideas, we went on an excursion to Home Depot and Radio Shack to get the necessary materials. It was when we could not find any torsion springs at Home Depot that we had to make our first design revision. Originally, we had hoped to build a couple of foot pedals attached to dowel rods with torsion springs and potentiometers at the end. This was not only for the purpose of keeping as much realism as possible, but also because the output values of turn potentiometers tend to be much less random than those of a pressure sensor based foot pedal. This could allow us to do some precision continuous controlling using the foot pedals, but without the torsion spring, we had to improvise and resort to a standard compression springs and pressure sensors. Our second big materials dilemma was finding a steering wheel to use. The wheels online were all beyond our price range, and no retail stores carried anything to suit our needs. We almost resorted to thievery until we got lucky and happened upon an old toy car with a plastic steering wheel, which was perfect.

Building the actual "car" proved to be extremely difficult, considering our lack of a wood shop. Cutting the wood with the jigsaw left unleveled edges, so eventually we just stuck to making our cuts with the hand saw. Also, the particle board that we bought had a tendency to split whenever you tried to nail into it, so we avoided this problem by either pre-drilling holes, or just using wood glue. Probably the biggest challenge that we faced in building the physical interface was attaching the turn potentiometer to the steering wheel. In order to do this, we mounted the actual potentiometer to the plexiglass front panel of the "dashboard", and then placed the steering wheel over the turning cylinder. Then, we used a tight fitting plumbing gasket washer and a couple of regular washers to make a direct connection between the turning cylinder and the steering wheel. Then, to secure this connection, we used a combination of methods. First, we glued each washer together, and then the washers to the base of the steering wheel. To reinforce this, we soldered a couple of smaller metal washers to the larger washers so that they would catch on the notches of the steering wheel. (We would have preferred to spot weld the washers, but this was not an available option.) Then, just for good measure, we heated up the washer using the soldering iron, to enlarge and squeeze/melt the washer into the plastic of the steering wheel.

For the blinker, we again had to do some creative improvisation, and use a toggle switch with a hinge to recreate a switch with the feel of a real blinker. The windshield wiper switch, on the other hand, we kept simple, and just attached a dowel to the end of a toggle switch. For the gear shifter we built a box with a plexiglass top with etched in gears, and inside it we mounted a slide potentiometer with a dowel on it. At first, the shifter was hard to use because the dowel was so long that it created a large moment and made the whole potentiometer want to rotate. To fix this we shortened the length of the dowel to reduce the distance from the applied force to the point of rotation, and we also secured the potentiometer in place with small blocks of wood.

With most of the tangible aspects of the project completed, we began to focus more on the programming portion. By this time, it had been decided to use the blinker as a toggle switch to toggle between different sound parameters of the sequence components, such as LFO amount, and filter frequency, and then to use the steering wheel as a continuous controller for each of these. With some help from the other groups, we were able to use the "select" function in MAX to toggle among four separate parameters, and we sent the values in from the steering wheel directly into the control out. However, a problem arose with the blinker switch, because it kept on getting random noise values when it was off. Because of this, every time the switch was toggled off, the random noise would send a new bang for every random value, sending the select into a frenzy. After a number of failed attempts, a gate was used to send a bang when the value was greater than 126 (switched on), and then if the values were less than 127, the gate would immediately disregard the values being sent. The only problem with this set up is it then required two toggles of the switch for every controller change, but we feel this is an acceptable tradeoff to have it work.

For programming the shifter, we again needed a little assistance, but we were very happy with the results. By using a select function over a range of numbers, we were able to make it so that if the slider gave a value within a certain range, it would send out MIDI data for a specific instrument in the sequencer, but if the number did not fall in that range, a zero would be sent. In this way, by moving the slider in different positions, you could mute specific instruments from the song, and have other instruments solo.

Since we had to abandon the turn potentiometer foot pedal idea, we instead decided to use a pressure sensor. We decided to use the higher quality FSR sensor, but this actually proved to be too sensitive, and gave values of 127 just from the weight of the spring and wood base on top of it. For this reason, we switched to using regular pressure sensor, which despite a large amount of random noise, gave a much more workable range. (Also, due to a lack of parameters left to control, we opted to stick with just one foot pedal instead of the original intention of two.) Since this pedal was giving such varied ranges of noise, we decided to assign it to something that wouldn’t need to be precise to sound good, this being delay. Also, we used the remaining wiper switch to control the "wetness" of the delay, which in actuality is just turning it on and off. Also, as another cool feature, we added a flip switch that serves as an ignition. When flipped, this switch actually just sends either a 127 or a 0 to the master volume in Reason, in effect acting as an on/off switch for the entire program.

Although we were able to work out just about all of the bugs in our project, there was one problem that kept arising, and continues to arise frequently. This is, our potentiometers keep on heating up and smoking when the five volts runs through them for extended periods of time. In fact, if you look, you can see that the inside starts to glow with an orange luminescence from the overheating. This could possibly be because of faulty wiring on our part, or the pots just really suck, but so far they haven’t burnt out, and proceed to work. Although it seems as if the output ranges have been shrinking gradually with each use, which could be a problem in the long run. Overall though, this project has been very fun, and interesting, and certainly feels like it has been a success. A good deal has changed since our original brainstorms, but everyone in the group is very happy and proud of the final product. •

see Jordan Kolasinski's report