The mb85_fram from zanduino

Chip identification issue

I found something strange when I attach different memories to i2c using the auto-identification method.
Analyzing the code I've found this in begin method:

        Wire.write((uint8_t)memSize >> 8);             // Write MSB of address
        Wire.write((uint8_t)memSize);                     // Write LsB of address

But in C++ and Gcc the cast operator (type) takes precedence over the bitwise scroll operator >>.
https://en.cppreference.com/w/c/language/operator_precedence
In effect, what you obtain is to cast the memSize (which is 16bit unsigned) to an unsigned 8bit AND THEN scroll it 8 position right; but when you cast a 16bit over a 8 bit only the LsB part of the source is copied into the destination variable, so you completely loose the MSB part when you send data through the i2c bus.

This is why you need to add a special case to detect 32kb memory at the end of the for cycle.

Finally I correct your method as follows:

uint8_t MB85_FRAM_Class::begin(const uint32_t i2cSpeed) {

  _wireCh->begin();
  _wireCh->setClock(i2cSpeed);
  for (uint8_t i = MB85_MIN_ADDRESS; i < MB85_MIN_ADDRESS + MB85_MAX_DEVICES; i++)  // loop all possible addresses
  {
    _wireCh->beginTransmission(i);
    if (_wireCh->endTransmission() == 0)  // If no error we have a device at this address
    {
      _wireCh->beginTransmission(i);  // Start transmission
      _wireCh->write((uint8_t)0);
      _wireCh->write((uint8_t)0);                        // Start at address 0
      _TransmissionStatus = _wireCh->endTransmission();  // Close transmission
      _wireCh->requestFrom(i, (uint8_t)1);               // Request 1 byte of data
      uint8_t minimumByte = _wireCh->read();             // Store value of byte 0

      _wireCh->beginTransmission(i);  // Start transmission
      _wireCh->write((uint8_t)0);
      _wireCh->write((uint8_t)0);                        // Start at address 0
      _wireCh->write(0xFF);                              // write high value to address 0
      _TransmissionStatus = _wireCh->endTransmission();  // Close transmission

      for (uint16_t memSize = 8192; memSize != 0; memSize = memSize * 2)  // Check each memory size
      {
        _wireCh->beginTransmission(i);                     // Start transmission
        _wireCh->write((uint8_t)(memSize >> 8));             // Write MSB of address
        _wireCh->write((uint8_t)memSize);                  // Write LsB of address
        _TransmissionStatus = _wireCh->endTransmission();  // Close transmission
        _wireCh->requestFrom(i, (uint8_t)1);               // Request 1 byte of data
        uint8_t maximumByte = _wireCh->read();             // Store value of high byte for chip
        _wireCh->beginTransmission(i);                     // Start transmission
        _wireCh->write((uint8_t)(memSize >> 8));             // Write MSB of address
        _wireCh->write((uint8_t)memSize);                  // Write LsB of address
        _wireCh->write(0x00);                              // write low value to max address
        _TransmissionStatus = _wireCh->endTransmission();  // Close transmission

        _wireCh->beginTransmission(i);  // Start transmission
        _wireCh->write((uint8_t)0);
        _wireCh->write((uint8_t)0);                        // Start at address 0
        _TransmissionStatus = _wireCh->endTransmission();  // Close transmission
        _wireCh->requestFrom(i, (uint8_t)1);               // Request 1 byte of data
        uint8_t newMinimumByte = _wireCh->read();          // Store value of byte 0
        if (newMinimumByte == 0x00)                    // If the value has changed
        {
          _I2C[i - MB85_MIN_ADDRESS] = memSize / 1024;  // Store memory size in kB
          _TotalMemory += memSize;                      // Add value to total
          _wireCh->beginTransmission(i);                     // Start transmission
          _wireCh->write((uint8_t)0);
          _wireCh->write((uint8_t)0);                        // Position to address 0
          _wireCh->write(minimumByte);                       // restore original value
          _TransmissionStatus = _wireCh->endTransmission();  // Close transmission
          break;                                             // Exit the loop
        } else {
          _wireCh->beginTransmission(i);                     // Start transmission
          _wireCh->write((uint8_t)(memSize >> 8));           // Write MSB of address
          _wireCh->write((uint8_t)memSize);                  // Write LsB of address
          _wireCh->write(maximumByte);                       // restore original value
          _TransmissionStatus = _wireCh->endTransmission();  // Close transmission
        }                                                // of if-then-else we've got a wraparound
      }                                     // of for-next loop for each memory size
      _DeviceCount++;                       // Increment the found count
    }                                       // of if-then we have found a device
  }                                         // of for-next each I2C address loop
  return _DeviceCount;                      // return number of memories found

As you can notice, I also moved the read part of the 0 address out of the memSize for since you don't really need to read the 0 address each time. In addition I've added a new constructor to manage multiple i2c ports.

MB85_FRAM_Class::MB85_FRAM_Class(TwoWire *wireChannel) {
  _wireCh = wireChannel;
}

And a local field to handle the instance:

TwoWire *_wireCh = &Wire; ///< Wire channel to use (for multi-channel platforms)

For "static" configurations I suggest you to add a begin override with a pre-defined configuration like this:

uint8_t MB85_FRAM_Class::begin(const uint8_t devices[MB85_MAX_DEVICES], const uint32_t i2cSpeed) {
  _wireCh->begin();
  _wireCh->setClock(i2cSpeed);

  for (uint8_t i = MB85_MIN_ADDRESS; i < MB85_MIN_ADDRESS + MB85_MAX_DEVICES; i++)
  {
    if (devices[i - MB85_MIN_ADDRESS] != 0)
    {
      _wireCh->beginTransmission(i);
      if (_wireCh->endTransmission() == 0)  // If no error we have a device at this address
      {
        _I2C[i - MB85_MIN_ADDRESS] = devices[i - MB85_MIN_ADDRESS];
        _TotalMemory += (devices[i - MB85_MIN_ADDRESS] * 1024);
        _DeviceCount++;
      }
    }
  }

  return _DeviceCount;
}

In this case you can avoid to read and write memory to detect the configuration if system has a pre-determined one.
Obviously, other minor changes were made in the code to adapt to the Wire pointer.

HTH

Lorenz

Specifications

Library Version: 1.0.7
IDE Version: platformIO
Platform: Win10 64
Subsystem: Teensy 4.0

zanduino / mb85_fram Goto Github PK

mb85_fram's People

Contributors

Stargazers

Watchers

Forkers

mb85_fram's Issues

Chip identification issue

Specifications

Change code to support Travis-CI

Make directory structure adhere to Arduino 1.5.x and later structure

Converted documentation to doxygen

Support faster I2C bus speeds

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent