I’ve written about how nice it is to be able to buy electronics supplies locally a few times.  All Electronics is one of those LA vendors. Tom brought in one of the SAW III digital voice recorders they sell for around 2 bucks in January, but, lets face it, it creeped me out. So what better to do than to Take it Apart!

Toys and random schwag are great resources for hacking projects. Frequently you can get whole working circuits for cheaper than an IC alone.  I tried to source comparable boards / chips and the next cheapest thing I found in a board was $6.95 (What looks like the Aplus APR9301 at  Electronics123). I found a chip alone at Digikey for $3.84 (The Nuvoton ISD1700 ChipCorder® Series)

As Make Magazine pointed out back in 2008, GetLoFi has a write up showing what resistor to replace with a potentiometer for pitch control (R4) how to add a phono jack, etc.  Briefly mentioned is hooking one of these up to an Arduino board via transistors, so that’s what I’m going to show in this article.

A word (or two) on transistors

Ahh transistors. Transistors are the electrical components making the information age possible. For example, they are what Moore’s Law is all about. Computer chip manufacturers keep figuring out  ways to double the number of transistors fitting on the same surface area every 18/20 months. This means exponential leaps in memory, sensor accuracy, processor speed, etc.  In other words, it is how we get so much fun obsolete-6-months-after-purchase stuff to take apart.

What can transistors do that make them vital to the cause? Well,  in the beginning, there was the button. And the button had to be pushed by a person in order to make anything happen.  And that was bad because we’re a slow and distractable sort of species with more fun stuff to do than pushing buttons and flipping switches. Do you watch LOST? Do you know how they spent season two pressing a button every 108 minutes? Well, if they had had an Arduino board and a transistor they could have written a quick little program and the darn hatch never would have blown up and maybe we could have had at least another season and I wouldn’t be so sad this week… But I digress.

So the magic of a transistor is that you can have one circuit “press a button” in a separate circuit which may have different voltages, current flows and other properties with no human actively involved.

Transistors are made by combining semiconducting materials.  Semiconductors come in two flavors. The N type and the P type. N type semiconductors tend to have extra electrons that they are happy to give away. They get the extra electrons because the silicon used to make them has been “doped” with phosphorous or arsenic.

In P type semiconductors boron or gallium are added to the silicon. Those additives cause cozy little holes in the silicon lattice. These holes make great homes for the overcrowded electrons in N type semiconductors.

When you put a layer of N-type next to a layer of P-type and apply current in the correct direction, the electrons will move from the N Type to the P type. Many diodes are made this way.  Think of them as taking advantage of a kind of electrical capillary action.  When you slap on an extra N-type layer you get an NPN transistor.  One N-layer is connected to a pin called an Emitter. Another N-layer is connected to a pin called a Collector. The P-layer is connected to the pin commonly known as the Base.

When you apply a current via a positive voltage to the P-type layer through the Base of an NPN transistor you’re basically flooding the porous P-type material so it is electrically-wet enough to allow electrons to pass from the Emitter N-layer to the Collector N-layer. If it sound weird for electrons to go in the Emitter and out the Collector, remember the direction of electrons is the opposite of how we talk about current.

Here is an example schematic of how you might wire something up. The gray circuit controls the teal circuit.

What does all this actually look like in a pretending-to-be-practical application?

Back to Our Saw Doll

Step 1: Take It Apart

The circuit board for the the digital recorder has a few things coming off of it:

- a Microphone
- a speaker
- Leads to the power supply

A heads up: all of the leads are very fragile. I had to replace/re-solder a few several times while I was mucking about with it.

Additionally there are two buttons: S1 for record and S2 for playback

Step 2: Prep for Use with Arduino

So there are a few things that need to be done if you want to pirate a battery powered device with switches for use with a microcontroller.

• Step 2a: Desolder the buttons and replace with wire leads (shown below already attached to breadboard)

• Step 2b: Remove the power supply and either replace the existing leads with 22 AWG wire or solder the existing wires to headers.

If you wanted to you could also replace R4 with a potentiometer like in the GetLoFi example, but I didn’t do that.

Step 3: Wire it up

Here is an illustration of the basic wiring.

The big things to notice:

- Power to the breadboard is from the Arduino 3.3 V supply

- When having one circuit communicate with another circuit, the most important thing is that they agree on where ground is. There are two wires going to the SAW III board from the breadboard to make that common ground connection. The first is part of the power supply hook up. The second is an extra wire that is wired into the ground plane at a separate position. I made it dark green in the picture. This wire could be used to create the common ground while using the original battery supply to drive the digital recording circuit if you want to go that route instead.

- There is a 1k current limiting resistor connecting the signal lines from the Arduino to the base of the PN2222 transistors.

Step 4: Code it Up

Here is the most basic code that records a sample, then plays it, records, then plays, records than plays, etc.  It is suuuuuuuper annoying. Just so you know. And here is the video to prove it!

Get Code Here

Homage to LOST project

Because I’m going to miss LOST so much, I went ahead and wrote a little program that will play a recorded clip every 108 minutes.  Thrown in is  record-on-button-release functionality to reset the message meant for use with a the same wiring as above with a momentary switch added to pin 2. I suggest “DON’T DO IT JACK”

Get Code Here

If people have their own projects that they’ve done with these things, I’d love to see them.

In this clip, Crash Space member and founder of Acceleren, Clive shows how to make a basic rocket out of under $100 worth of parts from Home Depot. As you can see he’s doing a lot of this at the space and we’ll likely have some kind of a rocket night in the very near future. Check out the Acceleren YouTube channel for more vlogs and updates.

While there is some fabulous motor fun in this machine, there is also a keypad that uses something called row column scanning to do it’s business. I bring this up because it is pretty common to want more buttons in your project than your micro-controller has pins.    Also, the board they’re using is one of the easiest circuit boards to completely reverse engineer that I’ve seen in awhile because it has no parts on it.   So for keypad circuit stealing, keep reading.

How did I know it was Row Column Scanning?

There are 3 general sections to the circuitry in this machine. The first chunk is the main circuit board with the logic chip and display on it. The second unit is the printer. The third is the keypad.

The adding machine keypad holds 37 momentary buttons. Additionally there are 6 switches that have a total of 20 possible positions between them.  This means there are 57 input readings the micro-controller needs to collect at any given moment .  The gray cable wire between the keypad board and the main logic board only has 30 wires, almost half of what you’d need to transmit the key/switch information directly.  There are no mysterious black-box ICs anywhere on the keypad board to do any compression, so something else has to be happening.  The most likely candidate: Row Column Scanning

What is Row Column Scanning?

Row Column Scanning basically takes any group of information and gives each item in the group a unique identifier by combining a row coordinate with a column coordinate.  For those of you who remember, this is exactly how you play the game Battleships.

To review: lets say you have 16 items and want to represent them row-column style using a 4×4 matrix

     1     2     3     4
A    A1    A2    A3    A4
B    B1    B2    B3    B4
C    C1    C2    C3    C4
D    D1    D2    D3    D4

In other words 1 = A1, 2 = A2, etc.

1       2       3       4       5      6      7       8       9     …    16
A1    A2    A3    A4    B1    B2    B3    B4    C1    …    D4

This can seem pretty overwrought, but it means getting 16 digital inputs (or outputs) while only using up 8 pins on your micro-controller.

How’s that you say?

Instead of thinking “rows” think output pins. Instead of thinking “columns” think input pins. In other words, each row is attached to a different pin on the micro controller and each column has it’s own pin, too.

So if you wanted to see if button B3 was being pressed you’d light up row B and listen on the pin attached to column 3. If you get a reading, the switch at that intersection is closed.

     1     2     3     4
A    A1    A2    A3    A4
B    B1    B2    B3    B4
C    C1    C2    C3    C4
D    D1    D2    D3    D4

The process is called Row-Column-Scanning because it’s more typical to scan through all the inputs at once rather than to check each button individually.  Programmaticly this requires one to:

• set the pin attached to Row A high,
• then sweep through a check all the columns
• set Row A back to low
• set Row B high
• and then check all the columns again, etc.

Identifying Rows and Columns in Real Hardware

To steal this key pad, I needed to identify the rows and columns electrically.  The physical buttons are in a nice little grid pattern, but the underlying circuit doesn’t have to follow the same layout.

The mechanical engineering for the buttons on the adding machine follows a typical formula for keypads by using 3 three layers: a hard outer shell, a flexible layer with conductive material selectively applied and a circuit board with contacts exposed.   Pressing the button deforms the flexible layer, mushing the conductive material into the contacts on the board, thereby closing the circuit.

To properly map out the board I needed to test continuity between each exposed contact and the pins across the top.  What I did was place one probe of my multimeter on a contact and then run the other across the top.

This is the board numbered out:

Once I had that done all that I put my pin info in a spread sheet that looked like this:

And then it looked like this:

And then I fiddled around with it until it looked like this:

Doing this helped me see relationships between the pins and make decisions as to what the most effective way to code a scan would be.

To do the wiring I desoldered the ribbon cable and soldered in 22 AWG solid-core wire which is easier to use with a breadboard. I didn’t solder up all the leads, just the ones I thought I might use in the code. I used yellow for “Rows” and red for “Columns”

I wrote up two Arduino code examples. One that prints out a “picture” of the rows and columns via a serial connection, Sending a 0 when there is no button press found and 1 when there is a press detected.

The other is a quick example of how you might integrate Row Column Scanning with a switch / case statement. The CS column in the last table I included are what the case statement numbers would be for each button if I had finished writing it out.

They both use nested for loops where the outer loop is the one that sets the Row/Output pins high and the inner loop sweeps the columns.

Just a reminder, to use this code you’ll have to put up with yet another layer of abstraction.  Each button now has yet another set of coordinates – which ARDUINO pins they map to. Circuit boards pins 1, 2, 3, 4 are Arduino pins 10, 11, 12, 13 for example.  Pins 10, 11, 12, 13, 18, 19, 20 and 21 on the keypad board are attached to pins 9, 8, 7, 6, 5, 4, 3 ,2 respectively.

Good luck!

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

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!

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);
  }
}

Okay, it seems I’m obsessed with power.

We took apart quite a few things Tuesday night: a massive HD projector from 1996, a little bit of a laptop, an antenna, and various miscellaneous items including a hand crank LED flashlight that Tom brought in.

That little flashlight was fun. Below is a video showing Sean having way too much fun twirling it around.

Conveniently this little device also represents yet another example of AC to DC power generation… the saga continues.

Overview

Not a lot of parts to this one so this time my overview is simply a link to the photo gallery on flickr:
http://www.flickr.com/photos/carlynorama/sets/72157623252086618

I’m afraid we don’t have a plug-in for this yet.

Electromagnetism

Moving electricity creates magnets. Moving magnets create electricity. This is what the right hand rule is all about. This is what creates electromagnets. This especially gets us motors.

Two very different reviews of this are the kid’s version or the semester at MIT version.

My vast simplification is this: Remember how if you have two magnets lining them up one way they attract, the other way they repulse? Motors use this property of magnets to create motion from electricity by having one permanent magnet (like a fridge magnet that is always a magnet) which gets shoved away from the electromagnet created when you turn on the switch and let current flow from the power source.

The crank flashlight flips the motor dynamic entirely around. When the handle of the flashllight gets pumped, it cranks a gear that spins a magnet. That moving magnet then induces an electric current in the wire. Since it would be impractical for a flashlight to have a giant magnet bigger than the size of a building continuously moving in one direction next to the wire, the whole unit spins in a circle. This spinning creates an alternating current that, with a little magic, then puts the charge into a capacitor.

Insert Magic Here

So, you can probably guess what that magic is… full wave rectification using diodes! I knew you had it. In order to get more bang for the buck the inductor they’ve chosen seems to be 3 phase – 3 pole which means we see 3 leads from it to the circuit rather than the 2 from that would come from a basic DC motor.

Looking at the parts and testing some continuity between them, this is my guess to how this circuit is working.

A very good resource I found on battery charging circuits is a project write up for a bike-powered generator.

Is it a battery or a capacitor?

Another great thing about this circuit is it brings up our safety lecture again. Capacitors hold charge and will slowly release it over time. That ability to store power can hurt you or help you. In this circuit it means a person can give their hand a rest!

It is important to note that the capacitor is not a battery. A battery uses a chemical reaction to create free electrons that will move from one end of the battery (the one labeled – ) to the other (the one labeled + ) when given a path through a circuit. A capacitor will store electrons that have been given to it and release them slowly over time.

We created moving electrons with the moving magnet and are storing them in the capacitor. The capacitor then safely discharges over time lighting the LED even after we stop cranking.

And this is where I stop cranking. Hope you enjoy!

But look at this! DVRs don’t do this!

Link to VCR Video on YouTube.

I’m going to spend a little more time on power sources again because last week I sort of glazed over some details on how not to kill yourself.

But you can always skip that and go look at the VCR cat feeder they made over at Make or the toaster on Instructibles.

Anatomy of a VCR

There is a nice article on how VCRs work at How Stuff Works which covers the basic anatomy. It should be pretty easy to identify the major players on the photos posted on Flickr. I’ve tried to do some commenting there.

There is alsothe wiki page where I’ve broken down sections that other people should feel free write up.

• the Video Processing
• the Motors
• the Power Supply
• the UI (buttons and how they look to the people vs the circuit)
• the Tape Verification (there are some nifty tricks with diodes & beam breaks going on…)
• the Magnetic Tape Readers (Think Sonic Fabric )

The Power Supply

Compared to last week, this power supply was different in a few ways. For starters it isn’t on a separate board, so it would be harder to harvest (but not impossible – think jewelers saw, a dust mask and goggles). Also, it uses 4 separate diodes in its AC to DC conversion rather than a pre-packaged rectifier.

It is cheaper and more space efficient to have all the electronics on one board. Because the power requirements of a VCR are so much less than the monitor’s it is easier to get away with doing that. A VCR pulls less juice out of the wall so it needs a less robust power management circuit.

Before you get out the sharpie and the saw these are the things you’ll want to do:

1: Uplug (Switch off all switches, unplug the unit, remove batteries)
2: Check Fuse (check continuity across the component)
3: Discharge Capacitor (Create a safe short across the leads)
4: Check the AC -> DC conversion (hello high power)
5: Check the DC -> DC voltage drops (making it usable)

Unplug and Fuse Check

I’m going to assume steps 1 & 2 are pretty clear. If step two isn’t here is a great tutorial on How To Use a Multimeter

Discharging A Capacitor

Step 3 can be a little controversial. I apparently created shock and awe by using a rubber handled screwdriver to rapidly discharging the main cap with a spark because I felt reasonably comfortable doing that with a capacitor the size used on the VCR board. Not really recommended. (Understatement.)

Ideally what you’d want to do is put something between the two ends of the capacitor the represents some kind of load relative to the voltage potential of the capacitor. A small lightbulb (not really an LED), a small motor or even just a big enough resistor.

The more voltage that the capacitor could have potentially stored, the more work you want to require of it to escape… but there is a balance between safety and speed: too much resistance and you’ll be waiting all day, too little and there is sparking. I got the ratio 5 to 50 Ohms / V rating of Cap from repairfaq.org.

Here is a way I could have done it better:

Shown is a 1k resistor (brown-black-red), the smallest recommended for a 200V capacitor.

AC to DC conversion

Honestly, the Wikipedia article on this one is pretty darn good. It is called Rectifier

Brief summary:

AC stands for Alternating Current, DC for Direct Current. AC oscillates. It buzzes in two directions. If your circuit is a DC circuit, you need it all to move in one direction.

Those of you who know about diodes are instantly thinking – oh, lets just put a super sturdy diode in there and then we’ll just get the power going one way – which is true but that would be wasteful (you’d only ever use half of whats available to you) and stuttery (Your circuit would only be receiving power half the time).

However, you can use 4 diodes in a bridge rectifier to get a smoother more efficient conversion called Full Wave Rectification. Here is an image from wikipedia to which I’ve added some additional labels so we can compare it to our actual circuit.

The R is technically a resistor, but it serves as a stand-in for whatever work you need that circuit to do; in our case that’s “insert VCR here.” Sometimes you might see it drawn more like this.

Notice that I’ve added a capacitor across the B wire to the D wire to ground. That cap is the big cap we talked about discharging. It looks like a short, but it only acts like one when there is a flood of power into the circuit. The size of this capacitor is determined by how much power would be considered a “flood” by the electronics downstream: Too small and the circuit after it could end up starved for juice, too large and the circuit will end up inundated before the capacitor has a chance to do its job.

So, when looking at the actual circuit board where do you put the probes to check the DC voltage drop? The following image is of our board, with the same labels as the two circuit diagrams.

So to see the full voltage drop, check between D and B. On this circuit you’ll get around 160 V. Between any two consecutive points (A to B, B to C…) you’ll see around 55 to 60 V.

This is all in comparison to last week where the manufacturers used an integrated circuit with a heat sink attached to do the same thing partially because that board pulls much more current.

DC stepping down

Now, most parts don’t want 160 V – a low power Arduino, for example, needs about only about 3.3V. Many modern devices combine multiple circuits all prefering different amounts of voltage.

That is what that big blue boxy-looking part is – a transformer to step the power down to useable voltages.

The thing is, transformers don’t work with DC voltages. The section of the circuit between the bridge rectifier and the transformer makes the DC voltage pulse at a rate much higher than AC out of the wall does.

I’m not going to dwell on this part expect to say that the usable voltage doesn’t really show up until after the second set of diodes, where on this circuit you get readings of around 12V, around 5V and around 40V. These supply lines probably get split/regulated/filtered, etc further into the circuit, but for stealing power this is where you could stop.

Stop!

Most of them work just fine for our purposes, but one of them popped and didn’t light up when it was tested that night.

The next day, with the sun shining, no internet, and a cable guy on the roof, ripping it to pieces seemed the only thing to do. Take it Apart Tuesday was born.

Hardware Hacking Basics

If you are going to start hacking things to pieces here are some good tools have:

• Assorted screw drivers (the computer sets are nice, but really just a regular flat head and basic Phillips is enough to start. They’re all we used for this)
• A knife (just in case)
• Blue masking tape (to tape down screws)
• A sharpie (to label the blue tape, if needed)
• A camera (so you know where things went)
• Small led flash light (makes part numbers easier to read)

Once you want to start seeing what does or does not work, rather than just an anatomy lesson add:

• A fused multimeter
• Internet access to look up part numbers

Super Basic safety:

• Be unplugged. (Not having things plugged into the wall is obvious, but remove internal batteries, too. )
• Check that all switches are in the off position.
• DO NOT touch large capacitors.
• Wear safety glasses if you are prying anything apart. (TIP: if you are near sighted, you’ll want to be wearing your glasses anyway to make reading part numbers easier)
• Wearing rubber soled shoes never hurts.

If you are going to take on a more radical parts harvesting than we’re doing here , i.e. desoldering individual items to use in a different circuit, be really really careful about fumes.  Solder has a number of chemicals that are incredibly harmful to breathe, so, bare minimum, have a fan and a window open, please.

Here is an Instructable on just that:
http://www.instructables.com/id/Recycle-old-PCB-components/

Our Victim: The Samsung LCD Monitor Model 244T S

The easiest part to salvage is the AC -> DC power converter, but the basic parts overview for the whole system is:

• 8 Circuit Boards
  1. PCB 1 The buttons for the front, connected to the video board [Flickr]
  2. PCB 2 The USB hub: BN41-00663A (SMSC USB2504-JT) [Flickr]
  3. PCB 3 Power converter: PSLF101401A, connected to the Board 4 in two places [Flickr]
  4. PCB 4 Video In / Processing: BN41-00659B [Flickr]
  5. PCB 5 LCD power supply: LCD Inverter board GH151A [Flickr]
  6. PCB 6 Logic Board: 240WUC4LV0.5 [Flickr]
  7. PCB 7 240M1S6LV0.4: No Google results but was connected to Logic board/long edge of LCD and has Rail-to-Rail Input-Output Op Amps (5420CRZ) [Flickr]
  8. PCB 8 240M1L01G_2LV0.1: Again no Google results, connected to short edge of LCD from logic board [Flickr]
• LCD
• Back Light & Filters
• Various pieces for the housing

There is now a section on the WIKI dedicated to Take Apart Tuesday so as people play with the different parts we can all keep learning. If you want to help identifying parts and aren’t sure where to start here are some good sites to start with:

To know what you’re looking at:
http://www.uchobby.com/index.php/2007/07/15/identifying-electronic-components/

To figure out what an IC is you can stick the part number into Google or find some help at the following two sites:
http://www.chipdocs.com/
http://www.educypedia.be/electronics/datacomponent.htm

We didn’t really think we’d be documenting this when we started so there are gaps and stuff, but here is the general overview.

http://www.flickr.com/photos/carlynorama/sets/72157623164028170/detail/

(we don’t have the flickr plugin yet… coming)

Harvesting the Power Supply

What popped during testing was probably one of the tubes in the back light.  If we were um, actually trying to fix it, we’d go through part by part seeing what broke. The first thing to check would be the power supply.

The power supply converts AC voltage into usable DC voltage.  Here are the steps we took to see if it was working. Tom took the lead on this part.

Notice in the images of the back area that the “HOT” or high voltage/AC area is marked off in black. This is the part that can hurt you so be careful working with components in this area.

Step 1: Unplugged it, made sure the switch is was off.

Step 2: Checked for continuity across the fuse (most likely thing to be broken)

Step 3: Checked the main capacitor for charge build up

These large capacitors can hold on to a charge for a long time and zap you.

Step 4: Plugged it in, turned it on, tested DC outputs

The low DC voltage pads read true, but no love on the 24 V connection, so to see if the problem was somewhere in the AC -> DC conversion we…

Step 5: Checked across the Bridge Rectifier

Everything looked good, in excess of 100 V there! HOT!

Step 6: Plugged it back into PCB 4 to check if there was something extra going on.

If you noticed, one of the pads in the low voltage part is labeled on/off.  We plugged that connector back into PCB 4 and let the power flow into that board, too. We got back a 3.3 V signal on the On/Off pad and then found that the 24 V pads lit up, too.  IC502 on PCB 4 is a 3.3 V regulator. A little more checking could find out if PCB 4 is just passing voltage straight back or if there is a system check happening in some other part of the circuit which gives the all clear.

The End: So now at the very least we have a 6V and multiple 24 V AC to DC power supply that we can use in other projects.Yay!

Okay so I’m a big RFID nerd, did a lot of consulting work using it.  So here’s a quick brain dump.

Regular passive RFID is designed for identification not localization.  The RFID tags can be reliably read only to within a few centimeters.  But the readers are cheap.  You can get 128kHz (LF) and 13.56MHz (HF) RFID readers for $20-40 and the reader chips themselves for under $2.  RFID tags that work with these systems are around $1.  These systems typically cannot handle multiple tags in the reader’s field at a time.

UHF (900MHz-2.4GHz) passive RFID readers can read up to a few meters, and the tags can be a $0.05 in large quantities.  The readers can get pretty expensive though: >$1000.  These are the systems used by Walmart et al to read a palette of Mach3 razors as they transit the warehouse.  And by the marathon race timers. The standard is called EPC, if you’re interested.  These systems can handle a few hundred tags in the reader’s field, but read time goes down exponentially with tag count.

“Active RFID” has ranges up to hundreds of meters.  The term “active RFID” is a bit loose, since one can describe a WiFi laptop or a cellphone as active RFID tag.  Really it just means an RF radio system that transmits a unique ID using its own power source.  There are active RFID versions of all the above technologies.  Eric’s suggested use of the RF Link boards is essentially an active RFID beacon.  One of my favorite active RFID designs is OpenBeacon (http://www.openbeacon.org/ ).  It uses the ubiquitous Nordic RF chips (used in almost every wireless keyboard & mouse)  Sparkfun has a ton of Nordic boards to play with.

“Localization” of RFID tags can mean two things.  For normal passive RFID, the tag is “located” when a reader sees it.  It’s a boolean: sees it / doesn’t see it.  This is often called “proximity detecton”.  So one way to approach localization is to just have a lot of readers.  True localization (knowing where in a reader’s field-of-view a tag is) is pretty tricky.  The main issue is just finding how far away an RF source is.  The simplest is signal-strength (“the louder you are the closer you are”), but that falls prey to the non-homogeneity of the environment: in free space it would work; in a room full of RF-absorbing humans, it fails.  If you’re really savvy, you can do time-of-flight calculation.  The reader sends out a ping and measures the time it takes to receive the tag’s echo ping. This requires nanosecond-accurate clocks on the reader (speed of light is very fast) and falls prey to multipath distortion (reflections off the environment).  And then you need multiple antennae for a single region to do triangulation.  It’s hard, but RFID vendors are starting to release stuff.

If there’s interest in a RFID show-n-tell, I’ve got examples of pretty much all this  tech I could bring in.  I’d be happy to let folks borrow some of it if they want to test out some ideas.