Hi TomE. i just changed the entire code to work within IIC interrupt acknowledge. but still can't get work... i could read once with debugger, step by step, but, not in run mode. this code returns a "flag" with 5 states, which 0 equals to "error". im getting 0 al time.
i don't really what to do with this module, i'm tempted to toogle pins as IIC module do, on forums everybody thinks that this module needs more documentation, has several bugs that Freescale seems to ignore, and, no one can get this work as it should without reseting the module.... is disappointing... 
with this new code, i need to charge a Data array to send and recieve data...... i don't like it...
what do you think???
Hi. i took a break from my personal project due to work. now, i think i've a better perspective of this problem (a "colder head" ejejj, don't really know how to say that in english 
). look at this code, taken from HCS08QRUGSW:
unsigned char WriteBytesI2C (unsigned char slaveAddress,unsigned char numberOfBytes){ unsigned char Temp; I2C_LENGTH = numberOfBytes; I2C_COUNTER =0; I2C_STEP = IIC_HEADER_SENT_STATUS; I2C_DATA_DIRECTION = 1; /* Format the Address to fit in the IICA register and place a 0 on the R/W bit.*/ slaveAddress &= 0xFE; IIC1C_IICEN = 0; IIC1C_IICEN = 1; Temp = IIC1S; /* Clear any pending interrupt */ IIC1S_IICIF=1; IIC1C_MST = 0; IIC1S_SRW=0; IIC1C_TX = 1; /* Select Transmit Mode */ IIC1C_MST = 1; /* Select Master Mode (Send Start Bit) */ DelayUs(1); IIC1D=slaveAddress; /* Send selected slave address */ return(1);}
slaveAddress &= 0xFE;
slaveAddress &=0XFE should be slaveAddress=(slaveadress<<1)|I2C_Status, being I2C_Status=0 to write and I2C_Status=1 to read??
actually, slaveAddress &=0XFE puts a 0 on LSB, but, the writting address changes...
i think that should be a problem, because i'm reading status flags in interupt acknoledge, and found that never runs over 3th or 4th state (sending and sent message).
what do you think?
> "colder head"
"Cool head", same in English.
There are two ways to represent the Slave Address. It is a seven bit field in an 8 bit register, and is 8 bits on the I2C bus when drawn on paper or on a CRO.
So you can either use the 7 bit value in the Data Sheets and in code or you can use the 8 bit value. I'm looking at an Atmel AT24C32 Data Sheet, and it represents the address on the bus as:
------------------------------------------| 1 | 0 | 1 | 0 | A2 | A1 | A0 | rw |------------------------------------------
So it's your choice (as a programmer) whether to call that "0xA0 - 0xAE" or "0x70 - 0x77".
If you've chosen the "more correct" 7 bit value, then at some point in your code you have to convert from the 7-bit address to the 8-bit register value. If you really want to make the code hard to follow you have different parts of the code using different representations, or you hide the conversion in a macro somewhere.
Of course if you're starting with someone else's code you have to unpick what they did.
There are ways to make this clear, by using good comments and sensible naming conventions. You could even declare typedefs for the 7-bit and 8-bit representations and have explicit conversion functions, but that would be way too professional for low level driver code like this 
.
I don't think I've ever seen "professional looking" I2C code. It is usually "hacked into shape" and left alone when it first seems to work, leaving confusion in its wake for the next programmer to work on it.
Welcome to the club
> slaveAddress &=0XFE should be slaveAddress=(slaveadress<<1)|I2C_Status
You're assuming it is passed in in 7 bit form. You're then converting a 7-bit-represented address into an 8-bit-represented address in the same variable witout a warning stating "must be 7 bits above here and is 8 bits below here".
The definition of that function should contain proper header comments detailing EXACTLY what each argument is.
I'd guess in not only doesn't detail this, but it doesn't have any description of the interface at all.
It is likely the shift is being done in the calling function, or (more likely) the original definition (or magic hex number) used to call that function was already shifted into "8 bit format".
Tom
