A few weeks ago we held a preorder for the Bus Pirate universal serial interface tool. We split the preorder into two parts due to a shortage of PIC 24FJ64GA002-I/SO chips. The first preorder is arriving worldwide now, the second preorder has a longer lead time. Here’s everything we currently know about preorder 2, it’s subject to change, but we wanted to keep you up to date.

Preorder 2 contains orders for 563 Bus Pirates. Seeed Studio noticed an error in our quality control testing routine that misclassified about 50 preorder 1 Bus Pirates as defective. We updated the test and passing units will ship immediately to preorder 2 participants on a first come, first serve basis. Another 500 PICs are scheduled to arrive after August 1, which should take care of most remaining orders.

A special thanks to the fantastic engineers at Microchip who took the time to peruse the Bus Pirate code, and immediately gave the correct solution to our quality control problem. Great job Microchip, thank you!

We released an updated version of the Bus Pirate firmware package. The firmware is exactly the same, we just changed a speed setting in the P24qp.exe quick programmer utility for MS Windows. During development we increased the baud rate of the quick programmer to make development faster, and we forgot to change it back to a safe speed for normal use.

For months we’ve used our Bus Pirate universal serial interface tool to demonstrate electronics parts, so it’s only appropriate that the Bus Pirate get it’s own parts post. We recently had a Bus Pirate preorder, and today we received the pre-production Bus Pirate prototype from Seeed Studio. This prototype was mailed just a few days before preorder 1 started to ship, so those packages should start arriving any day.

Follow along as we unbox the prototype Bus Pirate, and connect it to a debugger to determine the PIC24FJ64GA002-I/SO revision that shipped with this board. Use this post to share your own Bus Pirate unboxing experience. Pictures and discussion after the break.

Most Bus Pirates will ship in a padded envelope (JPG), but ours came in a box with some PCBs for future projects and an AVR programmer.

Inside the box, the Bus Pirate is protected by a static dissipative bag. The Bus Pirate pin headers are stuck in foam to protect the packaging.

We ran a battery of functionality tests that covered USB, the user terminal, protocol libraries, power supplies, and pullup resistors. Everything passed our tests.

Next, we used a Microchip ICD2 debugger/programmer to make a backup of the firmware prior to doing a test upgrade/downgrade with the bootloader.

Connecting to MPLAB ICD 2
…Connected
Setting Vdd source to target
Target Device PIC24FJ64GA002 found, revision = Rev 0×3042
…Reading ICD Product ID
Running ICD Self Test
…Passed
MPLAB ICD 2 ready for next operation

All of our previous Bus Pirate version were built using Rev 0×3003 (A3) of the PIC 24FJ64GA002. Version A3 has a few issues, known as errata (PDF), one of which is a flaky hardware I2C module. These chips aren’t ‘defective’, they just have a few quirks like any complicated integrated circuit. The Bus Pirate firmware works around these issues using software techniques. Most desktop computer processors go through a similar stepping process.

Our Bus Pirate appears to have a B4 revision PIC (0×3042) that corrects some, but not all, of the errata from A3. This is no guarantee that every Bus Pirate will have a B4 PIC, preorder 1 and 2 are both sourced from multiple international vendors. Additionally, there’s no immediate benefit from having a B4 chip, someone will have to write software that takes advantage of the hardware. The next firmware update will print the PIC revision in the user terminal, check the nightly compiles if you’re anxious.

There is a revision B5 mentioned in the PIC errata. Some of these might find their way into preorder 2 boards.

Now that you’ve got your Bus Pirate, what do you do with it? We’ve got a bunch of part demonstrations to get you started.

Please leave a comment about your unboxing experience, and the devices you plan to interface.

A few weeks ago we held a pre-order for the Bus Pirate V2go, the first official Hack a Day hardware. We had initially hoped for a group purchase of 20 or 40 Bus Pirates, maybe 200 if it was extremely popular. In total, nearly a thousand Bus Pirates will be made.

The first 350 Bus Pirates (pre-order 1) have already been manufactured and tested. Seeed Studio has done a great job handling the orders, pre-order 1 should start shipping more than a week early. How long will it take to get to your mail box? It will vary for everyone, but our packages usually arrive from Seeed in 7 days.

Seeed sent us pictures of the Bus Pirate depaneling, programming, and quality control process. Check them out after the break.

A panel of Bus Pirates.

Depaneling, also known as cutting a big sheet into individual circuit boards.

Visual inspection of each Bus Pirate.

Programming the unified bootloader/V0g firmware via the ICSP header.

Testing the bootloader and terminal interface after programming the firmware.

Completed Bus Pirates are stored on anti-static foam, we like the shiny quality control stickers.

Individual Bus Pirates are cut out for packaging.

Finished Bus Pirate packaged in an anti-static bag.

A box of Bus Pirates ready for handling.

One Bus Pirate, ready to ship. This might be be yours.

Futaba makes vacuum florescent character displays that can be used as a drop-in replacement for common character LCDs. VFDs have a wider viewing angle, and generally look cooler.

Futaba’s character displays can be interfaced using the standard 8-bit or 4-bit parallel LCD interface, or a simple two-wire protocol. The protocol type is set by resistors on the back of the display, so it’s not particularly easy to change without a hot-air rework station. Today we’ll demonstrate a serially-interfaced VFD using the Bus Pirate.

Futuba VFD character LCD replacement (NA204SD02, $7.00). Datasheet (PDF).

We used our Bus Pirate universal serial interface to demonstrate the Futaba VFD, but the interface operations will be the same for any microcontroller implementation. The connections we made between the VFD and the Bus Pirate are shown in the table above.

We setup the Bus Pirate for raw2wire mode (menu M, 7) with open drain outputs (HiZ). The open drain outputs let us interface the 5volt VFD from the 3.3volt Bus Pirate using the on-board pull-up resistors (menu P, 2). Finally, we enabled the on-board power supply (capital ‘W’).

The VFD’s strobe pin is connected to the Bus Pirate CS pin.  The auxiliary pin doesn’t have it’s own pull-up resistor but CS does. CS is otherwise unused in raw2wire mode, so we reassigned the auxiliary commands to the CS pin (menu C,2).

Interfacing

The two-wire interface uses a straight-forward 16bit (2byte)  protocol (datasheet page 20). The LCD control bits (R/W, RS) go in the first byte, and eight data bits go in the second. All transactions start with strobe low and end with strobe high. Read operations are similar to writes, except the R/W bit is set and the second byte is read.

The Futaba VFD accepts all the standard HD44780 LCD commands (datasheet page 27), see these tables for a detailed description of each command. After a reset (power-up), the VFD expects the first command to be the function set command.

RAW2WIRE>@ <–start with strobe high
AUX HIGH IMP, READ: 1 <– aux pin (CS) is now input, pull-up resistor holds strobe high
RAW2WIRE>a 0b11111000 0b00111000 @ <–command
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×38 <–instruction byte (function set)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Function set configures the data interface length (bit 4), display lines (bit 3), and brightness/luminescence (bits 1,0).  Before we start we set the strobe pin high (@) in case it’s currently low. Then, we start the transaction by taking the strobe pin low (a), and send the first byte with the R/W and register select (RS) settings.

The second byte is the command. We set the data interface length to 8bits (bit 4 = 1), but in serial mode this is probably ignored. Our display has multiple lines (bit 3 = 1), and we set brightness to full (bits 1,0 = 0). The sequence concludes when the strobe pin returns high (@).

RAW2WIRE>a 0b11111000 0b00001111 @
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×0F <–instruction byte (display on/off control)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

The display ON/OFF command enables the display (bit 3), toggles the cursor (bit 1), and blinks the cursor (bit 0). We enabled the display (bit 3 = 1) with a blinking cursor (bit 1,0 = 1) so it’s obvious that the display is working.

RAW2WIRE>a 0b11111000 0b10000000 @
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×80 <–instruction byte (DDRAM address set)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Before writing characters to the display we need to position the cursor by sending the DDRAM address set command (0b10000000) summed with the desired cursor position. We set the cursor to the first character on line 1.

The second character on line 1 is located at 0×01. To set this address we’d send 0b10000001 (0b10000000 +0b00000001).

Character display memory isn’t linear, the first line starts at 0×00, the second line starts on position 0×40, the third at 0×14, and the last line begins with position 0×54. Most displays have a similar configuration, here’s some tables for determining the layout of different character displays.

RAW2WIRE>a 0b11111010 0×48 0×61 0×63 0×6b 0×20 0×61 0×20 0×44 0×61 0×79 @
AUX LOW <–strobe low
WRITE: 0xFA <–start byte (R/W=0, RS=1)
WRITE: 0×48 <–ASCII letter ‘H’
…
WRITE: 0×79 <–ASCII letter ‘y’
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Finally, we can enter some characters at the position set with the previous command. Characters are entered as their ASCII equivalent values. We displayed “Hack a Day” with proper capitalization.

Multiple characters can be entered at once, but because the memory space isn’t contiguous it’s necessary to manually position the cursor at the beginning of each new line. After writing the last position of line 1, the cursor will advance to the first character of line 3. Use another position command, 0b10010100, to set the cursor to the beginning of line 2 (0b10000000 + 0×14 = 0b10010100).

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Hack a Day review disclosure: We bought the serial VFD demonstrated here on eBay, Futaba also sent us a sample with a parallel interface that we’ll demo later (shown here).

Ferrite beads (L1 in the photo) filter high frequency power supply noise by converting it into a tiny amount of heat. Power supply noise can cause various problems for many parts, especially in analog audio and display circuits.

Ferrite beads are simple, but choosing one can be confusing because they’re not commonly used by hobbyists. Most designs will still work if you omit the ferrite bead(s), but beads are so cheap there’s no reason to sacrifice the added reliability they provide. We describe how we pick ferrite beads for our projects after the break.

A ferrite bead is rated for current, impedance, and resistance; see this Mouser listing for an example. Unless a datasheet or circuit requests specific bead characteristics, we choose a bead rated for sufficient current, and ignore the impedance and resistance values.

If the bead is for a power supply, we determine the maximum possible current the circuit will use and find a bead rated for double that amount. Last week we calculated the the Bus Pirate’s worst-case current consumption as 525ma, so we looked at beads rated for at least 1000ma. We used this one, which is rated for 1500ma and costs 10 cents.

Sometimes a ferrite bead is used to filter the power supply for one specific part of a circuit. We used a dedicated bead to filter the LCD bias voltage on the DIY digital picture frame, and with the ENC28J60’s ethernet transceiver on the web server on a business card. These parts only consume a few milliamps, so we used a smaller 200ma ferrite bead ($0.11).

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Update, Saturday July 4th, 2009: All preorders are closed.

Today is the last day to pre-order a Bus Pirate. Get your own Bus Pirate, fully assembled and shipped worldwide, for only $30. We don’t plan to make more soon, this could be your last chance.

A special shout out to our partner, Seeed Studio, who handled the rush of orders like pros. The first pre-order is already being manufactured, and will ship as soon as possible. Seeed still has a few V2a PCBs if you’d like to roll your own Bus Pirate.

You’ve made this pre-order a huge success, and we’d like to make more projects available in the future. Were you just interested in the Bus Pirate? Should we arrange pre-orders of future Hack a Day hardware? Are there any past projects that we should revisit?

Thanks for the artwork [Aaron], licensed under Creative Commons Attribution 3.0.

Update, Saturday July 4th, 2009: All preorders are closed.

A probe cable makes it easy to connect the Bus Pirate to a circuit and get hacking. Good test clips make quick connections on cramped PCBs without causing short circuits. We made two cables for the Bus Pirate v2, keep reading for an overview of our designs and list of part suppliers.

Friday, July 3, 2009 is the last day to pre-order a Bus Pirate. There’s only two days left to get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

Overview

We use these cables to connect the Bus Pirate’s I/O pins to a microchip or test circuit. A cable consists of a 2×5 connector, a cable, and some kind of attachable probe like an alligator clip or test hook.

The gray cable (top) is a ‘junk box’ cable, we recycled it from scrap parts and old computer hardware. The ‘expensive’ cable (bottom) uses high quality and special-order parts.

2×5pin female connector

The Bus Pirate’s I/O header is two rows of five 0.1″ spaced pins. We used a 2×5 arrangement because 2×5pin female ribbon cable connectors are common and cheap. We decided against a single row of 10 pins because the connector is an expensive specialty item.

The pin names are shown above, and are silk-screened on the bottom of the PCB. See the Bus Pirate page for detailed descriptions of each pin function.

The junk box cable uses a 2×5pin female connector from an old PC ISA card.

The expensive cable uses a black connector with a reinforced cable holder. Mouser has gray connectors ($0.69) and black connectors ($1.15).

Ribbon cable connectors have internal pins that pierce the cable when the top part is pressed onto the bottom part.

Ribbon cable

Standard 2×5pin female connectors attach to 0.05″ 10-strand ribbon cable. The wire thickness is usually 22, 24, or 26 AWG. We think 12inches (30cm) is a useful length that doesn’t get in the way.

Grey ribbon cable is pretty common. We salvaged a piece from an old computer connector, you might get lucky and find one with a 2×5 connector already attached.

A color coded cable makes it easy to identify each connection. DigiKey has 5 foot sections ($3.03), Mouser has it by the foot ($1.16, $1.19).

Ribbon cable is cheap and readily available, but it tends to tangle and kink. A really nice probe could use a ribbon cable stub attached to thicker test leads.

Test clips

Test clips are the most important part of the cable. They have to be easy to position, and maintain contact with the circuit. Alligator clips work, but there’s a lot of exposed metal that can create short circuits. Professional test clips have a grabber that retracts into the probe leaving less metal exposed.

Alligator clips

The junk box cable has alligator clip probes, we pulled them off test leads like these (40 leads for $12). You could also use loose red and black clips (20 for $2.30).

Remember to put the rubber housing on the cable before soldering the wire to the alligator clip, it won’t go on later. In the photos you can see that some of our covers are cut to fit over the front of the clip because we forgot.

Round test hooks

This is the classic, round-bodied test hook. These are great for grabbing onto 0.1″ pin headers, wires, and the leads of through-hole components. The hooks are usually too big to use with surface mount components, and the round body makes it hard to fit more than a few in a small space.

Test hooks are easy to position. Squeeze the probe to extend a single metal hook, grab something, then release. The hook retracts into the body of the probe, securing it in place and preventing short circuits.

Most hooks come apart by pulling the top away from the body. Put the test lead through the hole in the cap and solder it to the metal tab. Push the halves together when the joint is cool.

DigiKey ($17.26) and Fry’s ($14.95) have multi-colored hooks in sets of 10. Deal Extreme has dirt-cheap 10 packs of yellow ($2.30)  and black ($2.33) hooks, but the reviews say the quality matches the price so buy extra (via [haku]).

Flat test tweezers

Tweezer-probes are great for clipping onto the legs of through-hole, surface mount, and many smaller chips. They usually have a flat body so they fit better in tight spaces than round hook probes.

This type of probe has tiny tweezers instead of a hook. Accidental short circuits are rare because there’s so little exposed metal when the tweezers retract.

Most tweezer-probes pull apart and have a metal solder tab inside. Run a cable strand through the hole in the cap, solder it to the metal tab, and then press the halves back together.

Tweezer quality varies dramatically among brands, we’ve used no-name probes that bend easily or don’t grip well. The X- series micro-hooks from E-Z-Hook are the Cadillac of tweezer-probes, we first used the XKM version that comes with the Saleae Logic. They’re intended to fit specialty test leads, but it’s easy to solder a wire to them instead. About $2 each, available directly from the E-Z-Hook website.

Conclusion

We highly recommend a cable with hook or tweezer-probes for secure connections without causing shorts. The right probe depends on the parts you use. Round test hooks work best with through-hole parts and wires. Flat test tweezers attach well to small, surface mount chips.

Please share any additional part sources in the comments. We did our best to provide a variety of sources, but there’s going to be some great places we’ve missed.

Friday, July 3, 2009 is the last day to pre-order a Bus Pirate. There’s only two days left to get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

Most of the parts we use operate at 3.3volts, but we still run into a lot of old 5volt stuff, and an occasional 2.5volt or 1.8volt part. This post explains how to use the Bus Pirate’s open collector pin mode to interface with parts at different voltages.

We’ve got more details and some example scenarios below the break. Yup, this is another Bus Pirate post. It’ll all be over soon though, because there’s a few days left to get your own Bus Pirate for $30, fully assembled and shipped worldwide.

Overview

The Bus Pirate has a normal pin mode and an open collector pin mode (also called high-impedance or HiZ). Normal pin mode can tolerate up to 5.5volts on input pins, but the output pins are fixed at 3.3volts. The open collector pin mode uses a pull-up resistor to set the bus voltage to something other than 3.3volts. Normal or open collector pin mode is offered as a configuration option after you select a protocol library in the Bus Pirate terminal (menu m). Some bus types always require open collector outputs with pull-up resistors, like 1-wire and I2C.

The image above shows a representation of normal and open collector pin functions.

Normal pin mode

Normal pins switch between the positive supply voltage (high state, usually 1) and ground (low state, usually 0), in the Bus Pirate that’s 3.3volts and 0volts respectively. A normal pin is depicted on the left, switch 1 (S1) toggles the output between supply (V+) and ground (GND).

Open collector mode

In open collector mode, pins switch between a ‘disconnected’ state (high impedance) and ground (low state, usually 0). The voltage that signals a high state is supplied by a pull-up resistor (R1). Without a pull-up resistor the attached devices will never register a high state. We can feed any voltage into the pull-up resistors that the Bus Pirate will tolerate, so we can use this mode to interface devices above and below 3.3volts.

An open collector output is depicted on the right. Switch 2 (S2) can only connect to ground. A resistor (R1) connected to the supply voltage (V+) holds the bus high. Most microcontroller pins are tri-state and become high impedance when configured as an input.

This technique isn’t without disadvantages. The maximum possible bus speed is much lower, and the pull-up resistors use a bit of extra current. Make sure every device you connect can tolerate the voltage you plan to use, most 3.3volt devices don’t have 5volt tolerant pins.

Usage examples

Scenario 1 – Bus Pirate interfacing 3.3volt UART/SPI/JTAG/MIDI bus
The Bus Pirate operates at 3.3volts, use normal pin outputs with no pull-up resistors.

Scenario 2 – Bus Pirate interfacing 5volt UART/SPI/JTAG/MIDI bus
The Bus pirate inputs are 5volt tolerant, but the output is only at 3.3volts. Use open collector outputs (HiZ) with pull-up resistors connected to the 5volt power supply.

Scenario 3 – Bus Pirate interfacing 2volt UART/SPI/JTAG/MIDI bus
The Bus pirate output is 3.3volts, which might damage a 2volt part. Use open collector outputs (HiZ) with pull-up resistors connected to the 2volt power supply.

Scenario 4 – Bus Pirate interfacing a 1-wire or I2C bus between 1.8volts and 5volts
1-wire and I2C are bi-directional, open collector buses. They always require a pull-up resistor to create the high bus state. Use pull-up resistors connected to the 1.8volt to 5volt power supply.

Microchip’s 25AA/25LC EEPROMs are data storage chips with a simple 3-wire interface. The 25AA/LC is an SPI version of the common 24AA/LC I2C EEPROM.  It comes in capacities of 128bytes to 128kilobytes. We looked at the smallest, the 128byte 25AA010A.

There are Bus Pirate demonstrations for most types of serial EEPROMs. Check out our previous 1-wire (DS2431) and I2C (24LC1025) EEPROM posts.

Continue below to see our test circuit and a demonstration of the 25AA010 EEPROM. We used the Bus Pirate to play with this chip from our PC.  For a limited time you can get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

25AA010A SPI EEPROM memory, 128bytes (Octopart search, $0.70). Datasheet (PDF).

The schematic above shows a simple test circuit that should work with any 25AA/25LC SPI EEPROM. It’s a good idea to use a 0.1uF decoupling capacitor (C1) on the power pin in a real circuit, but we didn’t use one for our demonstration. We also connected the write protect (WP) and hold (HOLD) pins to the supply voltage (V+) to disable these features.

We used our Bus Pirate universal serial interface to demonstrate this chip, but the command sequences will be the same for any setup. We connected the Bus Pirate to the 25AA010 as shown in the table above. We setup the Bus Pirate for SPI mode (M, 5) with normal outputs, and enabled the on-board power supply (capital ‘W’).

25AA parts work from 1.8volts to 5.5volts, 25LC parts have a 2.5volt minimum. We used a 3.3volt supply to power the chip, and interfaced it using the Bus Pirate’s normal 3.3volt pin outputs.

You could also power the chip from the Bus Pirate’s 5volt supply. Interface the chip at 5volts by choosing open drain pin type (HiZ) during the mode configuration, then hold the bus high with pull-up resistors connected to 5volts.

Interfacing

Page 7 of the datasheet has a complete list of interface commands. This demonstration shows the minimum operations needed to write and retrieve data.

SPI>[0b110] <–Bus Pirate command syntax
CS ENABLED <– Chip select enabled (0 volts)
WRITE: 0×06 <–Write enable command
CS DISABLED <– Chip select disabled (V+)
SPI>

A valid write enable command is required before data can be saved to the EEPROM. Enable the chip select signal to wake the chip ([), send the write enable command (0b110 binary, or 0x06 in hexadecimal), and then disable chip select (]).

SPI>[0b10 0 1 2 3 4 5] <– Bus Pirate command syntax
CS ENABLED <– Chip select enabled (0volts)
WRITE: 0×02 <– Write data command
WRITE: 0×00 <– Write address (*sometimes 2 bytes)
WRITE: 0×01 <– Data to write (5 bytes)
WRITE: 0×02
WRITE: 0×03
WRITE: 0×04
WRITE: 0×05
CS DISABLED <– Chip select disabled (V+)
SPI>

Store data in the EEPROM by sending the write command (0×02), the address to start writing (0×00), and the bytes to write (the values 1 to 5).

Up to 16 bytes can be written in a single operation. All writes must be on the same page of memory, see datasheet page 6 for details. EEPROMs larger than 256 bytes use 16 bit (2 byte) addresses.

SPI>[0b11 0 r:5] <– Bus Pirate command syntax
CS ENABLED <– Chip select enabled (0volts)
WRITE: 0×03 <–Read data command
WRITE: 0×00 <–Read address (*sometimes 2 bytes)
BULK READ 0×05 BYTES:
0×01 0×02 0×03 0×04 0×05 <– The data we wrote earlier
CS DISABLED <– Chip select disabled (V+)
SPI>

Read back the values to verify the write operation. Send the read command (0×03) and the address to start reading at (0×00), then read 5 bytes from the chip (r:5). The output should match the values we wrote earlier.

*EEPROMs larger than 256 bytes use 16 bit (2 byte) addresses. Enter a two byte address such as “0 0″ if you’re using one of these EEPROMs.

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

We’re only four days into the Bus Pirate pre-order, and we’ve exhausted the supply of PIC24FJ64GA002s available in Shenzhen. Thank you for supporting Hack a Day’s first official hardware pre-order. You helped make it a huge success, and we definitely want to do it again in the future.

We weren’t kidding about the PIC shortage. Seeed sourced all they could from Shenzhen, and then tried Hong Kong. It’ll take 4 to 6 weeks to get more.

If you already ordered a Bus Pirate then nothing changes, your Bus Pirate will ship ASAP. In fact, PCB production should start a few days early. The first pre-order item name starts with “[Preorder]“.

New orders are now forwarded to a second pre-order. The new pre-order will take 4 to 6 weeks longer. It should ship about 6 to 8 weeks after July 3, 2009, but we’ll try our best to get it out sooner. The new pre-order item name starts with “[Preorder 2]“.

Read more about the Bus Pirate in our latest How-to. Thank you again for your support!

Macetech’s ShiftBrite is a high-power RGB LED coupled with an Allegro A6281 backpack. The A6281 uses three 10bit pulse-width modulators to mix millions of colors using the red, green, and blue elements in the RGB LED. Multiple modules can be chained together for bigger projects, like the ShiftBrite table.

Below the break we demonstrate a ShiftBrite module using the Bus Pirate. For a limited time you can get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

ShiftBrite RGB LED module (Macetech, $4.99). ShiftBrite datasheet and example code, Allegro A6281 datasheet (PDF).

The ShiftBrite module is a complete A6281 development board. It doesn’t require any extra parts, just a 5-9volt supply.

The A6281 is one of the most complete RGB LED driver ICs, but it’s only made in a tiny QFN package. The ShiftBrite is a good way to try the A6281 without soldering a small chip.

A bunch of A6281 modules can be chained together. Each module repeats all of the serial input signals on separate output pins, so the A6281 will work over long cable runs.

We used our Bus Pirate universal serial interface to demonstrate the ShiftBrite, but the command sequences will be the same for any microcontroller. We connected the Bus Pirate to the ShiftBrite as shown in the table above.

We setup the Bus Pirate for raw3wire mode (M, 8), and chose open drain outputs (Hi-Z) so we can interface the ShiftBrite at 5volts. The Bus Pirate can’t output 5volts directly, so we enabled the bus pull-up resistors (menu ‘p’ in v2) and attached the pull-up resistor voltage input pin to the 5volt supply. Finally, we enabled the on-board power supply (capital ‘W’).

Interfacing

The LED driver output is only active when the enable pin (EI) is held low.

RAW3WIRE>A <– capital ‘A’, EI pin high, output disabled
AUX HIGH
RAW3WIRE>a <– small ‘a’, EI pin low, output active
AUX LOW
RAW3WIRE>

We used the Bus Pirate’s auxiliary pin to toggle the A6281’s enable pin, but you could also bypass this feature by wiring EI directly to ground. A small ‘a’ in the Bus Pirate terminal takes the AUX/EI pin connection low, enabling the LED output.

Two commands update the A6281 settings. The configuration command controls dot correction and clock settings. The LED pulse-width modulator (PWM) command updates the three 10bit values that set the red, green, and blue channel brightness. Both commands are 32 bits (4 bytes) long, bit 30 selects the configuration or pulse-width modulator command. Refer to the chart above, or datasheet page 7.

The interface protocol is like SPI, but the master-input-slave-output pin is unused. Data is sent most significant bit first, starting with bit 31. Commands are sent by clocking 32 bits into the chip and then toggling the latch pin.

Before we can start mixing colors, we need to setup the A628a’s internal clock and write the dot correction values.

RAW3WIRE>0b01000111 0b11110001 0b11111100 0b01111111 ][
WRITE: 0x47 <--write 32bits of data
WRITE: 0xF1
WRITE: 0xFC
WRITE: 0x7F
CS DISABLED <--latch pin high
CS ENABLED <--latch pin low
RAW3WIRE>

We wrote the values in binary so it's easy to follow along in the table above. Remember that bit 31 is sent first, so the order of bits shown here is opposite of what is shown in the table.

The complete setup command is 32 bits (4 bytes) long. Bit 30 sets this as a configuration command (1). Bit 7 and 8 configure the clock source, value 00 configures the 800KHz internal oscillator (datasheet page 7). Three 7bit 'dot correction' values fine tune the LED color channels if you want to correct a wonky pixel in a large array (see the register locations in the table above). We set all the dot correction values to full (1111111). Several bits trigger test functions or don't have a purpose, these should be entered as 0.

After entering 32 bits, toggle the A6281 latch pin (][) to lock the data into the register. Now that the chip is configured and the output enabled, we can finally play with the LED.

RAW3WIRE>0b00111111 0b11111111 0b11111111 0b11111111 ][
WRITE: 0x3F
WRITE: 0xFF
WRITE: 0xFF
WRITE: 0xFF
CS DISABLED
CS ENABLED
RAW3WIRE>

First, turn all the colors to full. Bit 31 (0) is ignored, bit 30 (0) indicates a LED pulse-width modulator update command, and the remaining bits set all three channels to 100%.  The three PWM values control the output intensity of each color as follows: blue (bits 29:20), red (bits 19:10), and green (bits 9:0). Raise and lower the latch pin (][) to end the command.

Next, test each each color individually.

RAW3WIRE>0b00111111 0b11110000 0b00000000 0b00000000 ][
WRITE: 0x3F
WRITE: 0xF0
WRITE: 0x00
WRITE: 0x00
CS DISABLED
CS ENABLED
RAW3WIRE>

Bit 30 (0) signals an LED PWM update command, followed by a 100% setting for the blue channel (1111111111) and 0% settings for the red and green channels. When we toggle the latch pin (][) the new values are saved and the LED color changes to blue.

RAW3WIRE>0b00000000 0b00001111 0b11111100 0b00000000 ][
WRITE: 0x00
WRITE: 0x0F
WRITE: 0xFC
WRITE: 0x00
CS DISABLED
CS ENABLED
RAW3WIRE>

This time we'll set the LED to 100% red. Bit 30 (0) signals an LED PWM update command, followed by a 0% setting for the blue channel, a 100% setting for the red channel (1111111111), and a 0% setting for green.  When we toggle the latch pin (][) the LED color changes to red.

RAW3WIRE>0b00000000 0b00000000 0b00000011 0b11111111 ][
WRITE: 0x00
WRITE: 0x00
WRITE: 0x03
WRITE: 0xFF
CS DISABLED
CS ENABLED
RAW3WIRE>

Finally, we set the LED to 100% green. Bit 30 signals an LED PWM update, followed by 0% settings for the blue and red channels, and a 100% setting for the green channel (1111111111).  Toggle the latch pin (][) and the LED color changes to green.

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Hack a Day review disclosure: Macetech gave us a couple free ShiftBrites at Maker Faire 2008.

The PCF8563 is a real-time clock/calendar/alarm chip with an I2C interface. This would be useful in projects where the primary microcontroller doesn’t have enough resources for an interrupt driven clock.

We demonstrate the PCF8563 using the Bus Pirate after the break. For a limited time you can get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

PCF8563 real-time clock calendar (Octopart search, $1.33). Datasheet (PDF).

The schematic above shows a bare-bones circuit for the PCF8563. It requires a simple external oscillator circuit with a 32.768khz watch crystal (Q1). The oscillator input pin needs an external capacitor (C1, 12pF), but the oscillator output pin already has an internal capacitor. C2 is a 0.1uf decoupling capacitor for the power supply pin. The power supply can be 1.5 to 5.5volts.

The datasheet also recommends a diode on the voltage input. We didn’t use this in our test.

We used our Bus Pirate universal serial interface to demonstrate this chip, but the transaction sequence will be the same for any microcontroller implementation. We connected the Bus Pirate to the PCF8563 as shown in the table above. We setup the Bus Pirate for I2C mode (M, 4) , and enabled the on-board power supply (capital ‘W’).

Don’t forget that you need pull-up resistors somewhere on the I2C bus. If you’re using a Bus Pirate, attach the Vpullup input to the circuit power supply then press p to configure the pullup resistors (or attach the pull-up jumpers for hardware v1a).

Interface

I2C>(1)<–search I2C address macro
Searching 7bit I2C address space.
Found devices at:
0xA2 0xA3
I2C>

The PCF8563 I2C  write address is 0xa2, and the read address is 0xa3. You can find this in the datasheet, or use the Bus Pirate search macro (1) to check all possible addresses.

This RTC has 16 one-byte registers that configure the clock, and set/retrieve the time. Bytes 0-8, shown in the table above, contain status and time information. The upper 7 bytes configure an alarm, timers, and other advanced features. We’re just going to focus on the clock functions.

The registers are accessed just like an I2C EEPROM. Write values by sending the I2C write address (0xa2), the address to start writing (0-15), and the data bytes(s) to write.

Read values from the chip in two steps. First, use the write command to position the read pointer, but don’t send any data bytes. Second, use the read address (0xa3) to read bytes starting at the position set during the write command.

I2C>{0xa2 2 0 30 12 31 1 5 9 }
I2C START CONDITION
WRITE: 162 GOT ACK: YES <–I2C write address (0xa2=162)
WRITE: 2 GOT ACK: YES <–register to begin writing
WRITE: 0 GOT ACK: YES <–seconds (0)
WRITE: 30 GOT ACK: YES <–minutes (30)
WRITE: 12 GOT ACK: YES <–hours (12/noon)
WRITE: 31 GOT ACK: YES<–day of the month (31)
WRITE: 1 GOT ACK: YES <–day of the week (1/Sunday)
WRITE: 5 GOT ACK: YES <–month (5/May)
WRITE: 9 GOT ACK: YES <–year (09/2009)
I2C STOP CONDITION
I2C>

Set the time by writing to registers 0×02 to 0×08. The values are entered in binary coded decimal format, with all numerical date representations being fairly standard (see datasheet pages 6-9). We set the time to 12:30:00 May 31, 2009.

First, send an I2C start condition to tell the chip to listen for its address (Bus Pirate command {). Next, send the PFC8563 write address (0xa2), and set the write pointer to the seconds register (2). Finally, write 7 bytes of data to the time registers at addresses 2-8. End the transaction with an I2C stop condition (Bus Pirate command }).

I2C>{0xa2 2 { 0xa3 r:7}
I2C START CONDITION
WRITE: 162 GOT ACK: YES <–send write address (0xa2=162)
WRITE: 2 GOT ACK: YES <–set pointer to register 2, seconds
I2C START CONDITION <–repeated start condition
WRITE: 163 GOT ACK: YES <–send read address (0xa3=163)
BULK READ 7 BYTES: <–read back 7 bytes
17 31 12 31 1 5 9 <–time: 12:31:17 Sunday, May 31, 2009
I2C STOP CONDITION
I2C>

We set the Bus Pirate’s output mode to decimal (menu ‘o’) before reading the time. This displays the values in the more familiar decimal format.

Retrieving the time takes two steps. First, a partial write transaction sets the memory location to read. Then, instead of sending any data, send a second start condition ({) and the PCF8563 I2C read address (0xa3) to put the chip in read mode. Finally, read 7 bytes (r:7) from registers 2 to 8. The output shows that a minute has passed since we set the time.

I2C>{0xa2 2 { 0xa3 r:7}
I2C START CONDITION
WRITE: 162 GOT ACK: YES <–send write address (0xa2=162)
WRITE: 2 GOT ACK: YES <–set pointer to register 2, seconds
I2C START CONDITION <–repeated start condition
WRITE: 163 GOT ACK: YES <–send read address (0xa3=163)
BULK READ 7 BYTES: <–read back 7 bytes
34 32 12 31 33 37 9 <–day of week (33) and month (37) appear wrong
I2C STOP CONDITION
I2C>

Sometimes the chip appears to return garbage results. The above output is actually a valid time reading, even though it’s obviously not the 33rd day of the week or the 37th month of the year.

Each register has several ‘do not care’ bits (see datasheet page 6). In most devices  ‘do not care’ bits are always set to 0, but the PCF8563 appears to use them in some time keeping capacity.

Day of week reads 33, or 0b00100001 in binary. If we ignore the upper 5 bits we get 0b001, or 1/Sunday, the proper day of the week. Similarly, ignore the upper three bits of month (37 = 0b00100101), giving 0b00101 or 5/May.

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Update, Saturday July 4th, 2009: All preorders are closed.

The Bus Pirate is a universal serial interface tool, we use it to test new chips without writing any code. It currently supports most serial protocols, including 1-Wire, I2C, SPI, JTAG, asynchronous serial, MIDI, and more. We added some other features we frequently need, like pulse-width modulation, frequency measurement, voltage measurement, bus sniffers, pull-up resistors, and switchable 3.3volt and 5volt power supplies.

The new v2 family adds USB power and connectivity to the best Bus Pirate design yet. We also reduced the part count and cost wherever possible. If you want to get your hands on some Bus Pirate USB goodness, Seeed Studio has assembled hardware for $30 (including worldwide shipping).

Read about the new design after the break.

Concept overview

The Bus Pirate connects to a PC USB port. The user send commands to the Bus Pirate from a serial terminal on the PC. Commands are translated to the bus protocols that control microchips. See our Bus Pirate page for full documentation.

The latest firmware supports 1-Wire, I2C, SPI, JTAG, asynchronous serial, MIDI, and PC keyboards. Bit-wise 2- and 3-wire libraries can interface most proprietary serial protocols.  More protocols are being added all the time, check out the source code on our Google Code SVN page.

Hardware

Click for a large image of the schematic (PNG). The schematic and board layout were made with the freeware version of Cadsoft Eagle. Download the latest files from our Google Code page.

PIC24F

A Microchip PIC24F series microcontroller generates the user interface and translates input into bus communications. V2 uses the same 24FJ64GA002 as the previous Bus Pirate versions. It’s cheap, has a ton of memory, a couple 5volt tolerant input pins, and the peripheral pin select feature lets us assign hardware modules anywhere we want.

The PIC (IC1) is powered by a 3.3volt regulator (VR2, C23). Each PIC power pin gets a 0.1uF bypass capacitor (C1,2). The internal 2.5volt regulator requires a 10uF tantalum capacitor (C20). The programming pins are brought to a five pin header (ICSP) on the edge of the PCB.

USB interface

The Bus Pirate is powered from the USB 5volt supply, which is first filtered with a ferrite bead (L1) and 10uF tantalum capacitor (C21). We used the small, still-not-quite-common, USB mini-b connector (J2).

Choosing a ferrite bead is a common hangup. Its purpose is to filter small power fluctuations, all the current for the circuit will go through it. We can guestimate that the Bus Pirate’s worst case current consumption is 525ma (3 power supplies @ 150ma, the FTDI chip @ 25ma, 2 LEDs @ 50ma max). Use a ferrite bead rated for at least 1000ma to be safe. We used this one, which is rated for 1500ma and costs 10 cents.

An FTDI FT232BL USB->serial chip (IC2) handles the USB connection. You might be familiar with this chip from various Arduino boards. FTDI has extensive driver support for most platforms, we used the virtual com port drivers.  This is the latest generation chip, and it’s only available in small SSOP and QFN packages. We had no problem hand-soldering it to a professional PCB, but it’s not for everyone.

The FT232BL is powered directly from the filtered, unregulated USB supply. C4 is a  decoupling capacitor for the FTDI232BL supply pin. A single LED (LED4/USB) indicates USB status and activity. The FT232BL RXLED pin sinks current, so we powered the LED from the 5volt USB supply through a 1.1K resistor (R3).

While the FT232BL runs at 5volts from the USB supply, its serial IO pins have an independent supply input – they can operate at another voltage. Since the microcontroller is 3.3volts, we just feed the FT232BL IO pins a 3.3volt supply and eliminate any funky translation circuitry. We used the chip’s internal 3.3volt regulator to supply the IO pins because it was the easiest trace to route. The IO pins get their own 0.1uF bypass capacitor (C5).

Switchable power supplies

The Bus Pirate has on-board 3.3volt and 5volt supplies (VR3, VR4) that can power a test circuit. The supplies are switchable, so we can reset the circuit from software when something goes wrong. To be extra safe, the supplies are held off until activated in the terminal.

[Nathan Seidle] at SparkFun recommended that we replace the  TPS796xx ($2.50) we used in The Bus Pirate v1a with a MIC5205-xxYM5 ($0.90). They supply just 150ma maximum current, compared to 800ma from the TPS796xx, but the cost savings and reduced part-count are worth it.

The regulators are fed from the 5volt USB supply. The 5volt regulator drops a few millivolts below optimal because there’s no headroom, but it’s within the minimum level specified by most 5volt parts.

The MIC5205 requires a large output filter capacitor (C22-24, 10uF), but no input capacitor. An optional small-value capacitor on the BP pin can decrease power supply noise, but we left this off because it didn’t make much difference in practice.

A small voltage on the EN pin enables the supply, we used a 10K pull-down resistor (R18, not shown) to ensure that the supplies stay off while the PIC initializes. LED3/VREG, with current limiting resistor R32, lights when the power supplies are active.

On-board pull-up resistors

Bus Pirate V2 has multi-voltage, software controlled pull-up resistors via the 4066 (PDF) quad bilateral switch (IC3). When enabled, the 4066 connects the four on-board bus pull-up resistors (R20-23, 10K) to any external signal on the Vpullup pin (0 to 5volts). When disabled, the outputs are high-impedance and have no effect on the bus lines.

The 4066 can’t switch an input voltage greater than the supply voltage. To give it the widest possible range, we powered it from the USB supply (5volts).

When operated at 5volts, it takes 4volts+ to enable the 4066. The PIC pins have a maximum output of 3.3volts, so we have a problem. We solve it with a 5volt tolerant PIC pin and a pull-up resistor.  We turn on the 4066 with a pull-up resistor to 5volts (R19, 10K), and then disable it by switching the connected PIC pin to ground.

For a brief instant at power-on, the PIC pin is high-impedance and the 4066 outputs are active because the pull-up resistor holds the control pins at 5volts. This is a concern if the Vpullup input is connected to an external 5volt supply while the bus is connected to a 3.3volt device – the brief exposure to 5volts might harm the device. If you’re worried about this, make sure there’s no active power supply connected to the Vpullup input before powering the Bus Pirate. This isn’t a concern if you use one of the on-board power supplies for the pull-up voltage because they’re disabled at startup.

Voltage monitoring

Four voltage dividers (R10-17, 10K), attached to analog to digital converters, allow the 3.3volt PIC to safely measure up to 6volts DC.

Two voltage monitors measure the switchable power supply output. One measures the Vpullup input voltage, and another connects to the external voltage measurement probe.

Indicator LEDs

Three LEDs indicate power, mode, and voltage regulator status (LED1-3). LED4/USB displays USB activity.

There are pads for resistors R30-32 and LEDs 1-3 on the front and back of the PCB. Only one set should be populated. We put pads on both sides so the board could be mounted with the indicator LEDs abutting the top of an enclosure.

V2a vs V2go

Click for large schematic (PNG) and layout (PNG) images of the version 2a hardware. The Eagle layout files are available in our Google Code SVN.

Bus Pirate V2a is a developer’s board. In addition to all the features of V2go, it includes a jack (J1) for an external power supply and an additional 5volt regulator (VR1).  A switch (S1) selects between USB power and the external supply.

The FT232BL chip on V2a is powered directly from the USB supply, and is not connected to the external supply. This is useful if you want to disable USB and use the Bus Pirate with a serial port on a PC or PDA.

The V2a 4066 enable pull-up resistor is powered by the switchable 5volt regulator. The 5volt regulator must be enabled for the 4066 to be active. Don’t forget to install the 4066 pull-up resistor (R19), located on the back of the v2a PCB.

PCB

The PCB is a compact, 2-layer design. We prepared gerbers and had PCBs made by our usual service, BatchPCB ($21, shipped to EU), and tried a new service offered by Seeed Studio ($32, shipped worldwide).

Seeed has a PCB service specifically for open source hardware projects. For $32 (including worldwide shipping) we got 5 small PCBs, and Seeed made a few extra to sell in their shop. We liked the idea that there would be extra PCBs available.

You might know Seeed Studio from their cheap, improved Seeeduino Arduino clone. They’re located in Shenzhen, a Chinese electronics manufacturing hot-spot. A bunch of notable bloggers recently visited the region and wrote about the huge electronic component markets.

The Seed order arrived in 14 days (left), the BatchPCB order arrived in 30 days (right).  Seeed and BatchPCB both make beautiful PCBs. Seeed has a much faster turn-around, and has better minimum trace widths and separation (8mil vs 6mil). BatchPCB has standard green PCBs, Seeed gives you the choice of green, black, or white; red, blue and yellow are $7.50 extra.

We really like the Seeed PCB service, extra Bus Pirate v2go and v2a PCBs from our order are available in the Seeed shop. BatchPCB remains the cheapest prototyping option if you want a single board, closed source work, or don’t mind the extra wait.

Parts list

Firmware

The latest Bus Pirate firmware for all hardware version is always available on our Google Code page. The code is written in C, and is compiled with the Microchip C30 demonstration compiler.

Bootloader

The biggest change in the latest firmware is the addition of a bootloader. Now the firmware can be updated through the USB or serial connection.

A bootloader is small program that sits at the beginning of the PIC program memory. It accepts updated firmware through the USB or serial port and saves it to the chip.

The bootloader comes from Microchip application note AN1157. We modified the bootloader to check for a jumper between the programming clock (PGC) and data (PGD) pins at power-up (update, above left). If there’s a connection, the bootloader takes over and waits for new code. Without a connection, the bootloader exits and runs the main program.

There’s a very minor chance of accidentally entering the bootloader with no jumper installed. This won’t damage the Bus Pirate, but you will need to connect it again.  You can prevent it by moving the jumper over one position,  between the ground pin and the inner programming pin (normal, above right).

Upgrading the firmware with the bootloader

If you’re using a fresh chip, first program it with the bootloader firmware (vxx-PIC Bootloader.hex) through the ICSP header using a ‘real’ programmer like an ICD2 or PicKit.

If you’re upgrading, follow this procedure or refer to the instructions in the firmware download.

• Disconnect the Bus Pirate from any power supply such as the USB cable.
• Place a jumper between the programming data and clock pins of the ICSP header. This will trigger the bootloader mode.
• Connect the Bus Pirate to a USB port (or, if applicable, power and serial cable).
• Start the MS Windows P24QP.exe programmer utility. You may need to modify the COM port (portindex=) in P24qp.ini to match your system.  Programmer source is available, and the simple bootloader protocol is documented in AN1157 if you want to write an app for a non-Windows system.
• Click the connect to device icon (#1). The program will connect to the PIC.
• Click the folder icon (#2) and open the firmware update file (vxx-Firmware for BL.hex).
• Click the erase device icon (#3) to erase the chip. DO NOT SKIP THIS STEP. Programming may not be successful if you forget to erase the chip.
• Click the write device icon (#4) to program the new firmware. Ignore any verify errors between 0×400 and 0xBFF, the bootloader lives in this region and doesn’t get updated.
• Click the green arrow icon (#5) to exit the bootloader and start the program. Click OK at the warning, we use the jumper to re-enter the bootloader.
• Remove the jumper from the programming pins, or move it over one position to connect the inner PGx pin to ground (GND).
• ***IMPORTANT*** Now restart the Bus Pirate by disconnecting and reconnecting the USB cable (or power cable). Some features won’t work until after a complete hardware reset.

Using it

USB device driver

You may need to install an FTDI virtual serial port driver for your platform.

On Windows, go to the Device Manager to configure the FTDI driver or check the COM port number.

Menus and Syntax

Use a serial terminal to communicate with the Bus Pirate. We like Tera Term.

The Bus Pirate works best with the terminal set to 115200bps, 8 databits, no parity, 1stopbit. Disable local echo in the terminal, and use CR for line breaks. Some modes also require Xon/Xoff software flow control.

In the serial terminal, press ? for the help menu. Read more about the Bus Pirate’s menu and syntax on the Bus Pirate page. There’s lots of demonstrations in our recent parts posts.

LED indicators

• PWR indicates power to the Bus Pirate.
• MODE is off when the I/O pins are in a safe, high-impedance state. MODE is lit when a bus mode is engaged, the pins may be active.
• VREG indicates that the on-board switchable power supplies are active.
• UR is a single USB activity indicator LED. It displays data coming from the PC to the Bus Pirate. You can probably change what this LED displays with the FTDI configuration utility.

Connections

Pin location diagrams: v2a, v2g0.

Notes: * TX moved from CS to MOSI in firmware v0g.

The 10 pin I/O block contains the data signals and power supplies that connect to a test circuit. Each pin is labeled on the back of the PCB, refer to the table above for a detailed description.

The pinout on V2 is similar to V1, but we moved the power supply output and Vpullup input to the cable bundle. We also eliminated the second, unused auxiliary pin.

Conclusion

If you want a complete Bus Pirate or a kit, here’s a couple options:

• Seeed Studio is accepting pre-orders for assembled Bus Pirate v2go hardware until the end of Friday, July 3.  An assembled Bus Pirate v2go is $30, including worldwide shipping.
• Seeed Studio also has the extra v2g0 ($5.90) and v2a ($6.50) PCBs from our order.
• Fundamental Logic sells a through-hole kit version of the Bus Pirate V1a ($29.50). ***v1a is serial port only***

Thanks to everyone who contributed to this project. The Bus Pirate wouldn’t be possible without a ton of great feedback from the comments. If you’d like to get involved, join the Bus Pirate project at Google Code.

Hack a Day review disclosure: We asked Seeed Studio to make our first order of PCBs for free. Since then, we’ve made several paid orders.

Firmware v0g for all Bus Pirate revisions is now available. Updates in this release include a bootloader, frequency generator/pulse-width modulator, SPI bus sniffer, MIDI library, configuration reports, improved user interface, and bug fixes. v0g is also the first firmware to fully support the v2 hardware branch.

We’re really proud of this release as it brings a much more consistent structure to the internal operation of the Bus Pirate. It lays the foundation for future CAN, LIN, and OBDII libraries, and it supports localization and translations.  Install and upgrade instructions are included with the firmware. Report bugs on the project issue tracker.

We document the new features after the break.

Bootloader

Firmware v0g includes a bootloader. After the bootloader is installed, firmware updates can be done over the serial or USB connection, instead of using a proper ICSP programmer. Install and update instructions are included in the firmware archive.

Frequency generator/pulse-width modulator

1-WIRE>g <–frequency generator/PWM setup command
1KHz-4,000KHz frequency generator/PWM (beta)
FREQUENCY in KHz (50) >50 <–enter frequency in KHz
PRESCALE:8 <–calculated prescaler
PR2:39 <–calculated PR2 value
DUTY CYCLE in % (50) >50 <–enter percent duty cycle
PWM ACTIVE
1-WIRE>f <–frequency measurement command
PWM ACTIVE: DISABLE PWM <–not available when PWM is active
1-WIRE>g <–g again to disable PWM
PWM DISABLED
1-WIRE>

A 1Hz-4MHz frequency generator/pulse-width modulator function is available on the auxiliary pin using menu option ‘g’. This feature is still in development, but v0g has the essential functionality.  The frequency generator and frequency measurement features can not be used at the same time. We also squashed a small bug in the frequency measurement code for hardware v1+.

SPI bus sniffer

SPI>(1) <–sniffer macro
Sniff when:
1. CS low
2. CS high
3. All traffic
(1) >3 <–when to sniff bus
SPI BUS SNIFFER, PRESS ANY KEY TO EXIT
0×10(0×00) 0xC6(0×00) <–displays data as MOSI(MISO)
SPI>

The PIC24F’s SPI slave mode made it easy to add an SPI bus sniffer. It works fine on slow or intermittent data transmissions, but it needs additional output buffering for better performance at high speeds. For the best performance, change the Bus Pirate display mode to ‘raw output’.

MIDI library

MIDI, a popular interface for musical instruments, is simply a 33.2K baud/8/N/1 UART. The MIDI library has the same functions as the asynchronous serial port library, with the settings fixed for MIDI communications. MIDI devices require an isolated transceiver, we’re working on one but need a MIDI connector footprint and part number.

Bus Pirate status report

RAW3WIRE>i <– status report command
Hack a Day Bus Pirate v2g0
http://www.buspirate.com
Firmware v0g
*———-*
POWER SUPPLIES ON
VOLTAGE MONITOR: 5V: 5.0 | 3.3V: 3.3 | VPULLUP: 5.0 |
AUX: DEFAULT SETTING (AUX PIN)
High-Z outputs (H=input, L=GND)
PULLUP RESISTORS OFF
MSB SET: MOST SIG BIT FIRST
*———-*
RAW3WIRE>

A new in-terminal status report lists the features available in the active protocol library, and the current settings.

User prompts with defaults

HiZ>m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. JTAG
7. RAW2WIRE
8. RAW3WIRE
9. PC KEYBOARD
10. MIDI
(1) > <–press enter for default option (1/HiZ)
MODE SET
HiZ>

The user prompt has been updated to accept multiple-digit values. Enter without any input selects the default value shown in parentheses before the prompt. All user input is now handled by this single user prompt function.

User value input format

SPI>r:0×02 <–repeat in hex format
BULK READ 0×02 BYTES:
0×00 0×00
SPI>(0b0) <–macro command in binary format
0.Macro menu
1.SPI bus sniffer
SPI>

All user prompts now support input values in binary, hexadecimal, or decimal. Previously, menu and macro prompts only supported decimal formatted input.

Localization, translations

A lot of the text used in the program has been moved to a translation file, which is defined in base.h.

If you make a translation, please share it with us. We’ll host the translation in SVN and compile a localized firmware for anyone that might be interested.

Test the v0h beta

If you like to live on the edge, try the v0h nightlies. These features are already implemented in v0h nightlies:

• I2C sniffer,
• HD44780 character LCD test library.
• Keyboard library I/O timeout.
• Improved syntax parser.
• Software reset command.

Check the issue tracker for future features, or to make feature requests.

Fundamental Logic is selling a Bus Pirate kit and bare PCB based on our universal serial interface tool. They started with our serial port-based v1a hardware, and modified it to use all through-hole parts.  8pin DIP LP2951ACN/-3.3 switchable voltage regulators replace the surface mount TPS79650/33 that we used. The PIC is pre-programmed with our latest firmware, version 0f, which includes a bootloader for easy firmware updates through the serial port. Documentation includes illustrated assembly instructions.

Speaking of Bus Pirate goodness, we’re busy working on hardware V2. As astute readers may have already noticed, the final version of the Bus Pirate incorporates an FTDI USB->serial chip, and draws its power from the USB port. We also tackled the software-controlled pull-up resistor feature, and reduced the overall part count and cost. Best of all, we’re working to make assembled PCBs available with world-wide shipping. The how-to should be ready in a few weeks.