Yes I have the I2C version and can read the data from it using both a PIC micro and a NIOS soft CPU, what I can't do is get the coeficients to work 
Here is the code I use (you will need your own I2C start/stop/read/write functions)
void Measure_ambient_presure(void) { unsigned char x; unsigned char MPL115A2_data[16]; printf(";Read MPL115A2\r"); i2c_start(); // I2C Bus Start condition i2c_write(MPL115A2_I2C_address); // I2C bus Device address i2c_write(MPL115A2_start_both_conversion_command); // Command to Convert both Pressure and Temperature i2c_write(0x01); i2c_stop(); // I2C Bus Stop condition delay_ms(5); // wait for A-D conversion to take place i2c_start(); // I2C Bus Start condition i2c_write(MPL115A2_I2C_address); // I2C bus Device address i2c_write(0x00); // address in MPL115A2 i2c_start(); // I2C Bus Start condition (a restart) i2c_write(MPL115A2_I2C_address|0x01); // address in MPL115A2 + read bit MPL115A2_data[0] = i2c_read(1); // read with ACK MPL115A2_data[1] = i2c_read(1); // read with ACK MPL115A2_data[2] = i2c_read(1); // read with ACK MPL115A2_data[3] = i2c_read(1); // read with ACK MPL115A2_data[4] = i2c_read(1); // read with ACK MPL115A2_data[5] = i2c_read(1); // read with ACK MPL115A2_data[6] = i2c_read(1); // read with ACK MPL115A2_data[7] = i2c_read(1); // read with ACK MPL115A2_data[8] = i2c_read(1); // read with ACK MPL115A2_data[9] = i2c_read(1); // read with ACK MPL115A2_data[10] = i2c_read(1); // read with ACK MPL115A2_data[11] = i2c_read(1); // read with ACK MPL115A2_data[12] = i2c_read(1); // read with ACK MPL115A2_data[13] = i2c_read(1); // read with ACK MPL115A2_data[14] = i2c_read(1); // read with ACK MPL115A2_data[15] = i2c_read(0); // read with noACK i2c_stop(); // I2C Bus Stop condition printf(";MPL115A2 Data= "); for (x=0;x<16;x++) { printf("%02X ",MPL115A2_data[x]); } printf("\r"); }
;MPL115A2 Data= 64 C0 75 80 3D 9B B9 4A C7 46 32 BC 02 20 FD 60
;MPL115A2 Data= 65 00 76 80 3D 9B B9 4A C7 46 32 BC 02 20 FD 60
;MPL115A2 Data= 65 40 76 80 3D 9B B9 4A C7 46 32 BC 02 20 FD 60
;MPL115A2 Data= 65 00 76 C0 3D 9B B9 4A C7 46 32 BC 02 20 FD 60
;MPL115A2 Data= 65 80 75 C0 3D 9B B9 4A C7 46 32 BC 02 20 FD 60
;MPL115A2 Data= 65 00 75 40 3D 9B B9 4A C7 46 32 BC 02 20 FD 60
Regards, Mark Leman
The coefficients are not all the same size,but are packed into a 12 bytes (96 bits) in registers x04 to x0F. The coeffs are really floating point numbers but the decimal point is in a different place in each number and some are negative etc. So since I was unable to get the sample code to work due possibly to the byte endian nature of the data I wrote a function that can convert the bytes to the doubles.
First here is the code to download the coeffs. Obviously the implementation of the I2C is left to the reader.
void CMPL115A:
ownloadCoeffs()
{
int err=0;
int resultL,resultH;
BYTE data;
iA0=0;
iB1=0;
iB2=0;
iC11=0;
iC12=0;
iC22=0;
// Get A0
err=m_I2C.ModuleReadByte(BAROMETER,0x05,&data);
if(err==ERROR_SUCCESS) // Then we probably have a device connected. so assume rest of calls will succeed.
{
resultL=INT8(data);
m_I2C.ModuleReadByte(BAROMETER,0x04,&data);
resultH=INT8(data);
iA0=(resultH<<8)+(resultL&0x00FF);
dA0=ConvertCoeffToDouble(iA0,16,12,3,0);
// Get B1
m_I2C.ModuleReadByte(BAROMETER,0x07,&data);
resultL=INT8(data);
m_I2C.ModuleReadByte(BAROMETER,0x06,&data);
resultH=INT8(data);
iB1=(resultH<<8)+(resultL&0x00FF);
dB1=ConvertCoeffToDouble(iB1,16,2,13,0);
// Get B2
m_I2C.ModuleReadByte(BAROMETER,0x09,&data);
resultL=INT8(data);
m_I2C.ModuleReadByte(BAROMETER,0x08,&data);
resultH=INT8(data);
iB2=(resultH<<8)+(resultL&0x00FF);
dB2=ConvertCoeffToDouble(iB2,16,1,14,0);
// Get C12
m_I2C.ModuleReadByte(BAROMETER,0x0B,&data);
resultL=INT8(data);
m_I2C.ModuleReadByte(BAROMETER,0x0A,&data);
resultH=INT8(data);
iC12=(resultH<<8)+(resultL&0x00FF);
dC12=ConvertCoeffToDouble(iC12,14,0,13,9);
// Get C11
m_I2C.ModuleReadByte(BAROMETER,0x0D,&data);
resultL=INT8(data);
m_I2C.ModuleReadByte(BAROMETER,0x0C,&data);
resultH=INT8(data);
iC11=(resultH<<8)+(resultL&0x00FF);
dC11=ConvertCoeffToDouble(iC11,11,0,10,11);
// Get C22
m_I2C.ModuleReadByte(BAROMETER,0x0F,&data);
resultL=INT8(data);
m_I2C.ModuleReadByte(BAROMETER,0x0E,&data);
resultH=INT8(data);
iC22=(resultH<<8)+(resultL&0x00FF);
dC22=ConvertCoeffToDouble(iC22,11,0,10,15);
m_InitSuccess=true;
}
else
{
m_InitSuccess=false;
}
}
and the here is the ConvertCoeffToDouble which takes the 2byte word and then parameters which describe the number of bits, integer bits, fractional bits and padbits. There may be more efficient ways to do this, but since it only has to be done once when the device is initialized it is not critical to optimize.
double ConvertCoeffToDouble(INT16 coeff,short bitCount,short iBits, short fracBits, short padBits)
{
// Utility function to convert the coeff's into floating point parameters.
// See Freescale App note AN3785 for details of how the parameters are stored.
double result=0;
bool s=false;
bool bit;
int fb=0;
// We start working our way through the bits from high to low.
// The incoming data is a 16bit integer which we have to shorten since the lower LSB's are empty if <16 bits. (see pg 15 of AN3785).
if (bitCount<16)
{// Make coeff the appropriate size
coeff=coeff>>(16-bitCount);
}
// Sanity check that the parameters passed into the function make sense. We can't have more or less bits than the amount of data.
// Add 1 to account for sign bit.
if((iBits+fracBits+1)!=bitCount)
{
TRACE(_T("Error in parameters!!\n"));
return 0;
}
//Sanity check that if we are padding the decimal point that we can't also have integer bits.
if((padBits>0)&&(iBits>0))
{
TRACE(_T("Error in parameters. iBits and padBits not consistent!!\n"));
return 0;
}
for(int b=bitCount;b>0;b--)
{
bit=bool((int(pow(2.0,b-1))& coeff)>>(b-1)); // Get each bit in turn as a 1 or a 0.
if (b==bitCount) // if this is the first bit (sign bit check if it is set)
{
s=bit;
if(s)
{
coeff=~coeff+1; //Calculate 2's complement; //(See App note AN3785 middle of Pg15 for explanation.
}
}
else // process the bits in turn.
{
if(iBits>0)
{ // we have an integer bit;
if(bit)
{
result+=pow(2.0,iBits-1);
}
iBits--;
}
else // we have a fractional bit
{
fb++;
if(bit)
{
result+= (1/pow(2.0,fb+padBits));
}
fracBits--;
}
}
}
if(s)
{
result*=-1;
}
TRACE(_T("Result=%f\n"),result);
return result;
}
Only after you have converted all the coefficients to the correct sign, significant digits etc, does the thing start to make sense and read correctly.
Peter
