Late 2006 MacBook Pro, MacBook Air SuperDrive, VMWare Fusion and 32-bit Windows XP

The basic gist is that they don’t play well together out of the box. You can make them work if you’re willing to do a bit of fiddling and if you’re not afraid of the OS X command line.

The first problem is that Apple decided that the new MBA SuperDrives should only be used in MacBooks that didn’t come with a factory-installed optical drive. You’ll actually encounter two different issues

The first has to do with whether the MBP will actually recognize the drive. You can solve that issue by following the instructions at Use the Apple external SuperDrive on (almost) any Mac. In a nutshell, you need to edit /Library/Preferences/SystemConfiguration/ and set the empty element to mbasd=1. The file should now look like this:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "">
<plist version="1.0">
<key>Kernel Flags</key>

If your version of the file already has text between <string> and </string>, insert a space after the existing text, then insert mbasd=1.

and the other has to do with whether you can use it to play a DVD.

Arduino Series: Working With An Optical Encoder

The Goal

I have an old White 1602 knitting machine that uses a light scanner to produce patterns in the knit fabric. The bed of the knitting machine syncs up with the controller via two obsolete rotary encoders and the stitch patterns are produced as a sequence of pulses causes specific needles to be selected.

The first problem is that the light scanner has a lot of mechanical parts that have deteriorated with age. Parts are no longer available.

The second problem is that the width of the pattern is constrained by the width of the mylar that feeds into the light scanner to product the pattern.

The third problem is that while the light scanner does its job well when it’s functioning, all of its capabilities could be performed more efficiently and accurately by a computer.

My goal is to completely replace the light scanner with newer technology. This post illustrates a prototype for how I might use an optical coder to track the position of the knitting carriage as well as when it changes direction.


Arduino Mega 2560 R2
US Digital Optical Encoder S1-1250-I
4 male-to-female jumpers
Electrical tape

About The Encoder

While obsolete, the S1-1250-I encoder is a very capable piece of hardware, but much more expensive than what’s available on today’s market. I used it because I already had one, but the information presented in this post should work with any rotary quadrature encoder. I’ll most likely replace the US Digital with a SparkFun’s COM-11102 1024 P/R Quadrature Encoder I have on order.

About The Approach

There are basically two ways to interface with the encoder: polling and interrupts. A little project I’m playing with will require a considerable amount of accuracy, so I chose to use interrupts as polling might result in missed pulses.


The encoder has 3 outputs: channel A, channel B and index. We’re not going to use index, so we need to make 4 connections — one for each of the two channels, one for power and one for ground. The encoder has raw wires so we need to add pins in order to attach it to the Arduino.

  1. Make sure the Arduino is powered off.
  2. Strip 1/4″ – 3/8″ of insulation from the encoder’s leads for power, ground, channel A and channel B.
  3. Insert the end of each wire into the female end of a jumper and secure with electrical tape.
  4. Connect the power lead to the 5V power pin.
  5. Connect the ground lead to one of the Arduino’s ground pins.
  6. Connect the channel A lead to digital pin 20. This pin is one of the 6 Arduino pins that support interrupts. The other pins with interrupts are 2, 3, 18, 19 and 21.
  7. Connect the channel B lead to digital pin 17.

The Code


Author:    Brenda A Bell


#define ENCODER0PINA         20      // this pin needs to support interrupts
#define ENCODER0PINB         17      // no interrupt required
#define CPR                  1250    // encoder cycles per revolution
#define CLOCKWISE            1       // direction constant
#define COUNTER_CLOCKWISE    2       // direction constant

// variables modified by interrupt handler must be declared as volatile
volatile long encoder0Position = 0;
volatile long interruptsReceived = 0;

// track direction: 0 = counter-clockwise; 1 = clockwise
short currentDirection = CLOCKWISE;

// track last position so we know whether it's worth printing new output
long previousPosition = 0;

void setup()

  // inputs

  // interrupts
  attachInterrupt(3, onInterrupt, RISING);

  // enable diagnostic output
  Serial.begin (9600);

void loop()
  // only display position info if has changed
  if (encoder0Position != previousPosition )
    Serial.print(encoder0Position, DEC);
    Serial.print(currentDirection == CLOCKWISE ? "clockwise" : "counter-clockwise");
    Serial.println(interruptsReceived, DEC);
    previousPosition = encoder0Position;

// interrupt function needs to do as little as possible
void onInterrupt()
  // read both inputs
  int a = digitalRead(ENCODER0PINA);
  int b = digitalRead(ENCODER0PINB);

  if (a == b )
    // b is leading a (counter-clockwise)
    currentDirection = COUNTER_CLOCKWISE;
    // a is leading b (clockwise)
    currentDirection = CLOCKWISE;

  // track 0 to 1249
  encoder0Position = encoder0Position % CPR;

  // track the number of interrupts

How It Works

Lines 8 – 12 define a few useful constants to make the code more readable. What they do should be obvious from the comments.

Lines 15 – 16 define global variables that will be modified by the interrupt handler.

Line 19 & 22 define other global variables we’ll use inside the Arduino loop.

The setup() function on line 24 configures our channel A and channel B pins for input, attaches an interrupt handler to channel A’s pin and configures the serial port so we can see some diagnostic output. Note that we’re going to interrupt on a rising state change so we know that the state of channel A will always be high when our interrupt is triggered. Using a rising or falling interrupt means:

  • We always know the state of A without having to perform a read: A is always high in a rising interrupt and always low in a falling interrupt.
  • Since we always know the starting state of A, we only have to test the state of B to determine direction and track the current position.

The Arduino loop() function on line 40 does nothing more than print some diagnostic information about what we’re reading from the encoder. To avoid chatter, the loop is tracking current values against previous values to we don’t print information we’ve already seen.

The interrupt handler on line 55 does all the heavy lifting:

  • When the encoder is moving in one direction, the pulse from channel A is leading the pulse from channel B. When the encoder is moving in the other direction, the pulses are reversed.
  • When the state of A and B are equal, B must be leading A, so the encoder is turning counter-clockwise. Otherwise, A is leading B, so the encoder is turning clockwise. Remember when we configured our interrupt to fire on rising? The state of channel A will always be high, so we only need to check the state of channel B to determine direction.
  • By comparing A to B instead of hard-coded constants, we can change the interrupt between rising and falling without breaking the interrupt handler.

The code on line 75 keeps the counter within the range 0 to 1249. This would allow us to compute angle or synchronize the position of the encoder to some other device.

The code on line 78 is an extra bit of diagnostic info we can use to track how many times our interrupt has fired.

Further Discussion

It’s much easier to understand how the interrupt handler works if you understand what’s happening when you turn the encoder shaft and reverse direction.

When you turn the encoder’s  shaft clockwise, A is leading B. This results in 4 distinct transitions that are repeated over and over as long as the shaft continues rotating in the same direction.


What’s important is this:

  • The inputs are latched, meaning that when we read B’s value from A’s interrupt handler the value we get is B’s state as it existed at the time the interrupt handler was fired. 
  • The handler is fired when A goes high.
  • When the shaft is turning clockwise, the handler is fired between the first two transitions —before B goes high — so we know the shaft is rotating clockwise when A is high and B is low.

If the shaft is turning clockwise and you stop turning, A remains high and B remains low.

If the shaft then starts turning counter-clockwise, B is leading A. This means that B has to go high before A’s interrupt fires again. Therefore, when both A and B are high, the shaft must be turning counter-clockwise.

Some makers may be inclined to use interrupts on both A and B. Unless you have an application where you absolutely must perform some action between A and B going high in both directions, the second interrupt is completely unnecessary. Interrupts are an expensive, limited resource so it’s wise to only use them when you need them.


Texas puppy makes good

Recognize this puppy?


Of course not. This was taken before he made himself famous by winning Best of Breed at Westminster yesterday.

Way to go Patton! Just always remember who your friends are, dude.

Machine Knit Leg Warmers / Boot Toppers

Tomorrow is New Year’s Day. No commitments, have lots of time of knit, looking forward to doing the first project of the year and the forecast high for Thursday is 10 degrees. It’s a perfect time to whip up a pair of leg warmers. These were knit flat on a Brother KH860 with KR850 ribber using Franklin Sock Yarn from Valley Yarns.


Stockinette: 31 stitches x 40 rows = 4″/10cm
Finished Size:
Ankle: 7 1/2″
Cuff: 10 1/2″
Total Length: 14″

Cast On

Disconnect ribber carriage and position it on the left.
Position main carriage with ribber arm on the right.
Set pitch lever to H and rack to position 5.
Set up for industrial rib with edge pairs on the main bed (see note 1): 36L – 35R on the main bed, 35L – 33R on the ribber. Pull one extra ribber needle (35R) to WP to round off the zig-zag row.
Pull ribber needles a little higher than WP and make sure all latches are open. The tips of the ribber needles should be even with the main bed’s gate posts. Main bed needles should be in WP.
Thread the main carriage leaving long tail for seam, set the tension to T0 and RC = 0.
Rack to position 6. Knit from right to left with the main carriage only.
Carefully push the ribber needles back to WP. Make sure the floats that passed over the ribber needles are caught in the needle hooks.
Hang the ribber comb and weights (see note 2).
Connect the ribber carriage and set the carriages to knit circular:  depress the left part button on the main carriage and set the ribber’s right cam lever  to PR.
Set the tension on both carriages to T1. Knit 2 rows, ending COL RC=3.
Transfer the extra ribber stitch on 35R to 34R on the main bed.
Set the tension on both carriages to T2. Knit 1 more row, ending COR RC = 4.

Ribbed Ankle

Set both carriages to knit: release the part button on the main carriage and set the ribber’s right cam lever to N).
Set the tension on both carriages to T5.
Rack to position 5.
Knit 21 rows, ending COL RC = 25.
Transfer the left stitch of each pair of ribber stitches to the corresponding empty main bed needle (see note 3).
Knit 1 row, ending COR RC = 26.
Set pitch lever to P.
Transfer the remaining stitches from the ribber to the corresponding needle on the main bed. There will be two stitches on these needles.


Drop ribber bed, remove ribber arm and attach normal sinker plate.
Set RC = 0.
Knit 1 row.
* Increase 1 stitch each side.
Knit 4 rows.
Increase 1 stitch each side.
Knit 5 rows. **
Repeat from * to ** 10 more times RC = 100 (58L – 57R).
Increase 1 stitch each side (59L – 58R).
Knit 1 rows RC = 101.

Ribbed Cuff

Set pitch lever to P and rack to position 5.
Transfer pairs of stitches from main bed to ribber for industrial rib 59L – 57R (see note 4). On right hand side, put two stitches on 56R and edge stitch on 57R. On main bed, there will be one stitch every 3rd needle from 57L – 55R.
Transfer heel of each main bed stitch right one needle needle to complete industrial rib setup.
Set pitch lever to H.
Set RC = 0.
Knit 44 rows and bind off.


With right side facing, seam ankle rib and leg.
Turn inside out and continue seaming cuff.


  1. Placing the edge stitches on the main bed means there will be one knit stitch on either side of the ankle seam.
  2. On my Brother, the two beds are close enough that getting the ribber comb and thick industrial rib to hang freely is problematic. I get around that issue by pulling up on the bracket levers and pushing down on the ribber bed to position it slightly lower than normal.
  3. I find that transferring both stitches from the ribber to the main bed at the same time creates a little bump on the inside of the knit that I don’t like. Transferring half the stitches on one row and the other half on a separate row eliminates the bump.
  4. Similar to the ankle rib, placing the edge stitches on the ribber means there will be one knit stitch on either side of the cuff seam. This is a turn-down cuff, so the side facing is the side that will be showing.

Holiday Leftovers: HoneyBaked Ham & Bean Soup


Bone from HoneyBaked ham (fat and scraps in tact)
1 pound bag of dried mixed beans
12 cups water
1 T garlic powder
1 T dried onion flakes
2 T cajun seasoning
2 T Superior Touch Better Than Bouillon Vegetable Base
1-2 cups diced onions and carrots
1-2 cups diced ham


Soak beans in room temperature water for 24 hours. Don’t attempt to cheat with the hot water method. It’s not the same.

Place the beans, water, ham bone, water, spices and vegetable base in a large crock pot. Cook on low for 4 hours.

Add the onions and carrots. Continue cooking on low for another hour.

Add the diced ham and cook on low for one more hour.