MCHPStack2.20/Source/xeeprom.c

/*********************************************************************
 *
 *               Data EEPROM Access Routines
 *
 *********************************************************************
 * FileName:        xeeprom.c
 * Dependencies:    compiler.h
 *                  xeeprom.h
 * Processor:       PIC18
 * Complier:        MCC18 v1.00.50 or higher
 *                  HITECH PICC-18 V8.10PL1 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * The software supplied herewith by Microchip Technology Incorporated
 * (the “Company”) for its PICmicro® Microcontroller is intended and
 * supplied to you, the Company’s customer, for use solely and
 * exclusively on Microchip PICmicro Microcontroller products. The
 * software is owned by the Company and/or its supplier, and is
 * protected under applicable copyright laws. All rights are reserved.
 * Any use in violation of the foregoing restrictions may subject the
 * user to criminal sanctions under applicable laws, as well as to
 * civil liability for the breach of the terms and conditions of this
 * license.
 *
 * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 * This is a modified version of C18 library functions.
 * This version supports data EEPROM with two bytes of address.
 * It still uses some of the routines from C18 library.
 *
 *
 * HiTech PICC18 Compiler Options excluding device selection:
 *                  -FAKELOCAL -G -O -Zg -E -C
 *
 *
 * Author               Date        Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     5/20/02     Original (Rev. 1.0)
********************************************************************/
#include "compiler.h"
#include "xeeprom.h"

#define IdleI2C()       while ( ( SSPCON2 & 0x1F ) | ( SSPSTAT_R_W ) );
#define StartI2C()      SSPCON2_SEN=1
#define RestartI2C()    SSPCON2_RSEN=1
#define StopI2C()       SSPCON2_PEN=1
#define NotAckI2C()     SSPCON2_ACKDT=1, SSPCON2_ACKEN=1

static unsigned char getcI2C( void );
static unsigned char WriteI2C( unsigned char data_out );
XEE_RESULT XEEClose(void);


/*********************************************************************
 * Function:        void XEEInit(unsigned char baud)
 *
 * PreCondition:    None
 *
 * Input:           baud    - SSPADD value for bit rate.
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Initialize I2C module to communicate to serial
 *                  EEPROM.
 *
 * Note:            None
 ********************************************************************/
#define   MASTER    8     /* I2C Master mode                    */
/* SSPSTAT REGISTER */
#define   SLEW_OFF  0xC0  /* Slew rate disabled for 100kHz mode */
#define   SLEW_ON   0x00  /* Slew rate enabled for 400kHz mode  */
#define   SSPENB    0x20  /* Enable serial port and configures
                             SCK, SDO, SDI                      */
void XEEInit(unsigned char baud)
{
  SSPSTAT &= 0x3F;                // power on state
  SSPCON1 = 0x00;                 // power on state
  SSPCON2 = 0x00;                 // power on state
  SSPCON1 |= MASTER;            // select serial mode
  SSPSTAT |= SLEW_ON;                // slew rate on/off

  TRISC_RC3 = 1;                    // Set SCL (PORTC,3) pin to input
  TRISC_RC4 = 1;               // Set SDA (PORTC,4) pin to input

  SSPCON1 |= SSPENB;              // enable synchronous serial port

  SSPADD = baud;
}


/*********************************************************************
 * Function:        XEE_RESULT XEESetAddr(unsigned char control,
 *                                        XEE_ADDR address)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           control     - data EEPROM control code
 *                  address     - address to be set
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Modifies internal address counter of EEPROM.
 *
 * Note:            This function does not release the I2C bus.
 *                  User must close XEEClose() after this function
 *                  is called.
 ********************************************************************/
XEE_RESULT XEESetAddr(unsigned char control, XEE_ADDR address)
{
    union
    {
        unsigned short int Val;
        struct
        {
            unsigned char LSB;
            unsigned char MSB;
        } bytes;
    } tempAddress;

    tempAddress.Val = address;

    IdleI2C();                      // ensure module is idle
    StartI2C();                     // initiate START condition
    while ( SSPCON2_SEN );      // wait until start condition is over
    if ( PIR2_BCLIF )           // test for bus collision
        return XEE_BUS_COLLISION;                // return with Bus Collision error

    if ( WriteI2C( control ) )    // write 1 byte
        return XEE_BUS_COLLISION;              // set error for write collision

    IdleI2C();                    // ensure module is idle
    if ( !SSPCON2_ACKSTAT )   // test for ACK condition, if received
    {
        if ( WriteI2C( tempAddress.bytes.MSB ) )  // WRITE word address to EEPROM
            return XEE_BUS_COLLISION;            // return with write collision error

        IdleI2C();                  // ensure module is idle

        if ( WriteI2C( tempAddress.bytes.LSB ) )  // WRITE word address to EEPROM
            return XEE_BUS_COLLISION;            // return with write collision error

        IdleI2C();                  // ensure module is idle
        if ( !SSPCON2_ACKSTAT ) // test for ACK condition received
            return XEE_SUCCESS;
        else
            return XEE_NAK;            // return with Not Ack error
    }
    else
        return XEE_NAK;              // return with Not Ack error
}

/*********************************************************************
 * Function:        XEE_RESULT XEEBeginRead(unsigned char control,
 *                                          XEE_ADDR address)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           control - EEPROM control and address code.
 *                  address - Address at which read is to be performed.
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Sets internal address counter to given address.
 *                  Puts EEPROM in sequential read mode.
 *
 * Note:            This function does not release I2C bus.
 *                  User must call XEEEndRead() when read is not longer
 *                  needed; I2C bus will released after XEEEndRead()
 *                  is called.
 ********************************************************************/
XEE_RESULT XEEBeginRead(unsigned char control, XEE_ADDR address )
{
    unsigned char r;

    r = XEESetAddr(control, address);
    if ( r != XEE_SUCCESS )
        return r;

    r = XEEClose();
    if ( r != XEE_SUCCESS )
        return r;


    IdleI2C();
    StartI2C();
    while( SSPCON2_SEN );
    if ( PIR2_BCLIF )
        return XEE_BUS_COLLISION;

    if ( WriteI2C(control+1) )
        return XEE_BUS_COLLISION;

    IdleI2C();
    if ( !SSPCON2_ACKSTAT )
        return XEE_SUCCESS;
    return XEE_NAK;
}


XEE_RESULT XEEWrite(unsigned char val)
{
    IdleI2C();                  // ensure module is idle

    if ( WriteI2C( val ) )   // data byte for EEPROM
        return XEE_BUS_COLLISION;          // set error for write collision

    IdleI2C();
    if ( !SSPCON2_ACKSTAT )
        return XEE_SUCCESS;
    return XEE_NAK;
}

/*********************************************************************
 * Function:        XEE_RESULT XEEEndWrite(void)
 *
 * PreCondition:    XEEInit() && XEEBeginWrite() are already called.
 *
 * Input:           None
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Instructs EEPROM to begin write cycle.
 *
 * Note:            Call this function after either page full of bytes
 *                  written or no more bytes are left to load.
 *                  This function initiates the write cycle.
 *                  User must call for XEEWait() to ensure that write
 *                  cycle is finished before calling any other
 *                  routine.
 ********************************************************************/
XEE_RESULT XEEEndWrite(void)
{
    IdleI2C();
    StopI2C();
    while(SSPCON2_PEN);
    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEERead(void)
 *
 * PreCondition:    XEEInit() && XEEBeginRead() are already called.
 *
 * Input:           None
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Reads next byte from EEPROM; internal address
 *                  is incremented by one.
 *
 * Note:            This function does not release I2C bus.
 *                  User must call XEEEndRead() when read is not longer
 *                  needed; I2C bus will released after XEEEndRead()
 *                  is called.
 ********************************************************************/
unsigned char XEERead(void)
{
    getcI2C();
    while( SSPCON2_RCEN );  // check that receive sequence is over.

    SSPCON2_ACKDT = 0;      // Set ack bit
    SSPCON2_ACKEN = 1;
    while( SSPCON2_ACKEN );

    return SSPBUF;
}

/*********************************************************************
 * Function:        XEE_RESULT XEEEndRead(void)
 *
 * PreCondition:    XEEInit() && XEEBeginRead() are already called.
 *
 * Input:           None
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Ends sequential read cycle.
 *
 * Note:            This function ends seuential cycle that was in
 *                  progress.  It releases I2C bus.
 ********************************************************************/
XEE_RESULT XEEEndRead(void)
{
    getcI2C();
    while( SSPCON2_RCEN );  // check that receive sequence is over.

    NotAckI2C();
    while( SSPCON2_ACKEN );

    StopI2C();
    while( SSPCON2_PEN );

    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEReadArray(unsigned char control,
 *                                          XEE_ADDR address,
 *                                          unsigned char *buffer,
 *                                          unsigned char length)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           control     - EEPROM control and address code.
 *                  address     - Address from where array is to be read
 *                  buffer      - Caller supplied buffer to hold the data
 *                  length      - Number of bytes to read.
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Reads desired number of bytes in sequential mode.
 *                  This function performs all necessary steps
 *                  and releases the bus when finished.
 *
 * Note:            None
 ********************************************************************/
XEE_RESULT XEEReadArray(unsigned char control,
                        XEE_ADDR address,
                        unsigned char *buffer,
                        unsigned char length)
{
    XEE_RESULT r;

    r = XEEBeginRead(control, address);
    if ( r != XEE_SUCCESS )
        return r;

    while( length-- )
        *buffer++ = XEERead();

    r = XEEEndRead();

    return r;
}


XEE_RESULT XEEClose(void)
{
    IdleI2C();
    StopI2C();
    while( SSPCON2_PEN );           // wait until stop condition is over.
    if ( PIR2_BCLIF )
        return XEE_BUS_COLLISION;
    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEIsBusy(unsigned char control)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           control     - EEPROM control and address code.
 *
 * Output:          XEE_READY if EEPROM is not busy
 *                  XEE_BUSY if EEPROM is busy
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Requests ack from EEPROM.
 *
 * Note:            None
 ********************************************************************/
XEE_RESULT XEEIsBusy(unsigned char control)
{
    XEE_RESULT r;

    IdleI2C();                      // ensure module is idle
    StartI2C();                     // initiate START condition
    while ( SSPCON2_SEN );      // wait until start condition is over
    if ( PIR2_BCLIF )           // test for bus collision
    {
        return XEE_BUS_COLLISION;                // return with Bus Collision error
    }

    else
    {
        if ( WriteI2C( control ) )    // write byte - R/W bit should be 0
            return XEE_BUS_COLLISION;              // set error for write collision

        IdleI2C();                    // ensure module is idle
        if ( PIR2_BCLIF )         // test for bus collision
            return XEE_BUS_COLLISION;              // return with Bus Collision error

        if ( !SSPCON2_ACKSTAT )
            r = XEE_READY;
        else
            r = XEE_BUSY;

#if 0
        while ( SSPCON2_ACKSTAT ) // test for ACK condition received
        {
            RestartI2C();               // initiate Restart condition
            while ( SSPCON2_RSEN ); // wait until re-start condition is over
            if ( PIR2_BCLIF )       // test for bus collision
                return XEE_BUS_COLLISION;            // return with Bus Collision error

            if ( WriteI2C( control ) )  // write byte - R/W bit should be 0
                return XEE_BUS_COLLISION;            // set error for write collision

            IdleI2C();                  // ensure module is idle
        }
#endif
    }


    StopI2C();                      // send STOP condition
    while ( SSPCON2_PEN );      // wait until stop condition is over
    if ( PIR2_BCLIF )           // test for bus collision
        return XEE_BUS_COLLISION;                // return with Bus Collision error

    return r;
    //return XEE_READY;                   // return with no error
}


/********************************************************************
*     Function Name:    WriteI2C                                    *
*     Return Value:     Status byte for WCOL detection.             *
*     Parameters:       Single data byte for I2C bus.               *
*     Description:      This routine writes a single byte to the    *
*                       I2C bus.                                    *
********************************************************************/
static unsigned char WriteI2C( unsigned char data_out )
{
  SSPBUF = data_out;           // write single byte to SSPBUF
  if ( SSPCON1_WCOL )      // test if write collision occurred
   return ( -1 );              // if WCOL bit is set return negative #
  else
  {
    while( SSPSTAT_BF );   // wait until write cycle is complete
    return ( 0 );              // if WCOL bit is not set return non-negative #
  }
}


/********************************************************************
*     Function Name:    ReadI2C                                     *
*     Return Value:     contents of SSPBUF register                 *
*     Parameters:       void                                        *
*     Description:      Read single byte from I2C bus.              *
********************************************************************/
static unsigned char getcI2C( void )
{
  SSPCON2_RCEN = 1;           // enable master for 1 byte reception
  while ( !SSPSTAT_BF );      // wait until byte received
  return ( SSPBUF );              // return with read byte
}
1	hedin	62	/*********************************************************************
2			*
3			* Data EEPROM Access Routines
4			*
5			*********************************************************************
6			* FileName: xeeprom.c
7			* Dependencies: compiler.h
8			* xeeprom.h
9			* Processor: PIC18
10			* Complier: MCC18 v1.00.50 or higher
11			* HITECH PICC-18 V8.10PL1 or higher
12			* Company: Microchip Technology, Inc.
13			*
14			* Software License Agreement
15			*
16			* The software supplied herewith by Microchip Technology Incorporated
17			* (the “Company”) for its PICmicro® Microcontroller is intended and
18			* supplied to you, the Company’s customer, for use solely and
19			* exclusively on Microchip PICmicro Microcontroller products. The
20			* software is owned by the Company and/or its supplier, and is
21			* protected under applicable copyright laws. All rights are reserved.
22			* Any use in violation of the foregoing restrictions may subject the
23			* user to criminal sanctions under applicable laws, as well as to
24			* civil liability for the breach of the terms and conditions of this
25			* license.
26			*
27			* THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
28			* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
29			* TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
30			* PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
31			* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
32			* CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
33			*
34			* This is a modified version of C18 library functions.
35			* This version supports data EEPROM with two bytes of address.
36			* It still uses some of the routines from C18 library.
37			*
38			*
39			* HiTech PICC18 Compiler Options excluding device selection:
40			* -FAKELOCAL -G -O -Zg -E -C
41			*
42			*
43			* Author Date Comment
44			*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
45			* Nilesh Rajbharti 5/20/02 Original (Rev. 1.0)
46			********************************************************************/
47			#include "compiler.h"
48			#include "xeeprom.h"
49
50			#define IdleI2C() while ( ( SSPCON2 & 0x1F ) \| ( SSPSTAT_R_W ) );
51			#define StartI2C() SSPCON2_SEN=1
52			#define RestartI2C() SSPCON2_RSEN=1
53			#define StopI2C() SSPCON2_PEN=1
54			#define NotAckI2C() SSPCON2_ACKDT=1, SSPCON2_ACKEN=1
55
56			static unsigned char getcI2C( void );
57			static unsigned char WriteI2C( unsigned char data_out );
58			XEE_RESULT XEEClose(void);
59
60
61
62			/*********************************************************************
63			* Function: void XEEInit(unsigned char baud)
64			*
65			* PreCondition: None
66			*
67			* Input: baud - SSPADD value for bit rate.
68			*
69			* Output: None
70			*
71			* Side Effects: None
72			*
73			* Overview: Initialize I2C module to communicate to serial
74			* EEPROM.
75			*
76			* Note: None
77			********************************************************************/
78			#define MASTER 8 /* I2C Master mode */
79			/* SSPSTAT REGISTER */
80			#define SLEW_OFF 0xC0 /* Slew rate disabled for 100kHz mode */
81			#define SLEW_ON 0x00 /* Slew rate enabled for 400kHz mode */
82			#define SSPENB 0x20 /* Enable serial port and configures
83			SCK, SDO, SDI */
84			void XEEInit(unsigned char baud)
85			{
86			SSPSTAT &= 0x3F; // power on state
87			SSPCON1 = 0x00; // power on state
88			SSPCON2 = 0x00; // power on state
89			SSPCON1 \|= MASTER; // select serial mode
90			SSPSTAT \|= SLEW_ON; // slew rate on/off
91
92			TRISC_RC3 = 1; // Set SCL (PORTC,3) pin to input
93			TRISC_RC4 = 1; // Set SDA (PORTC,4) pin to input
94
95			SSPCON1 \|= SSPENB; // enable synchronous serial port
96
97			SSPADD = baud;
98			}
99
100
101			/*********************************************************************
102			* Function: XEE_RESULT XEESetAddr(unsigned char control,
103			* XEE_ADDR address)
104			*
105			* PreCondition: XEEInit() is already called.
106			*
107			* Input: control - data EEPROM control code
108			* address - address to be set
109			*
110			* Output: XEE_SUCCESS if successful
111			* other value if failed.
112			*
113			* Side Effects: None
114			*
115			* Overview: Modifies internal address counter of EEPROM.
116			*
117			* Note: This function does not release the I2C bus.
118			* User must close XEEClose() after this function
119			* is called.
120			********************************************************************/
121			XEE_RESULT XEESetAddr(unsigned char control, XEE_ADDR address)
122			{
123			union
124			{
125			unsigned short int Val;
126			struct
127			{
128			unsigned char LSB;
129			unsigned char MSB;
130			} bytes;
131			} tempAddress;
132
133			tempAddress.Val = address;
134
135			IdleI2C(); // ensure module is idle
136			StartI2C(); // initiate START condition
137			while ( SSPCON2_SEN ); // wait until start condition is over
138			if ( PIR2_BCLIF ) // test for bus collision
139			return XEE_BUS_COLLISION; // return with Bus Collision error
140
141			if ( WriteI2C( control ) ) // write 1 byte
142			return XEE_BUS_COLLISION; // set error for write collision
143
144			IdleI2C(); // ensure module is idle
145			if ( !SSPCON2_ACKSTAT ) // test for ACK condition, if received
146			{
147			if ( WriteI2C( tempAddress.bytes.MSB ) ) // WRITE word address to EEPROM
148			return XEE_BUS_COLLISION; // return with write collision error
149
150			IdleI2C(); // ensure module is idle
151
152			if ( WriteI2C( tempAddress.bytes.LSB ) ) // WRITE word address to EEPROM
153			return XEE_BUS_COLLISION; // return with write collision error
154
155			IdleI2C(); // ensure module is idle
156			if ( !SSPCON2_ACKSTAT ) // test for ACK condition received
157			return XEE_SUCCESS;
158			else
159			return XEE_NAK; // return with Not Ack error
160			}
161			else
162			return XEE_NAK; // return with Not Ack error
163			}
164
165			/*********************************************************************
166			* Function: XEE_RESULT XEEBeginRead(unsigned char control,
167			* XEE_ADDR address)
168			*
169			* PreCondition: XEEInit() is already called.
170			*
171			* Input: control - EEPROM control and address code.
172			* address - Address at which read is to be performed.
173			*
174			* Output: XEE_SUCCESS if successful
175			* other value if failed.
176			*
177			* Side Effects: None
178			*
179			* Overview: Sets internal address counter to given address.
180			* Puts EEPROM in sequential read mode.
181			*
182			* Note: This function does not release I2C bus.
183			* User must call XEEEndRead() when read is not longer
184			* needed; I2C bus will released after XEEEndRead()
185			* is called.
186			********************************************************************/
187			XEE_RESULT XEEBeginRead(unsigned char control, XEE_ADDR address )
188			{
189			unsigned char r;
190
191			r = XEESetAddr(control, address);
192			if ( r != XEE_SUCCESS )
193			return r;
194
195			r = XEEClose();
196			if ( r != XEE_SUCCESS )
197			return r;
198
199
200			IdleI2C();
201			StartI2C();
202			while( SSPCON2_SEN );
203			if ( PIR2_BCLIF )
204			return XEE_BUS_COLLISION;
205
206			if ( WriteI2C(control+1) )
207			return XEE_BUS_COLLISION;
208
209			IdleI2C();
210			if ( !SSPCON2_ACKSTAT )
211			return XEE_SUCCESS;
212			return XEE_NAK;
213			}
214
215
216			XEE_RESULT XEEWrite(unsigned char val)
217			{
218			IdleI2C(); // ensure module is idle
219
220			if ( WriteI2C( val ) ) // data byte for EEPROM
221			return XEE_BUS_COLLISION; // set error for write collision
222
223			IdleI2C();
224			if ( !SSPCON2_ACKSTAT )
225			return XEE_SUCCESS;
226			return XEE_NAK;
227			}
228
229			/*********************************************************************
230			* Function: XEE_RESULT XEEEndWrite(void)
231			*
232			* PreCondition: XEEInit() && XEEBeginWrite() are already called.
233			*
234			* Input: None
235			*
236			* Output: XEE_SUCCESS if successful
237			* other value if failed.
238			*
239			* Side Effects: None
240			*
241			* Overview: Instructs EEPROM to begin write cycle.
242			*
243			* Note: Call this function after either page full of bytes
244			* written or no more bytes are left to load.
245			* This function initiates the write cycle.
246			* User must call for XEEWait() to ensure that write
247			* cycle is finished before calling any other
248			* routine.
249			********************************************************************/
250			XEE_RESULT XEEEndWrite(void)
251			{
252			IdleI2C();
253			StopI2C();
254			while(SSPCON2_PEN);
255			return XEE_SUCCESS;
256			}
257
258
259
260			/*********************************************************************
261			* Function: XEE_RESULT XEERead(void)
262			*
263			* PreCondition: XEEInit() && XEEBeginRead() are already called.
264			*
265			* Input: None
266			*
267			* Output: XEE_SUCCESS if successful
268			* other value if failed.
269			*
270			* Side Effects: None
271			*
272			* Overview: Reads next byte from EEPROM; internal address
273			* is incremented by one.
274			*
275			* Note: This function does not release I2C bus.
276			* User must call XEEEndRead() when read is not longer
277			* needed; I2C bus will released after XEEEndRead()
278			* is called.
279			********************************************************************/
280			unsigned char XEERead(void)
281			{
282			getcI2C();
283			while( SSPCON2_RCEN ); // check that receive sequence is over.
284
285			SSPCON2_ACKDT = 0; // Set ack bit
286			SSPCON2_ACKEN = 1;
287			while( SSPCON2_ACKEN );
288
289			return SSPBUF;
290			}
291
292			/*********************************************************************
293			* Function: XEE_RESULT XEEEndRead(void)
294			*
295			* PreCondition: XEEInit() && XEEBeginRead() are already called.
296			*
297			* Input: None
298			*
299			* Output: XEE_SUCCESS if successful
300			* other value if failed.
301			*
302			* Side Effects: None
303			*
304			* Overview: Ends sequential read cycle.
305			*
306			* Note: This function ends seuential cycle that was in
307			* progress. It releases I2C bus.
308			********************************************************************/
309			XEE_RESULT XEEEndRead(void)
310			{
311			getcI2C();
312			while( SSPCON2_RCEN ); // check that receive sequence is over.
313
314			NotAckI2C();
315			while( SSPCON2_ACKEN );
316
317			StopI2C();
318			while( SSPCON2_PEN );
319
320			return XEE_SUCCESS;
321			}
322
323
324			/*********************************************************************
325			* Function: XEE_RESULT XEEReadArray(unsigned char control,
326			* XEE_ADDR address,
327			* unsigned char *buffer,
328			* unsigned char length)
329			*
330			* PreCondition: XEEInit() is already called.
331			*
332			* Input: control - EEPROM control and address code.
333			* address - Address from where array is to be read
334			* buffer - Caller supplied buffer to hold the data
335			* length - Number of bytes to read.
336			*
337			* Output: XEE_SUCCESS if successful
338			* other value if failed.
339			*
340			* Side Effects: None
341			*
342			* Overview: Reads desired number of bytes in sequential mode.
343			* This function performs all necessary steps
344			* and releases the bus when finished.
345			*
346			* Note: None
347			********************************************************************/
348			XEE_RESULT XEEReadArray(unsigned char control,
349			XEE_ADDR address,
350			unsigned char *buffer,
351			unsigned char length)
352			{
353			XEE_RESULT r;
354
355			r = XEEBeginRead(control, address);
356			if ( r != XEE_SUCCESS )
357			return r;
358
359			while( length-- )
360			*buffer++ = XEERead();
361
362			r = XEEEndRead();
363
364			return r;
365			}
366
367
368
369
370			XEE_RESULT XEEClose(void)
371			{
372			IdleI2C();
373			StopI2C();
374			while( SSPCON2_PEN ); // wait until stop condition is over.
375			if ( PIR2_BCLIF )
376			return XEE_BUS_COLLISION;
377			return XEE_SUCCESS;
378			}
379
380
381
382			/*********************************************************************
383			* Function: XEE_RESULT XEEIsBusy(unsigned char control)
384			*
385			* PreCondition: XEEInit() is already called.
386			*
387			* Input: control - EEPROM control and address code.
388			*
389			* Output: XEE_READY if EEPROM is not busy
390			* XEE_BUSY if EEPROM is busy
391			* other value if failed.
392			*
393			* Side Effects: None
394			*
395			* Overview: Requests ack from EEPROM.
396			*
397			* Note: None
398			********************************************************************/
399			XEE_RESULT XEEIsBusy(unsigned char control)
400			{
401			XEE_RESULT r;
402
403			IdleI2C(); // ensure module is idle
404			StartI2C(); // initiate START condition
405			while ( SSPCON2_SEN ); // wait until start condition is over
406			if ( PIR2_BCLIF ) // test for bus collision
407			{
408			return XEE_BUS_COLLISION; // return with Bus Collision error
409			}
410
411			else
412			{
413			if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
414			return XEE_BUS_COLLISION; // set error for write collision
415
416			IdleI2C(); // ensure module is idle
417			if ( PIR2_BCLIF ) // test for bus collision
418			return XEE_BUS_COLLISION; // return with Bus Collision error
419
420			if ( !SSPCON2_ACKSTAT )
421			r = XEE_READY;
422			else
423			r = XEE_BUSY;
424
425			#if 0
426			while ( SSPCON2_ACKSTAT ) // test for ACK condition received
427			{
428			RestartI2C(); // initiate Restart condition
429			while ( SSPCON2_RSEN ); // wait until re-start condition is over
430			if ( PIR2_BCLIF ) // test for bus collision
431			return XEE_BUS_COLLISION; // return with Bus Collision error
432
433			if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
434			return XEE_BUS_COLLISION; // set error for write collision
435
436			IdleI2C(); // ensure module is idle
437			}
438			#endif
439			}
440
441
442			StopI2C(); // send STOP condition
443			while ( SSPCON2_PEN ); // wait until stop condition is over
444			if ( PIR2_BCLIF ) // test for bus collision
445			return XEE_BUS_COLLISION; // return with Bus Collision error
446
447			return r;
448			//return XEE_READY; // return with no error
449			}
450
451
452			/********************************************************************
453			* Function Name: WriteI2C *
454			* Return Value: Status byte for WCOL detection. *
455			* Parameters: Single data byte for I2C bus. *
456			* Description: This routine writes a single byte to the *
457			* I2C bus. *
458			********************************************************************/
459			static unsigned char WriteI2C( unsigned char data_out )
460			{
461			SSPBUF = data_out; // write single byte to SSPBUF
462			if ( SSPCON1_WCOL ) // test if write collision occurred
463			return ( -1 ); // if WCOL bit is set return negative #
464			else
465			{
466			while( SSPSTAT_BF ); // wait until write cycle is complete
467			return ( 0 ); // if WCOL bit is not set return non-negative #
468			}
469			}
470
471
472
473			/********************************************************************
474			* Function Name: ReadI2C *
475			* Return Value: contents of SSPBUF register *
476			* Parameters: void *
477			* Description: Read single byte from I2C bus. *
478			********************************************************************/
479			static unsigned char getcI2C( void )
480			{
481			SSPCON2_RCEN = 1; // enable master for 1 byte reception
482			while ( !SSPSTAT_BF ); // wait until byte received
483			return ( SSPBUF ); // return with read byte
484			}