Неустойчивое поведение при использовании DUE с чипом Microchip 24FC64 EEPROM?

Я пытаюсь читать и писать с/на чип EEPROM и получил доступ к этому 64-кбит-устройству.

Похоже, я могу писать на устройство и читать с него, но, похоже, есть некоторая странность в обращении к записанным данным для последующей записи.

Я использую эту страницу в качестве ссылки для своего кода и получаю некоторые странные результаты. Во-первых, 64 кбит на самом деле 8k, и я смог записать в 10000 байт и прочитать из него (хотя я подозреваю, что он перевернулся по адресу памяти).

Странность заключалась в том, что я попытался записать два соседних байта на два соседних адреса. Последующее считывание двух адресов считывает второй байт оба раза. Это было так, как если бы указатель местоположения застрял на последнем чтении.

когда я сбрасываю свой код, я могу прочитать ранее записанные адреса, подтверждая, что они не просто застряли в памяти.

Точно так же, когда я записываю массив байтов в адрес, я могу прочитать обратно байты, но если я изменю указатель чтения на чтение снова, байты возвращаются все равно, пока указатель не уйдет на значительное расстояние от адреса чтения (скажем, более 50 байт). На данный момент возвращаемые данные равны 255.

Наконец, если я прочитаю много байтов, запросив, скажем, 50, то максимум, что я получу, - это 32 байта.

Скажем, я пишу:

[60, 61, 62, 63, 64, 65] to position 8000 in memory

если я попытаюсь прочитать адрес или адреса рядом с ним или где-нибудь еще, я либо получу точные байты, которые я написал в любой позиции, которую я запрашиваю, либо ничего не получу (все 255).

Мне удалось прочитать старые данные из других мест из предыдущих компиляций, так что данные наверняка находятся в чипе, просто доступ к ним кажется неопределенным.

Некоторые результаты чтения:

7000: [255, 255, ..., 255]
7500: [255, 255, ..., 255]
7980: [60, 61, 62, 63, 64, 65, 255, 255, ..., 255]
8040: [60, 61, 62, 63, 64, 65, 255, 255, ..., 255]
7960: [60, 61, 62, 63, 64, 65, 255, 255, ..., 255]
8060: [60, 61, 62, 63, 64, 65, 255, 255, ..., 255]
7940: [60, 61, 62, 63, 64, 65, 255, 255, ..., 255]
8500: [255, 255, ..., 255]
8150: [60, 61, 62, 63, 64, 65, 255, 255, ..., 255]

Код:

  const int memoryI2CAddress = 0x50;

  void Initialise() {
    Wire.begin();
    Test();
  }

  void Test() {
    unsigned int baseAddress = 8000;
    byte data[6] = {64, 65, 66, 66, 65, 61};
    Wire.beginTransmission(memoryI2CAddress);
    Wire.write((byte)(baseAddress >> 8));
    Wire.write((byte)(baseAddress && 0xFF)); 
    Wire.write(data, 6);
    Wire.endTransmission();
    delay(10);

    ReadTest(7000);
    ReadTest(7500);
    ReadTest(7980);
    ReadTest(8040);
    ReadTest(7960);
    ReadTest(8060);
    ReadTest(7940);
    ReadTest(8000);
    ReadTest(8500);
    ReadTest(8150);
  }


  void ReadTest(unsigned int baseAddress) {
    Serial.println(baseAddress);
    Wire.beginTransmission(memoryI2CAddress);
    Wire.write((byte)(baseAddress >> 8));
    Wire.write((byte)(baseAddress && 0xFF));   
    Wire.endTransmission();

    int count = Wire.requestFrom(memoryI2CAddress, 50);
    Serial.print(count);
    while (Wire.available()) { Serial.println(Wire.read()); }
  }

Обновление:

Адресация данных, по-видимому, чувствительна к первому байту адреса, а не ко второму. При инвертировании порядка наиболее и наименее значимых байтов и сравнении изменения MSB с адресом я могу надежно вернуть байт по правильному адресу. Это, по-видимому, объясняет, почему я получаю одни и те же данные для некоторых адресов, а не для других, где MSByte меняется или не меняется.

Так почему же система нечувствительна к наименее значимому байту в адресе?