cubieboard A10 A20 I2C设备读写

jiangdou

1. /*
   
2. * \file        ii.c
   
3. * LIS3LV02DQ
   
4. *
   
5. * \version     1.0.0
   
6. * \date        2014年03月10日
   
7. * \author      jiangdou  <jiangdouu88@126.com>
   
8. *
   
9. *
   
10. */
    
11. 
    
12. /*
    
13. *usage
    
14. *dou@ubuntu:~/a10/linshi_chenxu$  arm-linux-gnueabi-gcc -o gpio gpio_test.c -static
    
15. 
    
16. *
    
17. */
    
18. 
    
19. #include <stdio.h>  
    
20. #include <linux/types.h>  
    
21. #include <fcntl.h>  
    
22. #include <unistd.h>  
    
23. #include <stdlib.h>  
    
24. #include <sys/types.h>  
    
25. #include <sys/ioctl.h>  
    
26. #include <errno.h>  
    
27. #include <assert.h>  
    
28. #include <string.h>  
    
29. #include <linux/i2c.h>  
    
30. #include <linux/i2c-dev.h>
    
31. #define        devic        "/dev/i2c-2"
    
32. 
    
33.   
    
34. int i2c_read_reg(char *dev, unsigned char *buf, unsigned slave_address, unsigned reg_address, int len)  
    
35. {  
    
36.     struct i2c_rdwr_ioctl_data work_queue;  
    
37.     unsigned char w_val = reg_address;  
    
38.     int ret;  
    
39.   
    
40.     int fd = open(dev, O_RDWR);  
    
41.     if (!fd) {  
    
42.         printf("Error on opening the device file\n");  
    
43.         return 0;  
    
44.     }  
    
45.   
    
46.     work_queue.nmsgs = 2;  
    
47.     work_queue.msgs = (struct i2c_msg*)malloc(work_queue.nmsgs *sizeof(struct  
    
48.             i2c_msg));  
    
49.     if (!work_queue.msgs) {  
    
50.         printf("Memory alloc error\n");  
    
51.         close(fd);  
    
52.         return 0;  
    
53.     }  
    
54.   
    
55.     ioctl(fd, I2C_TIMEOUT, 3);  
    
56.     ioctl(fd, I2C_RETRIES, 3);  
    
57.   
    
58.     (work_queue.msgs[0]).len = 1;  
    
59.     (work_queue.msgs[0]).addr = slave_address;  
    
60.     (work_queue.msgs[0]).buf = &w_val;  
    
61.   
    
62.     (work_queue.msgs[1]).len = len;  
    
63.     (work_queue.msgs[1]).flags = I2C_M_RD;  
    
64.     (work_queue.msgs[1]).addr = slave_address;  
    
65.     (work_queue.msgs[1]).buf = buf;  
    
66.   
    
67.     ret = ioctl(fd, I2C_RDWR, (unsigned long) &work_queue);  
    
68.     if (ret < 0) {  
    
69.         printf("Error during I2C_RDWR ioctl with error code: %d\n", ret);  
    
70.         close(fd);  
    
71.         free(work_queue.msgs);  
    
72.         return 0;  
    
73.     } else {  
    
74.         //printf("read salve:%02x reg:%02x\n", slave_address, reg_address);  
    
75.         close(fd);  
    
76.         free(work_queue.msgs);  
    
77.         return len;  
    
78.     }  
    
79. }  
    
80.   
    
81. int i2c_write_reg(char *dev, unsigned char *buf, unsigned slave_address, unsigned reg_address, int len)  
    
82. {  
    
83.     struct i2c_rdwr_ioctl_data work_queue;  
    
84.     unsigned char w_val = reg_address;  
    
85.     unsigned char w_buf[len+1];  
    
86.     int ret;  
    
87.   
    
88.     w_buf[0] = reg_address;  
    
89.   
    
90.     int fd = open(dev, O_RDWR);  
    
91.     if (!fd) {  
    
92.         printf("Error on opening the device file\n");  
    
93.         return 0;  
    
94.     }  
    
95.   
    
96.     work_queue.nmsgs = 1;  
    
97.     work_queue.msgs = (struct i2c_msg*)malloc(work_queue.nmsgs *sizeof(struct  
    
98.             i2c_msg));  
    
99.     if (!work_queue.msgs) {  
    
100.         printf("Memory alloc error\n");  
     
101.         close(fd);  
     
102.         return 0;  
     
103.     }  
     
104.   
     
105.     ioctl(fd, I2C_TIMEOUT, 2);  
     
106.     ioctl(fd, I2C_RETRIES, 1);  
     
107.   
     
108.     (work_queue.msgs[0]).len = 1 + len;  
     
109.     (work_queue.msgs[0]).addr = slave_address;  
     
110.     (work_queue.msgs[0]).buf = w_buf;  
     
111.   
     
112.     memcpy(w_buf + 1, buf, len);  
     
113.   
     
114.     ret = ioctl(fd, I2C_RDWR, (unsigned long) &work_queue);  
     
115.     if (ret < 0) {  
     
116.         printf("Error during I2C_RDWR ioctl with error code: %d\n", ret);  
     
117.         close(fd);  
     
118.         free(work_queue.msgs);  
     
119.         return 0;  
     
120.     } else {  
     
121.         printf("write salve:%02x reg:%02x\n", slave_address, reg_address);  
     
122.         close(fd);  
     
123.         free(work_queue.msgs);  
     
124.         return len;  
     
125.     }  
     
126. }  
     
127.        
     
128.        
     
129. int init_LIS3LV02DQ(char *dev)
     
130. {
     
131.         printf("ACC OPEN is 3\n\r");
     
132.         unsigned char temp1,temp2,temp3;
     
133.         temp1 = 0x57;
     
134.         temp2 = 0x81;
     
135.         temp3 = 0x03;
     
136.         //寄存器配置
     
137.         i2c_write_reg(dev, &temp1, 0x1D, 0x20, 1);
     
138.         i2c_write_reg(dev, &temp2, 0x1D, 0x21, 1);
     
139.         i2c_write_reg(dev, &temp3, 0x1D, 0x22, 1);
     
140.          
     
141. }
     
142. 
     
143. int read_x(char *dev)                //read x
     
144. {       
     
145.         unsigned char tem1,tem2;
     
146.         int x = 0;
     
147.         i2c_read_reg(dev, &tem1, 0x1D, 0x28, 1);
     
148.        
     
149.         i2c_read_reg(dev, &tem2, 0x1D, 0x29, 1);
     
150.         x = (tem2 << 8) | tem1;
     
151.         return x;
     
152. }
     
153. 
     
154. int read_y(char *dev)                //read y
     
155. {
     
156.         unsigned char tem1,tem2;
     
157.         int y = 0;
     
158.         i2c_read_reg(dev, &tem1, 0x1D, 0x2A, 1);
     
159.         i2c_read_reg(dev, &tem2, 0x1D, 0x2B, 1);
     
160.         y = (tem2 << 8) | tem1;
     
161. 
     
162.         return y;
     
163. 
     
164. }
     
165. 
     
166. int read_z(char *dev)                //read z
     
167. {       
     
168.         unsigned char tem1,tem2;
     
169.         int z = 0;
     
170.         i2c_read_reg(dev, &tem1, 0x1D, 0x2C, 1);
     
171.        
     
172.         i2c_read_reg(dev, &tem2, 0x1D, 0x2D, 1);
     
173.         z = (tem2 << 8) | tem1;
     
174.         return z;
     
175. 
     
176. 
     
177. }
     
178. 
     
179. int main(void)
     
180. 
     
181. {
     
182.         int X;
     
183.         int Y;
     
184.         int Z;
     
185.        
     
186.         unsigned int fd;  
     
187.     unsigned char r_val;  
     
188.        
     
189.         fd = open(devic, O_RDWR);  
     
190.   
     
191.     if (!fd) {  
     
192.         printf("Error on opening the device file %s\n", devic);  
     
193.         return 0;  
     
194.     }  
     
195.        
     
196.         init_LIS3LV02DQ(devic);
     
197.         while(1)
     
198.         {
     
199.                
     
200.                 X = read_x(devic);        //read X_axis
     
201.                 Y = read_y(devic);        //read Y_axis        //0 -> 65535
     
202.                 Z = read_z(devic);        //read Z_axis
     
203.                
     
204.                 printf("X_axis is %d,y_axis is %d,Z_axis is %d\n\r", X,Y,Z);
     
205.          
     
206.                 printf("\n");
     
207.                 usleep(8);
     
208.         }
     
209.        
     
210. 
     
211.         return 0;
     
212. }
     

复制代码