eeprom

#include <Wire.h>

#define GOT_HERE()  do {Serial.print('['); Serial.print(__LINE__); Serial.println(']'); Serial.flush();} while(0)
#define SDA_PIN 4
#define SCL_PIN 5

// define memory address of blocks
#define I2C_SLAVE_ADDR0 0x50
#define I2C_SLAVE_ADDR1 0x51
#define I2C_SLAVE_ADDR2 0x52
#define I2C_SLAVE_ADDR3 0x53
#define I2C_SLAVE_ADDR4 0x54
#define I2C_SLAVE_ADDR5 0x55
#define I2C_SLAVE_ADDR6 0x56
#define I2C_SLAVE_ADDR7 0x57

#define PAGE_BUFFER 16
#define NUM_OF_PAGES 16
#define MAX_MEMORY 256

bool ok = true;
char addrpk[] = "{\"bc1qjaz2248t09y98vaqguq2560t7kclhesapce5sf\":\"KxdK7M6b148NsEyH6EvR91xSWN27uzCxYfhgdRznZEZfX7Kkr9Rh\"}";
uint16_t i = 0;
char* data;

// Read bytes from eeprom device
void readEEPROM(uint8_t deviceaddr, uint16_t eepromaddr, char* data, uint8_t datalen){
    Wire.beginTransmission(deviceaddr);
    Wire.write(eepromaddr);
    Wire.endTransmission();
    Wire.requestFrom(deviceaddr, datalen);
    while( Wire.available() )
        data[i++] = Wire.read();
    i = 0;
}

void writeEEPROM(byte deviceaddr, byte eepromaddr, char* data){
    uint8_t msglen = 0, bytes_left_in_page = 0, page_number = 1;
    uint8_t data_fit = 0, avail_eemem = 0, last_write_size = 0;
    uint8_t remaining_pages = 0, pages_needed = 0;

    // Compute the length of the string
    do{
       msglen++;
    }while(data[msglen]);

    // Given the address to write to, we need to know how much space is
    // available in the current page
    bytes_left_in_page = PAGE_BUFFER - (eepromaddr % PAGE_BUFFER);
    // bytes_left_in_page = 11

    // Calculate size of last write
    last_write_size = (msglen - bytes_left_in_page) % PAGE_BUFFER;
    // last_write_size = 10

    // We also need to know where does the target address is located in
    // terms of pages, starting at page [0]
    page_number = eepromaddr / PAGE_BUFFER;
    // page_number = 7

    // Therefore, for 24LC16B, there are more x pages available for write
    // including the page where the target address actually is
    remaining_pages = NUM_OF_PAGES - page_number - 1;
    // remaining_pages = 8

    // Check how much memory there is available, starting from the
    // target address
    avail_eemem = MAX_MEMORY
                - ( remaining_pages * PAGE_BUFFER - bytes_left_in_page );
    // avail_eemem = 139

    // Check if data fits the eeprom memory capacity, starting from
    // target address - [1] doesn't fit, [0] it fits
    data_fit = msglen > avail_eemem ? 1 : 0;
    // data_fit = 1

    // Check how many pages we need to write the string
    pages_needed = msglen % PAGE_BUFFER ? (msglen / PAGE_BUFFER + 1)
                                        : msglen / PAGE_BUFFER;
    // pages_needed = 7

    // Check if data fits eeprom block memory
    // Also check if target addres is at the beginning of a page
    // if it is, then, we write 16 bytes at once and then we
    // keep writting the remaining string always 16 bytes at
    // aa time, until the end of the string
    if( !data_fit )
        if ( !bytes_left_in_page ){
            for(uint8_t i = 0; i < pages_needed; i++){
                Wire.beginTransmission(deviceaddr);
                Wire.write(eepromaddr + i * PAGE_BUFFER);
                Wire.write(data[eepromaddr + i * PAGE_BUFFER], PAGE_BUFFER);
                Wire.endTransmission();
                delay(6); // delay for page write
            }
        }else{
            // We are not at the beginning of any page
            // Fill the remaining bytes of the current page
            Wire.beginTransmission(deviceaddr);
            Wire.write(eepromaddr);
            Wire.write(data[0], bytes_left_in_page);
            Wire.endTransmission();
            delay(6); // delay for page write

            // Fill next (complete) pages with 16 bytes
            for(uint8_t i = 0; i < pages_needed - 2; i++){
                Wire.beginTransmission(deviceaddr);
                Wire.write(eepromaddr + i * PAGE_BUFFER);
                Wire.write(data[bytes_left_in_page + i * PAGE_BUFFER], PAGE_BUFFER);
                Wire.endTransmission();
                delay(6); // delay for page write
            }
            // Last write
            Wire.beginTransmission(deviceaddr);
            Wire.write((page_number + remaining_pages - 2) * PAGE_BUFFER);
            Wire.write(data[msglen - last_write_size], last_write_size + 1);
            Wire.endTransmission();
            delay(6); // delay for page write
        }
    else
        // Turn on a red led because data is larger than eeprom memory
}

void setup(){
    Serial.begin(115200);
    Wire.begin(SDA_PIN, SCL_PIN);
}

void loop(){
    if(ok){
        Wire.beginTransmission(I2C_SLAVE_ADDR7);
        Wire.write(0x2f);
        Wire.write(addrpk);
        Wire.endTransmission();
        delay(5);
        /* ---- Read from EEPROM ---- */
        Wire.beginTransmission(I2C_SLAVE_ADDR7);
        Wire.write(0x2f);
        Wire.endTransmission();
        Wire.requestFrom(I2C_SLAVE_ADDR7, sizeof(myData));
        Serial.print("Byte read: ");
        while( Wire.available() ){
            Serial.print(Wire.read(), HEX);
            Serial.print(" ");
        }
        Serial.println();
        ok = false;
        GOT_HERE();
    }
}