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	torben	2	#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			}