10 years, 7 months ago.

Sadly I can reproduce it. The long one on the KL25Z doesn't have the greatest implementation, since the hardware wasn't really intended for it to be used like that, still it should work. Aditionally the MMA is a bit of a snob what it wants regarding I2C waveforms, and once it doesn't understand something, it will always keep returning zero until a power reset (even while it should detect a stop condition and restart its I2C circuits).

I did some checking, and first of all, the official code seems to work fine: http://mbed.org/teams/Freescale/code/FRDM_MMA8451Q/. Second, if I comment the 'long' I2C commands it also works fine. It is just them confusing the MMA, and when it gets confused it doesn't recover generally from it.

I think I found the bug in the mbed source code in the byte write functions (which tbh would have been removed long ago if I was in charge, they serve no purpose when there is also the block write functions). And it is hard to blame the source code, the device was never intended to be used like this with single byte write operations. Also the fix only would fix it for single byte read operations, multi-byte read with the byte-read commands would still be problematic, especially with the MMA which doesn't like errors on its I2C bus.

The issue is that the KL25Z does two things when reading its I2C data, it reads the last byte, and starts the next read operation. Unless it is set to send a NACK, then it prevents another byte from being read. The first read operation has a dummy read, to initiate the first reading of a byte. This currently does not set the ACK/NACK flag, causing the MMA to go bad. Adding the ACK/NACK flag there does seem to solve the issue you are seeing.

The problem however is if you do multiple reads. The block function knows what is coming next, and handles it fine. The byte-read function doesn't know what is coming. Since a byte-read also starts the next read operation, the issue is then that the one before the last read already starts the last read, without knowing that the next one should be the last, so the ACK/NACK flag again isn't set properly.

Now I might be able to force it similar to when the last byte is read, to always only read one byte, and not initiate the next read. But I really prefer to make such changes only when I got a logic analyzer. And that should arrive somewhere in the coming weeks. Since I don't think this is a critical issue for you right now, I personally prefer also to not do a pull-request with the solution for the single read, and wait until I can properly try to solve it. And the reason that I don't think it is a critical issue for you, is that the block writes should work fine. If you would really need to use the single byte writes/reads for some reason I can publish a modified mbed-src lib you can use.

Edit: Wow that became a long one :P. I hope it is a bit clear. You really need some kind of flow diagram to properly explain it, but that is too much work :)

And the TL;DR, use block writes/reads, they should work fine. If you manage to get the MMA confused (for example resetting in the middle of a transaction), you need to power cycle it.

#include "mbed.h"

#define MMA8451_I2C_ADDRESS (0x1d<<1)
#define REG_WHO_AM_I        0x0D


DigitalOut myled(LED_GREEN);
Serial pc(USBTX, USBRX);
I2C i2c(PTE25, PTE24); //MMA8451 Accelerometer

int main() {
    
    pc.baud(9600);
    
    while (true) {
        
        //This uses the I2C library function long forms
        //uint8_t who_am_i;
        //char t[1] = {REG_WHO_AM_I};
        //i2c.write(MMA8451_I2C_ADDRESS, t, 1, true);
        //i2c.read(MMA8451_I2C_ADDRESS, (char*) &who_am_i, 1);
        //End of Long form
        
        //This uses the I2C library function short forms
        
        uint8_t who_am_i_2;
        i2c.start();
        i2c.write(MMA8451_I2C_ADDRESS);         // Slave address with direction=write
        i2c.write(REG_WHO_AM_I);             // Subaddress (register)
        
        i2c.start();                // Break transmission to change bus direction
        i2c.write(MMA8451_I2C_ADDRESS + 1);     // Slave address with direction=read [bit0=1]
        
        who_am_i_2 = i2c.read(0);
        i2c.stop();
        //End of short form
        
        
        wait(0.5);
        pc.printf("Short: %x\n", who_am_i_2);  //Print SHORT to screen
              

        myled = !myled; //Heartbeat
    }
}

#include "mbed.h"

#define MMA8451_I2C_ADDRESS (0x1d<<1)
#define REG_WHO_AM_I        0x0D


DigitalOut myled(LED_GREEN);
Serial pc(USBTX, USBRX);
I2C i2c(PTE25, PTE24); //MMA8451 Accelerometer

int main() {
    
    pc.baud(9600);
    
    while (true) {
        
        //This uses the I2C library function long forms
        uint8_t who_am_i;
        char t[1] = {REG_WHO_AM_I};
        i2c.write(MMA8451_I2C_ADDRESS, t, 1, true);
        i2c.read(MMA8451_I2C_ADDRESS, (char*) &who_am_i, 1);
        //End of Long form
        
        //This uses the I2C library function short forms
        /*
        uint8_t who_am_i_2;
        i2c.start();
        i2c.write(MMA8451_I2C_ADDRESS);         // Slave address with direction=write
        i2c.write(REG_WHO_AM_I);             // Subaddress (register)
        
        i2c.start();                // Break transmission to change bus direction
        i2c.write(MMA8451_I2C_ADDRESS + 1);     // Slave address with direction=read [bit0=1]
        
        who_am_i_2 = i2c.read(0);
        i2c.stop();
        //End of short form
        */
        
        wait(0.5);
        pc.printf("Long: %x\n", who_am_i);  //Print both to screen
                

        myled = !myled; //Heartbeat
    }
}