PIC/Torbens/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)
{

#ifdef I2C_MODULE
        PEN = 1;
        DelayUs(1);
#else
        /* 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 */
#endif
        return;
}

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

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