Working with the AT24C32n.py package

[Comalco]

Hello Folks,
I am new to Micropython and am enjoying retirement playing with ESP8266 modules, various add-on modules (servos, ultrasonics, PIRs, displays), and Thonny.
I have bought a collection of reference books to get me going, but they havent arrived yet in the post and I am impatient as I am playing with various ideas on the workbench to pass time during our poor weather here. I have found so many great examples of code, interesting projects, and read a lot of blog comments, but searching the web isn't super friendly when you're looking for specifics like this in Micropython.

Using the AT24C32 chip on the common DS3231 i2c module, I am trying to use a single memory location for a stored variable.
I wish to store a number within the range 0-255 (using a single hex byte, for efficiency)
I need to read this value from the memory location, increment it (or change it to a different value), and resave it back to the EE chip. This variable will track the location of a 16 byte half-page block of data stored within the EE chip.

Using AT24C32.py, reading a value, hexlify'ing it to an integer, to then use '+=" to increment, converting that back to hex to then write it back seems long winded. I can read and write my text string data to the EE ok, but I keep running foul of my hotch potch of using hex, integers, and different commands' syntax requirements trying to manage this single variable stored in the EE. I am sure I am tackling this the wrong way. Is there a simpler way to do this task? Perhaps there is a better package than AT24C32n.py to work with this EE chip?

Could an experienced soul please give me a code snipper, or point me in the right direction to a TUT or example to get me going?
Like I said, I am a newbie, so apologies for what is probably such a simple task. I am sure reading the books I have ordered will help me develop some knowledge and skills along the way..... until then I am hoping someone can get me past this brain fade?

[mcauser]

Are you talking about this one?
https://github.com/mcauser/micropython-tinyrtc-i2c/blob/master/at24c32n.py

I added some egs. to the readme:
https://github.com/mcauser/micropython-tinyrtc-i2c#at24c32n-eeprom-examples

>>> import at24c32n
>>> eeprom = at24c32n.AT24C32N(i2c)

# the write() function expects bytes or a bytearray to set one or more values
# create a byte array to store a single byte (a value 0-255)
>>> buf = bytearray(1)

# lets say you want to store the integer value 70 in memory address 5.
# 70 in dec == 46 in hex == "F" in ascii.
# set the decimal integer value as the first element in the byte array
>>> buf[0] = 70
# you can also use hex
>>> buf[0] = 0x46
# you can also use bytes
>>> buf[0] = b'F'[0]
# if you hex value is in a string, you can convert it to an int like so
>>> buf[0] = int('0x46', base=16)

# write one byte starting at address 5
>>> eeprom.write(5, buf)

# read one byte from address 5
>>> eeprom.read(5, 1)
b'F'

# To make that an integer again, pluck the first byte
>>> b'F'[0]
70
# want that as hex?
>>> hex(b'F'[0])
'0x46'
>>> hex(70)
'0x46'

# If you wanted that hex value as a string without the 0x prefix
>>> '{:x}'.format(b'F'[0])
'46'
>>> '{:x}'.format(70)
'46'

[mcauser]

Do you think it would be useful for me to add support for writing integers, one at a time?

>>> eeprom.write_int(5, 70)
>>> eeprom.read_int(5)
70

[Comalco]

I did try another package before yours, but it kept throwing memory allocation errors (even in small amounts of code) that I couldn't understand or resolve. Then I found AT24C32n.py package. No more errors on memory allocations.... thanks.
I am a newbie and probably not best placed to qualify an answer.
It seems to me that it may help in general data usage, as opposed to text strings etc.
But, as a newbie to Micropython, I might be missing a simple way of performing the functions I am seeking.
I will go through your comments above....thanks for responding. Much appreciated!

[Comalco]

I have tried iterations of what you have written above....... I think the problem I have had is getting from the read byte to placing it into INT to increment it, then back into a hex byte to write it back as a single byte. In your examples above you have inserted actual values into someof the syntax, which works. I need to read that value using eeprom.read, at which point it is assigned to a variable (i.e. adata), which cannot be them inserted into the INT syntax (I am saying this based on my usage and the errors thrown. As a newbie, my undestanding is that only a value can be used in "buf[0] = int('0x46', base=16)" as you have used '0x46'. A variable (like "adata") cannot be used in this syntax structure?

read one byte from address 5
adata = eeprom.read(5, 1)
b'F' #aka decimal 70

turn it into an INT
bdata = int(adata, base=16)
'70'

increment that value
bdata += 1 # aka decimal 71

save that back
eeprom.write(5, bdata)

I think the above saves it in EE as a 2 byte string as "71" ?
I am probably blundering badly here, but this is where I am currently at .....
Perhaps if you could show me the 5 (?) lines of code that go from a eeprom.read of one hex byte of a 0-255 hex value, incrementing it by one, and then writing it back as one hex byte using eeprom.write ? Then I can understand where I am missing things.....

[karfas]

I'm pretty sure the following will work:

adata = eeprom.read(5, 1) # eeprom.read() returns bytes
bdata = bytearray(1)
bdata[0] = adata[0]
bdata[0] += 1
eeprom.write(5, bdata)   # eeprom.write() wants an array

Your mistake here is to assume that eeprom.write() can handle plain integers (hence the question of @mcauser above).
This is wrong - the code in https://github.com/mcauser/micropython-tinyrtc-i2c/blob/master/at24c32n.py reads:

def write(self, addr, buf):
    """Write one or more bytes to the EEPROM starting from a specific address"""
    ....
    self.i2c.writeto_mem(self.i2c_addr, addr, buf[0:partial], addrsize=16)

This clearly indicates that the buf argument to write() needs to be some kind of array.
See also the micropython documentation of I2C.writeto_mem.

[Comalco]

Thank you, it does work. I will read up on writeto_mem as you suggest.
In my original code I was using the eeprom.read value as a string, converting it to an integer to increment it, but then struggling to convert it back to a hex value as a string to write as eeprom.write. My old knowledge of VB and VB.net struggled to find similar Micropython methods. I have bought several reference books online and will no doubt skill-up as I have more references to learn from. Many thanks for everyones' patience and assistance.

[karfas]

I was using the eeprom.read value as a string, converting it to an integer to increment it, but then struggling to convert it back to a hex value as a string to write as eeprom.write

This sounds like you get confused by the not-so-subtile difference between "hex value" and "byte".
Why "convert it to a hex value as a string to write" ?

A byte is a byte (an 8-bit-integer), a "hex value" is only some kind of string representing the value of one or more bytes.

Converting from hex strings to integers can be done by e.g. int(string, base=16).
In your case, your bdata = int(adata, base=16) happily did what you told it to do: convert the string "F" in adata to an integer.
However, this gives you the wrong result (not 70 as you expected according to your comments):

>>> a1 = b'F'
>>> int(a1,base=16)
15

Above ist the output from real python 2.7, but I doubt micropython behaves different in this case.

[Comalco]

Thanks for your comments. I have a lot to learn !