Gaugette

SwitecX25 Quad Driver Tests

Sat, 29 Apr 2017 14:16:00 +1000

This article demonstrates a modification of the Arduino SwitecX25 driver library to use a AX1201728SG quad driver chip (equivalent to the X12.017 or VID6606). This chip offers some significant advantages over driving the motor directly:

it uses microstepping to provide smoother positioning - 12 steps per degree rather than 3.
it requires only two GPIO pins per motor (plus one global reset pin)
it protects the microprocessor from the inductive effects of the motor coils
it places lower current requirements on the microprocessor

In the past I’ve been unable to find a low-volume supplier for the X12.017 Quad Driver Chip, or any of the functionally identical chips from other manufacturers. These are the ones I know about:

The VID VID6606 Quad Driver (datasheet)
The NOST Microelectronics BY8920 Quad Driver (datasheet, in Chinese)
The AX1201728SG (by EmMicroe maybe?)

Recently both the AX1201728SG and VID6606 have become readily available in small quantities.

The AX1201728SG

The AX1201728SG is available in single quantities from ebay for a few dollars apiece. The one complication is that they are SOP28 surface mount packages, which are a little harder to prototype with than DIP packages. I bought some drivers, and some SOP28 to DIP28 adaptors so I could mount the drivers on a breadboard for testing.

Mounting

I haven’t worked with SMD chips before, so I had a friend help me mount them. We used tweezers to apply the paste, and a regular household oven for reflowing. Very basic, but it worked fine.

Wiring It Up

Initially I’m testing with a single motor on output A. The wiring is as follows:

VSS (chip pin 12) to GND
VDD (chip pins 1 and 15) to 5V
RESET (chip pin 26) to Arduino pin 10
CW/CCW A (chip pin 27) to Arduino pin 9
f(scx) A (chip pin 28) to Arduino pin 8

The motor connections are:

OUT1A (chip pin 7) to Motor pin 1
OUT2A (chip pin 6) to Motor pin 2
OUT3A (chip pin 4) to Motor pin 3
OUT4A (chip pin 5) to Motor pin 4

Software

I started with a basic hello-world program to run the motor forward and backwards so I could work out any setup issues before switching to the more complicated driver software.

/*
  X12.017 Quad Driver Test
  Drive the motor forward and backwards through 270 degrees
  at constant speed.
 */

const int LED = 13;
const int DIR_A = 9; // pin for CW/CCW
const int STEP_A = 8; // pin for f(scx)
const int RESET = 10; // pin for RESET
const int DELAY = 250; // μs between steps
const int ANGLE = 270; // of 315 available
const int RANGE = ANGLE * 3 * 4;
int steps = 0;
bool forward = true;

// pull RESET low to reset, high for normal operation.

void setup() {
  pinMode(DIR_A, OUTPUT);
  pinMode(STEP_A, OUTPUT);
  pinMode(LED, OUTPUT);
  pinMode(RESET, OUTPUT);

  digitalWrite(RESET, LOW);
  digitalWrite(LED, HIGH);
  digitalWrite(STEP_A, LOW);
  digitalWrite(DIR_A, HIGH);
  delay(1);  // keep reset low min 1ms
  digitalWrite(RESET, HIGH);
}

// The motor steps on rising edge of STEP
// The step line must be held low for at least 450ns
// which is so fast we probably don't need a delay,
// put in a short delay for good measure.

void loop() {
  digitalWrite(STEP_A, LOW);
  delayMicroseconds(1);  // not required

  steps++;
  if (steps > RANGE) {
    forward = !forward;
    steps = 0;
    digitalWrite(DIR_A, forward ? LOW : HIGH);
    digitalWrite(LED, forward ? HIGH : LOW);
  }

  digitalWrite(STEP_A, HIGH);
  delayMicroseconds(DELAY);
}

This worked, mostly. If I leave the motor running for a while I notice that the needle position drifts, which indicates either missed steps, or a counting problem. Increasing the inter-step delay from 250ms to 500ms resolved that problem, so most likely I’m exceeding the (low) torque limit during the turnaround. I’m not worried about that - once I port the SwitecX25 library I can find a safe set of acceleration parameters to keep it from dropping steps.

Adapting the SwitecX25 Library

The SwitecX25 library provides an acceleration/deceleration model, and some higher-level control abstractions. Importantly, it is asynchronous. The caller sets a desired step position and then calls the update() method as frequently as possible and the library manages the scheduling of the steps.

One concern I have about supporting the quad driver is the being able to service the pin transitions quickly enough. When driving the motor directly we need to update 4 outputs once per step. With the quad driver we need to pulse the f(scx) line low then high once per micro-step, which equates to 8 transitions per full step. It may turn out to be difficult hit all of the timing deadlines to drive 4 motors at full speed simultaneously.

My first cut at this is to create an entirely new class SwitecX12 which duplicates the key timing code from SwitecX25, with new output logic and an adjusted acceleration curve.

The code below zeroes the needle, moves the needle to the centre of the sweep, then cycles between ¼ range and ¾ range.

#include <SwitecX12.h>

const int STEPS = 315 * 12;
const int A_STEP = 8;
const int A_DIR = 9;
const int RESET = 10;

SwitecX12 motor1(STEPS, A_STEP, A_DIR);


void setup() {
  digitalWrite(RESET, HIGH);
  Serial.begin(9600);
  motor1.zero();
  motor1.setPosition(STEPS/2);
}

void loop() {
  static bool forward = true;
  static int position1 = STEPS * 3/4;
  static int position2 = STEPS * 1/4;
  if (motor1.stopped) {
    motor1.setPosition(forward ? position1 : position2);
    forward = !forward;
  }
  motor1.update();
}

Conclusion

The AX1201728SG looks very promising. It’s a bit of a nuisance to deal with surface mount devices if you aren’t set up for it, but not insurmountable.

The microstepping is really smooth. Below is a video showing how smooth. I used a very exaggerated acceleration table to keep the needle in the slow range for longer.

Resources

Tue, 01 Nov 2016 14:39:00 +1000

Source Code

Switec X25 Series Stepper Motors

VID29 Series Motors

VID23 Series Motors

VID23 Transparent Shaft Motor

MCR Motor MR1107/MR1108

Driver Chips

X12.017 Quad Driver Chip Data Sheet
BY8290 Quad Driver Chip Data Sheet (in Chinese), and here’s a link to a Google-generated English translation of the data sheet
VID6606 Quad Driver Chip Data Sheet

OpenXC - Hack Your Car

Sun, 03 Mar 2013 15:20:48 +1000

OpenXC is a very cool initiative involving Ford Motor Company and Bug Labs aimed at creating an open development ecosystem for interfacing with in-car electronics. Looks like a pretty great project.

OpenXC Switec X25-based “Retro Gauge”

One of the OpenXC projects featured on their website is a retro gauge based around Switec X25 type micro-steppers.

They have published Eagle schematics for a gorgeous little combination analog/digital instrument gauge. Their in-gauge PCB cleverly incorporates an Arduino Pro Mini. They have also published STL files for a 3D-printable housing.
This all looks very slick to me.

Their firmware uses our very own Switec X25 library.

You can find detailed documentation and resources at their github repository.

Analog Gauge Stepper Breakout Board available on Tindie

Fri, 18 Jan 2013 07:27:00 +1000

Check out this great new Tindie project launched by The Renaissance Engineer Adam Fabio for a new breakout board designed for Switec motors and clones.

The breakout board incorporates flyback diodes to protect your circuit from inductive kickback, and the also serves as a convenient base to mount the motors. The kit includes the board, diodes, 6-pin header, a Switec X27.168 and 3d-printed needle.

If you want to get in on this initial offering act quickly - it closes in 12 days. The project has already exceeded the funding target. Nice work Adam!

Electric Imp Telepointer

Sat, 03 Nov 2012 12:43:00 +1000

Here’s an interesting project that makes use of Switec X25 steppers; Gavin Sallery has used two electric imps to gain very remote control of a Switec stepper. Electric Imp looks very cool.

Beverage-o-Meter

Tue, 07 Aug 2012 10:15:00 +1000

Phil Bambridge has blogged about his Beverage-o-Meter which demonstrates wireless remote control of an analog gauge using Arduinos eqipped with Nordic 2.4GHz radio boards. Fun, whimsical, and beautifully housed too. His project uses a Switec stepper for the gauge, and uses the SwitecX25 library. Check out his blog and source code here.

Buyers Guide

Fri, 25 May 2012 11:06:00 +1000

Manufacturers

I am aware of three companies manufacturing compatible motors. All appear to produce a good-quality product.

Switec

Switec was originally the technology arm of the Swiss watch company Swatch. The stepper business was sold off to Singapore-based Juken Technology in 2009. Switec motors are white, and have part numbers starting with “X”.

VID

Hong Kong based VID also manufacture a range of similar motors. Their motors are black, and have a black model number starting with “vid”.

MCR

Chinese company MCR Motor manufacture a range of compatible motors. Their motors are white. with part numbers starting with “MR”.

X25 Product Numbers

Each manufacturer produces a number of variations of the motor.

Switec	VID	MCR	Contacts	Mounting Pegs	Internal Stop	Shaft
X25.156			rear	no	no	standard
X25.166			rear	no	yes	standard
X25.158			rear	rear	no	standard
X25.168	VID29-02	MR1108	rear	rear	yes	standard
X25.278			rear	rear	no	long (+2mm)
X25.288	VID29-04		rear	rear	yes	long (+2mm)
X25.559			front	front	no	standard
X25.569	VID29-05	MR1107	front	front	yes	standard
X25.579			front	front	no	long (+2mm)
X25.589	VID29-07		front	front	yes	long (+2mm)
X25.679			front	front	no	long (+2mm)
X25.689			front	front	yes	long (+2mm)

Other Switec Series

X23 Series

The X23 motors have an a hollow metal shaft encasing a transparent light guide to make it possible to have an illuminated pointer.

X26 Series

The X26 motors are dual-shaft analog clock motors. The model numbers are X26.101, X26.103, X26.123, X26.504. See the the “Switec Series Buyers Guide” in the Resources for more details.

X27 Series

The X27 motors are a new line replacing the X25 series. The X27 part numbers mirror the X25 series.

X12 Motor Drivers

The X12 part numbers refer to a series of driver chips developed by Switec. I have not been able to locate a supplier of these chips since microcomponents.ch shut down.

Suppliers

I have not found any well-known online store supplying these parts. They are cheap and plentiful on ebay. However it can be difficult to determine exactly what you are getting; these motors are generally sold as Switec X25 replacements, without clearly specifying the manufacturer.

How Fast Is It?

Tue, 08 May 2012 09:06:00 +1000

I recently removed the internal stops on a VID-29 stepper. I’ve used this free-turning motor and an optical sensor to exerimentally test some operational limits of the motor. The test rig uses a photo-interruptor to determine the needle position:

Methodology

I move the need forward under varying conditions, then move the needle back to the home position in a known-reliable manner while counting the steps. If the steps counted back do not match the number of steps programmed forward then we know we have exceeded the operational limits of the motor.

After some experimentation I selected a delay of 1000μS per step for the counting phase as this is well within the safe limits of operation. I confirmed that in this safe range I get reliable results counting steps confirming that the sensor is accurate enough to detect a single one-third degree step.

Note: Be sure your needle is tight! Until I eliminated needle slippage, my results showed anomalous drifts both above and below the expected values.

Constant Speed Test

In this test the motor is turned at constant speed to identify the maximum constant speed that the motor will respond to. The speed is set by manipulating the motor accelleration table. I also recorded the total sweep time with the micros() function to determine the variation between the programmed inter-step time and the actual inter-step time.

The following table shows the results from the constant speed test. Each test was repeated 5 times. In each case the expected result was 500.

Delay μS	Test 1	Test 2	Test 3	Test 4	Test 5	Actual μS	Steps/Sec	°/S
500	4	-6	4	-6	4	509	1964	654
520	4	-6	4	-6	4	530	1886	628
540	2	-4	2	-4	2	549	1821	607
560	2	-4	2	-5	5	568	1760	586
580	2	-4	2	-4	2	589	1697	565
600	9	2	7	-4	2	610	1639	546
620	500	506	500	9	2	630	1587	529
640	500	500	500	500	500	649	1540	513
660	500	500	500	500	500	668	1497	499
680	500	500	500	500	500	691	1447	482
700	500	500	500	500	500	711	1406	468
720	500	500	500	500	500	729	1371	457
740	500	500	500	500	500	749	1335	445
760	500	500	500	500	500	771	1297	432
780	500	500	500	500	500	791	1264	421
800	500	500	500	500	500	810	1234	411

Results

The results show that with a programmed step period 600μS or less the motor could not advance with each step - and in fact often moved backwards. At 620μS the results were unreliable, and at 640μS and above the motor behaved reliably.

The actual inter-step delay was 8 to 11 μS more than the programmed delay.

Observations

I compared my results with the VID29 data sheet which states rather confusingly that “The angular speed can reach more than 500Hz” (presumably they mean °/S, not Hz?), and elsewhere that the maximum driving frequency is 600Hz (I can’t make any sense of that). The ~10μS difference between programmed delay and measured delay gives a useful measure of the error of the timing logic in the SwitecX25 library.

In setting up this test I discovered a bug in the SwitecX25 library: the library does not enforce a timing delay between the last signal change before stopping, and the first signal change after starting. This only exhibits if the motor is stopped and immediately restarted (within ~600μS). Because the two signals come too close together, the step may be missed. This leaves the motor out of phase with the libraries state map, and it appears the motor then misses 5 more steps before it gets back into phase, so this error shows as a 6-step error.

Test Code

Here’s the full source code for this test.

Making Wiring Harnesses

Wed, 04 Apr 2012 13:05:00 +1000

A quick note about wiring harnesses for these motors. I’ve found it really handy to make harnesses from 4-wire CD audio cables. My harnesses use push-on connectors at the motor end so I never accidentally cook the motor by soldering to the motor pins.

The cables I’m talking about have 4-pin JST connectors on each end, and are used to connect the analog audio signal from a PC’s internal CD player to the motherboard or sound card. I have accumulated a bunch of these over the years, so I’m glad to have a use for them.

I also use 0.1” breakaway headers and heatshrink tubing, both from AdaFruit.

Chop the audio cable in half (each half makes one wiring harness),
Strip and tin the wires on the cut end,
Cut off a 4-pin section of breakaway header,
Solder the wires to the header with the two black wires in the center positions,
Protect the connections with heat-shrink tubing.

Pull up the plastic tabs on the JST connector and slide the crimped terminator out of the block,
Use pliers to close the crimp connectors a little, but don’t crush them entirely. The pins on the Switec motors are really small, so you need to squeeze it down a little to create a tight fit.

You’ll notice that these harnesses have two black wires, which would normally be a bit annoying. However it turns out that the wires to pins 2 and 3 on the Switec motors are interchangable so you don’t need to distinguish between them.

Wire your motor up like this:

Motor Pin	Wire Color	Arduino Pin
1	white	4
2	black	5
3	black	6
4	red	7

Be careful not to bend the pins on the motors when you slide the crimp connectors on. Also note that the pins on the motor are flat, not round, so the orientation of the crimp connector matters; if it is too tight or too lose, try rotating the connector 90 degrees.

Finally, if you plug the header into an Arduino so that white is at pin 4, and red is pin 7, you can define your motor in code like this:

SwitecX25 motor1(MOTOR_STEPS, 4,5,6,7);

Pulling Out All The Stops

Wed, 04 Apr 2012 09:58:00 +1000

Or more accurately, filing off the stops.

Recently Tim Hirzel asked if I knew of a source of motors without stops, or if the X25.168’s could be modified to remove the stops and open up the full 360 degrees of rotation.

Good question! The X25 Series Buyers Guide lists 6 models of motors without stops, but a quick search turned up no suppliers selling these in small volumes.

Okay, time to figure out if the stops can be removed. Note that I’m working on a VID-29 clone, not a genuine Switec X25.168 here. There are 4 tiny screws that open the case revealing this:

The drive-shaft and attached gear sit loose and can be lifted out. Flipping the gear over reveals the mechanism for the stop; a raised trapezoidal bump on the gear face that stops against a matching protrusion at the bottom of the case.

I cut off the stop with a Stanley knife, and filed it flat with a small file.

Reassembly was easy, and bugger me, it works.

In the video you can see the needle hesitates on each rotation. This is because of the acceleration/deceleration logic in the SwitecX25 library; I’m accelerating the motor from stop, spinning 360 degrees, decelerating to a stop again, then repeating, using code like this:

          for (int i=0;i<nLoops;i++) {
            motor->currentStep = 0;    
            motor->setPosition(360*3);
            while (!motor->stopped) motor->update();
          }

To keep the speed constant I need to prevent it coming to a stop. I can do that by resetting the origin and destination before it reaches its goal step, like this:

          for (int i=0;i<nLoops;i++) {
            motor->currentStep = 0;         // reset origin on each rotation
            motor->setPosition(320*3*2);    // set target to way past end of rotation
            while (motor->currentStep<360*3) motor->update();  // turn until rotation is complete
          }

Or to run the motor in reverse:

          for (int i=0;i<nLoops;i++) {
            motor->currentStep = 360*3*2;
            motor->setPosition(0);
            while (motor->currentStep>360*3) motor->update();
          }

I think the SwitecX25 library will need some extensions to support stop-less motors… need to think about that a bit.

A Better Backlight

Thu, 22 Mar 2012 11:18:00 +1000

For the second gauge in this build, I tried to get better placement of the current-limiting resistor. By placing it tight in the corner, it wont cast a shadow.

These photos show the LEDs at 100% brightness, but they are on PWM pins so I can control the intensity from the Arduino code.

It is subtle, but in the next photo you can see the difference between the first and second gauge. The right-most gauge has a dark spot between 30 and 40. It’s fine, and the light spread isn’t that even anyway, so I’m going to call it ‘character’.

The mounting panel is made from salvaged hardwood fence pickets. It’s red stringybark, very hard and with nice colour and grain definition.

I’ve wired the 3-position switch to control “off”, “on” and “on with backlight”.

Using the SwitecX25 Library

Thu, 16 Feb 2012 18:04:00 +1000

Getting Started with the SwitecX25 Library

For Arduino IDE version 1.0 and later you can store user-contributed libraries in a subdirectory of your sketch directory named ‘libraries’. In fact you really should install them there to ensure that they persist when you upgrade the IDE.

So figure out where your project directory is (under OSX this is available in the Arduino -> Preferences menu), create a subdirectory called libraries with the project directory. The name is important, so use exactly that. Then inside that libraries directory checkout the SwitecX25 library. You should end up with this structure:

libraries
  |
  +-- SwitecX25
     |
     +-- SwitecX25.cpp
         SwitecX25.h

There is also an examples directory under that, but those two files are the critical parts of the library.

Restart the IDE and you should see the library in your Sketch -> Import Library menu. It appears in a separate section at the bottom marked contributed. Now start a new sketch. Here’s a minimum Hello World sketch for the Switec X25 that runs the motor against the zero stop then moves the motor to the center of its range.

#include <SwitecX25.h>

// standard X25.168 range 315 degrees at 1/3 degree steps
#define STEPS (315*3)

// For motors connected to pins 3,4,5,6
SwitecX25 motor1(STEPS,3,4,5,6);

void setup(void)
{
  // run the motor against the stops
  motor1.zero();
  // start moving towards the center of the range
  motor1.setPosition(STEPS/2);
}

void loop(void)
{
  // the motor only moves when you call update
  motor1.update();
}

I’ve added this little sketch to the library as an example, so it will appear as File -> Examples -> SwitecX25 -> center.

LED Gauge Backlighting

Sat, 11 Feb 2012 17:14:00 +1000

Today I added an LED backlight to my square gauge. I really like how light leaks from the grills at the top and bottom of gauge.

I decided not to use RGB LEDs in this build due to size and pin-count constraints. The white LED was originally part of a solar-powered LED light string.

These are side-emitting LEDs by virtue of a conical indent in the tip of the lens that refracts much of the light sideways. I tried grinding back the lens and using blobs of hot-glue to make the lighting more diffuse, but in the end I wasn’t convinced it was an improvement, and so the simpler design won out.

I soldered the 330Ω current-limiting resistor to the LED. I trimmed the leads on the LED and resistor really short to get it all to fit. I would have liked the resistor tight against the wall to prevent a dark spot, but it didn’t work out that way.

The holes for the connection wires had to be drilled right in the extreme inner corner to avoid the stepper motor on the back. The cathode wire goes to a PWM pin on the Arduino, and the anode to ground. I recently added LED control options to the Gaugette software to control the brightness.

ZOMG, now this gauge totally looks like the helmets worn by the Viper pilots in the original 80’s Battlestar Galactica series!

Just a Pretty Face

Mon, 06 Feb 2012 17:33:00 +1000

I made dial faces for a couple of the square gauges built in Build Number One. Nearly ready to install these guys.

Laying out the line-work on the square faces presents an interesting challenge. I decided to generate the bare line-work programmatically with a ruby script, and add the labels later with a graphics tool.

My first attempt at the script used the GD2 library, but GD2 doesn’t seem to support anti-aliasing or line-caps and the resulting line-work was just too damned ugly. I switched to Cairo which makes pretty, pretty lines. A revelation at this point was that I could use Cairo’s clipping operator to trim the graticule lines and remove the messy trig I was coding to figure out line intersections and stroke lengths. Finally I imported the generated image into OpenOffice to add the text labels.

So what to print on? On a recent trip to Cairns I looked in Officeworks for ideas. I didn’t find any card stock I liked, but I did find some 120 gsm paper (Quill brand “Metallique” in Mother of Pearl) with a cool metallic / opalesque finish. 120 gsm is heavier than standard typing paper, and maybe barely stiff enough to support itself in the gauge. Over time it might curl or slump in the varying humidity here in the tropics. There is just enough drive shaft length to place the paper over the original dial plate so that the needle just clears the face, but if the paper will support itself I could backlight it with an LED which might look nice in the dark.

One thing that had me stuffed is how to punch a neat hole in the paper for the drive shaft. A standard hole-punch makes big holes and can’t reach far enough from the edge of the paper. Drilling would leave messy edges. Scouring the aisles at Officeworks I found a set of three eyelet setters from Fiskars in the scrap-booking section. The hole punches use a crazy spring-driven hammer mechanism, so you can position them anywhere on the page, pull back the hammer, and smack, you have a hole. I reckon I want a 3mm hole, and the middle size is 3.2mm (1/8”). The downside is the set of 3 cost about $25. Anyway they work a treat and now I have some crafty hole punches.

I tried printing the dials with an ink-jet. That seemed okay until I mounted it in the gauge and I found that at certain angles the metallic finish on the paper made the line-work look really washed out. Redoing the printing with a laser printer gave much better results.

After installing the new face I calibrated it carefully and found a discrepancy between the printed face and needle position that I can’t explain. If I line up zero precisely, then at full-scale (230 degrees sweep) I find the needle is about 2 degrees short of the 100% mark on the dial. I’m not sure what the source of error is - presumably just measurement and positioning errors - but it is easily solved by changing the stepper motor sweep from 690 steps to 696 steps to full-scale deflection.

Separation Anxiety

Sat, 04 Feb 2012 11:38:00 +1000

I’ve separated the Switec X25 motor driver code into a separate library repository on GitHub. This will make it easier to use the driver library in other applications.

SwitecX25 Library

This contains only the Switec X25 driver.

Gaugette

This is an arduino application that controls analog gauges by interpreting commands received over the serial interface. To compile Gaugette you will now need to add the SwitecX25 library to your Arduino libraries folder.