//********************************************************
//********************************************************
signed char putrsI2C( const rom char *wrptr )
{
while ( *wrptr ) // transmit data until null character
{
if ( WriteI2C ( *wrptr ) ) // write 1 byte
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // test for idle condition
if ( SSPCON2bits.ACKSTAT ) // test received ack bit state
{
return ( -2 ); // bus device responded with NOT ACK
} // terminate putsI2C() function
wrptr ++; // increment pointer
}
return ( 0 );
}
//********************************************************
//********************************************************
//
// Escribir en Memoria EEPROM 24LC512
//
//********************************************************
//********************************************************
unsigned char EscribeDato_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, unsigned char data )
{
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( SSPCON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
else // start condition successful
{
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( address1 ) ) // write word address for EEPROM
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( address2 ) ) // write word address for EEPROM
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( data ) ) // data byte for EEPROM
{
return ( -3 ); // set error for write collision
}
}
else
{
return ( -2 ); // return with Not Ack error condition
}
}
}
else
{
return ( -2 ); // return with Not Ack error condition
}
}
IdleI2C(); // ensure module is idle
StopI2C(); // send STOP condition
while ( SSPCON2bits.PEN ); // wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
return ( 0 ); // return with no error
}
//********************************************************
//********************************************************
//
// Escribir Pagina en Memoria EEPROM 24LC512 desde un Cadena en la ROM
//
//********************************************************
//********************************************************
unsigned char EscribeDatos_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, const rom char *wrptr )
{
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( SSPCON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
else // start condition successful
{
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( address1 ) ) // write word address for EEPROM
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( address2 ) ) // write word address for EEPROM
{
return ( -3 ); // set error for write collision
}
//*******************************************************************************
//*******************************************************************************
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( putrsI2C( wrptr ) ) // data byte for EEPROM
{
return ( -4 ); // set error for write collision
}
}
//*******************************************************************************
//*******************************************************************************
else
{
return ( -2 ); // return with Not Ack error condition
}
}
}
else
{
return ( -2 ); // return with Not Ack error condition
}
}
IdleI2C(); // ensure module is idle
StopI2C(); // send STOP condition
while ( SSPCON2bits.PEN ); // wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
return ( 0 ); // return with no error
}
//********************************************************
//********************************************************
//
// Escribir Pagina en Memoria EEPROM 24LC512 desde una Cadena
//
//********************************************************
//********************************************************
unsigned char EscribeCadena_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, unsigned char *wrptr )
{
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( SSPCON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
else // start condition successful
{
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( address1 ) ) // write word address for EEPROM
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( WriteI2C( address2 ) ) // write word address for EEPROM
{
return ( -3 ); // set error for write collision
}
//*******************************************************************************
//*******************************************************************************
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
if ( putsI2C( wrptr ) ) // data byte for EEPROM
{
return ( -4 ); // set error for write collision
}
}
//*******************************************************************************
//*******************************************************************************
else
{
return ( -2 ); // return with Not Ack error condition
}
}
}
else
{
return ( -2 ); // return with Not Ack error condition
}
}
IdleI2C(); // ensure module is idle
StopI2C(); // send STOP condition
while ( SSPCON2bits.PEN ); // wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
return ( 0 ); // return with no error
}
//********************************************************
//********************************************************
//
// Lectura en Memoria EEPROM 24LC512
//
//********************************************************
//********************************************************
unsigned int LeeDato_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2 )
{
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( SSPCON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
else
{
if ( WriteI2C( control ) ) // write 1 byte
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
{
if ( WriteI2C( address1 ) ) // WRITE word address for EEPROM
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
{
if ( WriteI2C( address2 ) ) // WRITE word address for EEPROM
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
{
RestartI2C(); // generate I2C bus restart condition
while ( SSPCON2bits.RSEN );// wait until re-start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
if ( WriteI2C( control+1 ) )// write 1 byte - R/W bit should be 1
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT )// test for ACK condition, if received
{
SSPCON2bits.RCEN = 1; // enable master for 1 byte reception
while ( SSPCON2bits.RCEN ); // check that receive sequence is over
NotAckI2C(); // send ACK condition
while ( SSPCON2bits.ACKEN ); // wait until ACK sequence is over
StopI2C(); // send STOP condition
while ( SSPCON2bits.PEN ); // wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
}
}
else
{
return ( -2 ); // return with Not Ack error
}
}
else
{
return ( -2 ); // return with Not Ack error
}
}
else
{
return ( -2 ); // return with Not Ack error
}
}
return ( (unsigned int) SSPBUF ); // return with data
}
//********************************************************
//********************************************************
//
// Lee una Cadena en Memoria EEPROM 24LCXX
//
//********************************************************
//********************************************************
unsigned char LeeDatos_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2,unsigned char *rdptr, unsigned char length )
{
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( SSPCON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
else
{
if ( WriteI2C( control ) ) // write 1 byte
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
{
if ( WriteI2C( address1 ) ) // WRITE word address for EEPROM
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
{
if ( WriteI2C( address2 ) ) // WRITE word address for EEPROM
{
return ( -3 ); // return with write collision error
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
RestartI2C(); // generate I2C bus restart condition
while ( SSPCON2bits.RSEN ); // wait until re-start condition is over
if ( WriteI2C( control +1 ) )// WRITE 1 byte - R/W bit should be 1 for read
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( !SSPCON2bits.ACKSTAT )// test for ACK condition received
{
if ( getsI2C( rdptr, length ) )// read in multiple bytes
{
return ( -1 ); // return with Bus Collision error
}
NotAckI2C(); // send not ACK condition
while ( SSPCON2bits.ACKEN );// wait until ACK sequence is over
StopI2C(); // send STOP condition
while ( SSPCON2bits.PEN );// wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
}
else
{
return ( -2 ); // return with Not Ack error
}
}
else
{
return ( -2 ); // return with Not Ack error
}
}
else
{
return ( -2 ); // return with Not Ack error
}
}
return ( 0 ); // return with no error
}
}
//********************************************************
//********************************************************
//
// Esperar Ack en Memoria EEPROM 24LC512
//
//********************************************************
//********************************************************
unsigned char Ack_i2c_eeprom( unsigned char control )
{
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( SSPCON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
else
{
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
while ( SSPCON2bits.ACKSTAT ) // test for ACK condition received
{
RestartI2C(); // initiate Restart condition
while ( SSPCON2bits.RSEN ); // wait until re-start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
{
return ( -3 ); // set error for write collision
}
IdleI2C(); // ensure module is idle
}
}
StopI2C(); // send STOP condition
while ( SSPCON2bits.PEN ); // wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return ( -1 ); // return with Bus Collision error
}
return ( 0 ); // return with no error
}