topic Re: AN3291 oddity (problems with I2C device on QG8) in 8-bit Microcontrollers

AN3291 oddity (problems with I2C device on QG8)

jarin — Tue, 28 Nov 2006 21:39:00 GMT

Hi all,
I'm trying to connect 24FC512 EEPROM to QG8 device. I downloaded AN3291 and copied routines to read/write from EEPROM with I2C module in HCS08 devices into my project, after a slight changes (like converting IIC1S to IICS and so on) I downloaded code to FLASH and the routines behaved somehow strange. Write routine followed with read routine worked, but reading byte back stopped at waiting for ACK signal after third transmitted byte (first is device address, second and third are memory address bytes). I searched for problem in read routine, but when I placed two write routines subsequently, the second one stopped at the same place, indicating the is something wrong with the write routine. Putting AN in contrast with datasheet showed that IICIF flag should be cleared (by writing 1) after writing data byte into EEPROM.
This is how routine looked originally:

void I2C_write_byte (word addr,byte data)
{
EE_Addr = addr; // address input;
temp = (EE_Addr_H & 0x07) 1;
IIC1C_TX = 1; // Set transmit mode;
//-------start of transmit first byte to IIC bus-----
IIC1C_MST = 1; // Start transfer - Master bit = 1;
IIC1D = sl_addr | temp; // send "Write" + high address;
while (!(IIC1S_IIC1IF));
IIC1S_IIC1IF = 1;
while (IIC1S_RXAK); // wait for ACK from slave;
//-----Slave ACK occurred------------
IIC1D = EE_Addr_L; // send low address byte;
while (!(IIC1S_IIC1IF)); // wait till data transferred;
IIC1S_IIC1IF = 1;
while (IIC1S_RXAK); // wait for ACK from slave;
//-----Slave ACK occurred------------
IIC1D = data; // write data byte into EEPROM;
while (!(IIC1S_IIC1IF)); // wait till data transferred;
while (IIC1S_RXAK); // wait for ACK from slave;
IIC1C_MST = 0; // STOP bit;
}

and this is how the routine works for me:

void I2C_write_byte (word addr,byte data)
{
EE_Addr = addr; // address input;
temp = (EE_Addr_H & 0x07) 1;
IIC1C_TX = 1; // Set transmit mode;
//-------start of transmit first byte to IIC bus-----
IIC1C_MST = 1; // Start transfer - Master bit = 1;
IIC1D = sl_addr | temp; // send "Write" + high address;
while (!(IIC1S_IIC1IF));
IIC1S_IIC1IF = 1;
while (IIC1S_RXAK); // wait for ACK from slave;
//-----Slave ACK occurred------------
IIC1D = EE_Addr_L; // send low address byte;
while (!(IIC1S_IIC1IF)); // wait till data transferred;
IIC1S_IIC1IF = 1;
while (IIC1S_RXAK); // wait for ACK from slave;
//-----Slave ACK occurred------------
IIC1D = data; // write data byte into EEPROM;
while (!(IIC1S_IIC1IF)); // wait till data transferred;
//*****************************here is flag clearing*************************
IIC1S_IIC1IF = 1; //!!!!!!!!!!!ADDED LINE!!!!!!!!!!!!
//***************************************************************************
while (IIC1S_RXAK); // wait for ACK from slave;
IIC1C_MST = 0; // STOP bit;
}

I think it is quite logical to clear flag after it was set. This is also mentioned in datasheet for QG8 device (figure 11-3) - there is difference, described as interrupt routine, but it can be easily converted into polled routines, IICIF flag is cleared after EVERY entry to interrupt routine, it means everytime when IICIF flag is set.
After adding line routines work like expected - I'm able to write/read from external EEPROM.

Is the missed line mistake in document or I have got another problem?

By the way, interesting fact is that the write/read sequence worked well when doing single steps through routine code AND with Data window opened. With Data windows closed, routine hanged on the same place as before. It is probably because I2C module registers were showed in Data window and thus read by BDM POD.

Re: AN3291 oddity (problems with I2C device on QG8)

ddz — Thu, 15 Feb 2007 10:49:30 GMT

I'm experiencing same problem with the code in that AN. I will try your fix tomorrow...

Re: AN3291 oddity (problems with I2C device on QG8)

Alban — Thu, 15 Feb 2007 17:06:14 GMT

Thanks Jarin,

Reported to AN3291 author with the link to your description.

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Thu, 22 Feb 2007 04:49:07 GMT

Hi all,

I'm an author of the AN3291.

Thank you for your important feedback. I apologize for that mistake - you are right.

I have been tested the WRITE and READ routines from my AN3291. One mistake (mentioned previously) was in the write routine and I found another one in the read routine too. Now both routines are correct and they are in follow:

void I2C_write_byte (word addr,byte data)
{
    IICS_IICIF = 1;
    EE_Addr = addr;                // address input;
    temp = (EE_Addr_H & 0x07) << 1;
    IICC_TX = 1;                      // Set transmit mode;
       //-------start of transmit first byte to IIC bus-----
    IICC_MST = 1;                  // Start transfer - Master bit = 1;
    IICD = sl_addr | temp;      // send "Write" + high address;
    while (!(IICS_IICIF));
    IICS_IICIF = 1;
    while (IICS_RXAK);          // wait for ACK from slave;
      //-----Slave ACK occured------------
    IICD = EE_Addr_L;          // send low address byte;
    while (!(IICS_IICIF));        // wait till data transfered;
    IICS_IICIF = 1;
    while (IICS_RXAK);          // wait for ACK from slave;
      //-----Slave ACK occured------------
    IICD = data;                    // write data byte into EEPROM;
    while (!(IICS_IICIF));       // wait till data transfered;
    IICS_IICIF = 1;      // - ADDED;
    while (IICS_RXAK);        // wait for ACK from slave;
    IICC_MST = 0;               // STOP bit;
}

byte I2C_read_byte(word addr)
{
   IICS_IICIF = 1;
   EE_Addr = addr;              // address input;
   temp = (EE_Addr_H & 0x07) << 1;
   IICC_TX = 1;                     // Set transmit mode;
       //-------start of transmit first byte to IIC bus-----
   IICC_MST = 1;                  // Start transfer - Master bit = 1;
   IICD = sl_addr | temp;      // send "Write" + high address;
   while (!(IICS_IICIF));
   IICS_IICIF = 1;
   while (IICS_RXAK);          // wait for ACK from slave;
       //-----Slave ACK occured------------
   IICD = EE_Addr_L;             // send low address byte;
   while (!(IICS_IICIF));
   IICS_IICIF = 1;
   while (IICS_RXAK);           // wait for ACK from slave;
       //-----Slave ACK occured------------
   IICC_RSTA = 1;               // Generate repeat START condition;
   IICD = sl_addr | temp | 1; // Send combined address & "Read" command;
   while (!(IICS_IICIF));
   IICS_IICIF = 1;
   while (IICS_RXAK);         // wait for ACK from slave;
       //-----Slave ACK occured------------
   IICC_TX = 0;                   // Set receive mode;
   IICC_TXAK = 1;              // Last byte will be read; - ADDED;
   temp = IICD;                   // read IIC data
   while (!(IICS_IICIF));
   IICS_IICIF = 1;
   IICC_MST = 0;               // STOP bit;
   rd_data = IICD;
   return rd_data;
}

I made tests on my 9S08QG8 MCU with the 24LC16B serial EEPROM. The code in the AN3291 will be corrected as soon as possible.

I will make tests with the mentioned EEPROMs 24FC512 and QG8 MCU after I receive this type of EEPROM. I guess it could be finished next week - then I will place the message to this forum.

Sorry once again for this mistake.

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

FC — Fri, 09 Mar 2007 09:26:54 GMT

Can you use the TCF flag rather than the IICIF flag for byte transfer completion?

example:

while(! (IICS_TCF));

Also, does the simulator work for IIC module?

Thanks

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Fri, 09 Mar 2007 18:09:23 GMT

I suggest you use the IBIF flag instead TCF. The communication is relable. On the other site, the IBIF flag you can use for interrupt generation and make the code for IIC device access by the interrupts.

The CW Simulator does not simulate IIC comunication because you need the slave answers too and the simulator does not know simulate any slave IIC device.

The best way to debug or build the IIC SW code is use the storage scope.

Best Regards,

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Thu, 03 Sep 2009 04:10:50 GMT

Stano wrote:

I'm an author of the AN3291...

void I2C_write_byte (word addr,byte data)
{
    IICS_IICIF = 1;
    EE_Addr = addr;                // address input;
    temp = (EE_Addr_H & 0x07) << 1;
    IICC_TX = 1;                      // Set transmit mode;
       //-------start of transmit first byte to IIC bus-----
    IICC_MST = 1;                  // Start transfer - Master bit = 1;
    IICD = sl_addr | temp;      // send "Write" + high address;
    while (!(IICS_IICIF));
    IICS_IICIF = 1;       
    while (IICS_RXAK);          // wait for ACK from slave;
      //-----Slave ACK occured------------
    IICD = EE_Addr_L;          // send low address byte;
    while (!(IICS_IICIF));        // wait till data transfered;
    IICS_IICIF = 1;       
    while (IICS_RXAK);          // wait for ACK from slave;
      //-----Slave ACK occured------------
    IICD = data;                    // write data byte into EEPROM;
    while (!(IICS_IICIF));       // wait till data transfered;
    IICS_IICIF = 1;      // - ADDED;
    while (IICS_RXAK);        // wait for ACK from slave;
    IICC_MST = 0;               // STOP bit;
}

Stano, I'm confused in several areas with your app note and your code snippet (let's focus on the write routine.

First of all, the AN shows a nice write format in Figure 4 (for one byte address) and in Figure 5 (for two byte address) on page 4. However, in Figure 4, the address is described as "Word Address", even though it's an 8-bit word. Same goes for Figure 5.

Your example code seems to be the 2-byte address variety with low and high bytes. Yet, the 4-bit control code section seems to be mixed up with the high byte. Shouldn't the control bits + the lower three device address bits + Write bit be sent first to the device? Then, you send the high and low address bytes?

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Thu, 03 Sep 2009 16:03:04 GMT

Hi irob,

This address is really word format, because it is not only lower 8-bits but still upper 3 bits in the control byte. For detail information look at the datasheets of e.g. 24C16 or 24C32 EEPROMs.

Mentioned datasheets can be on the microchip web page.

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Thu, 03 Sep 2009 20:21:01 GMT

Stano, thanks for the clarification. I see what you're saying now. I was just compariing the diagram in your AN to your code and didn't come up with the right amount of bits. But I see what you're saying now.

I've got my software written now for a 1-byte addressable I2C peripheral, but I'm having a curious problem with it. I'm using the MC9S08QG8 and I have found that only in the debugger will the I2C module work correctly.

For instance, if I step through my code, I am able to trace through and over a complete I2C Write and I2C Read function, both working as expected. But if I let the program run, it getshung up in the interrupt flag polling while().

Another strange thing is that the entire I2C module won't seem to turn on without the use of this interrupt poll. I attempted -- like user "FC" above suggested -- to use the transfer complete (TOF) flag instead of the interrupt flag to wait for completion. In that iteration, the SCL won't even start. It's like the whole module is just dead. Can you explain why that would be? What is the TOF bit for then?

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Thu, 10 Sep 2009 14:09:26 GMT

Hi Irob,

sorry I answer a bit later, but I was very busy. A long time ago I write the routine for 1-byte address IIC communication between S08GB60 and PCF8574 GPIO extender. This application works very well - without debug interface of course. I use it as the standard GPIO port for buttons input or LED drive output. The SW routines are in follow:

//------------------------------------------------------------
void I2C_write_byte (byte data)
{
     IIC1C_IICEN = 1;
     IIC1C_TX = 1;
        //-------start of transmit first byte to IIC bus-----
     IIC1C_MST = 1;            // Start transfer - Master bit = 1;
     IIC1D = sl_addr;
   while (!(IIC1S_IICIF));
     IIC1S_IICIF = 1;
    while (IIC1S_RXAK);       // wait for ACK from slave;
       //-----Slave ACK occured------------
     IIC1D = data;             // write data byte into EEPROM;
     while (!(IIC1S_TCF));     // wait till data transfered;
     while (IIC1S_RXAK);       // wait for ACK from slave;
     while (!(IIC1S_TCF));     // wait till data transfered;
     IIC1C_MST = 0;            // STOP bit;
     IIC1C_IICEN = 0;
}
//------------------------------------------------------------
byte I2C_read_byte (void)
{
     IIC1C_TX = 1;             // Set transmit mode;
        //-------start of transmit first byte to IIC bus-----
     IIC1C_MST = 1;            // Start transfer - Master bit = 1;
     IIC1D = (sl_addr | 1);
     while (!(IIC1S_IICIF));
     IIC1S_IICIF = 1;
    while (IIC1S_RXAK);       // wait for ACK from slave;
       //-----Slave ACK occured------------
     IIC1C_TX = 0;             // Set receive mode;
    rd_data = IIC1D;          // read IIC data
    while (!(IIC1S_IICIF));
    IIC1S_IICIF = 1;
     IIC1C_MST = 0;            // STOP bit;
     return rd_data;
}

The important think is that the IIC bus can freeze when the salve device can't answer properly. Slave device must receive right amount of SCL clock impulses to send whole answer to master. When this state (IIC freeze) arrives, master must make the IIC bus reset - this means send 9 SCL impulses while SDA = 0. Then the communication can start. For this "reset" switch off the IIC internal module, go to GPIO mode and emulate IIC reset by the same pins but in GPIO mode. Then activate internal IIC module and use it. The best way to recognize that the byte transfer is complete is use the IICIF flag - you can use it in interrupt routine or not - see example above.

I don't know what kind of IC you use for 1-byte address communication, but this code could be good example. The best way for IIC debug is use the scope, because it is not possible debug it step-by-step.

I hope it hels you.

Bye,

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Fri, 11 Sep 2009 02:22:31 GMT

Thanks again, Stano, for your help! I'm confused about when exactly we must check the I2C interrupt flag. In your most recent example, you have that...

while (!(IIC1S_IICIF)

...happening every time you write to or read from the I2C data channel. And now you are also checking the TOF bit:

while (!(IIC1S_TCF))

...though you weren't above in your original code. Seems inconsistent to me.

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Fri, 11 Sep 2009 19:10:20 GMT

Hi irob,

sorry for confusion. I made test of these routines once again and the final result is - use the IICIF flag instead TCF flag. The TCF flag is valid only short time - durring or immediately after byte transfer. The IICIF flag is set and you need clear it by software - write "1" to this bit. So you have reliable information about transfered data to/from IIC module.

So the final code for communication between S08 MCU and PCF8574 GPIO port extender is in follow:

//-------------------------------------------------------------------------------
void I2C_write_byte (byte data)
{
     IIC1C_IICEN = 1;
        //-------start of transmit first byte to IIC bus-----
     IIC1C_MST = 1;              // Start transfer - Master bit = 1;
     IIC1C_TX = 1;                // Set transmit mode;
     IIC1D = sl_addr;
     while (!(IIC1S_IICIF));
     IIC1S_IICIF = 1;             // clear the flag;
     while (IIC1S_RXAK);        // wait for ACK from slave;
       //-----Slave ACK occured------------
     IIC1D = data;                 // write data byte into EEPROM;
     while (IIC1S_RXAK);        // wait for ACK from slave;
     while (!(IIC1S_IICIF));     // wait till data transfered;
     IIC1S_IICIF = 1;             // clear the flag;
     IIC1C_MST = 0;              // STOP bit;
     IIC1C_IICEN = 0;            // deactivate IIC module;
}
//-------------------------------------------------------------------------------
byte I2C_read_byte (void)
{
     IIC1C_IICEN = 1;
        //-------start of transmit first byte to IIC bus-----
     IIC1C_MST = 1;              // Start transfer - Master bit = 1;
     IIC1C_TX = 1;                // Set transmit mode;
     IIC1D = (sl_addr | 1);      // "read" command;
     while (!(IIC1S_IICIF));     // wait till data transfered;
     IIC1S_IICIF = 1;             // clear the flag;
     while (IIC1S_RXAK);        // wait for ACK from slave;
       //-----Slave ACK occured------------
     IIC1C_TX = 0;               // Set receive mode;
     temp = IIC1D;               // send SCL impulses to read slave;
     while (!(IIC1S_IICIF));    // wait till data transfered;
     IIC1S_IICIF = 1;            // clear the flag;
     IIC1C_MST = 0;             // STOP bit;
     rd_data = IIC1D;           // save received data from slave;
     IIC1C_IICEN = 0;           // deactivate IIC module;
     return rd_data;
}
//-------------------------------------------------------------------------------

So you can use it for one-byte transfer as example.

I hope it helps you;

Bye,

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

Richly — Mon, 30 Nov 2009 03:34:38 GMT

Hi, Stano.

I'm trying to figure out the IIC drivers. I note that your routines here in the forum either

Case 1: start with

IICS_IICIF = 1;

Case 2: start with

IIC1C_IICEN = 1;

and then end with

IIC1C_IICEN = 0;

Neither of these cases occurs in the latest version of AN3291.pdf (Rev. 2, 04/2007). Are they necessary? What problem does Case 1 solve? It seems excessive to disable the IIC module after each transfer and then enable it again for the next transfer (Case 2). Is it another way to solve the same problem as Case 1?

Would it be reasonable to have code that uses a counter to limit the amount of time to wait for the IIC device to respond instead of hanging in an infinite loop until a COP interrupt occurs (if it happens to be enabled)? Would this solve any of the issues the code above addresses?

Furthermore, the IIC_write_byte() routine in AN3291 has a line that is not in your forum code:

IICS_IICIF=1; // Clear the flag

just before its last line

IICC_MST = 0; // Generate STOP

I cannot figure out why this is needed, since the flag was already cleared immediately following the wait for the Interrupt flag and before waiting for the AK.

Actually, the situation is more confusing than that: your final forum I2C_write_byte() routine waits for an AK from the slave before it waits for the Interrupt flag to be set, indicating that the data finished transferring. All other drivers I've seen reverse this order, first waiting for the Interrupt flag and then the AK. Can you explain?

In short, there seem to be several different versions of IIC code on Freescale sites. They differ in just a few -- to me mysterious -- particulars. But these particulars seem to be related to serious issues that various posts have raised about failed IIC communications.

Can someone provide "gold standard" versions of IIC transfer code with comments especially for "gotcha" situations? It'd be nice if there were both single- and multiple-byte transfer routines, both with and without interrupts. Links to these "gold standards" should be prominently placed near all the older drivers, so people looking for help don't get bogged down with code that almost works.

Thanks,

Richly

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Fri, 25 Jun 2010 03:59:40 GMT

I've been beating my head against a wall all day on this, trying to get the IIC module to work. No offense to the author, but with the many versions of sample code posted, it's difficult to suss out the right "flavor" to get simple master IIC transactions working with a registered slave.

The best results I can achieve, using verbatim the code(s) posted by Stano, are passing write and read transactions in BDM mode only. In other words, I can only write a byte to my I2C slave chip and read it back successfully if I step through code in the debugger on my HCS908QG8. If I let the chip run, it always hangs in the slave acknowledge while.

Something that hasn't been discussed at all either here or in the app note, is the QG8's SDA hold time and SCL divider values. There's a fairly involved formula/chart on the matter in the datasheet on pages 162-163. I've tried both the values in the datasheet's example, and my own set, neither of which made a difference for me.

Anyone else make heads or tails of this mess?

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Fri, 25 Jun 2010 15:01:18 GMT

Hello,

I want to help you with this issue, so send me please the source code as a zipped attachmend and the type of the slave used.

Thanks,

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Tue, 29 Jun 2010 20:47:42 GMT

Thanks, Stano. I will PM you the code.

Before I left for a long weekend, I did make a breakthrough. I had noticed one key difference between your code example and mine. I had written an I2C init routine that I only called once to turn channels on, timing settings, etc. In your examples, you turn on and off the I2C module every time you call a Write or Read function. I believe on of the readers on this board questioned that.

I can indeed now get I2C functioning stand-alone outside of the debugger, but only if I do as you do -- turn on the module before use, turn back off after completed.

It's not clear to me why this is the case. Is this a shortcoming of the module only in QG8s? All S08s? Perhaps an errata is in order.

Re: AN3291 oddity (problems with I2C device on QG8)

Stano — Tue, 29 Jun 2010 21:34:05 GMT

Hello,

I saw my source code of IIC routines for Read and Write functions, but I turn ON the IIC module once only - in the Init routine. Then I use the Read or Write functions to put or get data to/from IIC device. I think the best way is check your source code - so send it to me please and I will check it. Send me please the type of IIC device used in your application too, otherwise I can check it with IIC memory only.

Thanks,

Stano.

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Tue, 29 Jun 2010 22:09:52 GMT

From your code above, Stano, you are enabling/disabling the module inside the I2C_write_byte and I2C_read_byte functions:

//-------------------------------------------------------------------------------
void I2C_write_byte (byte data)
{
     IIC1C_IICEN = 1;
        //-------start of transmit first byte to IIC bus-----
     IIC1C_MST = 1;              // Start transfer - Master bit = 1;
     IIC1C_TX = 1;                // Set transmit mode;
     IIC1D = sl_addr;
     while (!(IIC1S_IICIF));
     IIC1S_IICIF = 1;             // clear the flag;       
     while (IIC1S_RXAK);        // wait for ACK from slave;
       //-----Slave ACK occured------------
     IIC1D = data;                 // write data byte into EEPROM;
     while (IIC1S_RXAK);        // wait for ACK from slave;
     while (!(IIC1S_IICIF));     // wait till data transfered;
     IIC1S_IICIF = 1;             // clear the flag;
     IIC1C_MST = 0;              // STOP bit;
     IIC1C_IICEN = 0;            // deactivate IIC module;
}
//-------------------------------------------------------------------------------
byte I2C_read_byte (void)
{
     IIC1C_IICEN = 1;
        //-------start of transmit first byte to IIC bus-----
     IIC1C_MST = 1;              // Start transfer - Master bit = 1;
     IIC1C_TX = 1;                // Set transmit mode;
     IIC1D = (sl_addr | 1);      // "read" command;
     while (!(IIC1S_IICIF));     // wait till data transfered;
     IIC1S_IICIF = 1;             // clear the flag;       
     while (IIC1S_RXAK);        // wait for ACK from slave;
       //-----Slave ACK occured------------
     IIC1C_TX = 0;               // Set receive mode;
     temp = IIC1D;               // send SCL impulses to read slave;
     while (!(IIC1S_IICIF));    // wait till data transfered;
     IIC1S_IICIF = 1;            // clear the flag;
     IIC1C_MST = 0;             // STOP bit;
     rd_data = IIC1D;           // save received data from slave;
     IIC1C_IICEN = 0;           // deactivate IIC module;
     return rd_data;            
}
//-------------------------------------------------------------------------------

Re: AN3291 oddity (problems with I2C device on QG8)

Richly — Sat, 03 Jul 2010 12:18:17 GMT

I'm using a MC9S08SH16 and experiencing the same problems, e.g., works, if at all, only when single stepping. So it doesn't appear to be just the QG8.

I'm glad to see activity on this thread again and would love to receive answers to the series of questions I raised in my message of 2009-11-29 07:34 PM.

Thanks,

Richly

Re: AN3291 oddity (problems with I2C device on QG8)

irob — Tue, 06 Jul 2010 23:20:08 GMT

Richly, have you tried enabling the I2C module in your I2C write/read functions first, then disabling after complete? These steps got it working for me outside of the debugger.