Two years ago Microchip introduced serial EEPROMs with UNI/O. The speciality is the single pin data interface, so the memory chip needs only 3 pins including power. This can be great help for the smallest 6-pin microcontrollers like PIC10F or ATtiny10 series which doesn’t have any non-volatile memory writable from application itself. Memory densities range from 1 Kb to 16 Kb. It competes with 1-wire EEPROMs from Maxim but at significantly lower prices and lower working voltages.

UNI/O bus uses Manchester encoding to combine clock and data to single line. ACK bits at the end of each byte are similar to I2C bus, but there are always two: one from master and one from slave. Addressing and write protection is all managed by software. Currently there are no other UNI/O devices than EEPROMs but the bus manual suggest that there should be others like temperature sensors, A/D converters or port expanders. Application notes with code examples are available for several different MCUs.

megabug replaced the 1Mbit EEPROM storage chip on the web platform with a 32Mbit (4MB) flash rom chip. Support is already available in the Microchip TCP/IP stack, so all you need to do is swap the chip and enable a few options in the configuration file

Via the forum.

Restoring a Zeno zit zaper tip was one of the first published ‘hacks’ using the Bus Pirate a few years ago. It’s still a super popular post that gets a ton of hits. Here’s some updates:

Was jacking around with the Zeno again recently and figured out (as far as I can tell) how to get the most counts or uses possible onto a Zeno tip. I started by comparing the tip EEPROM data of the 60, 90 & 150 count tips. Of the three data sets bytes 2, 12, 49, 65 & 66 were the only ones that changed from tip to tip. After studying these changes I eventually found a pattern and was able to put together some formulas for creating your own custom count tip. But really, who wants less than the maximum amount? For the method I worked out, the tip count must be in multiples of 15. Not saying the Zeno cares, but for the pattern I observed the tip count must be a multiple of 15.

I use TeraTerm for resetting my Zeno tips. For those that dont want to use TeraTerm but need the EEPROM data, open the TeraTerm macro and extract the data you need. For those that do want the macro, here it is: 240 Count Macro for use with TeraTerm

Get your own handy Bus Pirate for $30, including world-wide shipping. Also available from our friendly distributors.

MrZor decided to find some use for his Bus Pirate. After dissembling a LED POV fan he figured out that it uses a 24LC02B EEPROM chip to store the text displayed on the device.

The 24LC02B is a I2C device so he used the I2C mode of the Bus Pirate to interface with it. After some deciphering he figured out the code used by the device and uploaded his text. The result can be seen above, and the tutorial on how he went about doing it can be found on the forum.

Via the forum.

Get your own handy Bus Pirate for $30, including world-wide shipping. Also available from our friendly distributors.

JJShortcut took one of the webkey USB devices his school was discarding and decided to reverse engineer it. The device plugs into the USB port on a PC and when its on-board button is pushed it opens the computer’s web browser, directing the user to a specific URL.

He found that the heart of the device was a 24C02 EEPROM containing the URL data. Using the Bus Pirate he was able to read the EEPROM and reprogram it with the URL of his choice.

You can get your own Bus Pirate for less than $30.

brentbxr via the contact form.

Some applications require you to store data that wont be lost if the power goes down. Usual solutions involve either using an on-chip EEPROM or external memory devices.

This app note from Microchip provides an alternative that allows you to store your data in the programming memory without having the usual low rewrite cycles associated with this approach. The algorithm described in the app note moves the stored date around the free programing memory to increase the rewrite cycle efficiency up to 500 times.

Emulated data EEPROM is an effective solution for cost-sensitive applications that require high-endurance, nonvolatile data memory. Applications suited for Microchip Technology’s cost-effective MCU and DSC devices can employ unused program memory and increase nonvolatile data endurance by a factor in excess of 500. This “effective endurance” can be customized by selecting the number of program memory pages, size of emulated data EEPROM and the erase/write limit. This flexible algorithm will enable you to add high-endurance data EEPROM to your applications.

STMicroelectronics has introduced the M24LR04E-R 4-Kbit Dual Interface EEPROM with RFID. “The M24LR04E-R device is a dual-interface, electrically erasable programmable memory (EEPROM). It features an I2C interface and can be operated from a VCC power supply. It is also a contactless memory powered by the received carrier electromagnetic wave. The M24LR04E-R is organized as 512 × 8 bits in the I2C mode and as 128 × 32 bits in RF mode. The M24LR04E-R also features an energy harvesting analog output, as well as a user- configurable digital output pin toggling during either RF write in progress or RF busy mode.” This device operates on a single supply voltage between 1.8 – 5.5 volts when using the I2C interface, with RFID operation harvesting energy from the reader device.

Information on managing simultaneous I²C and RF data transfers can be found in STM app note 4125. Use as an NFC vicinity tag is discussed in STM app note AN3408.

Single unit retail pricing on the 8-pin TSSOP package is in the $1.50 range from DigiKey.

Product details can be found in the 142 page PDF datasheet.

Bus Pirate v4 has an on-board 24xx64 8Kbyte data storage chip called an  EEPROM (IC3). It can be used to store various settings and preferences, but cooler, the EEPROM’s I2C interface can be accessed from within the Bus Pirate’s I2C mode. First time users can get familiar with the Bus Pirate without any added components!

Two 2K pull-up resistors (R8, R9) are connected to the I2C lines. The chip is powered at 3.3volts and gets a 0.1uF decoupling capacitor (C6) on the power supply pin.

24AA- series I2C EEPROM from Microchip come in a ton of sizes. AA parts work from 1.8volts to 5.5volts, while the 24LC- parts have a 2.5volt minimum requirement.

If you are a first time BP user please read Bus Pirate 101 tutorial first. Get familiar with I2C terminal commands from  I2C. Continue reading below on how to interface with the on board EEPROM.

Connections

• The on-board 24xx64 EEPROM is internally connected to alternate hardware I2C interface.
• Connect the BP4 to PC through a micro USB cable. No other connection is required.

Bus Pirate setup
1.Enter Mode command by typing m

 HiZ>
HiZ>m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. 2WIRE
7. 3WIRE
8. KEYB
9. LCD
10. PIC
11. DIO
x. exit(without change) 

2.Configure I2C mode by selecting mode 4.

 (1)>4 

3.Configure Hardware based I2C

  I2C mode:
1. Software
2. Hardware

(1)>2 

4. Set I2C clock speed to 400Khz (any speed listed below can be used for EEPROM).

  Set speed:
1. 100KHz
2. 400KHz
3. 1MHz
(1)>2
Ready 

5.List the available macros for I2C mode using (0) command

  I2C>(0)
0.Macro menu
1.7bit address search
2.I2C sniffer
3.Connect to on-board EEPROM
4.Enable Writing the on-board EEPROM 

We will be using macros (3), (4) and (1) for accessing onboard 24XX64 EEPROM

6.Use (3) macro to connect to the on-board EEPROM. This mode uses an alternate I2C hardware interface different from the one available in the BP4 connector.

 I2C>(3)
Now using on-board EEPROM I2C interface 

7.Use (1) to search for I2C slave address. This is always found in product datasheet. Bus Pirate can search this for us.

  I2C>(1)
Searching I2C address space. Found devices at:
0xA0(0x50 W) 0xA1(0x50 R) 

In the above output, address 0xA0 is used for writing data to the EEPROM and address 0xA1 is used for reading data from the EEPROM. This information is found in the device data sheet.

Configure the chip

The 24XX64 EEPROM is write protected when WP pin is set to high. The write protect has to be disabled by clearing the WP pin (i.e set to 0). WP pin is not connected to AUX as in an the case of external I2C EEPROM. This pin is internally wired and always set to 1 during setup.

Use macro (4) to disable write protection

 I2C>(4)
On-board EEPROM write protect disabled 

Interfacing

Write and read operation is accomplished with two command 0b1010 000 0 (i,e 0xA0) and 0b1010 000 1 (i,e 0xA1).

• In this 0b1010 is base address common to 24AA EEPROMs.
• It is followed by 000 for SOT23 package 24AA devices like 24AA64.
• The least significant bit indicate write (1) or read (0) operation

Writing to EEPROM

The simplest form of write operation is Page Write. In this operation, we can write data sequentially to EEPROM without sending a stop condition until reaching byte 31.

 START_CONDITION|WRITE_COMMAND|ADDRESS_HIGH|ADDRESS_LOW|DATA1|DATA2|...DATAn| STOP_CONDITION 

Please note that the start address should always be at page boundary. We can write any data up to the maximum of the page boundary in one operation.

  I2C> [0xA0 0 0 0 1 2 3 4 5 6 7 8 9 10 11 12 13]
I2C START BIT
WRITE: 0xA0 ACK
WRITE: 0x00 ACK
WRITE: 0x00 ACK
WRITE: 0x00 ACK
WRITE: 0x01 ACK
WRITE: 0x02 ACK
WRITE: 0x03 ACK
WRITE: 0x04 ACK
WRITE: 0x05 ACK
WRITE: 0x06 ACK
WRITE: 0x07 ACK
WRITE: 0x08 ACK
WRITE: 0x09 ACK
WRITE: 0x0A ACK
WRITE: 0x0B ACK
WRITE: 0x0C ACK
WRITE: 0x0D ACK
I2C STOP BIT
I2C> 

In the above operation, 0xA0 is write command. Followed by 0 and 0 are high and low begin addresses. 0 1 2 3 …. 13 are set of data written sequentially to EEPROM starting at address 0×0.

For each correct operation we get an ACK

Reading from EEPROM

Let us look into a simple read operation using Page Read. Let us read the data already written using the above Page Write operation.

1. Set the internal address pointer to address 0×0.

 START_CONDITION |WRITE_COMMAND|ADDRESS_HIGH|ADDRESS_LOW| STOP_CONDITION  

  I2C>[0xA0 0 0]
I2C START BIT
WRITE: 0xA0 ACK
WRITE: 0x00 ACK
WRITE: 0x00 ACK
I2C STOP BIT 

2.Read the data sequentially

 START_CONDITION|READ_COMMAND|rrrrrrrrrrrrrr| STOP_CONDITION 

 I2C>[0xA1 rrrrrrrrrrrrrr]
I2C START BIT
WRITE: 0xA1 ACK
READ: 0x00
READ: ACK 0x01
READ: ACK 0x02
READ: ACK 0x03
READ: ACK 0x04
READ: ACK 0x05
READ: ACK 0x06
READ: ACK 0x07
READ: ACK 0x08
READ: ACK 0x09
READ: ACK 0x0A
READ: ACK 0x0B
READ: ACK 0x0C
READ: ACK 0x0D
NACK
I2C STOP BIT  

For reading each byte, we have used a r. Totally 14 bytes were read sequentially. The data returned are same as the one we wrote with write (0xA0) operation

Random READ and WRITE Operations

Data can be written or read one byte at a time using the following operations

Byte WRITE

 START_CONDITION |WRITE_COMMAND|HIGH_ADDRESS|LOW_ADDRESS|ONE_BYTE_DATA| STOP_CONDITION 

  I2C>[0xA0 0x1 0xA 0xE]
I2C START BIT
WRITE: 0xA0 ACK
WRITE: 0x01 ACK
WRITE: 0x0A ACK
WRITE: 0x0E ACK
I2C STOP BIT 

0×1 is high address, 0xA  is low address and 0xE is one byte data.

Byte READ

 START_CONDITION |WRITE_COMMAND|HIGH_ADDRESS|LOW_ADDRESS| <strong>START_CONDITION</strong> |READ_COMMAND|r| STOP_CONDITION 

  I2C>[0xA0 0x1 0xA [0xA1 r]
I2C START BIT
WRITE: 0xA0 ACK
WRITE: 0x01 ACK
WRITE: 0x0A ACK
I2C START BIT
WRITE: 0xA1 ACK
READ: 0x0E
NACK
I2C STOP BIT
I2C> 

0×1 is high address, 0xA is low address and r is to read one byte data. We read the correct data 0x0E.

Bit Banging I2C on mid-range MCUs with the XC8 C compiler:

This application note is intended to serve as a reference for communicating with Microchip’s 24XXXX series Serial EEPROM devices without relying on a hardware serial port to handle the I2C operations.

Here’s is a video describing the basic concepts of using Freescale flash memory to emulate EEPROM.

mkeller0815 built  his own programmer – the MEEPROMMER, that is available at github:

The idea behind this EEPROM programmer was to have a tool to get data on a 28Cxxx EEPROM for my own 6502 based computer. There are a lot of professional programmers you can buy, but for a lot of money. Using cheap and easy available components should keep the price low.
The 28Cxx series of EEPROMs are 8 bit, parallel memory chips that are electric (re)programmable and also erasable.

There is a thread on the 6502.org forum covering the development of this programmer.

Via 6502.org.

Jechavarria shared some tips and tricks on using the 24LC256 I2C EEPROM  memories:

I resume this brief series of articles with another device I usually use. It’s the popular 24LC256 I2C EEPROM memory, from Microchip. First of all, you can find the datasheet here. This memory has a 32K x 8 bytes of capacity (36768 bytes if you prefer), and can works between 1.7V to 5.5V, with a maximun clock frequency of 1MHz (FC model with Vcc > 2.5V). Of course, it’s compatible with the 100khz and 400khz standard speeds. Here’s a block diagram of this memory.

Bob writes:

I found an old EEPROM chip in my spare parts collection, the 93LC46B. The data sheet says it communicates using 3-wire serial I/O, and can store 1024 bits organized either as 8- or 16-bit words.
Next was the question of how to wire the bus pirate to the chip. I liked the idea of plugging some headers into a breadboard
These give the Bus Pirate’s clips something to grab onto.
Then, I wasn’t sure if I needed to create a separate power supply. Turns out one can simply power the chip directly from the Bus Pirate’s 3.3V connector. This is undoubtedly one of the reasons the Bus Pirate is such a well-regarded tool.

Get your own handy Bus Pirate for $30, including world-wide shipping. Also available from our friendly distributors.

Cypress’ application note on smart E-Meters and why its more advantageous to use F-RAM over conventional EEPROMs.

This application note provides an overview of a smart electricity meter, or Smart E-Meter, and explains the benefits of using nonvolatile serial F-RAM rather than EEPROM in Smart E-Meter designs.

Steven Casagrande posted an update on his open source hardware GPIB USB adapter:

After many days, I just finished off firmware version 5 for my adapter. This is probably my biggest update yet. A lot of people asked for compatibility with the Prologix commands so that’s what I focused on. Here is an overview of the new firmware:

• Nearly all Prologix command set support. The adapter should now work with some pre-existing software tools and examples on the internet that were originally intended. Some will require a few changes for baud rate and flow control settings
• Improved termination character handling
• SRQ support (but no parallel polling, only serial)
• Improved stability
• Device mode (first version so there may be fixes in the future)
• Most settings can be stored in EEPROM
• Basic FIFO buffer for data sent from the PC

Via the forum.

Chris Holden has written an article on their new door entry system at BuildBrighton:

The basic idea is this:

• A keyfob is presented to the reader and the serial number read from it.
• The keyfob number is displayed on the character LCD.
• This is sent (via the ethernet module) to a URL to validate the serial number and the web site returns data to say who the key belongs to
• If data is successfully received from the website, it is stored in the local eeprom chip
• If there is a fault and no data can be received from the ‘net, the eeprom is searched, looking for a matching keyfob number. If a match is found in eeprom, the data is read out and handled as if it had just come from the website.
• If the keyfob belongs to a valid user, their name is displayed on the character LCD and a relay is activated to open the door.
• If the serial number is not recognised, a “not recognised” message is displayed in the lower part of the LCD display.

Check out the video after the break.

Schematics for RFID door entry system.

Another update on Scasagrande’s project, GPIBUSB Adapter rev4:

After working closely with a few individuals it was discovered that some of the pre-existing GPIB software (such as KE5FX’s tools) has some hardcoded serial port settings, one of which being the use of hardware flow control. After getting builds of the software tools with these disabled, some buffer problems were found using the default settings, under Windows, without the flow control. Running the software with WINE on Linux did not produce these issues. With some small tweaks to either the software or to Windows USB settings would fix the issue but that’s not very intuitive. A better long term solution would be to wire up the hardware flow control lines in the next hardware revision for use in a future firmware update.
That’s what I’ve done with the revision 4 PCB. In addition, I grounded a few unused digital lines on the micro to be able to, starting with rev4+, check what the hardware revision is in software. I also added two LEDs to the FT230X to allow it to signal on TX and RX.

Alain Iamburg over at FishNet Security writes:

Welcome to Part III of this series on hardware security. In Part II we explored passive data captures of EEPROM read operations over the SPI bus. In this installment, we will be looking at techniques for actively probing and communicating with such chips.
Memory chips can contain interesting data. You can find firmware, device configurations such as passwords or network addresses, and so on.

The tool of choice for this post is the Bus Pirate. This device can be used to interface with a wide range of chips using various low-level communication protocols, and it supports both interactive and binary modes. Think of it as a hardware hacker’s multi-tool.

Get an assembled Bus Pirate for $30, including world-wide shipping. Also available from our friendly distributors.

Jan Cumps tested out SPI Protocol using a Bus Pirate:

It wasn’t my initial intention to use the Bus Pirate.
But my first naive attempts to talk from Hercules to EEPROM failed.
I could create the SPI instructions with the LaunchPad, but I didn’t get a reply back from the 25LC256.
It’s in these cases that a Bus Pirate comes in handy. It’s easy to prototype a SPI conversation from the Pirate’s command prompt.

Details at Jan Cumps’s blog.

Save PCB space by utilizing EEPROM SOIC-8 area, here’s an application note from Microchip. Link here (PDF)

For many years, the 8-lead SOIC package has been the most popular package for serial EEPROMs, but now smaller packages are becoming more commonplace. This offers a number of benefits; the reductions in footprint size and component height are some of the more obvious ones. Smaller packages also generally offer a cost advantage over their larger counterparts.