I2C Bus Scanner

Introduction

This page is about an 'I2S bus scanner' circuit. This circuit can be used to scan a certain I2C bus to find out all chips that are present on that I2C bus.

I2C is a bus system, invented by Philips, to communicate between chips on a PCB. The goal was to save wires (space) on the PCB. All devices on the I2C bus are interconnected with only 2 wires (SCL and SDA). Each device has its own hardware address. The master, usual a microcontroller, can establish a bidirectional communication with the other chips.

I2C uses a 7-bit addressing system so there are 127 possible addresses. My I2C scanner will try to address each one these 127 combinations. Only the chips that are present will respond with an ACK (acknowledge) pulse. My scanner uses this ACK pulses to determine if a chip is present. No other data or commands are transmitted.

My scanner can collect up to 30 different addresses. After the scan these addresses will be shown on a pair of 7-segment display modules. The addresses will appear in a hexadecimal format. The display will show the 7-bit addresses but a hardware jumper allows you to show the result as an 8-bit value.

I think an I2C scanner is very handy if you work a lot with I2C components like LCD modules or EPROM memory chips. You can use the scanner to test if they are working properly. This can save you some time.

Schematic Design

The image below shows the complete schematic diagram for this circuit. You can click the schematic to enlarge it. Alternatively you can download it as a PDF file.

Schematic diagram for I2C bus scanner

This circuit is easy to understand. First there is a power supply. It accepts an AC or a DC input voltage. This voltage is then rectified by the 4 diodes. Then the 7805 regulator converts the voltage to a stable 5 VDC voltage. The component has some surrounding capacities to remove the high-frequency noise.

The circuit is controlled by a PIC microcontroller: the 16F628A. This PIC uses a 4 MHz internal oscillator, this avoids the need for any external oscillating components. The PIC uses the following connections:

RB.0: push button to operate the scanner
RB.1: I2C serial clock connection
RB.2: I2C serial data connection
RB.3: display controller
RB.5: display controller
RB.6: display controller
RB.7: operation mode jumper

The I2C scanner uses two 7-segment displays to show the result. Each segment is driven separately so I would have needed 14 I/O pins on my microcontroller. I implemented two shift registers to avoid this. The microcontroller will transmit some serial data to them. To do this the PIC will generate 14 clock pulses. A data bit (1/0) is transferred to the shift registers during each clock pulse. The shift registers are placed in cascade: the second register gets its data from the first register.

The I2C lines are pulled-up to the 5 VDC line, this is required by the I2C specifications. You should connect this circuit only to 5 VDC operated I2C systems. It is possible to connect them to 3.3 V systems by using a voltage adjustment circuit. The image below shows the circuitry that is required to do so (See my FEZ To K8000 Project).

Functional description

The circuit is very easy to use as it only has one push button. I didn't make any software option to turn the device off. You can do this by simply disconnecting the power supply (You could add a switch for this).

Here is a complete description of the procedure the device will follow to scan the I2C bus:

System startup: the displays are tested. They will count from 0 to 9. This allows you to see if all segments are working.
The message Pu (Push) appears: you need to push the button to start the scanning.
The I2C scanner will start the scanning process. First my circuit will try to detect if the I2C bus is already occupied: It will monitor the I2C bus for some time to detect this. It will then indicate "Bu" (Busy) to indicate the bus is already in use. When the device confirms the I2C bus is free the actual scanning process will begin. During this scan a counter is shown: -9 ... -8 ... -7 ... -6 ... -5 ... -4 ... -3 ... -2 ... -1 ... 0. The scan can be cancelled at any time: just push the button to jump to step #6 (indication "tE").
After the scan a summary of the results is shown: the scanner will show you the total count of detected addresses. The display will cycle the following messages: C= (Count), 03 (Number of results),Pu (Push Button). You can acknowledge this message by pushing the button.
Now the detected addresses will be displayed, one by one. The following display sequence is cycled: A= (Address), 70 (Address 0x70), Pu (Push Button). You can push the button to view the next sequence.
The scanner will now indicate that the process is terminated. The display will now show the message tE (Terminated).

The following image gives an idea on the possible output sequences you can encounter. This scan has resulted in 4 addresses, one of them is 0x40 (the other 3 results are not shown here). At the end the "te" appears to indicate the end of the scan.

Extra features

My I2C bus scanner has some additional features: you can remove jumpers JP1 and JP2 to disable the pull-up resistors. They are not required when you connect the scanner to a circuit that already has pull-up resistors. The I2C bus needs these pull-up resistors for both SCL and SDA lines to make sure they are "high" when the bus is not in use.

The jumper JP3 affects how the found addresses are displayed: when the JP3 is installed all found addresses are shifted one bit to the left. So the real hexadecimal address 0x38 (0b00111000) will be shifted to (0b01110000). I will explain the reason with an example. The picture below is a snippet from the datasheet of the IC PCF8574AP (I2C Port Expander).

I2C uses 7-bit addresses. The 8th bit of the addressing byte is a R/W (read/write) bit to indicate the kind of operation you want to perform. The data sheets often show this 8th bit as a zero, so I added an option to show these addresses as they would appear in the datasheet.

Let's assume the A0,A1 and A2 are set to 0. Then the hardware address that is shown is 0b01110000 (0x70). The bit at the right "0" (LSB: Least Significant Bit) doesn't actually belong to the hardware address, but it is a read/write byte to specify the type of I2C operation. So the real hardware address is 0b0111000 (0x38). The jumper JP3 will allow you to select how the address will be shown.

PIC Firmware

I wrote the PIC's firmware with the Lite-version of High-Tech C. I won't explain the program in detail, but the source code is well commented.

The PIC 16F628A doesn't support hardware I2C so I had to write my own I2C functions in software. These functions will emulate open-collector outputs on the PIC: the software will change them from inputs to outputs when required.

/************************************************************************** * I2C Bus Scanner * Copyright (c) 2012 Vanderhaegen Bart * bvsystems.be * * Target PIC: 16F628A * * This device can scan all 127 hardware addresses of an I2C bus. It * will connect the I2C hardware addresses from all chips that respond * to their address. Afterwards, the results are shown on 2 7-segment * displays. * *************************************************************************/ #include <pic.h>; // define I2C communications #define SCL TRISB1 // serial clock (requires pull-up) #define SDA TRISB2 // serial data(requires pull-up #define SCL_IN RB1 // #define SDA_IN RB2 // #define I2C_ADR_BUFFER_SIZE 30 // number of addresses to store // define shift registers #define SERDATA RB3 #define SHIFTCLK RB5 #define DISABLE_LCD RB6 // define buttons #define BUTTON RB0 #define JMP_SHIFT_RESULT RB7 // Define hex characters for display const char hexData[]= {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07, 0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71}; // Define symbols #define LCD_P 0x73 #define LCD_A 0x77 #define LCD_B 0x7C #define LCD_u 0x1C #define LCD_min 0x40 #define LCD_equ 0x48 #define LCD_clr 0x00 #define LCD_C 0x39 #define LCD_T 0x78 #define LCD_E 0x79 // PIC Timebase (internal oscillator) #define _XTAL_FREQ 4000000 // define boolean values #define true 1 #define false 0 // define global variables. This variable is used across the // program. (it is set by the interrupt handler). bit buttonPushed = 0; bit busy=0; // Function prototypes void doSelfTest(void); void waitForUserPush(void); void waitForEndConfirmation(void); void runScanner(char* addresses,char* units,char* dozens,char* results); void showNumberOfResults(char units,char dozens); void showResults(char * addresses,char results); void delay(void); void i2cStart(void); void i2cStop(void); bit waitForAck(void); void clock(void); void sendData(char Data); void giveI2Ccommand(char address,char data); void delay_ms(int ms); void sendAck(void); void wait500ms(void); void wait1500ms(void); void showValues(char digit1,char digit2); void sendValue(char digit); void checkFreeI2Cbus(void); /************************************************************************** Interrupt handler (with some software anti-bounce) *************************************************************************/ void interrupt irq() { if (INTF) { buttonPushed=1; __delay_ms(50); // I know... while(!BUTTON); INTF=0; } } /************************************************************************** * I2C bus scanner - Main Program * *************************************************************************/ void main(void) { // initialisation TRISB=0x10000001; PORTB=0x00; DISABLE_LCD=1; TRISA=0x00; PORTA=0x00; // setup I2C values SCL = 1; SDA = 1; SCL_IN = 0; SDA_IN = 0; // setup interrupt system INTEDG=0; INTE=1; INTF=0; ei(); // perform an LCD selftest doSelfTest(); while(true) { // Step 1: Wait until the user presses the Pu button waitForUserPush(); // Step 2: define the array with the scan results char addresses[I2C_ADR_BUFFER_SIZE]; char results=0x00; char units=0; char dozens=0; buttonPushed=0; // Step 3: start a full I2C system scan runScanner(addresses,&units,&dozens,&results); // Step 4: show the results (if no interruption occured) if (!buttonPushed) { // Step 4: Show the number of results showNumberOfResults(units,dozens); // Step 5: buttonPushed=0; showResults(addresses,results); } // Step 5: show the ending of the program waitForEndConfirmation(); } } /************************************************************************** * Program Functions * Optimized for the SN74AHC595 8-bit shift register *************************************************************************/ // This function waits for a release of the I2C bus void checkFreeI2Cbus(void) { buttonPushed=0; SCL=1; SDA=1; busy=0; for (char i=0;i<100;i++) { busy=(!SCL_IN || !SDA_IN); __delay_ms(1); } if (busy) { showValues(LCD_u,LCD_B); while(!buttonPushed); } } // This function performs an auto test of the LCD void doSelfTest(void) { // first a selftest is performed for (char cycle=0;cycle<2;cycle++) { for (char digit=0;digit<10;digit++) { if (cycle==0) showValues(hexData[digit],LCD_clr); else showValues(LCD_clr,hexData[digit]); __delay_ms(90); } } } // This function waits until the user has pushed OK void waitForUserPush(void) { // Step 1: show Pu (Push) message: wait until pushed. buttonPushed=0; showValues(LCD_u,LCD_P); while(!buttonPushed); } // This function waits until the user has pushed OK void waitForEndConfirmation(void) { // step 7: show the end message showValues(LCD_E,LCD_T); // step 8: show button buttonPushed=0; while(!buttonPushed); } // This function will run the actual scanner void runScanner(char* addresses,char* units,char* dozens,char* results) { buttonPushed=0; char adressesToGo=9; checkFreeI2Cbus(); if (!busy) { for (char adrToTest=0;adrToTest<128 && !buttonPushed;adrToTest++) { if (!buttonPushed) { i2cStart(); sendData(adrToTest<<1); if (waitForAck()==1) { if (*results<I2C_ADR_BUFFER_SIZE) { (*addresses++)=adrToTest; *results=*results+1; *units=*units+1; if (*units==10) { *units=0; *dozens=*dozens+1; } } } i2cStop(); // show progress if (!(adrToTest%15)) adressesToGo--; if (adrToTest%4) showValues(hexData[adressesToGo],LCD_clr); else showValues(hexData[adressesToGo],LCD_min); } } } } // showNumberOfResults shows the number of results void showNumberOfResults(char units,char dozens) { while(!buttonPushed) { // Show "C=" showValues(LCD_equ,LCD_C); wait500ms(); // Show counter# showValues(hexData[units],hexData[dozens]); wait1500ms(); // Show "Pu" showValues(LCD_u,LCD_P); wait500ms(); } } // showResults shows the actual I2C addresses void showResults(char * addresses,char results) { for (char resultScroller=0;resultScroller<results;resultScroller++) { char address=*addresses; // shift the address with 1 bit - if required if (!JMP_SHIFT_RESULT) { address<<=1; } // get the upper and the lower byte char lsb=address&0x0F; char msb=(address&0xF0)>>4; while (!buttonPushed) { // Show "A=" showValues(LCD_equ,LCD_A); wait500ms(); // show address showValues(hexData[lsb],hexData[msb]); wait1500ms(); // Show "Pu" showValues(LCD_u,LCD_P); wait500ms(); } buttonPushed=0; *addresses++; // pointer increase } } /************************************************************************** * Shift register LCD controller * Optimized for the SN74AHC595 8-bit shift register *************************************************************************/ // sendValue will send some data over the shift registers void sendValue(char digit) { for (char j=0;j<8;j++) { if(digit & 0x80) SERDATA=1; else SERDATA=0; // generate a clockpulse for the shift register SHIFTCLK=1; SHIFTCLK=0; digit<<=1; } } // showValues is used to send the data to the displays void showValues(char digit1,char digit2) { // disable the shift register's output for a while DISABLE_LCD=1; // send the character data sendValue(digit1); sendValue(digit2); // send an additional clock pulse SERDATA=0; SHIFTCLK=1; SHIFTCLK=0; // enable the shift register's output again DISABLE_LCD=0; } /************************************************************************** * Delay functions with time-out * See http://www.bvsystems.be/pic_loop.php for more information. *************************************************************************/ // Wait 500 ms void wait500ms() { unsigned int timeout=38462; while (buttonPushed==0 && (--timeout>0)); } // Wait 1500 ms void wait1500ms() { unsigned long timeout=55556; while (buttonPushed==0 && (--timeout>0)); } /************************************************************************** * Implementation of the I2C protocol *************************************************************************/ // initiate a new I2C command void giveI2Ccommand(char address,char data) { i2cStart(); sendData(address); waitForAck(); sendData(data); waitForAck(); i2cStop(); } // send 8 bits of data over the I2C bus // Assumption: SCL is already low void sendData(char Data) { unsigned char i; for (i=8;i>0;i--) { if(Data & 0x80) { SDA=1; } else { SDA_IN=0; SDA=0; } SCL=1; delay(); Data<<=1; SCL_IN=0; SCL=0; delay(); } } // send the I2C start sequence // SDA must go from high to low while SCL is high. void i2cStart() { SDA=1; delay(); SCL=1; delay(); SDA_IN=0; SDA=0; delay(); SCL_IN=0; SCL=0; delay(); } // send the I2C stop sequence // SDA must go from low to high while SCL is high void i2cStop() { SDA_IN=0; SDA=0; delay(); SCL=1; delay(); SDA=1; delay(); } // wait for an acknowledge signal // Receiver must make SDA low while SCL is high // The waitForAck times out after approximately 10 ms bit waitForAck() { SDA=1; delay(); SCL=1; unsigned int timeout=1923; while (SDA_IN && (--timeout > 0)); SCL_IN=0; SCL=0; delay(); return (timeout>0); } // send the clock pulse // SCL must be made high for a short period of time void clock() { delay(); SCL=1; delay(); SCL_IN=0; SCL=0; delay(); } // send the acknowledge pulse required by the slave device void sendAck() { SDA_IN=0; SDA=0; delay(); SCL=1; delay(); SCL_IN=0; SCL=0; delay(); } // delay execution void delay(void){ __delay_us(100); }

Download

You can download the High-Tech C source files together with the data sheets of the used components.

Download I2C Scanner Firmware