//
// I2C Master interface for PIC16/PIC18, software implementation
//
// Written by Svetoslav Pirev, Bulgaria, Plovdiv, ICQ: 321848589
// ver 1.0 - 30 Oct 2001
// ver 1.1 - 16 Jul 2003
// ver 1.2 - 08 Oct 2005
//

#bit _SCL=PORTC.3
#bit _SDA=PORTC.4
#bit _SCLTRIS=TRISC.3
#bit _SDATRIS=TRISC.4

//#define M2416
//#define M2432
//#define M2465
//#define M24128
//#define M24256
//#define M24512
#define M24515

#ifdef M2416   // 24LC16B
const int8 I2C_SLAVE = 0xA0;
const int16 I2C_EEPROM_SIZE = 2048;
const int8 I2C_PAGE_SIZE = 16;
#else

#ifdef M2432   // 24LC32
const int8 I2C_SLAVE = 0xA0;
const int16 I2C_EEPROM_SIZE = 8192;
const int8 I2C_PAGE_SIZE = 32;
#else

#ifdef M2465   // 24LC65
const int8 I2C_SLAVE = 0xA0;
const int16 I2C_EEPROM_SIZE = 8192;
const int8 I2C_PAGE_SIZE = 8;
#else

#ifdef M24128   // 24LC128
const int8 I2C_SLAVE = 0xA0;
const int16 I2C_EEPROM_SIZE = 16384;
const int8 I2C_PAGE_SIZE = 64;
#else

#ifdef M24256   // 24LC256
const int8 I2C_SLAVE = 0xA0;
const int16 I2C_EEPROM_SIZE = 32768;
const int8 I2C_PAGE_SIZE = 64;
#else

#ifdef M24512   // 24LC512
const int8 I2C_SLAVE = 0xA0;
const int32 I2C_EEPROM_SIZE = 65536;
const int8 I2C_PAGE_SIZE = 128;
#else

#ifdef M24515   // 24LC515
const int8 I2C_SLAVE = 0xA2;
const int32 I2C_EEPROM_SIZE = 65536;
const int8 I2C_PAGE_SIZE = 64;
#endif

#endif
#endif
#endif
#endif
#endif
const int8 I2C_NORMAL_BUS = 5;    // 5us - 100kHz bus
const int8 I2C_FAST_BUS = 2;    // 2us - 400kHz bus
const int8 I2C_WRITE_DELAY = 5;   // 5ms

// Variables for I2C interface
int16   i2caddr;
int8   i2cslave,   // I2C address of slave device
      i2cflags,   // I2C bus flags
      i2cdata,
      i2ccount,
      i2ccount2,
      i2ctemp;

#bit i2c_error=i2cflags.0
#bit i2c_page_cross=i2cflags.1

void I2CFreeBus(void);

void I2CInitMaster(void) {
   i2cslave = I2C_SLAVE;
   I2CFreeBus();
}

void I2CDelay(void)   {
   delay_us( I2C_NORMAL_BUS );
}

void I2CWriteDelay(void)   {
   delay_ms( I2C_WRITE_DELAY );
}

void InSDA(void)   {
   _SDATRIS = 1; _SDA = 0;
}

void OutSDA(void)   {
   _SDATRIS = 0;
}

void I2CFreeBus(void)   {
   _SDATRIS = 1; _SCLTRIS = 1;
}

void I2CGetBus(void)   {
   _SDA = 1; _SCL = 1;
   _SDATRIS = 0; _SCLTRIS = 0;
}

void IsI2CFree(void)   {
#asm
   bcf      i2c_error
   btfsc   _SDA
   btfss   _SCL
   bsf      i2c_error
#endasm
}

void I2CStart(void)   {
   _SCL = 1; I2CDelay();
   _SDA = 0; I2CDelay();
   _SCL = 0; I2CDelay();
}

void I2CStop(void)   {
   _SDA = 0; I2CDelay();
   _SCL = 1; I2CDelay();
   _SDA = 1; I2CDelay();
}

void I2CWrite(int8 data)   {
   i2ccount = 8;
   do {
      _RLF_F( data );
      if( _C )
         _SDA = 1;
        else
         _SDA = 0;
        _SCL = 1; I2CDelay();
       _SCL = 0; I2CDelay();
   } while( --i2ccount != 0 );
}

int8 I2CRead(void)   {
   InSDA();
     i2ccount = 8;
     do {
         _SCL = 1; I2CDelay();
         _C = 0;
      if( _SDA )
         _C = 1;
         _RLF_F( i2cdata );
         _SCL = 0; I2CDelay();
     } while( --i2ccount != 0 );
     OutSDA();
     return i2cdata;
}

void I2CReadAck(void)   {
   InSDA();      // Make _SDA to be input
   _SCL = 1; I2CDelay();
   i2c_error = 0;
   if( _SDA )
      i2c_error = 1;
    _SCL = 0; I2CDelay();
   OutSDA();
}

// Master in receive mode must generate AckNo signal for slave
void I2CWriteAck(void)   {
   _SDA = 0; I2CDelay();
   _SCL = 1; I2CDelay();
   _SCL = 0; I2CDelay();
}

void I2CWriteNotAck(void) {
   _SDA = 1; I2CDelay();
   _SCL = 1; I2CDelay();
   _SCL = 0; I2CDelay();
}

void I2CRepStart(void)   {
   _SDA = 1; I2CDelay();
   I2CStart();
   // Write device address for read operation
   I2CWrite( i2cslave | 0x01 );
   I2CReadAck();
}

void I2CWriteAddr(void)   {
   IsI2CFree();
   if( i2c_error )
      return;
   I2CGetBus();
   I2CStart();
#ifdef M24515
   i2cslave &= ~0x08;
   if( bit_test(i2caddr,15) )
      i2cslave |= 0x08;
#endif
   // Write device address
   I2CWrite( i2cslave ); I2CReadAck();
   if( i2c_error )
      return;
   // Write high byte of address in memory
   I2CWrite( (int8)(i2caddr>>8) ); I2CReadAck();
   if( i2c_error )
      return;
   // Write low byte ot address in memory
   I2CWrite( (int8)i2caddr); I2CReadAck();
}

void I2CCheckPageCross(void) {
   i2c_page_cross = 0;
   if( ++i2caddr % I2C_PAGE_SIZE == 0 )
      i2c_page_cross = 1;
}

// I2CReadByte() - Ok !
int8 I2CReadByte(int16 addr)   {
   i2caddr = addr;
   I2CWriteAddr( );
   if( i2c_error )
      goto RdByteErr;
   I2CRepStart();
   if( i2c_error )
      goto RdByteErr;
   i2cdata = I2CRead();
   I2CWriteNotAck();
   I2CStop(); I2CFreeBus();
   return i2cdata;
RdByteErr:
    I2CFreeBus();
   return 0;
}

// I2CReadBuffer() - Ok !
void I2CReadBuffer(int16 addr, char *dst,int8 count )   {
   i2caddr = addr;
   I2CWriteAddr( );
    if( i2c_error )
      goto RdSeqErr;
   I2CRepStart();
   if( i2c_error )
      goto RdSeqErr;
   do {
        *dst++ = I2CRead();
      if( --count == 0 )
         break;
#ifdef M24515
      if( ++i2caddr == 0x8000 )   {
         I2CStop();
         I2CWriteAddr( );
         if( i2c_error )
            break;
         I2CRepStart();
         if( i2c_error )
            break;
      } else
         I2CWriteAck();
#else
      I2CWriteAck();
#endif
   } while( 1 );
   I2CWriteNotAck();
   I2CStop();
RdSeqErr:
   I2CFreeBus();
   i2caddr = addr;
}

void I2CWriteByte(int16 addr,int8 data)   {
   i2caddr = addr;
   I2CWriteAddr( );
   if( i2c_error )
      goto WrByteErr;
   I2CWrite( data );
   I2CReadAck();
   if( i2c_error )
      goto WrByteErr;
   I2CStop();
   // Polling for end of write operation
   i2caddr = addr;
   while( 1 ) {
      I2CWriteAddr( );
      if( ! i2c_error )
         break;
      I2CInitMaster();
   }
   // Verify data
   I2CRepStart();
   if( i2c_error )
      goto   WrByteErr;
   if( data != I2CRead() )
      i2c_error = 1;
   I2CWriteNotAck();
WrByteErr:
   I2CStop();
   I2CFreeBus();
}

/*
Note: 24xx512, 24xx515, 24xx256, 24xx128 ( MicroChip & Atmel )
   Page write operations are limited to writing
   bytes within a single physical page, regardless
   of the number of bytes actually being
   written. Physical page boundaries start at
   addresses that are integer multiples of the
   page buffer size (or ‘page size’) and end at
   addresses that are integer multiples of
   [page size - 1]. If a page write command
   attempts to write across a physical page
   boundary, the result is that the data wraps
   around to the beginning of the current page
   (overwriting data previously stored there),
   instead of being written to the next page as
   might be expected. It is therefore necessary
   for the application software to prevent
   page write operations that would attempt to
   cross a page boundary.
*/
void I2CWriteBuffer(int16 addr,int8 *src,int8 count)   {
   i2ccount2 = count;
   i2caddr = addr;
   I2CWriteAddr( );
   if( i2c_error )
      goto I2CWriteBufferNotOk;
   while( 1 ) {
      I2CWrite( *src++ );
      I2CReadAck();
      if( i2c_error )
         goto I2CWriteBufferNotOk;
      if( --i2ccount2 == 0 )
         break;
#ifdef M24515
      I2CCheckPageCross();
      if( i2c_page_cross ) {
         I2CStop();
         while( 1 ) {
            I2CWriteAddr();
            if( ! i2c_error )
               break;
            I2CInitMaster();
         }
      }
#endif
   }
   I2CStop();
   i2caddr = addr;
   // Waiting memory with polling
   while( 1 ) {
      I2CWriteAddr();
      if( ! i2c_error )
         break;
      I2CInitMaster();
   }
   I2CRepStart();
   if( i2c_error )
      goto I2CWriteBufferNotOk;
   // Veryfication
   src -= count;
   i2ccount2 = count;
   do {
      if( *src++ != I2CRead() )
         goto I2CWriteBufferNotOk;
      if( --i2ccount2 == 0 )
         break;
#ifdef M24515
      I2CCheckPageCross();
      if( i2c_page_cross ) {
         I2CWriteNotAck();
         I2CStop();
         I2CWriteAddr();
         if( i2c_error )
            goto I2CWriteBufferNotOk;
         I2CRepStart();
         if( i2c_error )
            goto I2CWriteBufferNotOk;
      } else
         I2CWriteAck();
#else
      I2CWriteAck();
#endif
   } while( 1 );
   I2CWriteNotAck();      // Send Not Acknowledge signal
   goto I2CWriteBufferOk;
I2CWriteBufferNotOk:
   i2c_error = 1;
I2CWriteBufferOk:
   I2CStop();
   I2CFreeBus();
   i2caddr = addr;
}