trunk/PIC/i2c.c

#include        <pic18.h>
#include        "delay.h"
#include        "i2c.h"

/*
 *      I2C functions for HI-TECH PIC C - master mode only
 */

/*
 *      TIMING - see Philips document: THE I2C-BUS SPECIFICATION
 */


/*
 *      Send stop condition
 *        - data low-high while clock high
 */

void
i2c_Stop(void)
{
        /* don't assume SCL is high on entry */

        SDA_LOW();                      /* ensure data is low first */
        SCL_HIGH();

        DelayUs(I2C_TM_DATA_SU);
        SCL_DIR = I2C_INPUT;            /* float clock high */
        DelayUs(I2C_TM_STOP_SU);
        SDA_HIGH();                     /* the low->high data transistion */
        DelayUs(I2C_TM_BUS_FREE);       /* bus free time before next start */
        SDA_DIR = I2C_INPUT;            /* float data high */

        return;
}

/*
 *      Send (re)start condition
 *        - ensure data is high then issue a start condition
 *        - see also i2c_Start() macro
 */

void
i2c_Restart(void)
{
        SCL_LOW();                      /* ensure clock is low */
        SDA_HIGH();                     /* ensure data is high */

        DelayUs(I2C_TM_DATA_SU);

        SCL_DIR = I2C_INPUT;            /* clock pulse high */
        DelayUs(I2C_TM_SCL_HIGH);

        SDA_LOW();                      /* the high->low transition */
        DelayUs(I2C_TM_START_HD);
        return;
}

/*
 *      Send a byte to the slave
 *        - returns true on error
 */

unsigned char
i2c_SendByte(unsigned char byte)
{
        signed char i;

        for(i=7; i>=0; i--)
        {
                SCL_LOW();                      /* drive clock low */
                                                /* data hold time = 0, send data now */
                SDA_DIR = ((byte>>i)&0x01);
                if ((byte>>i)&0x01) {           /* bit to send */
                    SDA_HIGH();
                }
                else {
                    SDA_LOW();
                }
                DelayUs(I2C_TM_DATA_SU);
                SCL_DIR = I2C_INPUT;            /* float clock high */

                if(i2c_WaitForSCL())            /* wait for clock release */
                        return TRUE;            /* bus error */

                DelayUs(I2C_TM_SCL_HIGH);       /* clock high time */
        }


        return FALSE;
}

/*
 *      send an address and data direction to the slave
 *        - 7-bit address (lsb ignored)
 *        - direction (FALSE = write )
 */

unsigned char
i2c_SendAddress(unsigned char address, unsigned char rw)
{
        return i2c_SendByte(address | (rw?1:0));
}

/*
 *      Check for an acknowledge
 *        - returns ack or ~ack, or ERROR if a bus error
 */

signed char
i2c_ReadAcknowledge(void)
{
        unsigned char ack;

        SCL_LOW();                              /* make clock is low */
        SDA_DIR = I2C_INPUT;                    /* disable data line - listen for ack */
        DelayUs(I2C_TM_SCL_TO_DATA);            /* SCL low to data out valid */
        SCL_DIR = I2C_INPUT;                    /* float clock high */
        DelayUs(I2C_TM_DATA_SU);
        ack = SDA;                              /* read the acknowledge */

        /* wait for slave to release clock line after processing byte */
        if(i2c_WaitForSCL())
                return I2C_ERROR;
        return ack;
}

/*
 *      Read a byte from the slave
 *        - returns the byte, or I2C_ERROR if a bus error
 */

int
i2c_ReadByte(void)
{
        unsigned char i;
        unsigned char byte = 0;

        for(i=0; i<8; i++)
        {
                SCL_LOW();                      /* drive clock low */
                DelayUs(I2C_TM_SCL_LOW);        /* min clock low  period */
                SDA_DIR = I2C_INPUT;            /* release data line */

                SCL_DIR = I2C_INPUT;            /* float clock high */
                if(i2c_WaitForSCL())
                        return I2C_ERROR;
                DelayUs(I2C_TM_SCL_HIGH);
                byte = byte << 1;               /* read the next bit */
                byte |= SDA;
        }
        return (int)byte;
}

/*
 *      Send an (~)acknowledge to the slave
 *        - status of I2C_LAST implies this is the last byte to be sent
 */

void
i2c_SendAcknowledge(unsigned char status)
{
        SCL_LOW();
        if ( status & 0x01) {
            SDA_LOW();                          /* drive line low -> more to come */
        }
        else { 
            SDA_HIGH();
        }
        DelayUs(I2C_TM_DATA_SU);
        SCL_DIR = I2C_INPUT;                    /* float clock high */
        DelayUs(I2C_TM_SCL_HIGH);
        return;
}

/*
 *      Send a byte to the slave and acknowledges the transfer
 *        - returns I2C_ERROR, ack or ~ack
 */

signed char
i2c_PutByte(unsigned char data)
{
        if(i2c_SendByte(data))
                return I2C_ERROR;
        return i2c_ReadAcknowledge();   /* returns ack, ~ack */
}

/*
 *      Get a byte from the slave and acknowledges the transfer
 *        - returns true on I2C_ERROR or byte
 */

int
i2c_GetByte(unsigned char more)
{
        int byte;

        if((byte = i2c_ReadByte()) == I2C_ERROR)
                return I2C_ERROR;

        i2c_SendAcknowledge(more);

        return byte;
}

/*
 *      Send an array of bytes to the slave and acknowledges the transfer
 *        - returns number of bytes not successfully transmitted
 */

int
i2c_PutString(const unsigned char *str, unsigned char length)
{
        signed char error;

        while(length)
        {
                if((error = i2c_PutByte(*str)) == I2C_ERROR)
                        return -(int)length;            /* bus error */
                else
                        if(error)
                                return (int)length;     /* non acknowledge */
                str++;
                length--;
        }

        return FALSE;                                   /* everything OK */
}

/*
 *      Reads number bytes from the slave, stores them at str and acknowledges the transfer
 *        - returns number of bytes not successfully read in
 */

unsigned char
i2c_GetString(unsigned char *str, unsigned char number)
{
        int byte;

        while(number)
        {
                if((byte = i2c_GetByte(number-1)) == I2C_ERROR)
                        return number;                  /* bus error */
                else
                        *str = (unsigned char)byte;
                str++;
                number--;
        }

        return FALSE;                                   /* everything OK */
}

/*
 *      Opens communication with a device at address. mode
 *      indicates I2C_READ or I2C_WRITE.
 *        - returns TRUE if address is not acknowledged
 */

unsigned char
i2c_Open(unsigned char address, unsigned char mode)
{
        i2c_Start();
        i2c_SendAddress(address, mode);
        if(i2c_ReadAcknowledge()) 
                return TRUE;

        return FALSE;
}

/*
 *      wait for the clock line to be released by slow slaves
 *        - returns TRUE if SCL was not released after the
 *          time out period.
 *        - returns FALSE if and when SCL released
 */

unsigned char
i2c_WaitForSCL(void)
{
        /* SCL_DIR should be input here */

        if(!SCL)
        {
                DelayUs(I2C_TM_SCL_TMO);
                /* if the clock is still low -> bus error */
                if(!SCL)
                        return TRUE;
        }
        return FALSE;
}
void
i2c_Free()
{
        unsigned char ucI;

        SDA_DIR=I2C_INPUT;
        for(ucI=0;ucI!=9;ucI++)
        {
                SCL_HIGH();
                DelayUs(5);
                SCL_LOW();
                DelayUs(5);
        }
}

unsigned char i2c_read(unsigned char ucAdr)
{
        unsigned char ucDat;

        if (i2c_ReadFrom(ucAdr)==0)
        {
                ucDat=i2c_GetByte(I2C_MORE);
                i2c_Stop();

        }

        return(ucDat);
}
1	#include <pic18.h>
2	#include "delay.h"
3	#include "i2c.h"
4
5	/*
6	* I2C functions for HI-TECH PIC C - master mode only
7	*/
8
9	/*
10	* TIMING - see Philips document: THE I2C-BUS SPECIFICATION
11	*/
12
13
14	/*
15	* Send stop condition
16	* - data low-high while clock high
17	*/
18
19	void
20	i2c_Stop(void)
21	{
22	/* don't assume SCL is high on entry */
23
24	SDA_LOW(); /* ensure data is low first */
25	SCL_HIGH();
26
27	DelayUs(I2C_TM_DATA_SU);
28	SCL_DIR = I2C_INPUT; /* float clock high */
29	DelayUs(I2C_TM_STOP_SU);
30	SDA_HIGH(); /* the low->high data transistion */
31	DelayUs(I2C_TM_BUS_FREE); /* bus free time before next start */
32	SDA_DIR = I2C_INPUT; /* float data high */
33
34	return;
35	}
36
37	/*
38	* Send (re)start condition
39	* - ensure data is high then issue a start condition
40	* - see also i2c_Start() macro
41	*/
42
43	void
44	i2c_Restart(void)
45	{
46	SCL_LOW(); /* ensure clock is low */
47	SDA_HIGH(); /* ensure data is high */
48
49	DelayUs(I2C_TM_DATA_SU);
50
51	SCL_DIR = I2C_INPUT; /* clock pulse high */
52	DelayUs(I2C_TM_SCL_HIGH);
53
54	SDA_LOW(); /* the high->low transition */
55	DelayUs(I2C_TM_START_HD);
56	return;
57	}
58
59	/*
60	* Send a byte to the slave
61	* - returns true on error
62	*/
63
64	unsigned char
65	i2c_SendByte(unsigned char byte)
66	{
67	signed char i;
68
69	for(i=7; i>=0; i--)
70	{
71	SCL_LOW(); /* drive clock low */
72	/* data hold time = 0, send data now */
73	SDA_DIR = ((byte>>i)&0x01);
74	if ((byte>>i)&0x01) { /* bit to send */
75	SDA_HIGH();
76	}
77	else {
78	SDA_LOW();
79	}
80	DelayUs(I2C_TM_DATA_SU);
81	SCL_DIR = I2C_INPUT; /* float clock high */
82
83	if(i2c_WaitForSCL()) /* wait for clock release */
84	return TRUE; /* bus error */
85
86	DelayUs(I2C_TM_SCL_HIGH); /* clock high time */
87	}
88
89
90	return FALSE;
91	}
92
93	/*
94	* send an address and data direction to the slave
95	* - 7-bit address (lsb ignored)
96	* - direction (FALSE = write )
97	*/
98
99	unsigned char
100	i2c_SendAddress(unsigned char address, unsigned char rw)
101	{
102	return i2c_SendByte(address \| (rw?1:0));
103	}
104
105	/*
106	* Check for an acknowledge
107	* - returns ack or ~ack, or ERROR if a bus error
108	*/
109
110	signed char
111	i2c_ReadAcknowledge(void)
112	{
113	unsigned char ack;
114
115	SCL_LOW(); /* make clock is low */
116	SDA_DIR = I2C_INPUT; /* disable data line - listen for ack */
117	DelayUs(I2C_TM_SCL_TO_DATA); /* SCL low to data out valid */
118	SCL_DIR = I2C_INPUT; /* float clock high */
119	DelayUs(I2C_TM_DATA_SU);
120	ack = SDA; /* read the acknowledge */
121
122	/* wait for slave to release clock line after processing byte */
123	if(i2c_WaitForSCL())
124	return I2C_ERROR;
125	return ack;
126	}
127
128	/*
129	* Read a byte from the slave
130	* - returns the byte, or I2C_ERROR if a bus error
131	*/
132
133	int
134	i2c_ReadByte(void)
135	{
136	unsigned char i;
137	unsigned char byte = 0;
138
139	for(i=0; i<8; i++)
140	{
141	SCL_LOW(); /* drive clock low */
142	DelayUs(I2C_TM_SCL_LOW); /* min clock low period */
143	SDA_DIR = I2C_INPUT; /* release data line */
144
145	SCL_DIR = I2C_INPUT; /* float clock high */
146	if(i2c_WaitForSCL())
147	return I2C_ERROR;
148	DelayUs(I2C_TM_SCL_HIGH);
149	byte = byte << 1; /* read the next bit */
150	byte \|= SDA;
151	}
152	return (int)byte;
153	}
154
155	/*
156	* Send an (~)acknowledge to the slave
157	* - status of I2C_LAST implies this is the last byte to be sent
158	*/
159
160	void
161	i2c_SendAcknowledge(unsigned char status)
162	{
163	SCL_LOW();
164	if ( status & 0x01) {
165	SDA_LOW(); /* drive line low -> more to come */
166	}
167	else {
168	SDA_HIGH();
169	}
170	DelayUs(I2C_TM_DATA_SU);
171	SCL_DIR = I2C_INPUT; /* float clock high */
172	DelayUs(I2C_TM_SCL_HIGH);
173	return;
174	}
175
176	/*
177	* Send a byte to the slave and acknowledges the transfer
178	* - returns I2C_ERROR, ack or ~ack
179	*/
180
181	signed char
182	i2c_PutByte(unsigned char data)
183	{
184	if(i2c_SendByte(data))
185	return I2C_ERROR;
186	return i2c_ReadAcknowledge(); /* returns ack, ~ack */
187	}
188
189	/*
190	* Get a byte from the slave and acknowledges the transfer
191	* - returns true on I2C_ERROR or byte
192	*/
193
194	int
195	i2c_GetByte(unsigned char more)
196	{
197	int byte;
198
199	if((byte = i2c_ReadByte()) == I2C_ERROR)
200	return I2C_ERROR;
201
202	i2c_SendAcknowledge(more);
203
204	return byte;
205	}
206
207	/*
208	* Send an array of bytes to the slave and acknowledges the transfer
209	* - returns number of bytes not successfully transmitted
210	*/
211
212	int
213	i2c_PutString(const unsigned char *str, unsigned char length)
214	{
215	signed char error;
216
217	while(length)
218	{
219	if((error = i2c_PutByte(*str)) == I2C_ERROR)
220	return -(int)length; /* bus error */
221	else
222	if(error)
223	return (int)length; /* non acknowledge */
224	str++;
225	length--;
226	}
227
228	return FALSE; /* everything OK */
229	}
230
231	/*
232	* Reads number bytes from the slave, stores them at str and acknowledges the transfer
233	* - returns number of bytes not successfully read in
234	*/
235
236	unsigned char
237	i2c_GetString(unsigned char *str, unsigned char number)
238	{
239	int byte;
240
241	while(number)
242	{
243	if((byte = i2c_GetByte(number-1)) == I2C_ERROR)
244	return number; /* bus error */
245	else
246	*str = (unsigned char)byte;
247	str++;
248	number--;
249	}
250
251	return FALSE; /* everything OK */
252	}
253
254	/*
255	* Opens communication with a device at address. mode
256	* indicates I2C_READ or I2C_WRITE.
257	* - returns TRUE if address is not acknowledged
258	*/
259
260	unsigned char
261	i2c_Open(unsigned char address, unsigned char mode)
262	{
263	i2c_Start();
264	i2c_SendAddress(address, mode);
265	if(i2c_ReadAcknowledge())
266	return TRUE;
267
268	return FALSE;
269	}
270
271	/*
272	* wait for the clock line to be released by slow slaves
273	* - returns TRUE if SCL was not released after the
274	* time out period.
275	* - returns FALSE if and when SCL released
276	*/
277
278	unsigned char
279	i2c_WaitForSCL(void)
280	{
281	/* SCL_DIR should be input here */
282
283	if(!SCL)
284	{
285	DelayUs(I2C_TM_SCL_TMO);
286	/* if the clock is still low -> bus error */
287	if(!SCL)
288	return TRUE;
289	}
290	return FALSE;
291	}
292	void
293	i2c_Free()
294	{
295	unsigned char ucI;
296
297	SDA_DIR=I2C_INPUT;
298	for(ucI=0;ucI!=9;ucI++)
299	{
300	SCL_HIGH();
301	DelayUs(5);
302	SCL_LOW();
303	DelayUs(5);
304	}
305	}
306
307	unsigned char i2c_read(unsigned char ucAdr)
308	{
309	unsigned char ucDat;
310
311	if (i2c_ReadFrom(ucAdr)==0)
312	{
313	ucDat=i2c_GetByte(I2C_MORE);
314	i2c_Stop();
315
316	}
317
318	return(ucDat);
319	}