MEL PICBASIC Forum - EEPROM automatic identification routine

  • EEPROM automatic identification routine

    by
    aberco
    Published on - 2nd September 2010 05:24  Number of Views: 12515  
    Here is my final version of the EEPROM automatic identification routine. The problem: I2C EEPROM don't have embedded ID code and it is not possible to detect which type of EEPROM is connected to a PIC. Since different size EEPROMs require different variables to be used, the code can only accommodates for a single type of EEPROM size. The topic was previously discussed here: Auto-Dectect EEProm Size. However I found out that melanie's routine does not work as expected. I got a hand on smaller EEPROMs and especially a 24C01 and found out that small EEPROMs wrap the memory space in a strange way, and the last byte of a non-existing byte reads $01 regardless of the value programmed in what would be it's mirror in existing memory space. This may be due to the change in address space, because wrapping does work as expected on 24C16 through 24C512 (should also work with 24C08 but not tested).

    Let me do a modest contribution by wrapping it all into a single routine that identify everything from 24LC00 to 24LC512. This is provided that pins A0, A1, and A2 of the I2C memory = 0 (grounded). A later evolution would be to add address detection as well.


    <<< DOWNLOAD THE FILE HERE: EEPROM_detect.pbp >>>

    SOURCE CODE:
    Code:
    '***************************************************************************
'*  Name    : EEPROM_detect.pbp                                            *
'*  Author  : Antoine Bercovici                                            *
'*  Date    : 02/10/2010                 iEMMMt                            *
'*  Version : 1.1                ......UMMMMMMMMMM.                        *  
'*                         .,:i,:.. .      .;AMMMMMMS                      *
'*                       :i:..                  .WMMMM@                    *
'*                    .i;.    .  YMMMMMMMWv        YMMMMMi                 *
'*                  i:;.   ..... @M#UU0MMMMMU  ...   0MMMMMZ               *
'*              :EMMM,  .........        oMMM0 .,.,.. oMMMMMMM             *
'*          i@MMMMMM   ...........   .    MMMM ii;i;:, MMMMMMMM            *
'*        #MMMMMMMMS  ..........,.,.  .iBMMMM:.:iiiii,.7MMMMMMMM#          *
'*        MMMMMMMMMA  .......,,iii,iMMMMMMM0 .:ii;iiii.oMMMMM@SM#          *
'*       .MMMMMMMMMM   ...,.i:;ii:.7MMMAv.  ,:ii;i;ii,,MMMMM2  vM.         *
'*       CM6AMMMMMMMU   .,,ii;ii:: .;   .,,ii;i;;;i;:i,MM#i ,M#@$          *
'*       #M:  0MMMMMM@. ..iiiiii::MMMMM.ii;;;;;i;ii,iviQB    MM0@          *
'*       WM     vMMMMMM0. ..,iii,,MMMMM::;i;i;i;i;vb@@#@I    XQ@Mi         *
'*                :MMMMMMMS.  ..,. :ci.,i::,,.:v7icM@bb@#      MM1         *
'*                   @MMMMMMMM097;,..:i;ii;Yn$@n7;.MM#W0.      BM$         *
'*                     0MMMMMMMMMzzMM7XvQMMMMMM.i,. .#MY       tMM         *
'*                       CMMMMM@C2WMM .. MM$W@o      nM#        @E         *
'*                         .6i  WMBBS    ,o$@v       .MM.                  *
'*                              ,@U#0      bMb        @M,                  *
'*                               M@S       iM@         .                   *
'*                               BMn        MM.                            *
'*                               7M$        ib                             *
'*                               .MM                                       *
'*                                C6                                       *
'*                                                                         *
'*  USAGE  1. Place INCLUDE EEPROM_detect.pbp within your program and      *
'*            modify the user defined variable below to suit your program  *
'*         2. Call first ReadMemoryIDTag routine to identify the EEPROM by *
'*            its ID tag. If no ID tag is present the program will perform *
'*            data destructive identification on the EEPROM followed by a  *
'*            complete erase. Result of identification is given by         *
'*            variables MemType, MemSize and PageSize                      *
'*         3. Call MemoryErase when you need to perform full erase         *
'*         4. Call MemoryRead when you need to read data at MemAddressLong *
'*            address. Data is retrieved in DataValue                      *
'*         5. Call MemoryWrite to write DataValue at MemAddressLong        *
'***************************************************************************

'*******************************************************
'Variable declaration for controlling the EEPROM
'*******************************************************
MemAddressLong      VAR WORD '16 bit address variable for memory from 24C32 to 24C512
MemAddress          VAR BYTE '8 bit address variable for memory up to 24C16
Control             VAR BYTE 'Control byte for EEPROM test
MemType             VAR BYTE 'Type of memory after size control: 11=24C00, 10=24C01, 9=24C02, 8=24C04, 7=24C08, 6=24C16, 5=24C32, 4=24C64, 3=24C128, 2=24C256, 1=24C512
PageSize        	VAR BYTE 'Size of memory pages in bytes
PageSizeBis     	VAR BYTE 'For internal use
MemSize             VAR WORD 'Size of EEPROM in bytes
Blank               VAR BYTE [16] 'Define EEPROM blanking array
WriteDelay          VAR BYTE 'Delay after writing to EEPROM
TagAddress          VAR BYTE 'EEPROM ID tag
DataValue           VAR BYTE 'Data to be written in EEPROM
InternalCounter     VAR BYTE 'For internal use

'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
'MODIFY THESE VARIABLES TO SUIT YOUR APPLICATION
'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SCLpin              VAR PORTB.6 'SCL Pin
SDApin              VAR PORTB.4 'SDA Pin

Writedelay = 5 			'Use a 5ms delay between write operations, Increase to 10 if needed by your EEPROM
TagAddress = 12			'EEPROM address where you want to record your ID tag (from 0 to 15, limited by 24C00)

'*******************************************************
'EEPROM Size detection for 24C16 and smaller (8bit Address)
'*******************************************************
MemorySizeCheck:

FOR InternalCounter = 6 to 11
	MemAddress = 255
	Control = %10100000
	If InternalCounter = 6 then Control = %10101110
	If InternalCounter = 7 then Control = %10100110
	If InternalCounter = 8 then Control = %10100010
	IF InternalCounter = 10 THEN MemAddress = 127
	IF InternalCounter = 11 THEN MemAddress = 15
	I2CWRITE SDApin, SCLpin, Control, MemAddress, [InternalCounter]
	PAUSE WriteDelay
NEXT InternalCounter

I2CRead SDApin, SCLpin, %10101110, 255, [MemType]
IF MemType = 6 THEN GOTO DoneChecking
I2CRead SDApin, SCLpin, %10100110, 255, [MemType]
IF MemType = 7 THEN GOTO DoneChecking
I2CRead SDApin, SCLpin, %10100010, 255, [MemType]
IF MemType = 8 THEN GOTO DoneChecking
I2CRead SDApin, SCLpin, %10100000, 255, [MemType]
IF MemType = 9 THEN GOTO DoneChecking
I2CRead SDApin, SCLpin, %10100000, 127, [MemType]
IF MemType = 10 THEN GOTO DoneChecking
I2CRead SDApin, SCLpin, %10100000, 15, [MemType]
IF MemType = 11 THEN GOTO DoneChecking

IF MemType < 6 OR MemType > 11 THEN
	GOSUB BigMemorySizeCheck
ENDIF

'*******************************************************
'EEPROM Size detection for 24C32 to 24C512 (16bit Address)
'*******************************************************

MemAddressLong = 65535

    FOR InternalCounter = 1 TO 5
	   Control = %10100000
	   I2CWRITE SDApin, SCLpin, Control, MemAddressLong, [InternalCounter]
        MemAddressLong = MemAddressLong >> 1
	   PAUSE WriteDelay
    NEXT InternalCounter

MemAddressLong = 65535

I2CRead SDApin, SCLpin, Control, MemAddressLong, [MemType]

ENDIF

DoneChecking:

IF MemType = 0 OR MemType > 10 THEN
    MemSize = 0
    IF MemType = 11 THEN MemSize = 15
ELSE
    MemSize = 65535 >> (MemType - 1)
ENDIF

IF (MemType > 10) OR (MemType = 0) THEN
    PageSize = 0
ELSE
    PageSize = 8
    IF MemType < 9 THEN PageSize = 16
    IF MemType < 6 THEN PageSize = 32
    IF MemType < 4 THEN PageSize = 64
    IF MemType = 1 THEN PageSize = 128
ENDIF

RETURN

'*******************************************************
'Read EEPROM
'*******************************************************
MemoryRead:

Control = 160
SELECT CASE MemType
	CASE 11, 10, 9, 8, 7, 6
	   MemAddress = MemAddressLong.byte0
	   IF MemAddressLong.8 = 1 THEN Control = Control + 2
	   IF MemAddressLong.9 = 1 THEN Control = Control + 4
	   IF MemAddressLong.10 = 1 THEN Control = Control + 8
	   I2CREAD SDApin, SCLpin, Control, MemAddress, [DataValue]
	CASE 5, 4, 3, 2, 1
	   I2CREAD SDApin, SCLpin, Control, MemAddressLong, [DataValue]
END SELECT

RETURN

'*******************************************************
'Write EEPROM
'*******************************************************
MemoryWrite:

Control = 160
SELECT CASE MemType
	CASE 11, 10, 9, 8, 7, 6
	   IF MemAddressLong.8 = 1 THEN Control = Control + 2
	   IF MemAddressLong.9 = 1 THEN Control = Control + 4
	   IF MemAddressLong.10 = 1 THEN Control = Control + 8
	   MemAddress = MemAddressLong.byte0
	   I2CWRITE SDApin, SCLpin, Control, MemAddress, [DataValue]
	CASE 5, 4, 3, 2, 1
	   I2CWRITE SDApin, SCLpin, Control, MemAddressLong, [DataValue]
END SELECT

PAUSE WriteDelay

RETURN

'*******************************************************
'Erase EEPROM
'*******************************************************
MemoryErase:

GOSUB MemorySizeCheck

For InternalCounter = 0 to 15 'Fill Blank array with blank data for EEPROM
Blank[InternalCounter] = $FF
Next InternalCounter

SELECT CASE MemType
	CASE 11
	   Control = 160
	   For MemAddress = 0 TO MemSize
	       I2CWRITE SDApin, SCLpin, Control, MemAddress, [$FF]
            Pause WriteDelay
        NEXT MemAddress			
	CASE 10, 9, 8, 7, 6
        PageSizeBis = PageSize / 2
        For Control = 160 TO 174 STEP 2
            FOR MemAddress = 0 to MemSize Step PageSize
                I2CWRITE SDApin, SCLpin, Control, MemAddress, [STR Blank\PageSizeBis, STR Blank\PageSizeBis]
                Pause WriteDelay
            NEXT MemAddress
		IF MemType = 1 OR MemType = 2 THEN GOTO WriteMemoryIDTag
		IF MemType = 3 AND Control = 162 THEN GOTO WriteMemoryIDTag
		IF MemType = 4 AND Control = 166 THEN GOTO WriteMemoryIDTag
	NEXT Control
	CASE 5, 4, 3, 2, 1
        PageSizeBis = PageSize / 8
        FOR MemAddressLong = 0 to MemSize Step PageSize
            I2CWRITE SDApin, SCLpin, 160, MemAddressLong, [STR Blank\PageSizeBis, STR Blank\PageSizeBis,_
                                                            STR Blank\PageSizeBis, STR Blank\PageSizeBis,_
                                                            STR Blank\PageSizeBis, STR Blank\PageSizeBis,_ 
                                                            STR Blank\PageSizeBis, STR Blank\PageSizeBis]
        Pause WriteDelay
    NEXT MemAddressLong
END SELECT

WriteMemoryIDTag:
MemAddressLong = TagAddress
DataValue = MemType
GOSUB MemoryWrite

RETURN

'*******************************************************
'Retrieve preprogrammed EEPROM ID tag at address TagAddress
'*******************************************************
ReadMemoryIDTag:
MemAddress = TagAddress

I2CREAD SDApin, SCLpin, %10100000, MemAddress, [MemType]
IF MemType = 0 OR MemType > 11 THEN
	MemAddressLong = TagAddress
	I2CREAD SDApin, SCLpin, %10100000, MemAddressLong, [MemType]
	IF MemType = 0 OR MemType > 11 THEN
		GOSUB MemoryErase
	ENDIF
ENDIF
GOSUB DoneChecking

RETURN
    USAGE:

    Note that the EEPROM detection routine does erase part of the data, and should not be used on a memory that contain code. To perform a "data safe" identification, a location in EEPROM is chosen for subsequent ID.
    1. Place EEPROM_detect.pbp within your project file and call INCLUDE EEPROM_detect.pbp within your program. Some declarations needs to be modified within EEPROM_detect.pbp: change SDApin and SCLpin to match your I/O ports, and declare an EEPROM address where you'd like the ID tag to be stored (provided it exists in the smallest memory, the 24C00).

    2. Call first ReadMemoryIDTag routine in your program initialization to identify the EEPROM by its ID tag. If no ID tag is present the program will perform data destructive identification on the EEPROM followed by a complete erase. Result of identification is given by the following variables:

      MemType (11=24C00, 10=24C01, 9=24C02, 8=24C04, 7=24C08, 6=24C16, 5=24C32, 4=24C64, 3=24C128, 2=24C256, 1=24C512)

      MemSize (15, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535, 0=detection failed) in bits

      PageSize (0, 8, 16, 32, 64, 128) in bytes per pages

    3. Call MemoryErase routine when you need to perform full memory erase within your program. A 24C512 takes about 5 seconds to be erased with page-write mode.

    4. Call MemoryRead routine when you need to read data. Use MemAddressLong variable (WORD) as your address pointer, data will be dumped in DataValue.

    5. Call MemoryWrite routine when you need to write data. Use MemAddressLong variable (WORD) as your address pointer, place data in DataValue.

    SAMPLE CODE:

    Below is a quick and dirty little example that identify an EEPROM and display results on LCD (add all the defines for your LCD).

    Code:
    '*******************************************************
'Display EEPROM size on LCD
'*******************************************************
INCLUDE EEPROM_detect.pbp

GOSUB ReadMemoryIDTag

LCDOUT $FE,1, "Memory type:"
Select CASE MemType
	CASE 11
	LCDOUT $FE,$C0, "24LC00, 16B"
	CASE 10
	LCDOUT $FE,$C0, "24LC01, 128B"
	CASE 9
	LCDOUT $FE,$C0, "24LC02, 256B"
	CASE 8
	LCDOUT $FE,$C0, "24LC04, 512B"
	CASE 7
	LCDOUT $FE,$C0, "24LC08, 1kB"
	CASE 6
	LCDOUT $FE,$C0, "24LC16, 2kB"
	CASE 5
	LCDOUT $FE,$C0, "24LC32, 4kB"
	CASE 4
	LCDOUT $FE,$C0, "24LC64, 8kB"
	CASE 3
	LCDOUT $FE,$C0, "24LC128, 16kB"
	CASE 2
	LCDOUT $FE,$C0, "24LC256, 32kB"
	CASE 1
	LCDOUT $FE,$C0, "24LC512, 64kB"
	CASE ELSE
	LCDOUT $FE,$C0, "Not recognized"
END SELECT
    This article was originally published in forum thread: Auto-Dectect EEProm Size started by DynamoBen View original post
    Tags: