标题: 松翰SN8F5703单片机IIc例程 [打印本页]

---

作者: hexinquan    时间: 2020-12-8 11:18
标题: 松翰SN8F5703单片机IIc例程
松翰单片机5703例程——IIC

1. //-----------------------------------------------------------------------------
   
2. //  FILE:   Master_I2C.c
   
3. //-----------------------------------------------------------------------------
   
4. //  Copyright 2014 SONiX Technology Corp. All rights reserved.
   
5. //
   
6. //  AUTHOR:     SONiX
   
7. //  DATE:       2014/11/11
   
8. //
   
9. //  The program is an example of Master I2C to implement it.
   
10. //   
    
11. //  I2C decription:
    
12. //      User need to external pull-high at SDA and SCL pin
    
13. //
    
14. //
    
15. //  The system clock frequency is IHRC 32MHz
    
16. //
    
17. //  Device:     SN8F5708
    
18. //  Tool chain: KEIL C51 V9.50a
    
19. //
    
20. //-----------------------------------------------------------------------------
    
21. // Includes
    
22. //-----------------------------------------------------------------------------
    
23. #include <string.h>
    
24. #include <SN8F5703.h>
    
25. #include "GenericTypeDefs.h"
    
26. //-----------------------------------------------------------------------------
    
27. // Global Constants
    
28. //-----------------------------------------------------------------------------
    
29. #define MAXDATALEN  5
    
30. //-----------------------------------------------------------------------------
    
31. // Global Variables
    
32. //-----------------------------------------------------------------------------
    
33. UINT8 u8I2CFlag = 0;
    
34. UINT8 u8I2CData[MAXDATALEN];
    
35. UINT8 u8I2CAddr = 0;
    
36. UINT8 u8I2CLen = 0;
    
37. UINT8 u8I2CCnt = 0;
    
38. //-----------------------------------------------------------------------------
    
39. // Function Prototypes
    
40. //-----------------------------------------------------------------------------
    
41. void I2C_Init(void);
    
42. UINT8 I2C_Master_Write_One_Byte(UINT8 u8Addr, UINT8 u8data);
    
43. UINT8 I2C_Master_Write_N_Byte(UINT8 u8Addr, UINT8 *u8data, UINT8 u8size);
    
44. UINT8 I2C_Master_Read_N_Byte(UINT8 u8Addr, UINT8 *u8data, UINT8 u8size);
    
45. //-----------------------------------------------------------------------------
    
46. // Main loop
    
47. //-----------------------------------------------------------------------------
    
48. void main(void)
    
49. {
    
50.     UINT8 u8TxData[MAXDATALEN] = {0xAA,0xBB,0xCC,0xDD,0xEE};                                                                                             // for test
    
51.     UINT8 u8RxData[] = {0};
    
52.     UINT8 u8SlaveAddr = 0x2C;                                                   // set addr
    
53. 
    
54.                 CLKSEL = 0x06;                                                                                                                                                        // Fcpu = 32M/2 = 16M
    
55.                 CLKCMD = 0X69;
    
56.                 CKCON = 0X10;       
    
57.                
    
58.     WDTR = 0x5A;                                                                                                                            // clear watchdog if watchdog enable
    
59.                
    
60.                 P0 = 0;
    
61.                 P0M = 0;
    
62.                 P0UR = 0xFF;
    
63.        
    
64.                 P1 = 0;
    
65.                 P1M = 0;
    
66.                 P1UR = 0xFF;
    
67.        
    
68.                 P2 = 0;
    
69.                 P2M = 0;
    
70.                 P2UR = 0xFF;
    
71.        
    
72.                                        
    
73.                 I2C_Init();   
    
74. 
    
75.     // Write one data to slave
    
76.                 I2C_Master_Write_One_Byte(u8SlaveAddr, u8TxData[0]);
    
77. 
    
78.     // Write multi data to slave
    
79.                 I2C_Master_Write_N_Byte(u8SlaveAddr, u8TxData, sizeof(u8TxData));
    
80. 
    
81.                 // read 1 data form slave
    
82.                 I2C_Master_Read_N_Byte(u8SlaveAddr, u8RxData, 1);
    
83.                
    
84.     // read multi data form slave
    
85.                 I2C_Master_Read_N_Byte(u8SlaveAddr, u8RxData, sizeof(u8RxData));
    
86.                
    
87.     while (1)
    
88.                 {
    
89.                         WDTR = 0x5A;                                                                                                                        // clear watchdog if watchdog enable
    
90.     }
    
91. }
    
92. //-----------------------------------------------------------------------------
    
93. //  Function:   void I2C_Init(void)
    
94. //  Description:
    
95. //          SCL and SDA need to external pull high
    
96. //-----------------------------------------------------------------------------
    
97. void I2C_Init(void)
    
98. {
    
99.                 I2CCON = 0x43;                                                                                                                         // I2C enable (ENS1),Fclk = Fcpu/160 = 100K
    
100. 
     
101.                 EI2C = 1;                                                                                                                       // I2C interrupt enable
     
102.                 EAL = 1;                                                                                                                        // Interrupt enable
     
103. }
     
104. //-----------------------------------------------------------------------------
     
105. //  Function:   UINT8 I2C_Master_Write_One_Byte(UINT8 u8Addr, UINT8 u8Data)
     
106. //  Description:
     
107. //
     
108. //-----------------------------------------------------------------------------
     
109. UINT8 I2C_Master_Write_One_Byte(UINT8 u8Addr, UINT8 u8Data)
     
110. {
     
111.     if (!u8I2CFlag) {
     
112.         u8I2CFlag = 1;                                                                                              // get Use Right            
     
113.         u8I2CLen = 1;                                                                                               // set length
     
114.         u8I2CCnt = 0;                                                                                               // clear tx count
     
115.         u8I2CData[0] = u8Data;
     
116.         u8I2CAddr = u8Addr & 0xFE;                                                                                  // write mode               
     
117.         I2CCON |= 0x20;                                                                                             // START (STA) = 1
     
118. 
     
119.         while(u8I2CFlag);                                                                                           // wait Trasmit end
     
120. 
     
121.         return TRUE;
     
122.     }
     
123.     else
     
124.         return FALSE;
     
125. }
     
126. 
     
127. //-----------------------------------------------------------------------------
     
128. //  Function:   UINT8 I2C_Master_Write_N_Byte(UINT8 u8Addr, UINT8 *u8data, UINT8 u8size)
     
129. //  Description:
     
130. //
     
131. //-----------------------------------------------------------------------------
     
132. UINT8 I2C_Master_Write_N_Byte(UINT8 u8Addr, UINT8 *u8data, UINT8 u8size)
     
133. {
     
134.     if (u8size > MAXDATALEN)   
     
135.         return FALSE;                                                                                               // over buf size
     
136.    
     
137.     if (u8size == 0)   
     
138.         return FALSE;                                                                                               // error size
     
139.    
     
140.     if (!u8I2CFlag) {
     
141.         u8I2CFlag = 1;                                                                                      // get Use Right
     
142.         u8I2CLen = u8size;                                                                                  // set length
     
143.         u8I2CCnt = 0;                                                                                       // clear tx count
     
144.         u8I2CAddr = u8Addr & 0xFE;                                                                          // write mode            
     
145.         memcpy(u8I2CData, u8data, u8size);
     
146.         I2CCON |= 0x20;                                                                                     // START (STA) = 1
     
147. 
     
148.         while(u8I2CFlag);                                                                                   // wait Trasmit end
     
149. 
     
150.         return TRUE;
     
151.     }
     
152.     else
     
153.         return FALSE;
     
154. }
     
155. 
     
156. //-----------------------------------------------------------------------------
     
157. //  Function:   UINT8 I2C_Master_Read_N_Byte(UINT8 u8Addr, UINT8 *u8data, UINT8 u8size)
     
158. //  Description:
     
159. //
     
160. //-----------------------------------------------------------------------------
     
161. UINT8 I2C_Master_Read_N_Byte(UINT8 u8Addr, UINT8 *u8data, UINT8 u8size)
     
162. {
     
163.     if (u8size > MAXDATALEN)   
     
164.         return FALSE;                                                                                       // over buf size
     
165.     if (u8size == 0)   
     
166.         return FALSE;                                                                                       // error size
     
167.     if (!u8I2CFlag) {
     
168.         u8I2CFlag = 1;                                                                                      // get Use Right
     
169.         u8I2CLen = u8size;                                                                                  // set length
     
170.         u8I2CCnt = 0;
     
171.         u8I2CAddr = u8Addr | 0x01;                                                                          // read mode
     
172.         I2CCON |= 0x20;                                                                                     // START (STA) = 1
     
173.    
     
174.         while(u8I2CFlag);                                                                                   // wait recevier end
     
175.    
     
176.         memcpy(u8data, u8I2CData, u8size);
     
177.    
     
178.         return TRUE;
     
179.     }
     
180.     else
     
181.         return FALSE;
     
182. }
     
183. //-----------------------------------------------------------------------------
     
184. //  Function:   I2C interrupt
     
185. //  Description:      
     
186. //
     
187. //-----------------------------------------------------------------------------
     
188. void I2C_ISR(void) interrupt ISRI2c                                                                    // Vector @  0x43
     
189. {
     
190.     switch (I2CSTA)
     
191.     {
     
192.         // tx mode
     
193.         case 0x08:
     
194.             I2CCON &= 0xDF;                                                                     // START (STA) = 0
     
195.             I2CDAT = u8I2CAddr;                                                                 // Tx/Rx addr
     
196.             break;
     
197.         case 0x18:                                                                              // write first byte
     
198.             I2CDAT = u8I2CData[u8I2CCnt++];
     
199.             u8I2CLen--;
     
200.             break;
     
201.         case 0x28:                                                                              // write n byte
     
202.             if (u8I2CLen == 0) {                                                                // chk length if empty
     
203.                 I2CCON |= 0x10;                                                                 // STOP (STO)
     
204.                 u8I2CFlag = 0;
     
205.                 u8I2CCnt = 0;
     
206.             }
     
207.             else {
     
208.                 I2CDAT = u8I2CData[u8I2CCnt++];
     
209.                 u8I2CLen--;
     
210.             }
     
211.             break;
     
212.             
     
213.         //    rx mode   
     
214.         case 0x40:                                                                              // get slave addr
     
215.             if(u8I2CLen > 1)        I2CCON |= 0x04;         // AA = 1
     
216.                                                 else        I2CCON &= 0xFB;  
     
217.             break;
     
218.         case 0x50:                                                                              // read n byte
     
219.             u8I2CData[u8I2CCnt++] = I2CDAT;
     
220.             if (u8I2CCnt == (u8I2CLen-1)) {
     
221.                 I2CCON &= 0xFB;                                                                 // AA = 0
     
222.             }
     
223.             else {               
     
224.                 I2CCON |= 0x04;                                                                        // AA = 1
     
225.             }
     
226.             break;
     
227.         case 0x58:                                                                              // read last byte & stop
     
228.             u8I2CData[u8I2CCnt] = I2CDAT;
     
229.             I2CCON |= 0x10;                                                                     // STOP (STO)
     
230.             u8I2CFlag = 0;
     
231.             break;
     
232.         default:
     
233.             I2CCON |= 0x10;                                                                     // STOP (STO)
     
234.             u8I2CFlag = 0;
     
235.     }
     
236.                
     
237.     I2CCON &= 0xF7;                                                                             // Clear I2C flag (SI)        
     
238. }

复制代码

5703_I2C_20161104.rar

2020-12-8 11:35 上传

点击文件名下载附件

下载积分: 黑币 -5

115.79 KB, 下载次数: 10, 下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1