In an effort listen to his music on shuffle without the need to touch the volume knob [Mike] build his own automatic volume leveling hardware. He knows what you’re thinking right now: there’s software to do that for you. But building the feature in hardware is a great stepping off point for a project.

He started the prototype using LabVIEW along with a Mobile Studio development board and a Bus Pirate. This project will be a mix of digital and analog components and it’s a bit easier starting off the exploration with these tools rather than jumping right into the AVR code.

The circuit will sample the incoming audio, modify it accordingly, and output the result. The output side is where the Bus Pirate really shines. He’s using some MCP42010 digital potentiometer chips to make the necessary changes to the levels. They communicate via SPI and it’s nice to have the Bus Pirate’s terminal to issue commands without the need to reflash a microcontroller.

[Mike] made a video showing an audio waveform with and without the hardware leveling. Sound quality is still great, and each clip is played at a reasonably comfortable listening level. We’ve embedded that demonstration after the break.

[yotuube=http://www.youtube.com/watch?v=YaEc6_wQ9FM&w=470]

[Fezoj] likes to play around with microcontrollers and decided that he wanted to try a Bus Pirate as a new tool in his adventures. Since it’s open hardware he had his own board made and populated it himself. The trouble is, he works only with AVR chips and doesn’t have a PIC programmer. No problem, he figured out how to flash the PIC24FJ using an ATmega8.

To get started, he grabbed a copy of the flash programming specifications from Microchip. Once he had implemented the protocol in the AVR code, it was just a matter of getting the downloaded PIC firmware to the AVR. An RS232 chip gives him the serial connection he needs, with the help of his own programming software written with Visual Studio.

It’s not a robust solution for prototyping on the PIC platform, but maybe it could be developed for that purpose. For now, all he needed was a bootloader so that he could flash the Bus Pirate via a USB connection.

[via Dangerous Prototypes]

The team at nonolith labs announced their CEE, a device for billed as, “an analog buspirate” that is meant to control, experiment, and explore the world of analog electronics. Nonolith labs started a kickstarter campaign for the CEE.

The CEE is capable of sub-millivolt and milliamp sampling at 44.1k samples/second, and sourcing 2 channels of 5V @ 2A with a little bit of soldering. This allows for precise control of motors and sensors with the web-based UI. We’re thinking this would be a great way to teach high schoolers the art of electronics, and would be great combined with a few lectures from Paul Horowitz.

The CEE ties into nonolith labs Pixelpulse, a pretty handy tool for visualizing analog and digital signals. You can check out a demo of Pixelpulse simulating a charging capacitor here.

We’re hoping this focus on education on analog electronics catches on – you can learn a lot more by building a 555-based mini Segway than you can slapping a microcontroller in every project. This would go under the same theory as, “any idiot can count to one.”

Check out the video of the CEE on the kickstarter campaign page.

It’s fun to pick apart code, but it gets more difficult when you’re talking about binaries. [Joby Taffey] opened up the secrets to one of [Travis Goodspeed's] hacks by disassembling and sniffing the data from a Zombie Gotcha game binary.

We looked in on [Travis'] work yesterday at creating a game using sprites on the IM-ME. He challenged readers to extract the 1-bit sprites from an iHex binary and that’s what got [Joby] started. He first tried to sniff the LCD data traces using a Bus Pirate but soon found the clock signal was much too fast for the device to reliably capture the signals. After looking into available source code from other IM-ME hacks [Joby] found how the SPI baud rate is set, then went to work searching for that in a disassembly of [Travis'] binary. Once found, he worked through the math necessary to slow down communication from 2.7 Mbit/s to 2400 bps and altered the binary data to match that change. This slower speed is more amenable to the Bus Pirate’s capabilities and allowed him to dump the sprite data as it was sent to the LCD screen.

[Thanks Travis]

[Koala] was worried his pseudo smart card trick wouldn’t be considered a HackaDay worthy. We’re more worried the internet police will find this article and have us all tarred and feathered.

Jokes aside, it seems Laundromat owners sure aren’t learning. Long story short, using a Bus Pirate and a few techniques we’ve seen before for smart card hacking [Koala] is able to write whatever amount he needs onto his pseudo smart card; thus giving him a free load of laundry.

If you’re like us you’ve got quite a few prototyping tools that are bare PCB boards. If you’re using them a lot you might want to protect them with some type of case but the lack of mounting holes can make this difficult. One popular solution to this problem is to design a case for a perfect fit, then cut it with a laser or print it out of plastic. We’ve got examples of both.

[Stewart Allen] set to work designing laser cut cases for the AVR Dragon and the Bus Pirate V2go after seeing our post about on-the-go prototyping. We think this is especially important if you have an AVR Dragon as it’s been known to bite the dust if the bottom is shorted out. If you have access to a laser cutter you can download is DXF files and the models and cut your own.

If you don’t have a laser cutter but can get some time with a 3D printer check out the Bus Pirate V2go printed case and the Arduino printed case.

Sometimes your project needs a lot of non-volatile ROM, right on cue [Matthew] let us know how to not only connect, interface, read, and write to SD cards with a PIC over serial, but also how to do the above mentioned with an old PATA HDD. For those without a PIC/serial connection don’t fret, [nada] let us know about his Bus Pirate SD card hack, of which our personal favorite part is the creative use of an old 5.25″ floppy connector as the SD card socket.

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: 0x0F <–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 0x6b 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).

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.

2x5pin 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 2x5pin 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 2x5pin 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 2x5pin 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.