Following Maker Faire, we’ve had a few days to poke around with Digilent’s 32-bit Arduino-compatible chipKIT boards and compiler. We have some initial performance figures to report, along with impressions of the hardware and software.

Disclaimer: Digilent has provided Hack a Day with Uno32 and Max32 boards for evaluation.

chipKIT isn’t the first attempt to extend the Arduino form factor to a 32-bit microcontroller core…other products such as Maple, Netduino or the FEZ Domino have been around for well over a year…but the chipKIT boards are notable for the effort Digilent has put into creating a seamless transition. The aim is to create a single unified tool both for traditional 8-bit Arduino boards and Digilent’s 32-bit work-alikes, where the same IDE, the same code, and a good number of the same shields can all work despite the different underlying architectures. In fact, they’re hoping the Arduino project accepts their integration method as an official means of adding new hardware to the Arduino IDE — not just for their own product, but for anyone else to use as well.

As noted in our prior report, we were impressed that they do appear to deliver on this promise. The transition between “classic” Arduinos and the 32-bit boards is indeed quite slick. But we’re finding at this early stage that there are still some rough bits to be worked out. So, for the time being, we’re keeping both the Arduino IDE and Mpide (Digilent’s multi-platform derivative) installed on the development system; the latter has not yet obviated the need for the former. But we see how the concept is supposed to work, and we like it.

For the most part, Mpide works as intended as a dual-platform IDE. Just select the appropriate device from the Tools->Board menu, recompile, and the code is now ready for the corresponding chip. But a couple things have bit us in the rear:

• The AVR compiler in Mpide either isn’t fully optimizing, or the floating-point libraries were built sans optimization or something. This threw off our benchmark numbers initially — the results were atrocious! In order to keep the numbers realistic, we’re using the standard Arduino IDE for the corresponding benchmarks. To be fair, they did warn us about this performance issue in person at Maker Faire, but until it’s fixed they could be more forthcoming about it with some documentation or on the web site…otherwise it could look like they’re trying to skew benchmarks more in their favor.
• The String() constructor is borked when handling integers. The following line compiles fine for AVR chips, but throws a tizzy fit with the PIC32 compiler:
  

  String foo = String(42);

Given that the IDE was wrapped up literally hours before going live online and at Maker Faire, it’s understandable that there are some loose ends. Just be prepared as an early adopter that this won’t be as pain-free a transition as they’re aiming for. The great thing with open source is that we can get in there, spot such problems, and offer suggestions and submit fixes…the situation will no doubt improve with time.

Some Benchmarks

We wanted to create a fractal demo similar to what they were displaying at Maker Faire. We didn’t have the spiffy SparkFun Color LCD Shield on hand, so instead we had to settle for a serial LCD, 4D Systems’ uLCD-144. This does affect the numbers somewhat, as we’ll see.

In MIPS alone, the chipKIT should beat the Arduino by a factor of five. Then there’s the native 32-bit-ness of it: when dealing with larger numbers, the AVR processor at Arduino’s core has to shift and fiddle bits between consecutive 8-bit values in order to achieve 32-bit results. So the PIC32 should show a considerable performance benefit beyond MIPS alone. In practice, this doesn’t always pan out.

The uLCD-144 is a 128 by 128 pixel 16-bit color LCD with a serial UART interface running at 115,200 bits per second. The graphics commands aren’t terribly efficient, and it’s necessary to send a five byte packet for every pixel drawn. This includes coordinate data; there’s no block write function in serial mode. On the plus side, it’s easy to talk to using the Arduino or chipKIT’s native serial UART.

Here’s the code for the Mandelbrot sketch, using floating-point math:

/* Simple Mandelbrot set renderer for Arduino vs. chipKIT benchmarking
   w/floating-point math, via www.hackaday.com.  This example uses the
   4D Systems uLCD-144(SGC) serial display module, wired as follows:

      uLCD Pin:   RES  GND  RX  TX  VIN
   Arduino Pin:     2  GND   1   0   5V    */

const int
  pixelWidth  = 128,  // LCD dimensions
  pixelHeight = 128,
  iterations  = 255;  // Fractal iteration limit or 'dwell'
const float
  centerReal  = -0.6, // Image center point in complex plane
  centerImag  =  0.0,
  rangeReal   =  3.0, // Image coverage in complex plane
  rangeImag   =  3.0,
  startReal   = centerReal - rangeReal * 0.5,
  startImag   = centerImag + rangeImag * 0.5,
  incReal     = rangeReal / (float)pixelWidth,
  incImag     = rangeImag / (float)pixelHeight;

void setup()
{
  pinMode(13,OUTPUT);   // Arduino status LED
  pinMode(2,OUTPUT);    // LCD reset pin
  digitalWrite(13,LOW); // LED off
  Serial.begin(115200);

  digitalWrite(2,LOW);  // Reset LCD
  delay(10);
  digitalWrite(2,HIGH);
  delay(2000);          // Allow time for reset to complete

  Serial.write(0x55);   // Issue auto-baud command
  while(Serial.read() != 0x06); // Wait for ACK
}

void loop()
{
  unsigned char cmd[20];   // Serial packet for LCD commands
  int           x,y,n;
  float         a,b,a2,b2,posReal,posImag;
  long          startTime,elapsedTime;

  Serial.write(0x45);      // Clear screen
  delay(100);              // Brief pause, else 1st few pixels are lost

  cmd[0] = 0x50;           // 'Pixel' command is issued repeatedly

  digitalWrite(13,HIGH);   // LED on while rendering
  startTime = millis();

  posImag = startImag;
  for(y = 0; y < pixelHeight; y++) {
    cmd[2] = y;            // Y coordinate of pixel
    posReal = startReal;
    for(x = 0; x < pixelWidth; x++) {
      a = posReal;
      b = posImag;
      for(n = iterations; n > 0 ; n--) {
        a2 = a * a;
        b2 = b * b;
        if((a2 + b2) >= 4.0) break;
        b  = posImag + a * b * 2.0;
        a  = posReal + a2 - b2;
      }
      cmd[1] = x;          // X coordinate of pixel
      cmd[3] = n * 29;     // Pixel color MSB
      cmd[4] = n * 67;     // Pixel color LSB
      Serial.write(cmd,5); // Issue LCD command
      posReal += incReal;
    }
    posImag -= incImag;
  }

  elapsedTime = millis() - startTime;
  digitalWrite(13,LOW);    // LED off when done

  // Set text to opaque mode
  cmd[0] = 0x4f;
  cmd[1] = 0x01;
  Serial.write(cmd,2);

  // Seems the chipKIT libs don't yet handle the String(long)
  // constructor, hence this kludge.  Working backward, convert
  // each digit of elapsed time to a char, with " ms" at end
  // and text command at head.  Length is variable, so issue
  // command from final determined head position.
  cmd[19] = 0;
  cmd[18] = 's';
  cmd[17] = 'm';
  cmd[16] = ' ';
  n = 15;
  do {
    cmd[n--] = '0' + elapsedTime % 10;
    elapsedTime /= 10;
  } while(elapsedTime);
  cmd[n--] = 0xff; // Color LSB
  cmd[n--] = 0xff; // Color MSB
  cmd[n--] = 0;    // Use 5x7 font
  cmd[n--] = 0;    // Row
  cmd[n--] = 0;    // Column
  cmd[n] = 0x73;   // ASCII text command
  Serial.write(&cmd[n],20-n);

  delay(5000); // Stall a few seconds, then repeat
}

And the timing results, in milliseconds, for the Arduino (top) and chipKIT (bottom):

Arduino: 54,329 ms.
chipKIT: 12,417 ms.

To reiterate (pardon the pun), due to some performance issues we used the traditional Arduino compiler, not the one included in Mpide. If you’re curious, the output from that compiler took about 8.5 minutes to complete the task! Oof.

So, about a 4.4x speedup. Not bad, but we were expecting a more dramatic difference. Part of this is due to the inherent bottleneck of the serial communication with the LCD…we’ll get back to that in a moment. Another limiting factor is that both chips are emulating floating-point math. If we can use 32-bit integer data types, thePIC32 should really shine. So, a fixed-point Mandelbrot generator followed:

/* Simple Mandelbrot set renderer for Arduino vs. chipKIT benchmarking
   w/fixed-point math, via www.hackaday.com.  This example uses the
   4D Systems uLCD-144(SGC) serial display module, wired as follows:

      uLCD Pin:   RES  GND  RX  TX  VIN
   Arduino Pin:     2  GND   1   0   5V    */

const int
  bits        = 12,   // Fractional resolution
  pixelWidth  = 128,  // LCD dimensions
  pixelHeight = 128,
  iterations  = 255;  // Fractal iteration limit or 'dwell'
const float
  centerReal  = -0.6, // Image center point in complex plane
  centerImag  =  0.0,
  rangeReal   =  3.0, // Image coverage in complex plane
  rangeImag   =  3.0;
const long
  startReal   = (long)((centerReal - rangeReal * 0.5)   * (float)(1 << bits)),
  startImag   = (long)((centerImag + rangeImag * 0.5)   * (float)(1 << bits)),
  incReal     = (long)((rangeReal / (float)pixelWidth)  * (float)(1 << bits)),
  incImag     = (long)((rangeImag / (float)pixelHeight) * (float)(1 << bits));

void setup()
{
  pinMode(13,OUTPUT);   // Arduino status LED
  pinMode(2,OUTPUT);    // LCD reset pin
  digitalWrite(13,LOW); // LED off
  Serial.begin(115200);

  digitalWrite(2,LOW);  // Reset LCD
  delay(10);
  digitalWrite(2,HIGH);
  delay(2000);          // Allow time for reset to complete

  Serial.write(0x55);   // Issue auto-baud command
  while(Serial.read() != 0x06); // Wait for ACK
}

void loop()
{
  unsigned char cmd[20];   // Serial packet for LCD commands
  int           x,y,n;
  long          a,b,a2,b2,posReal,posImag,startTime,elapsedTime;

  Serial.write(0x45);      // Clear screen
  delay(100);              // Brief pause, else 1st few pixels are lost

  cmd[0] = 0x50;           // 'Pixel' command is issued repeatedly

  digitalWrite(13,HIGH);   // LED on while rendering
  startTime = millis();

  posImag = startImag;
  for(y = 0; y < pixelHeight; y++) {
    cmd[2] = y;            // Y coordinate of pixel
    posReal = startReal;
    for(x = 0; x < pixelWidth; x++) {
      a = posReal;
      b = posImag;
      for(n = iterations; n > 0 ; n--) {
        a2 = (a * a) >> bits;
        b2 = (b * b) >> bits;
        if((a2 + b2) >= (4 << bits)) break;
        b  = posImag + ((a * b) >> (bits - 1));
        a  = posReal + a2 - b2;
      }
      cmd[1] = x;          // X coordinate of pixel
      cmd[3] = n * 29;     // Pixel color MSB
      cmd[4] = n * 67;     // Pixel color LSB
      Serial.write(cmd,5); // Issue LCD command
      posReal += incReal;
    }
    posImag -= incImag;
  }

  elapsedTime = millis() - startTime;
  digitalWrite(13,LOW);    // LED off when done

  // Set text to opaque mode
  cmd[0] = 0x4f;
  cmd[1] = 0x01;
  Serial.write(cmd,2);

  // Seems the chipKIT libs don't yet handle the String(long)
  // constructor, hence this kludge.  Working backward, convert
  // each digit of elapsed time to a char, with " ms" at end
  // and text command at head.  Length is variable, so issue
  // command from final determined head position.
  cmd[19] = 0;
  cmd[18] = 's';
  cmd[17] = 'm';
  cmd[16] = ' ';
  n = 15;
  do {
    cmd[n--] = '0' + elapsedTime % 10;
    elapsedTime /= 10;
  } while(elapsedTime);
  cmd[n--] = 0xff; // Color LSB
  cmd[n--] = 0xff; // Color MSB
  cmd[n--] = 0;    // Use 5x7 font
  cmd[n--] = 0;    // Row
  cmd[n--] = 0;    // Column
  cmd[n] = 0x73;   // ASCII text command
  Serial.write(&cmd[n],20-n);

  delay(5000); // Stall a few seconds, then repeat
}

And the numbers:

Arduino: 27,734 ms.
chipKIT:  7,209 ms.

Now only a 3.8x difference, despite the PIC32 speaking its native tongue. What gives?

Even at 115,200 bits/sec, the serial LCD is seriously holding us back, as the code is going to “block” as each character is output. Some back-of-envelope calculations suggest how much time is being lost there:

128 x 128 pixels, 5-byte command per pixel = 81,920 bytes.
Including start and stop bits for each byte = 819,200 bits total
819,200 bits / 115,200 bps = ~7.1 seconds.

So our MCU is sitting there for seven seconds with its thumb up its ASCII in order to update the display. Sure enough, if we comment out the Serial.write() command but leave all the calculations in place, the results are significantly more dramatic:

Floating-point:

Arduino: 49,685 ms.
chipKIT:  5,822 ms.
9.3x improvement.

Fixed-point:

Arduino: 22,326 ms.
chipKIT:    168 ms
133x improvement. Hot damn. Now we’re talking!

So we could actually render this at interactive frame rates, for the want of a sufficiently fast interface to the LCD. This sort of limitation is going to crop up every time we connect to a real-world device. Not everything is 100% internal code and math…there are finite limits to I/O throughput, and that more than anything can cap the speed of the total application. So we really can’t give a consistent “Everything will be X percent faster” estimate for this board.

The performance looks good for math, especially if an algorithm can work in integer or fixed-point formats. Another thought we had was analog-to-digital sampling, which has applications in robotics…say for a line-follower or balancing robot. More frequent samples should yield smoother operation, or multiple samples can be averaged to yield higher-precision results. The PIC32 should scream in that regard. And yet…

void setup()
{
  const int samples = 10000;
  int       i,n;
  long      startTime,elapsedTime;

  Serial.begin(115200);

  startTime = millis();
  for(i = 0; i < samples; i++) {
    n = analogRead(0);
  }
  elapsedTime = millis() - startTime;

  Serial.print(samples);
  Serial.print(" samples in ");
  Serial.print(elapsedTime);
  Serial.print(" ms = ");
  Serial.print(((float)samples * 1000.0) / (float)elapsedTime);
  Serial.println(" samples/sec");
}

void loop()
{
}

Arduino: 10000 samples in 1119 ms = 8936.55 samples/sec
chipKIT: 10000 samples in 1008 ms = 9920.63 samples/sec

Running full-tilt, the PIC32 is capable of up to 1 million ADC samples per second, compared to 125,000 on the Atmel chip. Certainly the library implementation is going to introduce some overhead, but what gives? Rooting through the library source code turns up this gem in wiring_analog.c:

 //*     A delay is needed for the the ADC start up time
 //*     this value started out at 1 millisecond, I dont know how long it needs to be
 //*     99 uSecs will give us the same approximate sampling rate as the AVR chip
 //      delay(1);
 delayMicroseconds(99);

This raises a couple of red flags. First, why should the sampling rate aim to match the AVR? For time-related functions like delay() and for Serial.begin() bitrates, of course we’d want similar numbers, those relate to temporal increments. But we don’t — or at least shouldn’t — measure time with ADC readings. And secondly, well, why not find out how long the ADC startup time really needs to be? A few minutes’ sifting through Microchip datasheets eventually turned up the correct answer: two microseconds. So, changing the line in wiring_analog.c to:

delayMicroseconds(2);

Yields dramatically different results:

chipKIT: 10000 samples in 101 ms = 99009.90 samples/sec

About a tenfold improvement, and the readings still look valid. This does break like-timing compatibility with the AVR-based Arduinos, but as we said, why? It’s understandable that some decisions may have been made in haste…it’s a monumental project, getting all this code ported to an entirely different chip, and the IDE is still fresh from the oven…but some of these little broken details do have us concerned about what other surprises may still lurk beneath.

Don’t get us wrong…we’re enthusiastic about the chipKIT boards. The technical challenge is met, and just needs some cleaning up. What remains for Digilent now is a marketing challenge: who is this really for? When we talk about things like megasamples and fixed-point algorithms, these aren’t exactly day-one topics familiar to the Arduino’s target audience of first-time programmers. And the more advanced user may have moved on already, leaving Arduino behind. So why keep this form factor? Why keep this IDE?

Obviously, part of the allure is the existing ecosystem of Arduino shields. There’s some pretty nifty stuff out there, networking and touch screens and stepper motor drivers, most of which will physically plug right in. Having an existing solution saves development time. Then there’s the ease and familiarity of the Arduino libraries. Even though they’re slow and clunky in places, it can be really handy sometimes just to squirt out some status information to a serial port without having to do all the UART setup manually.

The chipKIT boards are cleverly priced to approximate Arduino on a cost basis (even undercutting a bit). That’s a great start, with code and price parity, but where’s the extra value? What the Uno32 and Max32 may need are some killer apps. Ideas that the novice can implement, but that really take advantage of the PIC32 chip’s added performance and capabilities. Speed may be just one part of that. What can we do with the extra RAM and flash space that a normal Arduino just can’t handle, even with the fanciest of shields? Folks have done some mind-blowing stuff with the little 8-bit AVR. We’re looking forward to seeing if this is the tool that takes these hacks to the next level.

At the beginning of the Month we came across a coupon code for a free eZ430-F2013 development stick. TI has given these things now and again so we took the opportunity to acquire one. It arrived yesterday and we’ve spent just a bit of time looking it over. Above you can see the first project completed; Hello World on a salvaged Nokia cell phone screen. Join us after the break for our thoughts on the device, as well as more pictures and details.

The development board comes as a USB dongle. But this isn’t the extent of the packaging. It came in a DVD case, along with a CD that has User’s Guides and “web resources” on it. We don’t need this, but okay. But wait, that’s not how it shipped. The DVD case came inside of a 9″x9″x10.5″ box that was shipped priority overnight via FedEx. That seems a bit wasteful, especially considering that we didn’t pay a dime for the hardware or the delivery. A manila envelope would have sufficed, but if it’s free we don’t get to make the decisions about this stuff.

Inside you’ll find the mainboard with a USB connector that makes up the programmer itself. The hind-end is small detachable board that hosts the F2013 microcontroller. The case was a bit finicky to remove but a little bit of prying does the trick.

0451:f430 Texas Instruments, Inc. MSP-FET430UIF JTAG Tool

When plugged in an LED on the daughter board happily blinks away as the example firmware intended. We were pleased to see that dongle was recognized by Ubuntu 10.04 as a UIF device that MSPdebug, the software we used to program with the Launchpad, can talk to. Time to make this little guy do something.

Here’s the microcontroller board. Note the small-pitch 4-pin socket for connecting to the programmer board. Also note the unpopulated 0.1″ pitch pads.

Here’s the underside of that board after adding two 7×1 pin sockets. This is where we discovered a nice design consideration. Since we didn’t have any IDC sockets that are this large (to plug into a pin header on is board) we went with the pin socket and will just insert jumper wires. Now that they’re installed we realized that the pin-out from the bottom is the same as the chip would be from the top; pin 1 in the upper left and pin 14 in the upper right. Time to hook this up to something and start coding.

We pulled out an old Nokia 3595 LCD screen that we’ve used in the past because it uses 3.3V which is the upper end for this chip. Porting the code over was a snap since it was already used with another MSP430 chip. A few minutes later out pops ‘Hello World’. To review: it was free, works with Linux tools, and it seems like the code works across several different chips. Win!

Our Thoughts on the Hardware

So what do we think about this as a development package? If it’s free, great! We’re a little baffled because it seems to be disposable hardware. No thought has gone into using the programmer for anything other than TI’s daughter boards that have the fine pitch connector. We’ll most likely end up gluing a pin header to the plastic case and soldering those pins to the proper connections to make this more robust. We do get the feeling that one hand doesn’t know what the other’s doing over there because the Launchpad feels like superior hardware. That being said, neither of the development boards have made it easy to program and debug off-board so for now we consider both of these as novelties.

You do have to give them credit though, by giving it away for free we now have an MSP430 chip already on hand for the next time we’re prototyping a small project. And this might be just the thing to use the 1.8V serial EEPROM we ordered a few years back thinking we were getting the 5V version.

Resources

It’s nothing special, and probably of no use to anyone, but here’s the git repository for the hello world code.

Follow Me

@szczys

At the Bay Area Maker Faire this past May, we had our first glimpse of Wild Planet’s Spy Video TRAKR, a $130 radio-controlled toy with some surprises under the hood.

On the surface, the Spy Video TRAKR — the latest addition to the popular Spy Gear toy line — is an R/C tank with a video camera and night vision, with the added ability to download new “apps” from the internet for extra functions. With a little detective work, one uncovers the TRAKR’s secret double life: it’s also an eminently hackable robotics platform! Prior Spy Gear toys have been popular hack targets, providing inexpensive, mass-produced sources of unusual items such as head-mounted displays. Rather than throw up barriers, Wild Planet has chosen to embrace this secondary market, with plans to release development tools and documentation making it possible to extend the device’s capabilities.

Read on for our image-heavy unboxing and initial impressions.

The packaging is outwardly consumer-oriented — this is, first and foremost, a kids toy after all — and the “USB Connected” and “Download & Build Custom Apps” labels are about as technical as it gets on the outside.

Batteries not included. You’ll need plenty. And did you ever expect to see Linux mentioned by name on anything at Toys R Us? Awesome!

Internal packaging is minimalist and largely recyclable. No twist ties, no staples, no plastic bubbles, no registration cards or catalogs. Much appreciated! We’ve seen much smaller toys with far more gratuitous packaging, so this was a welcome relief.

The entire contents of the box are as follows:

The TRAKR vehicle is a stubby, squat tank, measuring about 10 inches wide and 7 inches long. Six AA cells install behind a cover on the underside of the unit. The total weight with alkaline cells is 1065 grams, or about 2 pounds 5 oz. Picks up easily with one hand.

The front of the TRAKR vehicle features a number of sensors. Left to right, these include: microphone (the white circle at the left), a presently-unused accessory connection port which appears to contain a bump switch, the color video camera and infrared LED for night vision, and speaker (larger white circle at the right). The camera can be pivoted from straight ahead to about 30 degrees upward, but there is no servo control of this function; it must be manually positioned.

With the transport deck removed we can see the ports on the back of the TRAKR: an SD card slot for storing photos and video (also SDHC compatible), the USB mini-B connector for attaching to a PC (or Mac, etc.), and a USB type A connector that currently serves no purpose, but might be related to future accessories (and hacks, of course).

When connected to a host computer, the TRAKR appears as a 1-megabyte FAT12 filesystem. New apps, downloaded from the Spy Video TRAKR web site, are installed by simply copying the corresponding .bin file to the APPs directory on this flash drive. It’s quite a bit like the mbed microcontroller in this regard. With the three factory apps pre-loaded, there’s about 900K free space remaining. Additionally, the TRAKR can function as an SD card reader when attached via USB.

The remote control unit is a bit over 5 inches high and wide. Four AA cells install behind a back cover, and the total weight is 392 grams, or about 13.5 oz. The size and heft of the controller is sufficiently comfortable for both young and adult hands. There are two single-axis sticks for driving the tank Battlezone-style, five buttons (one dedicated to the “home” function, the rest being app-specific), a power and volume switch, speaker, and a 1.75″ color LCD screen in the center. Though the sticks have an analog feel, in practice they appear to be simple non-proportional controls.

The LCD looks to be half-QVGA resolution (160×120). The video feed averages a good 15 frames per second over the device’s wireless (2.4 GHz, but not WiFi) connection.

Night vision is provided by a single 8mm near-infrared LED, with a range of about six feet.

The camera can also take QVGA (320×240) color stills, and half-QVGA (160×120) video, recorded to the SD card as JPEG and AVI, respectively. Here are some unprocessed stills directly from the memory card:

So that’s an overview of the TRAKR as it comes straight from the box. To do more, we begin by visiting the Spy Video TRAKR web site:

The “Download Apps” link currently leads to a list of about a dozen simple apps developed in-house:

None of the apps is particularly outstanding; they appear to be for illustrative purposes, each one demonstrating a single idea and not wanting to overwhelm the budding programmer. Most range from about 20 to 40 kilobytes.

Clicking an app name reveals more information — a description, download link for the compiled app, and also a source code link for us geeks. Unfortunately, that’s where the fun ends for now. “APP BUILDR,” the code editor and compiler which works online (again like the aforementioned mbed microcontroller), is not yet accessible:

NOOOOOOOOOOOO!

The Spy Video TRAKR was originally slated to ship this fall for the holiday shopping season. Wild Planet managed a great head start at getting the TRAKR into production and distribution — we have the toy in-hand and you can already find this at a number of retailers — but the software is still on its original schedule for an October release. We understand software timelines and are sympathetic to that reality, but this does mean there’s little sense of urgency if your main interest in the TRAKR was for programming. It can wait.

In the interim, we can start to deconstruct the development process with the small bits of information available. From Maker Faire, we do know that the TRAKR contains an ARM9 processor, and is programmed in C. And while the code editor isn’t yet online, we can follow the “Download Source” link for an app to retrieve its source code. Here’s an excerpt from one of the demonstration programs:

Indeed it’s C, with just a light wrapping of functions (e.g. Start() and Run() instead of a main() function). There’s clearly a Spy Video TRAKR-specific API (svt.h) for accessing hardware functionality like the TRAKR’s motors or the controller’s buttons and display, but documentation for this library isn’t available online yet.

At this point, we’re still dealing entirely with standard, as-advertised, out-of-the-box capabilities. The thing about the TRAKR that really made us stop and take notice at Maker Faire, the thing that has us genuinely enthusiastic about the product even though this article probably sounds like a total corporate shill by now (we approached them first, honest), has everything to do with the toy’s Easter egg:

It’s a sublime detail: the clear letters on the otherwise frosted cover just above the rear ports hint at intriguing stuff within. The cover is held on with just a couple of ordinary Phillips screws. Say, were you the sort of curious kid who’d dismantle their toys to see what makes them work? We thought so.

On the outside: the URL for the consumer. On the inside: the URL for the inquisitive. Just a fraction of an inch and a thin sheet of plastic apart. It’s absolutely brilliant, and there’s no mention of this on the packaging or the standard web site.

So — in addition to the standard app web site, a second web site (and sadly an equally unfinished one at this time) is planned to delve even deeper into the system’s inner workings. But even without this information, we can see hints of what’s ahead just by examining the board, which they’ve thoughtfully labeled. We can make out an unpopulated third USB port, an unpopulated switch connector, a breakout header that appears to have eight GPIO lines and one analog input, and a smaller breakout header for an SPI port of some sort (perhaps debugging).

Additionally, both the TRAKR and the remote control have switches and ports concealed under access panels:

The trim pots on the TRAKR are almost certainly for tuning the radio transceiver. The switches on both units are labeled “USB” for one position and “SPI” for the other, and this appears to be related to debugging or flash memory programming. Both switches ship in the “SPI” position.

With the growing popularity of the Android OS for smartphones, it has become a contender for the likes of Apple’s iPhone. With the rise of Android came the facet it revolves around; Open Source. Besides it revolving around being open sourced it also has deep roots with social media. There has been an outbreak of different Twitter applications for the Android devices, each with their ups and downs suited for different types of users ranging from the socialite to the power users of twitter. These are the top 5 Twitter clients for Android (A phone running Android 2.1 OS – Éclair – will be used but most of these will be compatible with 1.5 & 1.6 OS and will be stated if they are not available to all OS versions) :

1. Twitter for Android (Free)

This is the official application for accessing Twitter from your Android mobile device. Developed by Twitter themselves, it is the most comprehensive application on the market considering it was developed by the creators of Twitter. This has everything the average socialite would ever need as well as having the features Power Users will crave. Here are some of the pros and cons:

Pros:

Interface:

The interface of Twitter for Android is very crisp and concise for you to navigate to what they want quickly and efficiently. When first starting the app, you are presented with options of what they would like to do such as view tweets, lists, mentions, retweets, direct messages and view profile. It seems that the developers of Twitter for Android have taken a page out of Google’s handbook because load times are blazingly fast. The toolbar at the top of the application contains the ability to post updates to your page and to find certain tweets or people based on keyword and/or location. As well, the location map marker in the corner which will allow finding tweets closest to your location. It is also good to note that the Twitter logo at the top left of any screen will direct you back to the main menu.

Speed:

The loading times, as mentioned above, are quite fast. This is excellent for the user on the go who doesn’t want to wait around for the whole application to load before submitting a tweet. This may decrease on users with less RAM but not by much.

Trending Topics:

When navigating to twitters site a lot of trending topics appear. Bringing this feature to the mobile community and making it look good requires some finesse. Twitter for Android has been able to do this quite skilfully, having that little blue bird at the bottom of the main menu tweeting three changing trending topics around itself. This is quite innovative in itself because as of right now the UI for Android apps has been quite lacking but this goes to show that if you really dig into Android you can receive the same quality UI as an iPhone has in terms of apps.

Cons:

Availability:

Twitter for Android is only available for users with the 2.1 OS (Éclair) which will unfortunately leave out the fragmented versions of Cupcake (v1.5 OS) & Donut (v1.6 OS). This will be quite disappointing for most users out there since those versions lead in numbers (until updates are released).

1. HootSuite (Paid & Free)

   Price: US $2.99

This is the next best thing if users out there aren’t interested in an official application for Twitter. Hootsuite enables users to manage multiple Twitter accounts, as well as being a dashboard for many social media outlets. It contains the usual suspects; Facebook, MySpace, LinkedIn and Foursquare but also allows room for lesser used networks or hubs such as Ping.fm and WordPress (just added). Since being designed for the Android, HootSuite has trimmed down the interface and as of right now the user is able to only post tweets. This client is available to all versions of Android including the latest FroYo build. You should also note that the free version does not include stats and is limited to 3 accounts. Here is a look at the good and bad:

Pros:

Scheduling:

The ability to post tweets at certain points throughout the day without having to login to Twitter every time to do so is very desirable. If the user knows what they will be doing at a certain point throughout the day then scheduling updates for those times is a great way to not deter them from what they are doing. All that needs to be done is tap the top right button and click on the calendar button to schedule a date and time.

Statistics Tracking:

The greatest thing about HootSuite is the statistics tracking that is tightly integrated with the client. When on the main page, press the menu button and click on Stats to see the number of clicks per tweet you have made (accounting for the fact that you put a link in your post) as well as the rating of the tweet you made based on the number of clicks it has received. This is very useful information to monitor how many clicks you get per post and what keywords were used to get that many clicks a post.

Cons:

Very Chatty:

This particular client, when it loads, will load all of your accounts and lists and try and update them all at once. This can make for a very slow beginning to your tweets throughout the day. As well to note, if you have a task manager, it would be best to avoid ending HootSuite completely to avoid the clunky start-up it every time you press the icon. The best way to do it is use Androids multitasking capabilities to start the app then go do something else on the phone while it loads.

1. Twidroyd (Paid & Free)

   Price: US $3.99

With Twidroyd being claimed as the “industries standard twitter client”, this app has a lot to live up to. With such high hopes comes a high feature base including but not limited to, the ability to add plugins, edit lists, native bit.ly support and tweet outbox incase you are disconnected from your network. These features will only be available on the paid version but the price would be well worth it just for the ability to use plugins. This client looks like it has a lot to offer so let’s take a look at the good and bad.

Pros:

Layout:

Twidroyd has a simplistic interface and an easy learning curve. Buttons are easily identifiable and don’t leave you wondering where the hell you’re going. This is the type of an app that a power user and just your average socialite would use. Easily adaptable to any user is its strongest suite, if a casual user doesn’t want all the extras they don’t have to use them but they are there for the power user if they so require.

Plugins:

Want to extend your twitter client to be able to view your position on a map or maybe one to read out you notifications to you? Well Twidroyd has you covered! This is an amazing feature to have because it leaves the platform open for innovation, which if I remember correctly, is Google’s concept of Android.

Cons:

Free Features:

This is an amazing product by any measure of stick you test it on but the free features are lacking. Bit.ly support would be great because it allows you to track click stats on your posts but sadly if you go free it will not be available. Maybe in future versions when they add more features they might add a few to the free version to say they were thinking of you!

1. Seesmic (Free)

Seesmic has focused its efforts on a whole suite of tools that can pull information from many social networking sites and present it to you in an easy to read format. This has been brought to the Android OS in a more minimalistic yet crisp interface. Unlike the iPhone version, the client for Android can only add Twitter usernames and note Facebook profiles and the like. Everything is presented in a straightforward manner at the top of your screen, with the ability to switch from your timeline, replies, messages, and your profile. If the red bar at the top of the page is pressed and you are anywhere on the page but the top, the screen will move to the starting position.

Pros:

Functionality:

When in Seesmic, the ability to make a new post is as easy as pressing the menu button. When composing a tweet the availability attach a picture or video and upload it to tweetphoto.com – a real-time media sharing website – is as simple as taking a picture, the rest is done for you. Attaching your location becomes as easy as pressing the location icon and picking between attaching your location, attaching location map link, or location address. Last but no least is the automatic URL shortener which comes in handy for doing multiple links for one tweet (spam anyone?). The ability to do all this from the composition screen is an awesome feature and clients are quick to adopt it but Seesmic was amongst the first to venture and do it.

Cons:

Plugin Support:

With clients starting to use plugins for their products, this client is lacking. This is also an opportunity for Seesmic to look at what clients like Twidroyd are doing and build and improve an what they like and innovate new ways of using plugins. Who knows, maybe we will finally be able to see Foursquare, TripIt, Glympse, Waze, Tungle.me, and Yelp integrate as proposed by [Robert Scoble] in his post Location 2012: Death Of Information Silos [TechCrunch].

1. Touiteur (Paid & Free)

   Price: €1.99

Not to be fooled by its French name, this is among the top Twitter clients today. Designed by LevelUp Studio’s it boasts a clean beautiful interface that could rival the iPhones classic user interface (UI). This app does come with a free and paid version so it’s key to note what you would like from this client. The paid version will unlock multiple accounts, 3 widgets for home screen, URL shortening, customization, and viewing webpages and multimedia within the program.

Pros:

User Interface:

Probably the best interface we have seen for Android to date. The sheer simplicity and style draws memories of iPhone’s UI. If you are a fan of the iPhone’s interface then this is the client for you. Everything is laid out at the bottom of the screen and speed depends on how many accounts you have.

Ingenuity:

When clicking on a tweet, the page is expanded and you are given the option to choose a number of options which include reply, links, retweet, message and more. This is a feature definitely worth mentioning because it does not take you away from the tweets at hand and still allows you do what you wish with that tweet unlike other clients who have you view the tweet separate before performing an action.

Cons:

Free Widgets:

The lack of free widgets available to free users is disappointing and should at least include one to satisfy the user who doesn’t want to spend €1.99 on a twitter application.

Verdict:

Twitter is becoming an integral part of people’s social networking portfolio and as such, should have some free (hopefully), premium Android clients. Android supports widgets, most apps give you widgets to simplify the way you access information and take it in and some of these clients have that ability already, so will integrate it later (here is to hoping!). These clients incorporate the average socialite to the power users of twitter and as such they have gained recognition by many. Many will note that some clients only had one or two pros and cons and that is because most features are generic in any client for twitter, these focus on what makes them stand apart. These five described here aren’t the only good ones and more are sure to follow but these are the crème of the crop for now.

NGX Technologies sent us this Blueboard LPC1768-H to play with. It’s basically a breakout board for an NXP LPC1768 ARM cortex-M3 microcontroller (datasheet). The board adds a few extra goodies, such as a choice of mini-USB connector or barrel-jack to provide regulated power to the chip. There’s also a clock crystal for the internal RTC and an Atmel 256kb EEPROM chip. This chip has 70 I/O ports, accessed through the pin headers on top and bottom of the board. The 20-pin header to the left is for a JTAG programmer (yes, you’ll need a separate programmer). Coming in at only $32.78 this is a very accessible route for projects that require more power than some of the traditional hobby controllers. The shipping seems to have come down since NGX’s last offering, now it would be under $10 to ship to the States.

The LPC1768 is the same controller from the mbed that we reviewed. What’s missing is some of the interface hardware and the boot-loader, but the tradeoff comes with a $66 savings. This is to mbed what an AVR board is to the Arduino, a way to get even closer to the hardware.

There are a few things we think are missing. Most notably, there isn’t a datasheet or user guide for the board itself.  The only information available is a schematic (PDF), but that should be enough for those already well versed in working with microcontrollers. There is also a 12MHz clock crystal on the board but it doesn’t seem to be jumpered in case you wanted to use a different frequency. We’re not sure if this is much of an issue, the internal RC oscillators offer a lot of flexibility including operation up to 100MHz.

We feel this is a solid platform that will help to get more people into ARM development because of its low price. Let us know your thoughts in the comments.

mbed is a next-generation 32-bit microcontroller platform. It’s a prototyping and teaching tool somewhat along the lines of Arduino. On steroids. With claws and fangs. Other contenders in this class include the MAKE Controller, STM32 Primer and Primer 2, Freescale Tower, and Microchip’s PIC32 Starter Kit. The mbed hardware has a number of advantages (and a few disadvantages) compared to these other platforms, but what really sets it apart is the development environment: the entire system — editor, compiler, libraries and reference materials — are completely web-based. There is no software to install or maintain on the host system.

The Hardware

The mbed board is sensibly priced at $60; about middle of the road among its peers. mbed’s size (or lack thereof) is among its greatest assets, measuring only about 1″ by 2″ (26 x 52mm) in a stout 40-pin DIP package that just barely manages to fit in a breadboard…a major win.

The top of the board is dominated by the microcontroller itself: a 60MHz NXP LPC1768 based on the eminently capable 32-bit ARM Cortex-M3 core, sporting 64K of RAM and 512K flash, and rounded out with an embarrassment of peripheral riches: Ethernet, USB (host, device, and to-go), CAN bus, multiple serial, I2C and SPI buses, 12-bit A/D and even a 10-bit D/A converter and realtime clock/calendar. Also on top is the USB connector (mini-B), some power regulation circuitry (operating on 4.5 to 9 volts DC, or USB power), several indicator LEDs, and the reset button (a plain vanilla tactile switch on our purchased unit, not the candy-like blue button seen in product shots).

The underside conceals an Ethernet transceiver chip (requiring only the addition of an RJ45 jack to get the board on a network) and a DiskOnChip-style component that provides a small (about 2MB) FAT filesystem when attached to a host system through USB, much like a thumb drive.

This latter feature — the FAT filesystem — is half of the key to mbed’s software-free, cross-platform magic. Getting new code onto the device is simply a matter of copying the compiled program (as a .bin file) to this drive. Press the reset button, and the new code is copied to the MCU’s internal flash and run. No special programming hardware dongle, no special bootloader software, just drag and drop. This has some serious implications. Pretty much any system these days can mount a FAT filesystem. We’re not just talking about getting Mac and Linux users into the fold alongside Windows…there’s also the impending wave of featherweight netbooks with ARM and VIA chips running peculiar, instant-on operating systems. Or the OLPC XO-1. Or older PowerPC Macs. The computers in the school’s lab that you’re not allowed to install any software on. Game consoles.

The Software

“Cloud computing” is still the hot buzzword this week, and the mbed project has adopted the concept wholeheartedly, comprising the other half of their softwareless strategy. Everything with mbed — everything, even your own source code — resides on their servers and is accessed through a web browser. This carries with it all of the good and bad points of any other network-based service such as Google Docs. There’s the potential for this to be a fantastic tool for teaching and collaboration, and in fact they’ve created such an online community for mbed, with forums and publicly-shareable code libraries. One can move between home and office, or travel around the world, and resume editing code on any system with a solid ’net connection. No need to check for software updates; the server will always be current.

mbed programs are written in C++ (yes, thankfully it’s “programs” and “C++,” not “sketches” or “the mbed language”) using their JavaScript-based online editor. When ready, click the Compile button. The compiler and linker run on the back end, on the server at the other end of the network connection. Provided your code is all syntactically valid, a compiled .bin file will then be downloaded to your computer…save this to the mbed USB disk, press the reset button, and you’re good to go. In Arduino-like fashion, the mbed device also appears as a virtual COM port, so you can monitor a program’s serial output using any terminal program.

The Good

We were taught that you should always say something kind before criticizing, so we’ll point out that the above process does, in fact, work exceedingly well, and has proved to be both quick and reliable. Once you get into the groove, the sequence of operations is no more onerous than with Arduino or any other microcontroller-specific programmer dongle.

To their credit, unlike some microcontroller evaluation kits, there are no artificial limitations to the mbed compiler; the full code and memory space of the processor is available to your code. The editor has realtime syntax coloring and multiple undo levels. And double-clicking on an error message in the compiler output will take you directly to the offending line, as in any decent IDE. You can import existing code from your local system to the mbed “cloud,” or likewise export individual files or an entire project. All good stuff.

The real saving grace of this setup is the libraries, both the official functions in what they call the “Handbook,” and community-contributed code in the “Cookbook.” A tremendous amount of functionality has been implemented in a concise and usually object-oriented manner. It’s almost comical sometimes, after having worked with other microcontrollers and girding for some expected coding nightmare, only to find that the corresponding library handles a task in a couple of lines (browse through the Handbook and Cookbook for examples). There’s a tendency also to follow stdlib or “UNIX-like” conventions for file access, character I/O, realtime clock access, etc., so existing systems programmers new to microcontrollers will feel right at home, no weird function names or syntaxes.

The mbed’s FAT filesystem is also accessible to the microcontroller, making it useful for more than just program storage. Web pages can be served from this space, or a data logging program can store results here. If the two megabyte capacity is too limiting for your needs, have a look at the SDCard library in the Cookbook — it’s almost trivial to wire up and use. Pretty much all of the libraries are like that!

The Bad and the Ugly

Hardware-wise, there are just a few minor nitpicks:

First is with the local FAT filesystem. Even though this is one of the device’s most unique features, and the very thing that enables its platform neutrality, the implementation just seems a bit anachronistic. The aforementioned SDCard library demonstrates how readily that format can be used. It’s faster, with the potential for far greater capacity, and cards could be easily swapped out for different code or data files. Not a major disappointment, just seems like an opportunity was missed to make this product even better.

Second is with the indicator LEDs on the board. Four of them, scant millimeters apart, all blue…making them pretty much worthless as status indicators from across the room, where they all blur into a singular blob. Ten years ago, blue LEDs were novel. Five years ago, they were mainstream, festooning every last USB hub, mouse, flash drive and imported piece of crap. Today they’re just tired, let’s get over it. Different colors would indicate status at a distant glance.

Finally, not a problem with the mbed board itself, but it would be nice to see one of the Cookbook projects, the “BoB2” breakout board, made into an available product. The blank board can be ordered through BatchPCB, but after postage and handling the price for just the empty board — no components — is $33. Have this populated and mass-produced, bundle it with the mbed in a $100 package, and it sounds like a winning setup, ready to go head-to-head with the MAKE Controller.

But really, those are just nitpicks. Our real beef is with the software…the code editor specifically. If you find the Arduino editor aggravating, the mbed editor will have you seeing red (or maybe purple if you factor in all those blue LEDs). Like Arduino, there’s no true tab formatting; everything’s expanded to spaces, like it or not. Auto-indent cannot be disabled, and there’s seemingly no command to increase or decrease the indentation of a block of code. If you’re accustomed to anything more than arrow keys to move and click-and-drag to highlight text, the editor disregards a lot of system-native editing behaviors that may be deeply ingrained in your muscle memory (such as shift-clicking to select a range of text, or triple-click-and-drag for multiple contiguous lines). What’s more, the quirky behaviors are a little different across each browser and operating system. Don’t even try that triple-click-and-drag in Firefox for Mac…you won’t get your text cursor back without a complete reboot (seriously, just restarting the browser isn’t sufficient). And at present, only the most common browsers are supported; all others are currently shut out.

The closed-source nature of the tools may also be off-putting to some. If one finds the Arduino editor distasteful, there are options: get in there and change the code, or simply use a different editor and link with the Arduino libraries manually…it’s all legal and encouraged. With mbed, there are no alternatives. Access to the compiler and libraries is “free as in beer,” but not “free as in speech.” There’s little recourse should the service ever be taken down, or if they should suddenly start charging a subscription fee (there’s no indication this is planned, just a hypothetical scenario).

The good news, at least with regard to the former, is that software is of course infinitely more malleable than hardware, and it’s almost certain the tools will improve with time. The site is under active development…new “Home” and “Notebook” features were added for registered users just yesterday. Perhaps, given time, they’ll get the Command key working properly on the Mac. The selection of user-submitted code will expand regardless, making it progressively easier to do more and different things with this board.

In Summary

The mbed Tour page is frank about what the platform is good for, and what it’s not. mbed was intended as a quick prototyping and educational tool, and at that it excels. A lack of features such as a debugger or offline compiler keep this from being a professional-strength development platform, which is okay. Think of it as Arduino: The Next Generation. Although the mbed board costs more up front than Arduino, there are capabilities here that would otherwise require costly “shields” and strain every last byte and CPU cycle of the 8-bit ATmega328 processor: Ethernet, USB, SD cards…mbed handles these tasks with aplomb.

mbed is not without its flaws, and the “cloud” development approach may never sit right with some. For a product that’s just weeks out of beta testing, the results thus far are extremely encouraging. There’s immense potential here: a seriously powerful chip, easy to interface and to program. If the online tools can be improved, or if open source alternatives become available, mbed could be a major player. We expect to be seeing a lot more of this device in future hacks.

We’ve been eyeing Seeed Studio’s DSO nano digital storage oscilloscope with a mix of intrigue and skepticism. A pocket-sized $89 storage ’scope? This is a joke, right? Hack a Day reader [Blair Thomson] has written a thorough review based on his experience with one of the beta test units, and it might be a winner after all.

[Blair] feels the unit compares favorably to buying a similarly-priced secondhand analog oscilloscope. The DSO nano wins major points for ease of use, a good range of functionality, and of course the whole portability thing (the enclosure is a repurposed portable media player). Can’t say we’re entirely convinced though. As a single-trace ’scope with 1 MHz bandwidth, the DSO nano may be extremely limiting for anything but basic hobbyist use…which, to be fair, is exactly how they’re marketing it. We can see a place for this the same way there’s a place for $10 multimeters — an inexpensive, toss-in-the-toolbag second ’scope to quickly test for vital signs, something that might complement but not replace a good bench unit.

“The Manga Guide to Electricity”, part of “The Manga Guide” series by No Starch Press, is a novel approach to the old problem of getting over the initial mental block when trying to learn electronics.

We decided to compare this book to another introductory text: “Getting Started in Electronics” by [Forrest M. Mims].  [Mims]‘ book is a handwritten masterpiece of electronic literature. The writing style is friendly and concise, the examples are simple, and the drawings are excellent. It also makes sure to keep the learning process as application based as possible. Unlike other books, it doesn’t bog the reader down with math and theory that is only useful to advanced students. Since its original printing in 1983, [Mims]‘ has become the de facto standard for beginner electronic literature.

“The Manga Guide” attempts to walk the beginner through the very basics of electronics using the interactions between [Rereko], a resident of planet Electopia; [Yonosuke], a transdimensional robot cell phone; and [Hikaru Yano Sensei], an electrical engineering researcher at a Japanese university. [Rereko] is apparently very bad at electricity, and is sent to learn the basics from Hikaru over the summer by her professor.

“The Manga Guide” is a lot of fun to read. The interactions between the characters are lighthearted, and the whole setting has a sort of quirkiness about it that makes you keep reading just for the joy of it. It covers most of the basics thoroughly and with excellent examples. The art is a very well drawn, playful style of manga.

Unfortunately, in order to keep the story going, a lot of little but important details were left out of the manga. To compensate for this, there are mini chapters of what can be politely described as some of the most dry electronics text ever written. We found ourselves skipping over this text often to get back to the manga parts of the book. Another disadvantage to this book is that it is hard to go back to previous pages in order to reference things since one subject may be spread across several pages of story. This is just an unfortunate side effect of the manga format. A book like [Mims]‘ has the advantage here because the information is denser and easily indexed.

In conclusion, this book is a great addition to any library, but not to be relied on for learning. While “The Manga Guide to Electricity” introduces you to the basics very well, unless you want to suffer through the mini chapters, you will be no closer to building a circuit at the end than when you started reading. [Mims]’ book, on the other hand, leaves you with all the skills to begin experimenting with, building, and designing your own circuits. Luckily, at the price range of this book, there is really no reason not to pick it up and give it a read.

No Starch Press has provided us with two copies to give away. Just leave a comment including the words “I want this book.” and you’ll be entered in the random drawing. Please only use the phrase once or you’ll be disqualified. Entries will close 12PM PDT Thursday August 6, 2009. Congratulations to our winners [daniel n.] and [Fiach Antaw].

A logic analyzer records bus communications between two chips. If you’ve ever had a problem getting two chips to talk, or wanted to reverse engineer a protocol, a logic analyzer is the tool you need to spy on the bus.

The Logic is a USB logic analyzer with eight channels and sampling rates up to 24MHz. Among hobby-level logic analyzers, the Logic has a good mix of features and decent sampling rates. We’ve been following Joe Garrison’s work on the Logic for a long time. If you’ve ever considered bringing a product to market, you can learn a lot from Joe’s blog that documents his development process.

When it debuted, the Logic was so popular that it was hard to buy one. It’s now widely available, and Saleae gave us one to try. Read our review below.

Logic Analyzers vs. Oscilloscopes

Most modern electronics projects will benefit more from a logic analyzer than an oscilloscope. An oscilloscope displays a graph of an analog voltage as it varies over time, such as the curve of a sine wave. A logic analyzer only detects high and low digital states, but it records many signals simultaneously. Logic analyzers dump data to a computer for analysis, very few oscilloscopes have this feature.

What you get

The Logic comes packaged in an external hard drive case. The analyzer is a small, anodized aluminum puck with laser etched signal markers. It’s much smaller than we expected, slightly smaller than a compact flash storage card. A mini-B USB cable is included.

A heavy-gauge cable and nine E-Z-Hooks (5 shown) connect the Logic to a circuit. The hooks are a really nice touch; press the back of the hook to expose a pair of tweezers, grab onto a signal wire, and retract to hold it in place. The retractable tweezers prevent accidental shorts on cramped test circuits.

Software isn’t included, instead you get instructions to download the latest version from the Saleae web site. We always download the latest software, so we appreciate that there’s one less CD headed to the landfill.

Right now, only Windows XP/Vista software is available, but Mac and Linux software should be ready soon. Warning: the Windows version requires .NET 3.5, download the redistributable off-line installer if you don’t want to give internet access to Microsoft’s online installer.

Using it

Using the Logic is simple. Connect the gray ground wire to the ground of the test circuit, then hook into the signal lines you want to record. We connected it to the 32K SPI SRAM that we demonstrated earlier this week. SPI has four important signals; enable, data in, data out, and clock. The E-Z-Hooks make it dead simple to tap into the signals without accidental shorts.

Be mindful of wire orientation. We associate a black wire with ground, but the Logic cable uses gray. Comments on SparkFun’s product page suggest that reversing the connections will damage the Logic.

The software analyzes and displays signal captures. The primary configuration options are the sampling rate (200KHz-24MHz) and number of samples (millions to billions). We were able to sample at 24MHz, but the top speed depends on how much other stuff is using the USB bus. A 24MHz sampling rate can capture signals up to 12MHz, we found this suitable for all the protocols we use. The total number of samples is limited only by the available PC RAM.

There’s a four level trigger that watches the signals, and waits for a specific combination before it starts recording samples.  Since we’re analyzing SPI, the most logical place to start capturing is when the SPI enable signal drops at the beginning of a bus transaction. We set the Logic trigger to start sampling when SPI enable is 0 by changing its trigger to ’0′.

We really like the profiles that decode most common serial protocols; 1-Wire, I2C, SPI, and asynchronous serial.  CAN and other protocols will be added eventually.

Profiles suggest names for each signal, and convert squiggly lines into readable byte values. This is a really awesome feature. Without it, you’d have to count clock pulses to identify byte boundaries, and then manually decode the values.

This transaction shows the host issue the read configuration register command (0×05), and the SRAM response (0×41).

We also tried the 1-Wire decoder with a DS2431 EEPROM. The software identified the 1-Wire reset command, and the 1-Wire ‘search rom’ command (0xf0).

A look inside

The Logic is based on the Cypress Semiconductor CY7C68013A-56PVXC, an Intel 8052 microcontroller with a USB peripheral. The 8052 is an enhanced version of the well-known 8051. We can also identify a 24MHz crystal, which is probably multiplied to 48 or 96MHz by an internal phase-locked loop.

Conclusion

Logic analyzers take the guess work out of debugging inter-chip communication. If you can’t see what’s going on, the best you can do is guess about the problem. When a project won’t work, 99% of the time we can solve the problem immediately by looking at the signals with a logic analyzer. Without it, there’s no easy way to know what’s happening.

The Logic records 8 channels at 24MHz. The Windows software has useful features, and there’s an SDK if you want to write your own apps. Linux and Mac versions are under development. We really like this logic analyzer, and plan to use it to illustrate future articles.

The Logic is $149 at the Saleae website and SparkFun, and Joe is working on EU distribution. If you’re interested in the Logic, but aren’t ready to buy, you can download the software and try it in demo mode.

Hack a Day review disclosure: We asked for a Logic and Saleae sent it to us

A decent drill press is a crucial tool for an electronics lab. We use our drill press to make holes in our own circuit boards, and tap or break traces on existing circuit boards. We’ve used a lot of tools to drill circuit boards — power drills, power drills in “drill press stands”, and high-speed rotary tools — but when we started doing projects on a schedule, it was time for something more reliable.

We first spotted the Proxxon TBM115/TBM220 drill press in the window of a local shop.  Its tiny size and adjustable speed seemed ideal for drilling circuit boards. At $200, this is one of the pricier tools in our lab, but quality bearings and smooth drilling action aren’t cheap.  Read about our experience with this tool below the break.

This drill press is tiny, less than a foot tall. It’s easy to tuck away in a closet or under a bed. Despite it’s size, it has all the typical drill press functions like adjustable height and drill depth.

An adjustable drive belt connects the drill head to the motor. The belt moves to different positions on internal pulleys to create three combinations of speed and torque; 1,800, 4,700 and 8,500 rpm. It’s a bit of a pain to adjust the belt, and the instructions for proper tightness are a bit vague.

If the drill is left for long periods, the belt should be loosened so it doesn’t warp. We think our drill press was over-tightened and stood in a hot shop window for more than a year. Now it sometimes suffers excessive vibration and noise after long periods of drilling. This was ameliorated to some extent by the previously mentioned vague adjustment procedure, but we probably need a new belt. While this is a problem specific to our drill, it’s something to consider if you have similar problems, or if you have the opportunity to buy a new belt when you get the drill.

The drill came with 6 collets of various diameters, but no chuck. We bought the collet-compatible drill bit in the photo at the local electronics store for about $10. Reconditioned drill bits are much cheaper on eBay and we’ve also had Drill Bit City recommended to us.

We usually use cheap 0.8mm bits that don’t fit in a collet, so we bought the optional chuck. As you can see in the photo, after a couple years we still haven’t taken it out of the package. The drill is so smooth and straight that the first bit we purchased has lasted through two years of medium-duty use.

Proper safety is imperative when working with high-speed drills and tiny bits. You must wear safety glasses. Every bit will break, it’s just a question of when. A broken bit will usually stick inside the circuit board, but sometimes they shoot out like shrapnel and stick in the woodwork. Not wearing safety glasses while using a high-speed drill almost guarantees you’ll eventually lose an eye. We also wear a dust mask, not just to protect the lungs from fiberglass dust, but to shield the face from broken drill bit debris.

Like our soldering station, this is another tool that we absolutely love. It’s the prefect size for working with circuit boards, and worlds better than any high-speed rotary tool we’ve had the displeasure of using. The drilling action is very smooth, and the motor has tons of speed and torque. The biggest difference to us, migrating from a cordless drill on an old drill press stand, is the steadiness of the drilling head. It drills super sharp holes with no wobble or rough edges. This is one of the most important tools in our lab, and one of our favorites.

The 115volt North American model (TBM 115) is available here for about $200, a search shows several other outlets. The 220volt EU/AUS/world model (TBM 220) is available from here, and a number of online shops. You can also contact Proxxon to find nearby brick and mortar outlets.

The $10 “fire-starter” is the most common beginner soldering iron. These are simple irons with a hot end, a handle, and little else. There’s no temperature control or indication. Despite their simplicity, they’ll do just about anything. You can solder any legged chip type with this type of iron. We used fire-starters in the lab for years.

Eventually, we wanted a hot air rework tool to salvage SMD parts and solder QFN chips. Aoyue is a relatively unknown Chinese brand that makes soldering stations very similar in appearance and function to Hakko. Aoyue stations are recommended and used by Sparkfun Electronics, something that factored heavily in our decision to buy an Aoyue. Read more about our experiences with this tool after the break.

The Aoyue 968 combines three tools: an adjustable soldering iron, a digitally controlled hot air tool, and a fume extractor. We usually prefer separate units because the parts can be individually upgraded or replaced, but this combined tool is much cheaper and saves valuable bench space in the lab.

The soldering iron temperature is adjusted with a knob, with a range of 200 to 480 degrees Celsius. We usually solder between 300C and 350C.

The iron handle is an inexpensive plastic assembly that eventually broke along the threads that hold the iron in place. New irons are available for around $15, but we fixed the old one with some high-temperature epoxy.

The fume extractor is a tube that attaches to the soldering iron. The hot air rework tool air intake is used to suck fumes away from the tip of the iron. The fumes are filtered with a small plastic net before exiting through the hot-air tool. It works really well, and eliminates the breath-hold-solder-breath system we used to avoid getting a nose full of flux fumes. The tiny filter doesn’t look like it does much, but it came with a replacement. We worry somewhat about the long term effects of coating the hot air tool’s heating element with rosin and other crud.

It’s pretty obvious that the iron holder wasn’t intended for this particular iron because the holding ring doesn’t fit the fume extractor attachment, this is a bit of a pain.

The hot air rework tool has a temperature range of 90 to 480 degrees Celsius. We use 400C hot air to remove passive parts, and 420C to remove chips.

The temperature is adjusted in 2 degree increments using the digital numerical readouts. The air flow rate is adjusted with a knob, volume is indicated by a floating ball gauge. The hot air tool came with a half-dozen nozzles, we’ve only used the medium size.

We’re extremely happy with the Auyoe 968. It’s already paid for itself twice, in terms of not having to replace $10 soldering irons every month. If it breaks, we can buy a new one without regret. The hot air rework tool has opened a world of possibilities for salvaging parts and repairing projects. The adjustable soldering iron provides enough heat to solder something big and dirty, but also adjusts downward so it doesn’t destroy delicate traces.  We haven’t needed to replace the iron tip or either heating element, but we understand they’re compatible with parts from other major manufacturers .

Until recently, Auyoe was only available in Asia and Europe. We bought this one in Germany for about $100. The Aoyue 968 is now available on Amazon in North America, Sparkfun also has several other Aoyue models.

Sure, Aoyue isn’t haute couture for geeks like a Hakko or Weller, but for less than a third of the price you get a respectable rework  station that’s not a lifetime investment. As heavy DIY users, we think this station has performed great. We highly recommend it to anyone buying their first serious soldering iron. If you’re a pro with an industrial budget, buy yourself a Hakko or Weller; we’re doing just fine with our Aoyue!

Learn about soldering with an iron and hot air, and see an Aoyue in action, in the Sparkfun soldering tutorials.

Are there any tool reviews you’d like to see?

We’re big fans of surface mount parts. SMD components are cheaper, take less board space, and don’t require drilling; all the coolest new parts are only available in SMD packages.

Smart Tweezers are an advanced multimeter tool specifically designed to test and troubleshoot SMD circuits. It automatically identifies resistors, capacitors, and inductors, and displays the relevant measurements. Advanced Devices sent us a pair of Smart Tweezers to review. We used them while building our last few SMD projects, read about our experience with this tool after the break.

Tool overview

Smart Tweezers are a multimeter that measures resistance,  capacitance, inductance, and voltage with tweezer-like probes. The probes are shaped to hold loose SMD components, or test components already soldered to a PCB. Measurements are displayed on a small graphic LCD that reverses for left or right hand use. If you’ve ever tried to measure SMD components with a typical multimeter, the value of the tweezer profile is immediately apparent.

Starting at $300, this tool is intended for professionals who regularly debug, test, or repair SMD electronics. It’s a bit out of reach for a hobbyist who just wants to salvage SMD parts.

Using it

We tested the Smart Tweezers while developing three recent SMD projects: the DIY digital picture frame, the Bus Pirate version 1, and an upcoming ethernet device. It’s a real headache to debug an SMD circuit with typical multimeter probes: balance the probes on the correct pins, ensure that the probes don’t create momentary contacts that aren’t due to soldering, and then hold this position long enough to get a good measurement. This only gets worse if you have to repeat several times. The Smart Tweezers test SMD components with a quick single-handed squeeze.

The Smart Tweezers’ graphic menu is navigated with a simple jog wheel. The tool turns on with a press of the jog wheel, and turns off automatically after an adjustable timeout. The default auto-measurement mode attempts to detect the type of component and chooses the best properties to display, but auto-mode is a bit slower than setting a specific measurement mode.

Resistance

Every multimeter measures resistance, a typical multimeter has several test ranges that are toggled manually. The Smart Tweezers measure resistor values between 0.1Ohm and 5MOhms, without manual range adjustments. In the photo we’re measuring a 390ohm, 1% resistor.

Capacitance

Capacitance measurement is a feature that’s found on some high-end multimeters. The Smart Tweezers measure capacitance between 10pF and 499µF. In the photo we’re measuring a 27pF, 5% capacitor commonly used in a crystal oscillator.

A measurement taken from a single capacitor shows its value. A measurement taken from a circuit board shows the total capacitance of all connected components and of the PCB itself.

Inductance

Inductance measurement is rarely found on a multimeter. The Smart Tweezers measure inductance between 1µH and 1H. We didn’t have an SMD inductor to measure, but we tried a through-hole inductor coil from a switch mode power supply.

Voltage

The Smart Tweezers also measure up to 8volts AC or DC. After navigating to the voltage mode, the Smart Tweezers beep until you flip a small, recessed switch in the side of the case. The switch is too recessed to flip with a fingernail, so we used a through-hole resistor lead.

In the photo we’re doing a quick check to make sure that a tiny SOT-23 LTC2631a digital to analog converter is properly soldered to an adapter board and receiving power.

Continuity/Open Test

The Smart Tweezers have a continuity checking mode that beeps to verify connections between parts. This is an easy way to make sure every leg of a large SMD chip is properly soldered, or to hunt for broken/damaged components.

Current

The Smart Tweezers don’t directly measure current consumption, but it’s easy to calculate using voltage and resistance measurements with the equation Ir=Vr/R.

A look inside

As with any tool, we can’t help but take it apart and see what’s inside.

The batteries are replaced by removing three screws and the front cover of the device. This view reveals the batteries, the LCD screen, a small piezoelectric speaker, and the back of the circuit board.

A single screw in the back of the case holds the circuit board in place. We removed the screw to expose the front of the circuit board. The Smart Tweezers are powered by a Texas Instruments MSP430F135 microcontroller and a half-dozen analog chips. The MSP430 line is well-known for low power consumption, and it’s a logical choice for a portable device. Most of the passive support components are size 0402 or smaller.

Conclusion

The Smart Tweezers saved us a lot of time constructing and debugging three surface mount electronic designs. A simple squeeze and test is much faster and easier than awkwardly probing tiny parts with our cheap multimeter. It’s so much easier, in fact, we could hold the Smart Tweezers with one hand and take all the photos in this article with the other; try that with a normal multimeter.

We think two small changes could make the tool even easier to use. First, a larger button would make it easier to switch to voltmeter mode without a wire or screwdriver.  Second, it would be really nice if it could be turned-on by squeezing the tweezers together, rather than pressing the jog wheel.

We really liked the automatic component detection and auto ranging, and the measurement speed is excellent. We appreciate that the tweezer tips are replaceable because we’re really hard on our tools.

If you’re a professional or student who does a lot of work with SMD electronics, a pair of Smart Tweezers can save you time by reducing awkward multimeter measurements to a simple squeeze. This fairly expensive tool is probably overkill for all but the most hard-core hobbyists, but if you derive income from electronics, like we do, Smart Tweezers can be really handy.

I feel the need to include a disclaimer before getting into this: I don’t own an original Xbox, I own a Playstation 2, I consider myself a casual gamer, I’m a fan of Open Source and not Microsoft.

I purchased this box on the first day because early versions of consoles are generally easier to modify. With the PSP ver. 1.0 it was easy to run homebrew code, but with each successive firmware version, Sony makes it harder. The original Xboxes that are being sold now make it almost impossible to run Xbox Linux because of a hardware change.

Before we get to my experiences, here are some links that you might find interesting.

• Chipworks de-capps and photographs Xbox silicon. Chipworks is a leading silicon reverse engineering company. [via bunnie, who still needs a 360]

• Anandtech’s photo tour of the 360 internals, one and two

• batlogic’s VGA cable pinout and article on the original Xbox’s security model

• Free60.org, the Xbox 360 Linux project

Crashes

This is the current hot topic (puns are always intended), so I’ll start with it. As you can see from the photo above, I have experienced problems with my 360. You can see more photos on the Flickr Hack-A-Day photo pool. While observing a race that
Joystiq was in, I brought up the sidebar to play music from my iPod. This resulted in severe graphic glitches (the music wasn’t playing right either) and I had to reboot. Another time while playing PGR3 I brought up the sidebar and the system froze; I could still chat, but the system would not respond to any button presses, so I rebooted. I feel that both of these issues are Dashboard problems and not heat related. I’m guessing these problems will probably be cured in a future Dashboard upgrade. When you access Live for the first time the dashboard upgrades from ver. 2.0.1888.0 to 2.0.2241.0.

I haven’t experienced any problems that I would consider heat related. That being said: This console is extremely hot. Heat pours out of the back out the machine even when doing menial tasks like playing MP3s. If you place a hand across the right side of the box you can feel the suction from fans. This is the largest intake and because of that I think standing the box up on carpet would be a really bad idea. The feet are short enough that I wouldn’t feel good about standing it up on a hard surface either. The power supply has been blamed for most overheating problems. It has intake and exhaust ports that consist of two rows of holes in a 2×1/4 inch space. The power supply doesn’t get too hot; I’m sitting with my feet on top of it right now using it a foot warmer.

HiDef

From the top photo you can see I’ve got the 360 plugged into my
Dell 2405FP using the included component cable. The component cable also has a composite video connection so you don’t need a different cable when connecting to an SDTV. Yes, 720p looks amazing and I’m glad that Microsoft has required support for it in all games. It looks a lot better than the jaggie 480p from my Playstation 2. The clarity of the HD is a little lost on me since I use this as my regular computer monitor which can support resolutions up to 1920×1200. I did buy this monitor specifically for the HD support and it should be able to handle 1080p, if the Playstation 3 manages to support it. It’s also nice being able to work while monitoring Live using the picture in picture.

Controller

Following the trend set by Nintendo, the Xbox’s OEM wireless controller is great.  They added two shoulder buttons, but unlike the Playstation, placing four fingers on the shoulder buttons doesn’t feel natural. This is fine because the upper buttons are used for occasional tasks like switching view points; you spend most of your time with index fingers on the triggers. The light on top of the controller indicates which number 1-4 the controller is assigned to, a nice touch. It would be nice to see the possibility of more players supported on a single console though. The wired USB controllers can be used with Windows, but not the wireless controllers when connected with the “play &charge”. The obvious conclusion is that: the play & charge is just a power cable and doesn’t add any sort of USB functionality. I think the headset connector is identical to the original Xbox: 2.5mm jack like cellphone headsets, I also have a 2.5mm RCA cable from my digicam that would work. There are two slots next to the headphone jack that have two metal contacts each which aren’t used by the headset.

USB

One of the first things I did was plug every USB device I had into the Xbox to see how it behaved. My keyboard worked fine whenever there was an on-screen keyboard (It’s the keyboard from the Playstation 2 Linux kit). The system really hated the mouse; none of the other peripherals would work when it was plugged in. My video iPod came up almost immediately and was identified by its name “pwn3d by hackaday”. Plugging in the camera, card reader and flash drive all worked, but not at the same time. It also doesn’t like the card reader built into the monitor, but the flash drive and keyboard both work when connected through the monitor’s hub. My Prism2 based WiFi adapters were not recognized by the box.

Media

One of the main reasons I purchased the Xbox was its media streaming ability. Using the Windows Media Connect you can access music and photos stored on your Windows XP machine. The software will also stream video, but not to the Xbox 360 because Microsoft has decided to cripple it. This is an attempt to sell more Windows Media Center PCs since you can stream video using them. Media Connect uses the UPnP AV protocol to stream media, but the Xbox won’t recognize other UPnP servers like uShare. If it did, it would be easy to stream from a Mac or a Linux machine. The Xbox also doesn’t appear as a media renderer when using Cidero UPnP control Point software. Here is a good overview of the media center features. [via Xbox360Fanboy]

Playing music is easy enough. It was a lot more enjoyable navigating music stored on the iPod than on my roommate’s XP machine. The iPod is neatly organized while Media Connect scrapes every directory you give it, listing every random music file and playlist it comes across. The interface is pretty easy to use, but I have a couple complaints. Adding a song to a playlist takes at least three button pushes. When you click “add to playlist” it takes you to the playlist and then you have back up to get back to where you were before. They should dedicate one button on the controller for adding the song and not make you jump back and forth. Also, you can’t save playlists that include music not stored on the hard drive. The easiest way to manage playlists is building them on your PC or in iTunes for your iPod instead of using the Xbox interface. The Xbox does work really well if you want to play by album, artist, or genre though.

Live

I’ve enjoyed playing on Xbox live. Being able to jump easily into a game with friends is great. Delivering free demos to consoles is a wonderful idea: I’m much more likely to buy games I’ve already played just like buying DVDs of movies I’ve already seen. It would be nice to receive videos from videogame review sites too. The downloads from Live are extremely slow, they should really use a distributed system since they have a huge network of identical consoles. I wish Live had a way to organize friends into groups like I can on IM: coworkers, readers, random.

Money, money, money

This is what I hate the most about the new Xbox 360.

• Sure, you can buy a Core bundle for $299, which isn’t anymore than the last version, but it doesn’t come with a hard drive. The hard drive is a $30 SATA drive, but since it is for the Xbox it costs $99.
• The free Media Connect software is fully capable of streaming video, but you have to buy a Media Center PC to do it.
• Media Connect is using the open UPnP AV protocol, but you can’t use other UPnP software to stream to the Xbox
• Xbox Live costs extra – Didn’t I pay a huge entry fee by buying the console? Why do I have to pay a monthly fee just to use it?
• Micropayments – Sure, these little bits of content aren’t worth much, but we are still going to make you pay for it.

The bottom line

Is the Xbox 360 worth buying? If you have prerequisites like an HDTV and a Media Center PC the Xbox 360′s support for these items will make it well worth your time.  If you want to just use it as gaming system, it’s hard to justify the expense right now. Like most console launches, the titles aren’t that revolutionary. I think the best plan would be to wait till next year to make the purchase: the console will be cheaper, the selection of games will be broader, used games will be available, you’ll know the Playstation 3′s features, the Xbox 360 games will be making better use of the console’s power, Microsoft will have most of the bugs ironed out and you might be able to run Linux.