CircuitPython Driver for Adafruit 24LC32 I2C EEPROM Breakout 32Kbit / 4 KB

I have a custom build Adafruit CircuitPython 7.3.0-alpha.0-38-g862210b3f-dirty on 2022-03-13; Adafruit Trinket M0 with samd21e18 with 24lc32 frozen.

I can find the chip via I2C scan at the address 0x50 but the driver doesn't find it there.

import board
import time
import adafruit_24lc32
import supervisor

supervisor.disable_autoreload()

i2c = board.I2C()

#  scan I2C
while not i2c.try_lock():
    pass
try:
    while True:
        print(
            "I2C addresses found:",
            [hex(device_address) for device_address in i2c.scan()],
        )
        time.sleep(1)
finally:  # unlock the i2c bus when ctrl-c'ing out of the loop
    i2c.unlock()

#  setup for EEPROM
eeprom = adafruit_24lc32.EEPROM_I2C(i2c_bus=i2c)

I2C addresses found: ['0x50']

Traceback (most recent call last):
  File "code.py", line 24, in <module>
  File "adafruit_24lc32.py", line 240, in __init__
ValueError: No I2C device at address: 0x50

Please add something like this to the library about Line 250.

`

Added by Bruce Blake

def EEPROM_size(self, size):

    self._max_size = size

    return(self._max_size)

` Why? Gives the user the opportunity to use this library with larger EEPROMS. Scanning the EEPROM to determine it's size is an option too.

This fixes the issue mentioned the equivalent issue mentioned here in the FRAM library:

Also, updates example to use correct indexes as fixed with PR #1

In the online docs this part of the code doesn't work:

import adafruit_eeprom

i2c = board.I2C()
eeprom = adafruit_eeprom.EEPROM_I2C(i2c)

changing it like this makes it work:

import adafruit_24lc32

i2c = board.I2C()
eeprom = adafruit_24lc32.EEPROM_I2C(i2c)

(If documentation bugs are to be submitted elsewhere, please advise me. Thanks.)

Not sure what's up, but the badge on the repo doesn't bring you to documentation but instead a 404 screen. Looking into it now, but wanted to file a general issue in case anyone gets to it first.

It would be great if this library could also support smaller eeprom chips.

The main difference for those is in addressing, 04 parts borrow one bit from the slave address for the memory address (9 bits to address 500 bytes), 08 parts borrow 2 and 16 parts borrow three.

Following the slave address, only one byte is used for the rest of the address.

1. Adds type annotations like other libraries are getting
2. Changes a few instances of checking whether value is True OR False to isinstance() which is more Pythonic. Happy to revert if this was done for a specific reason
3. Updates Sphinx formatting in docstrings so things are clearer, or will display properly based on the hardships I've had with Sphinx haha. Can't confirm they help (or that anything was actually wrong yet) since documentation isn't viewable yet.

resolves #5

Updated all references to FRAM to EEPROM tested with get grep fram and git grep FRAM

Also comment out the write statements in simpletest so users will not unknowingly wear their device with extra writes.

It seems that the cleaning from FRAM to EEPROM could continue a little bit: ´´´ if self.write_protected: raise RuntimeError("FRAM currently write protected.") ´´´

But many other in the comment/doc.

For some reason the library is converting the 9, 10, 13 to TAB, NEW_LINE, CARRAGE_RETURN and storing the "" character, 0x53, into the EEPROM.

eeprom[0x10] = 9 print(eeprom[0x10]) eeprom[0x10:0x16] = [9, 10, 13, 3, 8, 1] print(eeprom[0x10:0x18])

EEPROM Dump: 0x0010 | 0x5C 0x03 0x08 0x01 0xFF 0xFF 0xFF 0xFF

The output shows: bytearray(b'\t') bytearray(b'\t\n\r\x03\x08\x01\xff\xff')

How do I get an output "stuff=eeprom(0x10:0x18)" other than in a bytearray?

Bruce

I have been able to use a modified version of this library and demo code to read the EEPROM content of ST25DV16K.

Maybe a more generalized version of EEPROM reading where the size and I2C address can be changed would be more usefull.

So here are the change I made are : _MAX_SIZE_I2C = const(0x800) # 16kbits and def __init__(self, i2c_bus, address=0x53, write_protect=False, wp_pin=None):

I have used the following code:

import board
import adafruit_st25dv16

i2c = board.I2C()
eeprom = adafruit_st25dv16.EEPROM_I2C(i2c)

print("length: {}".format(len(eeprom)))

for i in range(0, 4):
    j = i * 16
    hex_string = ":".join("%02x" % b for b in eeprom[j:j+15])
    print(j, "> ", hex_string, "> ", eeprom[j:j+15])

The result is a dump:

0 >  e1:40:40:05:03:10:d1:01:0c:55:01:73:74:2e:63:6f >  bytearray(b'\xe1@@\x05\x03\x10\xd1\x01\x0cU\x01st.co')
16 >  6d:2f:73:74:32:35:fe:2f:70:72:6f:64:75:63:74:2f >  bytearray(b'm/st25\xfe/product/')
32 >  34:37:30:31:fe:00:00:00:00:00:00:00:00:00:00:00 >  bytearray(b'4701\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
48 >  00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 >  bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

We can clearly see the URL written by ST arduino demo code: "st.com/st25" (Hello World exemple from https://github.com/stm32duino/ST25DV )

And part of the URL maybe set by Adafruit in factory: "/product/4701"

So with a bit of code that properly structure the NFC TAG value in the EEPROM it should be possible to use the ST25DV16K from CircuitPython for basic usage of setting the value of the tag.