pcDuino Linux驱动开发六 -- 最简单的LRADC驱动

tjcfeng

    先来说一下A10的ADC。A10的ADC共有两种，一种是LRADC，另一种是TPController。
    LARADC，是一种低分辨率的模数转换器，按照用途A10常把它当作按键检测的通道，可以检测长按、短按、按下、抬起等动作，最高电压可以支持到2V，有些低了。
    TPController一般用来检测触摸屏的控制，根据电压的变化获取坐标。玩过单片机+显示屏的应该都很熟悉，这个功能被集成到A10中了。TPController最大可以支持到5V。

    这次主要试验一下LRADC，对于TPController就不多说了。

    LRADC很简单，简单到所有的寄存器参数都使用默认值，只要控制一下启动就可以了，甚至比IO口都要简单。当然，它也有许多功能，为了简单起见先不考虑。

    本来按照手册说明LRADC可以检测按键的状态，但是还要接按键、电阻，还得动烙铁，有点麻烦；也想过接个光敏电阻，同样还是要找块板子来焊件连线，所以干脆用个最简单的办法，直接测试电池吧。

接线方式：

灰线接地，绿线接到ADC0口。

另一边（忽略蓝线和紫线，没接）：

灰线接电池的负极，绿线接正极。

好了，下面开始写程序：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/cdev.h>
   
5. #include <linux/device.h>
   
6. #include <linux/wait.h>
   
7. #include <linux/delay.h>
   
8. #include <asm/io.h>
   
9. #include <asm/uaccess.h>
   
10. 
    
11. #include <linux/kthread.h>
    
12. #include <linux/sched.h>
    
13. #include <linux/err.h>
    
14. 
    
15. #include "../A10.h"
    
16. 
    
17.         static uint8_t ADC[2];
    
18.         
    
19. /**********************************************************************/
    
20.         volatile static unsigned long* REG_LRADC_CTRL;
    
21.         volatile static unsigned long* REG_LRADC_INTC;
    
22.         volatile static unsigned long* REG_LRADC_INTS;
    
23.         volatile static unsigned long* REG_LRADC_DATA0;
    
24.         
    
25.         static struct task_struct* pThread;
    
26.         static int Inited = 0;
    
27.         
    
28. int LRADC_thread(void* Data)
    
29. {
    
30.         while (1)
    
31.         {
    
32.                 set_current_state(TASK_UNINTERRUPTIBLE);
    
33.                 if (kthread_should_stop()) break;
    
34.                
    
35.                 *REG_LRADC_CTRL |= (0x1 << 0); //LRADC Enable
    
36.                 while (!(*REG_LRADC_INTS & 0x1)) mdelay(1); //Waitting INT
    
37.                 ADC[0] = *REG_LRADC_DATA0;
    
38.                
    
39.                 printk("ADC0: %d\n", ADC[0]);
    
40.                 *REG_LRADC_INTS |= (0x1 << 0); //Clear Pending
    
41.                
    
42.                 schedule_timeout(100);
    
43.         }
    
44.         
    
45.         return 0;
    
46. }
    
47. 
    
48. static int LRADC_open(struct inode* n, struct file* f)
    
49. {
    
50.         int Result = 0;
    
51. 
    
52.         Inited++;
    
53.         if (Inited > 1)
    
54.         {
    
55.                 return 0;
    
56.         }
    
57. 
    
58.         REG_LRADC_CTRL = (volatile unsigned long*) ioremap(LRADC_CTRL, 4);
    
59.         REG_LRADC_INTC = (volatile unsigned long*) ioremap(LRADC_INTC, 4);
    
60.         REG_LRADC_INTS = (volatile unsigned long*) ioremap(LRADC_INTS, 4);
    
61.         REG_LRADC_DATA0= (volatile unsigned long*) ioremap(LRADC_DATA0, 4);
    
62.         
    
63.         *REG_LRADC_INTC |= (0x1 << 0); //ADC0 IRQ Enable
    
64.         
    
65.         pThread = kthread_create(LRADC_thread, NULL, "GY80");
    
66.         if (IS_ERR(pThread))
    
67.         {
    
68.                 pThread = NULL;
    
69.                 printk("Create Thread Error!");
    
70.                 return -1;
    
71.         }
    
72.         wake_up_process(pThread);
    
73. 
    
74.         printk("Open Finished!\n");
    
75.         return Result;
    
76. }
    
77. 
    
78. static ssize_t LRADC_write(struct file* f, const char __user* buf, size_t len, loff_t* l)
    
79. {
    
80.         //printk("Write Finished!\n");
    
81.         return 0;
    
82. }
    
83. 
    
84. static ssize_t LRADC_read(struct file* f, char __user* buf, size_t len, loff_t* l)
    
85. {
    
86.         //printk("Read Finished!\n");
    
87.         return 0;
    
88. }
    
89. 
    
90. static int LRADC_close(struct inode* n, struct file* f)
    
91. {
    
92.         Inited--;
    
93.         if (Inited > 0)
    
94.         {
    
95.                 return 0;
    
96.         }
    
97. 
    
98.         kthread_stop(pThread);
    
99.         pThread = NULL;
    
100. 
     
101.         *REG_LRADC_CTRL &= ~(0x1 << 0); //LRADC Disable
     
102.         
     
103.         iounmap(REG_LRADC_CTRL);
     
104.         iounmap(REG_LRADC_INTC);
     
105.         iounmap(REG_LRADC_INTS);
     
106.         iounmap(REG_LRADC_DATA0);
     
107. 
     
108.         printk("Close Finished!\n");
     
109.         return 0;
     
110. }
     
111. 
     
112. /**********************************************************************/
     
113.         #define DEV_NAME        "LRADC"
     
114.         #define DEV_COUNT        1
     
115. 
     
116.         static struct class* pClass;
     
117.         int major;
     
118.         
     
119.         static struct file_operations fops =
     
120.         {
     
121.                 .owner = THIS_MODULE,
     
122.                 .open = LRADC_open,
     
123.                 .write = LRADC_write,
     
124.                 .read = LRADC_read,
     
125.                 .release = LRADC_close,
     
126.         };
     
127. 
     
128. static int __init LRADC_init(void)
     
129. {
     
130.         major = register_chrdev(0, DEV_NAME, &fops);
     
131.         pClass = class_create(THIS_MODULE, DEV_NAME);
     
132.         if (pClass == NULL)
     
133.         {
     
134.                 unregister_chrdev(major, DEV_NAME);
     
135.                 return -1;
     
136.         }
     
137.         device_create(pClass, NULL, MKDEV(major, 0),  NULL, DEV_NAME);
     
138.         
     
139.         LRADC_open(NULL, NULL);
     
140.         //printk("Init Finished!\n");
     
141. 
     
142.         return 0;
     
143. }
     
144. 
     
145. static void __exit LRADC_exit(void)
     
146. {
     
147.         LRADC_close(NULL, NULL);
     
148.         
     
149.         unregister_chrdev(major, DEV_NAME);
     
150.         if (pClass)
     
151.         {
     
152.                 device_destroy(pClass, MKDEV(major, 0));
     
153.                 class_destroy(pClass);
     
154.         }
     
155.         //printk("Exit Finished!\n");
     
156. }
     
157. 
     
158. MODULE_LICENSE("GPL");
     
159. MODULE_AUTHOR("LiuYang");
     
160. module_init(LRADC_init);
     
161. module_exit(LRADC_exit);
     

复制代码

程序没什么好说的，还是为了简单，用了一个线程让它去循环检测。也可以不使用线程放到write、read里控制检测和获取值，看自己的需要了。

看一下输出结果：


由于是用手捏着线和电池，所以有时会有些虚。等读数正常了，可以看到数据是39。
39是多少伏呢？ LRADC是6位，也就是0~63， 计算的话就是 ((39 + 1) / 64) * 2V = 1.25V

这个结果对吗？还是用表来看一下吧：



最后再次感谢爱板网和各位版主管理员以及大家的支持，申请BananaPI试用通过，所以最近几天准备学习下香蕉派，pcDuino先放一放。不过都是全志的东西，寄存器相差不大，后面写笔记会将两种板子合在一起。如果帖子中有错误的地方还请大家多多指教，谢谢！

shuffelin

樓主好厲害~學習中~~幫頂一下！！

奋斗哥

学习，帮顶！

tjcfeng

感谢楼上两位

qswhb

jameswang

多谢楼主分享

haothree

学习学习