PIC/Demo%20trimmet/MyI2C.c

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

#define LED                     RB3

/****************************************************************************
 * Function:InitI2C                                                                                                                     *
 * Purpose:     Initialize 100 kHz I2C communication                                                    *
 ****************************************************************************/
void InitI2C(void)
{
        SSPADD = 0x0A;                         // 100 kHz I2C bus
        //SSPADD = 0x28;                         // 100 kHz I2C bus
        SSPCON1 = 0x28;                      // Enable I2C bus
        StopI2C();
}

/****************************************************************************
 * Function:StopI2C                                                                                                                     *
 * Purpose:     End communication with I2C slave                                                                *
 *                      Send stop signal on I2C bus                                                                             *
 * Input:       Nothing                                                                                                                 *
 * Output:      Nothing                                                                                                                 *
 ****************************************************************************/
void StopI2C(void)
{
        SSPIF = 0;                           // Clear interrupt flag
        PEN = 1;                             // Send Stop condition

        while (SSPIF == 0);                  // Wait until stop condition complete
}

/****************************************************************************
 * Function:WaitForWrite EEProm                                                                                         *
 * Purpose:     Wait for read write acces in EEProm                                             *
 *                      Send start signal on I2C bus                                                                    *
 *                      Send <I2CADD> on I2C bus                                                                                *
 *                      Receive acknowledge from I2C slave                                                              *
 * Input:       char I2CADD: Address of I2C slave to start communication with   *
 *          RWStruct *IOStruct2 ptr for data struct with Progress flag      *
 * Output:      0: No communication started (missing acknowledge)                               *
 *                      1: Communication started (acknowledge)                                                  *
 ****************************************************************************/
char WaitForWrite(char I2CADD, char *Progress)
{
    int BreakCount = 5000;
    
        do{
        SSPIF = 0;                           // Clear interrupt flag
        RSEN = 1;                             // Initiate start condition
        while (SSPIF == 0)
            LED = LED^1;                      // Wait until Start condition complete

        SSPIF = 0;                           // Clear interrupt flag
        SSPBUF = I2CADD;                     // Send address of slave device
      
        while (SSPIF == 0)
            LED = LED^1;                     // Wait until address has been sent
        
        if(BreakCount-- == 0){
                LED = 0;
                *Progress = 0;
            return 0;                        // Return 0 if device didn't acknowledge
        }
    }while(ACKSTAT == 1);

    LED = 0;
    *Progress = 0;
    return 1;                                // Return 1 if device acknowledged
}

/****************************************************************************
 * Function:StartI2C                                                                                                            *
 * Purpose:     Initiate communication with I2C slave                                                   *
 *                      Send start signal on I2C bus                                                                    *
 *                      Send <I2CADD> on I2C bus                                                                                *
 *                      Receive acknowledge from I2C slave                                                              *
 * Input:       char I2CADD: Address of I2C slave to start communication with   *
 * Output:      0: No communication started (missing acknowledge)                               *
 *                      1: Communication started (acknowledge)                                                  *
 ****************************************************************************/
char StartI2C(char I2CADD)
{
        SSPIF = 0;                           // Clear interrupt flag
        RSEN = 1;                             // Initiate start condition
    
        while (SSPIF == 0)
            LED = LED^1;                      // Wait until Start condition complete
  
        SSPIF = 0;                           // Clear interrupt flag
        SSPBUF = I2CADD;                     // Send address of slave device
  
        while (SSPIF == 0)
            LED = LED^1;                     // Wait until address has been sent
  
    LED = 0;

        if (ACKSTAT == 0)
                return 1;                        // Return 1 if device acknowledged
        else
                return 0;                        // Return 0 if device didn't acknowledge
}

/****************************************************************************
 * Function:ReStartI2C                                                                                                          *
 * Purpose:     Initiate communication with I2C slave                                                   *
 *                      Send start signal on I2C bus                                                                    *
 *                      Send <I2CADD> on I2C bus                                                                                *
 *                      Receive acknowledge from I2C slave                                                              *
 * Input:       char I2CADD: Address of I2C slave to start communication with   *
 * Output:      0: No communication started (missing acknowledge)                               *
 *                      1: Communication started (acknowledge)                                                  *
 ****************************************************************************/
char ReStartI2C(char I2CADD)
{
        SSPIF = 0;                           // Clear interrupt flag
        RSEN = 1;                             // Initiate start condition

        while (SSPIF == 0)
            LED = LED^1;                      // Wait until Start condition complete

        SSPIF = 0;                           // Clear interrupt flag
        SSPBUF = I2CADD;                     // Send address of slave device

        while (SSPIF == 0)
            LED = LED^1;                     // Wait until address has been sent

    LED = 0;

        if (ACKSTAT == 0)
                return 1;                        // Return 1 if device acknowledged
        else
                return 0;                        // Return 0 if device didn't acknowledge
}

/****************************************************************************
 * Function:WriteI2CByte                                                                                                        *
 * Purpose:     Send 1 byte to I2C slave                                                                        *
 * Input:       1 Data byte                                                     *
 * Output:      0: Communication did not succeed                                                                *
 *                      1: Communication succeeded                                                                              *
 ****************************************************************************/
char WriteI2CByte(char I2CByte)
{
    SSPIF = 0;
    SSPBUF = I2CByte;
//    while(SSPIF == 0);
Delay10us(1);
    
        if (ACKSTAT == 0)
                return 1;                        // Return 1 if device acknowledged
        else
                return 0;                        // Return 0 if device didn't acknowledge
}

/****************************************************************************
 * Function:ReadI2CByte                                                                                                     *
 * Purpose:     Send 1 byte to I2C slave                                                                        *
 * Input:       1 Data byte                                                     *
 * Output:      0: Communication did not succeed                                                                *
 *                      1: Communication succeeded                                                                              *
 ****************************************************************************/
char ReadI2CByte(char LastRead)
{
    char ReadChar=0;
    
    SSPIF = 0;                     // Clear interrupt flag
    RCEN = 1;                      // Initiate read sequence
    
    while (SSPIF == 0);
    
    ReadChar = SSPBUF;   // Store byte in buffer
    SSPIF = 0;
    
    if(LastRead == 1){
        ACKDT = 1;                 //  indicate we're done by no ack
    }else{
        ACKDT = 0;                 // else acknowledge the byte
    }
    
    ACKEN = 1;                     // Start acknowledge sequence
    
    return ReadChar;
}

/****************************************************************************
 * Function:WriteI2C                                                                                                            *
 * Purpose:     Send <I2CBYTES> bytes to I2C slave                                                              *
 * Input:       char I2CADD: Address of I2C slave to start communication with   *
 *                      char I2CBYTES: Number of bytes to send                                                  *
 *                      char*I2CBUFFER: Buffer containing data to send                                  *
 * Output:      0: Communication did not succeed                                                                *
 *                      1: Communication succeeded                                                                              *
 ****************************************************************************/
char WriteI2C(RWStruct *IOStruct) //char DevAddr, char NoBytes, char *WriteBuffer);
{
    char Count = 0;
    char Res = 1;
    
    if(IOStruct->WrInProgress == 1){
        Res = WaitForWrite(IOStruct->DevAddr & 0xfe, &IOStruct->WrInProgress);
    }else{
        Res = StartI2C(IOStruct->DevAddr & 0xfe);
    }
    if(Res == 1){
        if(!WriteI2CByte((char) IOStruct->RWAddress / 0x100))
            Res = 0;
        else if(!WriteI2CByte((char) IOStruct->RWAddress % 0x100))
            Res = 0;
        else{
            for(Count = 0; Count < IOStruct->NoBytes; Count++){
                if(WriteI2CByte(IOStruct->IOBuffer[Count]) == 0){
                    Res = 0;
                    break;
                }
            }
        }
    }else{
        Res = 0;
    }
    StopI2C();
    IOStruct->WrInProgress = 1;
    return Res;
}

/****************************************************************************
 * Function:ReadI2C                                                                                                             *
 * Purpose:     Reads <I2CBYTES> bytes to I2C slave                                                             *
 * Input:       char I2CADD: Address of I2C slave to start communication with   *
 *                      char I2CBYTES: Number of bytes to send                                                  *
 *                      char*I2CBUFFER: Buffer containing data to send                                  *
 * Output:      0: Communication did not succeed                                                                *
 *                      1: Communication succeeded                                                                              *
 ****************************************************************************/
char ReadI2C(RWStruct *IOStruct) //char DevAddr, char NoBytes, char *ReadBuffer);
{
    char Count = 0;
    char Ptr = 0;
    char Res = 1;
    
    if(IOStruct->WrInProgress == 1){
        Res = WaitForWrite(IOStruct->DevAddr & 0xfe, &IOStruct->WrInProgress);
    }else{
        Res = StartI2C( IOStruct->DevAddr & 0xfe);
    }
    if(Res == 1){
        if(!WriteI2CByte((char) IOStruct->RWAddress / 0x100))
            Res = 0;
        else if(!WriteI2CByte((char) IOStruct->RWAddress % 0x100))
            Res = 0;
        else if(!ReStartI2C(IOStruct->DevAddr | 0x1))
            Res = 0;
        else {
            Count = IOStruct->NoBytes - 1;
            for(Ptr = 0; Ptr < Count; Ptr++){
                IOStruct->IOBuffer[Ptr] = ReadI2CByte(0);
            }
            IOStruct->IOBuffer[Ptr] = ReadI2CByte(1);
        }
        StopI2C();
    }
    return Res;
}
1	hedin	109	#include <pic18.h>
2			#include "MyI2C.h"
3			#include "delay.h"
4
5			#define LED RB3
6
7			/****************************************************************************
8			* Function:InitI2C *
9			* Purpose: Initialize 100 kHz I2C communication *
10			****************************************************************************/
11			void InitI2C(void)
12			{
13			SSPADD = 0x0A; // 100 kHz I2C bus
14	hedin	111	//SSPADD = 0x28; // 100 kHz I2C bus
15	hedin	109	SSPCON1 = 0x28; // Enable I2C bus
16			StopI2C();
17			}
18
19			/****************************************************************************
20			* Function:StopI2C *
21			* Purpose: End communication with I2C slave *
22			* Send stop signal on I2C bus *
23			* Input: Nothing *
24			* Output: Nothing *
25			****************************************************************************/
26			void StopI2C(void)
27			{
28			SSPIF = 0; // Clear interrupt flag
29			PEN = 1; // Send Stop condition
30
31			while (SSPIF == 0); // Wait until stop condition complete
32			}
33
34			/****************************************************************************
35			* Function:WaitForWrite EEProm *
36			* Purpose: Wait for read write acces in EEProm *
37			* Send start signal on I2C bus *
38			* Send <I2CADD> on I2C bus *
39			* Receive acknowledge from I2C slave *
40			* Input: char I2CADD: Address of I2C slave to start communication with *
41			* RWStruct IOStruct2 ptr for data struct with Progress flag
42			* Output: 0: No communication started (missing acknowledge) *
43			* 1: Communication started (acknowledge) *
44			****************************************************************************/
45			char WaitForWrite(char I2CADD, char *Progress)
46			{
47			int BreakCount = 5000;
48
49			do{
50			SSPIF = 0; // Clear interrupt flag
51			RSEN = 1; // Initiate start condition
52			while (SSPIF == 0)
53			LED = LED^1; // Wait until Start condition complete
54
55			SSPIF = 0; // Clear interrupt flag
56			SSPBUF = I2CADD; // Send address of slave device
57
58			while (SSPIF == 0)
59			LED = LED^1; // Wait until address has been sent
60
61			if(BreakCount-- == 0){
62			LED = 0;
63			*Progress = 0;
64			return 0; // Return 0 if device didn't acknowledge
65			}
66			}while(ACKSTAT == 1);
67
68			LED = 0;
69			*Progress = 0;
70			return 1; // Return 1 if device acknowledged
71			}
72
73			/****************************************************************************
74			* Function:StartI2C *
75			* Purpose: Initiate communication with I2C slave *
76			* Send start signal on I2C bus *
77			* Send <I2CADD> on I2C bus *
78			* Receive acknowledge from I2C slave *
79			* Input: char I2CADD: Address of I2C slave to start communication with *
80			* Output: 0: No communication started (missing acknowledge) *
81			* 1: Communication started (acknowledge) *
82			****************************************************************************/
83			char StartI2C(char I2CADD)
84			{
85			SSPIF = 0; // Clear interrupt flag
86			RSEN = 1; // Initiate start condition
87
88			while (SSPIF == 0)
89			LED = LED^1; // Wait until Start condition complete
90
91			SSPIF = 0; // Clear interrupt flag
92			SSPBUF = I2CADD; // Send address of slave device
93
94			while (SSPIF == 0)
95			LED = LED^1; // Wait until address has been sent
96
97			LED = 0;
98
99			if (ACKSTAT == 0)
100			return 1; // Return 1 if device acknowledged
101			else
102			return 0; // Return 0 if device didn't acknowledge
103			}
104
105			/****************************************************************************
106			* Function:ReStartI2C *
107			* Purpose: Initiate communication with I2C slave *
108			* Send start signal on I2C bus *
109			* Send <I2CADD> on I2C bus *
110			* Receive acknowledge from I2C slave *
111			* Input: char I2CADD: Address of I2C slave to start communication with *
112			* Output: 0: No communication started (missing acknowledge) *
113			* 1: Communication started (acknowledge) *
114			****************************************************************************/
115			char ReStartI2C(char I2CADD)
116			{
117			SSPIF = 0; // Clear interrupt flag
118			RSEN = 1; // Initiate start condition
119
120			while (SSPIF == 0)
121			LED = LED^1; // Wait until Start condition complete
122
123			SSPIF = 0; // Clear interrupt flag
124			SSPBUF = I2CADD; // Send address of slave device
125
126			while (SSPIF == 0)
127			LED = LED^1; // Wait until address has been sent
128
129			LED = 0;
130
131			if (ACKSTAT == 0)
132			return 1; // Return 1 if device acknowledged
133			else
134			return 0; // Return 0 if device didn't acknowledge
135			}
136
137			/****************************************************************************
138			* Function:WriteI2CByte *
139			* Purpose: Send 1 byte to I2C slave *
140			* Input: 1 Data byte *
141			* Output: 0: Communication did not succeed *
142			* 1: Communication succeeded *
143			****************************************************************************/
144			char WriteI2CByte(char I2CByte)
145			{
146			SSPIF = 0;
147			SSPBUF = I2CByte;
148			// while(SSPIF == 0);
149			Delay10us(1);
150
151			if (ACKSTAT == 0)
152			return 1; // Return 1 if device acknowledged
153			else
154			return 0; // Return 0 if device didn't acknowledge
155			}
156
157			/****************************************************************************
158			* Function:ReadI2CByte *
159			* Purpose: Send 1 byte to I2C slave *
160			* Input: 1 Data byte *
161			* Output: 0: Communication did not succeed *
162			* 1: Communication succeeded *
163			****************************************************************************/
164			char ReadI2CByte(char LastRead)
165			{
166			char ReadChar=0;
167
168			SSPIF = 0; // Clear interrupt flag
169			RCEN = 1; // Initiate read sequence
170
171			while (SSPIF == 0);
172
173			ReadChar = SSPBUF; // Store byte in buffer
174			SSPIF = 0;
175
176			if(LastRead == 1){
177			ACKDT = 1; // indicate we're done by no ack
178			}else{
179			ACKDT = 0; // else acknowledge the byte
180			}
181
182			ACKEN = 1; // Start acknowledge sequence
183
184			return ReadChar;
185			}
186
187			/****************************************************************************
188			* Function:WriteI2C *
189			* Purpose: Send <I2CBYTES> bytes to I2C slave *
190			* Input: char I2CADD: Address of I2C slave to start communication with *
191			* char I2CBYTES: Number of bytes to send *
192			* charI2CBUFFER: Buffer containing data to send
193			* Output: 0: Communication did not succeed *
194			* 1: Communication succeeded *
195			****************************************************************************/
196			char WriteI2C(RWStruct IOStruct) //char DevAddr, char NoBytes, char WriteBuffer);
197			{
198			char Count = 0;
199			char Res = 1;
200
201			if(IOStruct->WrInProgress == 1){
202			Res = WaitForWrite(IOStruct->DevAddr & 0xfe, &IOStruct->WrInProgress);
203			}else{
204			Res = StartI2C(IOStruct->DevAddr & 0xfe);
205			}
206			if(Res == 1){
207			if(!WriteI2CByte((char) IOStruct->RWAddress / 0x100))
208			Res = 0;
209			else if(!WriteI2CByte((char) IOStruct->RWAddress % 0x100))
210			Res = 0;
211			else{
212			for(Count = 0; Count < IOStruct->NoBytes; Count++){
213			if(WriteI2CByte(IOStruct->IOBuffer[Count]) == 0){
214			Res = 0;
215			break;
216			}
217			}
218			}
219			}else{
220			Res = 0;
221			}
222			StopI2C();
223			IOStruct->WrInProgress = 1;
224			return Res;
225			}
226
227			/****************************************************************************
228			* Function:ReadI2C *
229			* Purpose: Reads <I2CBYTES> bytes to I2C slave *
230			* Input: char I2CADD: Address of I2C slave to start communication with *
231			* char I2CBYTES: Number of bytes to send *
232			* charI2CBUFFER: Buffer containing data to send
233			* Output: 0: Communication did not succeed *
234			* 1: Communication succeeded *
235			****************************************************************************/
236			char ReadI2C(RWStruct IOStruct) //char DevAddr, char NoBytes, char ReadBuffer);
237			{
238			char Count = 0;
239			char Ptr = 0;
240			char Res = 1;
241
242			if(IOStruct->WrInProgress == 1){
243			Res = WaitForWrite(IOStruct->DevAddr & 0xfe, &IOStruct->WrInProgress);
244			}else{
245			Res = StartI2C( IOStruct->DevAddr & 0xfe);
246			}
247			if(Res == 1){
248			if(!WriteI2CByte((char) IOStruct->RWAddress / 0x100))
249			Res = 0;
250			else if(!WriteI2CByte((char) IOStruct->RWAddress % 0x100))
251			Res = 0;
252			else if(!ReStartI2C(IOStruct->DevAddr \| 0x1))
253			Res = 0;
254			else {
255			Count = IOStruct->NoBytes - 1;
256			for(Ptr = 0; Ptr < Count; Ptr++){
257			IOStruct->IOBuffer[Ptr] = ReadI2CByte(0);
258			}
259			IOStruct->IOBuffer[Ptr] = ReadI2CByte(1);
260			}
261			StopI2C();
262			}
263			return Res;
264			}