In the kit you get the parts to build your own Bristlebot, a tiny robot made from a toothbrush:

(consists of toothbrush, pager motor, battery, and foam tape)

and LED throwie art:


(consists of two color-changing RGB LEDs, battery, and a magnet)

We’ll have a Bristlebot race track you can do time trials on:

And we’ll be showing you how to build all of this, no previous experience required. Come build bots and lights!

For this event, competitors worked to build Larson Scanners (see the picture below), a device which lights LEDs in sequence to create a scanning effect. People reverse engineered circuit boards, puzzled through IC spec sheets, breadboarded their projects, and totally ignored the optional crypto breaking aspect of the event (more’s the pity). We even got some Madden NFL-style commentary going. SpeedMake may not be the most gripping, thrilling sporting experience since the invention of the monster truck rally, but it looked like people were having fun.

If you find SpeedMake intriguing and you wish to subscribe to our newsletter, there’s more information at the Crash Space wiki, here. There will also be some announcements about the next upcoming SpeedMake event at this Tuesday’s Public Night meeting.

The Larson Scanner built by Tod Kurt and Chris Sloan of winning team ShortWire in a hard contested 30 minute match

On Feb 24th, Johannes Grenzfurthner will be giving a workshop called “Of drunken machines and horny relays” in which he’ll be talking about how to build DIY hedonistic machines as well as about two of his on going conferences/project Roboexotica (which explores the under appreciated art of cocktail robotics) and Arse Elektronica (which explores the intersection of porn and technology). His talk will start at 8PM Wednesday night at Crash Space and will be open to the public (free for members, $10 donation recommended for non members)

UPDATE: We streamed the talk live, and an archive of the video is available online now but it broken into 2 parts for some reason. Watch it yourself: Part 1 (15:00) | Part 2 (48:00)

So this week a bit on optical encoding, then some on stall torque and how it relates to component power ratings.  Just for giggles I threw in some DC Motor code on the Arduino at the end. So keep reading… The Case of the Smoking Potentiometer

Encoding Speed and Location with a DC Motor

So the original plan for for the HP DeskJet 1120C was to crack it open, swap out the ink cartridge for a pen and then control the stepper motors based on sensor data to create a custom output device that actually gives you an instant hard copy datalog like a seismograph or lie detector.  It is a fun thing to do with old printers.

The tricky part is that once the 1120C was open it wasn’t actually a stepper motor controlling the horizontal location of the print head. Instead this printer uses a method called optical encoding and a plain old DC motor to determine where the print head should be.

http://www.flickr.com/photos/carlynorama/sets/72157623489291976/

A strip of plastic with fine lines feeds past an IC called the Q9864, a quadrature decoder. This chip has two outputs that each use sensors to detect the black lines on the strip as they zip past.  The spacing between the sensors is such that the readings from outputs are offset, 90° out of phase, apparently.  This allows the processor receiving the data to determine which direction the print head is moving.  The output is TTL compliant. (TTL: Transistor to Transistor Logic, it means this IC can directly talk to other similar integrated circuits with the understanding that “1″ is conveyed by generating a voltage level somewhere between 2V and 5.25V and “0″ is represented by any voltage under 0.8V)

Now to attempt hacking into this chip it would be best to have an Oscilloscope, etc, but I haven’t even covered basic DC motor stuff and we have a smoking potentiometer to get to.  I’m going to take the dodge and point people to a project that was just in Issue 20 of MAKE called the Autophenakistoscope.

Video on Retro-Tronics

Why point to this project you ask? Well the Autophenakistoscope is a phenakistoscope (early moving-picture device) that uses an infrared emitter and detector pair in conjunction with regularly placed slits in a moving cardboard wheel  in order to control the speed of a motor. The Q9864 with it’s strip is essentially an advanced version of this setup so looking at the code MAKE has published is a good way to figure out what to do with the data once you’ve gotten it anyway.

But the thing I haven’t covered is, “Why would HP do this to me and ruin my fabulous quick project idea?” Um, I mean, “What are the advantages of using encoded motor control over a basic stepper motor?” Simply stated, motors sometimes slip so it is good to have an independent outside source confirming that the motor is where you think it is. Many CNC routers, printers, etc. opt for this type of encoding rather than taking on faith that a stepper will always be on it’s best behavior.

Direct DC Motor Control And What can Go Wrong

So instead of just hijacking another stepper, like we could do with the paper feed stepper, we needed to build a circuit for this new motor. If you remember, the motor in our toothbrush was a DC motor and the circuit consisted of a battery, a switch and the motor.  This is the most basic circuit and it is the one we recreated to verify that the motor worked and what voltage it needed to move.   Following the advice I gave in TAT0005 I started with my lowest available voltage – 5V from an Arduino board powered from am external power supply. When that failed to move the motor at all, the next available power source was a 9V battery. A straight from the package 9V moved the motor hesitantly.  The problem here may actually have been a current/torque issue since the motor was still attached to the rubber belt and the print head. What finally worked cleanly was a 12V/1Amp supply.

Video Recreation:

The Best Laid Plans

Off and on isn’t always fun enough, though.  The way to change the behavior of a motor is to change the way it’s getting its power.  To change direction – swap the position of the leads. To change speed – change the amount of voltage across the leads.  To provide more torque – increase the current available.

I wanted to quickly demonstrate speed control. To change the voltage available to the motor with a fixed voltage power supply you can add a resistor in series with the motor. This resistor will burn off some of the potential energy/voltage as heat, decreasing what is available to the motor.  How much energy it steals from the circuit is related to how big of a resistor it is; a 100 Ohm resistor will drop the voltage a lot less than a 10k Ohm resistor.  You can calculate all this with Ohm’s Law which I’ll use again later…

If you want to change the speed as you go the fixed resistor can be replaced by a variable resistor or rheostat.   All About Circuits has a very good explanation of how this is done using a potentiometer.

And…. well, if you watched the video at the top of the post, you know what happened.

Pot Smoking

So, why did the potentiometer smoke? A few things, but the most important was that I failed to know my component. What do I mean by that? I mean that I grabbed a potentiometer out of my kit and ignored its power rating because I thought for a couple of seconds it wouldn’t matter. Wrong!

The three things I should have had in mind:

• Resistors dissipate energy as heat
• Resistors/Potentiometers are given power ratings based on the combination of voltage and current they can handle before they get immensely hot and fail. This is given in Watts (Watts = Volts * Amps)
• Most of my pots are cheap 1/4 to 1/2 Watt jobs meant for use with a micro-controller
• Motors draw A LOT of current when they are stalled.  Their resistance drops because no counter EMF is being generated to push against the current supplied by the power supply and Ohm’s Law tells us a drop in resistance at a a steady voltage will lead to a rise in the current. (V=I*R)   (How much current are we talking about?)
• I was forcing the motor to stall. Repeatedly.
• Plastic burns.

So as the resistance in the potentiometer increased, the voltage to the motor dropped, and its speed dropped. The motor’s resistance plummeted faster than the resistance in the pot increased. The whole system started drawing more current.  This current was being pulled through the increased resistance of the pot… well to sum up it is entirely possible I was dragging a full amp at 12 V through a 1/4 W resistor set to its maximum resistance – hence smoke…

So how do all those cheap electronics work?

A potentiometer that can handle 12.5 W can run between $15.00 to $30.00, depending on the quantity ordered.  Additionally, dropping voltage to a motor through resistance wastes a lot of energy and creates a lot of heat.  For these and other reasons a rheostat directly in series with a DC motor of any strength is not the method of choice for controlling speed.  What frequently gets used instead is something called Pulse Width Modulation.  This involves separating your control circuit (microcontroller/other pulsing IC) from your load circuit (motor) and using a microcontroller or something like a  555 timer to turn the load on and off very fast. The ratio of on time to off time controls the speed. More on, faster. More off, slower.

FYI – separating the logic from the load makes switching directions easier because power and ground aren’t hardwired to the leads of the motor directly.  For the sake of symmetry with TAT0004 I’ve duplicated the Stepper Motor Random Motion program as an example.

Circuit Board:

Code Here

My outline notes of the meeting

We had another great Radio Mondays(about 10 attending), we discussed the wide variety of RC toys and models and organizations; paying special attention to areas people might be interested in trying out something.

The toy helicopter above was very popular to fly around, although it’s a bit tricky to control. Organizations like Big Gun scale ship combat and 3D-flying helicopter races were explored in detail, and we discussed some alternate uses of RC gear, like controlling art installations, decorations, using hobby flight gear as a cheap intro to UAV design, and much more.

Now is your chance to check out Crash Space. Tomorrow night (Tuesday Feb 9th) at 8pm our usual Tuesday night meeting is open to the public.

What do we do at our usual Tuesday night meeting? A brief bit of CrashSpace business. A show and tell session by our members. Lots of interesting parts and projects show up. Finally, there’s Take Apart Tuesday. The group takes apart a couple pieces of hardware and figures out what’s inside them, how they work, and what parts might be useful to scavenge.

Come on by Crash Space at 8pm and see what it’s all about. We’d love to meet you.

Here are some selected photos from that trip, more on flickr, and more resources on our wikipage.

I had dismantled two electric toothbrushes over the weekend preparing for an Introduction To Electronics class I’m teaching at Machine Project in March. I pretty much threw the parts on the table like chum saying “keep the talking to the commercials people.”

That said I have written up a little bit about the nature of DC motors and provided links.

DC motors are pretty much a piece of cake compared to stepper motors. No multiple leads attached to separate coils, no microcontrollers necessary.  In fact the most basic circuit is just a motor, a power source and maybe a switch.  This motor is a very low-current, low-voltage motor that isn’t going to face a lot of resistance as it runs.  In higher voltage/current situations you’ll likely see diodes and capacitors thrown into the mix to improve performance and stability. You might also see ways to change the motor’s speed or direction. I’ll talk about that stuff during the class.

Just like steppers, however, DC motors move because of the joys of electromagnetism.  Perhaps the best way to really get a handle on that is to build you own motor from scratch by either follow directions like the ones on the Exploratorium site and using materials you scavenge up yourself or by buying a kit. It can make a big difference to see the effect in action.

Commercial toy motors are commonly configured with 2 stationary magnets of opposite orientations (field magnets) jammed up against an the outside of the housing (stator). In the center is an electromagnet created by running current through coils wound about an armature (sometimes called a rotor). This armature is attached to the axle.  The current comes to the electromagnet through contacts on the axle which are rubbing against two brushes on the casing. In the toothbrush circuit each brush is attached to a different end of the battery.

The commutator (fancy name for axle contacts) allows the axle to spin freely unfettered by wires that would twist and snap while still allowing power to flow to the electromagnet. Because of the way the separate contacts on the axle are configured, the axle spinning translates into a change in the direction of the current through the coil windings of the electromagnet. The change in the direction of the current means the poles of the electromagnet invert. That flip happens at just the right time to prevent the magnets from getting comfortable with each other and reaching a stasis. The constant change keeps the motor agitated and in motion.

A lot of the “build your own motor” examples and basic “how motors work” illustrations show an armature shaped like a bar with only two coils. While that keeps things simple when explaining the concept, once you crack open a real motor there are going to be at least three windings. Having three makes for much smoother motion and the Solarbotics site has a nice animation of how that works.

This motor is pretty straight forward and will run off a 1.5 AA battery. But what if I gave it more juice? Different motors will have different strength magnets, have their wires wrapped around the armature more or less times, simply be bigger or smaller, etc. Therefore, each motor has different current and voltage requirements, and limitations. I found one article that talked about what to do if you get a motor and don’t know how much power it needs. It presumes quite a bit of knowledge and a way to detect RPM, but is super handy if you buy surplus motors. It is even handy if you pull a motor out a known circuit as the manufacturer might be starving or pushing the motor too hard.

The next time we have a surplus DC motor with no basic information to be found I’ll break down/illustrate his instructions the best I can. The more low-tech way to do things is to simply apply a low courrent/voltage source to the motor and slowly increase power to it until there is movement.

Happy motoring!

• Amateur Radio
•     Services
•       ARES/RACES
•       Military Afilliate Radio System
•       SKYWARN
•       SATERN(salvation army)
• cells
•    wireless priority service
•    e911
• NOAA weather alerts
• emergency alert system
• sat phones(iridium, globalsat)
• police/fire/coast guard

There are also a host of military and government radio systems that get used in an emergency, but they tend to be satellite or tight/encrypted links we can’t access.

We also talked about what direction we should go for our first project, we’re leaning towards a recreation of the famous experiments van Eck did, that led to the TEMPEST standards. It would be interesting and even possibly useful to other projects, to know what kind of RF things around crashspace were emitting.

[pics later]

Once again How Stuff Works comes to the rescue with a great article on inkjet printers. Give it a quick glance, especially the Inside an InkJet Printer, before you look at the dismantle porn on flickr so you can get a sense of what you’re looking at.

This poor printer had clearly been languishing in a garage somewhere, with bugs and dirt and stray pennies… we’re happy it’s now in a better place.

Here’s the flickr set: http://www.flickr.com/photos/carlynorama/sets/72157623309152076/

Last week we had a motor in our circuit inducing current for an LED so now we have the perfect segue for looking at a motor, well, being a motor.  We captured two stepper motors from the StyleWriter 1200 and got a 4 phase 5 wire unipolar stepping motor to do its thing.

Salvaging a Stepper Motor

A basic summary

There are many very good write ups on stepper motors online.

• The frequently sited Control of Stepping Motors by Douglas W. Jones THE UNIVERSITY OF IOWA Department of Computer Science
• Stepper Motors by Ian Harries
• Tom Igoe’s Stepper Motor Control
• And if you want some take-apart-extreme, Duck Tape Engineering has posted pictures of the inside of a stepper.

Stepper motors are the go-to motors when precise movement is more important than weight, torque or energy efficiency.   Their axles move in discrete steps, hence the name. So, for example, the motor I’m writing up here can be moved in 7.5° increments, dividing a full 360° turn into 48 discrete steps.

Unlike a DC motor that just spins freely in one or two directions, stepper motors need precise commands to each lead wire to get any kind of interesting behavior.  The motor will just sit there, shudder and try to elicit sympathy if you get it wrong. It is not a pretty sight. Which is why microcontrollers, like the Arduino, are used to control them.

Motors generally have different power requirements than microcontrollers, and since they use changing currents and magnetism to generate motion they make for very electrically noisy additions to the circuit neighborhood.  As a result keeping the motor’s power and the microcontroller’s power separate becomes necessary. You can accomplish that separation with transistors. However, transistors are bulky so various electronics companies have made integrated circuits that cram a whole bunch of transistors into one cute tiny little package. Well maybe not that cute, perhaps more black and svelte.

You can generally nab anything called an H-Bridge, Darlington Transistor Array, Quadruple Half-H Drivers, etc. The L293,  SN75441, ULN2003 are all chips you might notice in examples and they all do the trick. Important caveat: they do not have identical wiring diagrams, i.e. they get integrated into circuits differently because how each pin on the IC behaves is different from chip to chip. It is best to use the same chip as the example you are copying unless you are comfortable reading a datasheet.

For us that night,  I knew where there was a link to pictures of a L293 online and I had a L293 in my kit. So that is where we started.

What Happened That Night

So while I was starting to wire up the board, Justin jumped in to find out what kind of stepper we were dealing with. My old stepper example used a 4 wire bipolar stepper and this one had 5 wires sticking off it.

The motor’s label told us it was a Mitsumi M42SP-7. According to the datasheet it is a 4-phase unipolar stepper motor. Mitsumi motors are fairly common and here is a link to their full motor products list. The other motor in the printer was the M42SP-4N.

Justin discovered the example on the Arduino site using a 5 wired stepper and we decided to follow that.

Since wire colors on salvaged motors are fairly arbitrary we had to figure out what each wire was connected to. Ian Harris’ site has the clearest explanation on how to do that.

Find the common wire

In a 5 wire 4 Phase Unipolar Stepper Motor four of the wires are attached to coils in the motor and the fifth is a common source of power.

The first thing we had to do after extracting the motor was attach lead wires to it so we could use it with a breadboard. The white connector at the end of the motor’s soldered on lead wires is not the same spacing as the spacing on a breadboard so we couldn’t just use the 0.100″ breakaway male headers that fit into breadboards. The 22 gauge wire I had on hand also seemed to be a bit thick, but we managed to squish its ends a bit with pliers and get the wire into the motor’s interconnect.

Once those wires were attached, Justin tested resistance between all the leads on the wire.  Most of the wires had a reading around 150 Ohms between them, but the black wire in the center read 75 ohms to each of the other wires.

My recreation:

As Ian Hayes Says:

The Common Power wire will be the one with only half as much resistance between it and all the others. This is because the Common Power wire only has one coil between it and each other wire, whereas each of the other wires have two coils between them. Hence half the resistance.

We had some debate about whether that wire was really supposed to go to power or ground since it was black, but to power it goes.

Hitching up the Arduino

With the board finally wired up (a bit sloppily I will admit), Thereon lent his Arduino to the cause and we connected it up to the motor as indicated in the example on the Arduino site. We did the best we could given that we were using a different chip and a different motor. Basically, I guessed. After loading in David Cuartielles’ easy code we got stuttering but no real movement from the motor. (if you have no Arduino experience you can start here). No biggie. Swapping which wires were two and three got us motion! Yay! (I’ll explain why this worked later)

And the next day…

So the next day I come in and not so much with the working motor. Not that unusual with a Physical Computing project, so I took it as a chance to really figure out which wire was which following Ian Hayes directions which I mentioned before.  He shows a clear way to figure out the order of your coils on a 4-phase unipolar stepper. After running the common power into a supply voltage you pick any of the remaining wires and connect it to ground. He calls it “wire 4″ arbitrarily. By tying each successive wire to ground and seeing how the motor behaves you can ferret out which wire is tied to which coil.

The results:

• Wire 1 – Yellow
• Wire 2- White
• Wire 3 – Red
• Wire 4- Brown on motor / Green on lead wire
  

There were other tips on how to figure this out on a pic chip (type of microcontroller) reference site, but it was better for motors with a different number of leads than our 5 wire unipolar motor.

Hayes goes on to explain how to find the right sequences for a 5 wire / 4 phase unipolar motor. Cuartielles’ code matches up with Hayes recommendation with the following wiring (via the L293 in the middle)

• Arduino pin 8 -> wire 1 / A / Yellow
• Arduino pin 9 -> wire 2 / B / White
• Arduino pin 10 -> wire 3 / A’ / Red
• Arduino pin 11 -> wire 4 / B’ / Brown-Green

Notice I added the A/B/A’/B’  to this list. Many discussions of stepper motors talk about wires in terms of pairs: A/A’ or 1a/1b,  etc. In our motor what are being called wires 1 and  3 are a pair and wires 2 and 4 are a pair. The reason swapping the wires the night before worked is because what I had done was to wire two wires relating to the same pair in succession when really the key to stepper motor control is making sure that all the different coils are properly interleaved.  So, for example, Jones’ representation of what what your microcontroller pins need to do to create motion (version below) looks way fancier than the simple step through that Curtielles is doing in his Arduino code even though they are doing the same thing. Again, this is because Jones is grouping his wires by pair rather than by the coil sequence.

  Winding 1a 1000100010001... (our yellow wire)
  Winding 1b 0010001000100... (our red wire)
  Winding 2a 0100010001000... (our white wire)
  Winding 2b 0001000100010... (our brown/green wire)
              time --->

Not the problem.

So now confident in the fact that the wires were all lined up correctly, I was still facing a stuttering motor.  My next guess was the power supply. Because in the Arduino example we were copying they had gotten away with using 5 V from the USB port I had cheated and done the same thing by tying the motor power supply pin of L293 into Arduino board’s 5V pin-out.  The M24SP-7 is a 12V-24V motor, and while, for what ever reason, it had decided to humor us the night before it was no longer in any mood to make do with a paltry 5 volts.  I now suspect that this was because my computer that night was plugged in and the next day I was running off a battery. It’s an untested theory. Adding a 12v external supply into the mix solved the problem. (See the note in this picture for where that 12 V supply went into the breadboard)

More fun with code

So back to the video at the top of the post.

I have a longer history with Tom Igoe’s bipolar stepper motor code and decided to make it work with this motor. It lets you control how many steps you are moving and at what speed. His code is for a different type of motor and moved that motor 100 steps forward and 100 steps back.  I wanted something that was a little more fun to watch so I made the number of steps random and speed variable based on the number of random steps.

Those modifications are in the code here and below, salient changes marked. Enjoy!

/*
 Random Stepper Motor Motion
 by Carlyn Maw based on 2005 code by Tom Igoe

 This program moves a 4 phase unipolar stepper motor a random number of
 steps in one direction, then a different number of steps in the opposite
 direction, indefinitely. Speed of the motor is increased with the size of
 the random number.

 Created 28 January 2010
 Updated 

 */

int motorStep[4];        // array to hold the stepping sequence
int thisStep = 0;        // which step of the sequence we're on
long randomNumber;      // random muber that will be the number of steps the motor will move
int mySpeed;            // the delay interval between steps. The smaller the faster.

//  function prototypes:
void stepMotor(int whatStep, int speed);
void blink(int howManyTimes);

void setup() {
  /*
     save values for the 4 possible states of the stepper motor leads
   in a 4-byte array.  the stepMotor method will step through
   these four states to move the motor. This is a way to set the
   value on four pins at once.  The  digital pins 8 through 13 are
   represented in memory as a byte called PORTB. We will set
   PORTB to each  of the values of the array in order to set
   digital pins 8, 9, 10, and 11 at once with each step.

   We're representing the numbers as hexadecimal values below, but
   it'd be nicer to represent them as binary numbers, so that the
   representation shows us visually which pins of PORTB we're
   affecting.
   */
  motorStep[0] = B00001000;
  motorStep[1] = B00000100;
  motorStep[2] = B00000010;
  motorStep[3] = B00000001;

  /*
  //alternate step array with 1/2 steps
  motorStep[0] = B00001000;
  motorStep[1] = B00001100;
  motorStep[2] = B00000100;
  motorStep[3] = B00000110;
  motorStep[4] = B00000010;
  motorStep[5] = B00000011;
  motorStep[6] = B00000001;
  motorStep[7] = B00001001;
  */

  /*
   The DDRB register is the Data Direction Register.  It sets whether
   the pins of PORTB are inputs or outputs. a 1 in a given position
   makes that pin an output.  A 0 makes it an input.
   */

  // set the last 4 pins of port b to output:
  DDRB = 0x0F; //0b0000_1111;

  // set all the pins of port b low:
  PORTB = 0; //0b0000_0000;

  // start  program with a half-second delay:
  delay(500);  

  // blink the reset LED 3 times:
  blink(3);

  //seed random from analog pin so pattern is different everytime
  randomSeed(analogRead(0));
}

void loop() {

  /*
  move motor forward a random number of steps.
   note: by doing a modulo operation on i (i % 4),
   we can let i go as high as we want, and thisStep
   will equal 0,1,2,3,0,1,2,3, etc. until the end
   of the for-next loop.
   */

  // the max is higher than the number of steps it takes for
  // the small gear head to turn b/c it is attached to a larger
  // gearhead.
  randomNumber = random(5,100);
  mySpeed = 1000/randomNumber;
  for (int i = 1; i<= 100; i++) {
    thisStep = i % 4;
    stepMotor(thisStep, mySpeed);
  }

  // move motor backward
  randomNumber = random(5,100);
  mySpeed = 1000/randomNumber;
  for (int i = 100; i >=1; i--) {
    thisStep = i % 4;
    stepMotor(thisStep, mySpeed);
  }
}

//Step the motor forward one step:
void stepMotor(int whatStep, int speed) {
  // sets the value of the eight pins of port c to whatStep
  PORTB = motorStep[whatStep];

 // vary this delay as needed to make your stepper step:
  delay(speed);
}

// Blink the reset LED:
void blink(int howManyTimes) {
  int i;
  for (i=0; i< howManyTimes; i++) {
    digitalWrite(13, HIGH);
    delay(200);
    digitalWrite(13, LOW);
    delay(200);
  }
}