Chinaunix首页 | 论坛 | 博客

Star-Nightghost4embedded.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

ap0405209

  • 博客访问： 1760295
  • 博文数量： 1493
  • 博客积分： 38
  • 博客等级： 民兵
  • 技术积分： 5834
  • 用 户 组： 普通用户
  • 注册时间： 2009-08-19 17:28
文章分类

全部博文（1493）

文章存档

2016年（11）

2015年（38）

2014年（137）

2013年（253）

2012年（1054）

2011年（1）

我的朋友
最近访客
推荐博文
android下调试光感、温度、气压计(驱动篇)

分类：

2012-07-12 08:51:51

原文地址：android下调试光感、温度、气压计(驱动篇) 作者：huabinbin00

前一段时间刚好要调试几个sensors，最开始手头上啥代码也没有，最后花了几天的时间熟悉了这一块，最
后感觉sensors相对其他的模块还是要简单的多！
 
第一步：
     完成相关驱动的编写，这里最开始我挺犹豫的，我驱动的数据如何上报？？通过ioctl？？我不想那么麻烦，最好在网上找到一个关于用input机制上报对应的值，这样就简单多了，先贴下代码

点击(此处)折叠或打开

  1. #include <linux/platform_device.h>
  2. #include <linux/input-polldev.h>
  3. #include <linux/kernel.h>
  4. #include <linux/module.h>
  5. #include <mach/adc.h>
  6. //#include <linux/saradc.h>

  8. #define POLL_INTERVAL    2000     /* poll for input every 2s*/
  9. #define LUX_LEVEL    4                    /* 0~4 report 5 levels*/

  11. static struct platform_device *pdev;
  12. static struct input_dev *idev;
  13. static struct input_polled_dev *light_sensor_idev;



  17. static const int sAdcValues[LUX_LEVEL] = {
  18.     200,
  19.       1000,
  20.     1800,
  21.     3400,
  22. };

  24. struct light_sensor_info {
  25.     int lux_level;
  26.     int suspend;
  27. };
  28. static struct light_sensor_info ls_info;

  30. /* Sysfs Files */
  31. static ssize_t light_sensor_lux_level_show(struct device *dev,
  32.                  struct device_attribute *attr, char *buf)
  33. {
  34.     return sprintf(buf, "(%d)\n",get_s3c_adc_convert(3));
  35. }

  37. static DEVICE_ATTR(lux_level, 0444, light_sensor_lux_level_show, NULL);

  39. static struct attribute *light_sensor_attributes[] = {
  40.     &dev_attr_lux_level.attr,
  41.     NULL,
  42. };

  44. static struct attribute_group light_sensor_attribute_group = {
  45.     .attrs = light_sensor_attributes,
  46. };


  49. /* Device model stuff */
  50. static int light_sensor_probe(struct platform_device *dev)
  51. {
  52.     printk(KERN_INFO "light_sensor: device successfully initialized.\n");
  53.     return 0;
  54. }

  56. #ifdef CONFIG_PM
  57. static int light_sensor_suspend(struct platform_device *dev, pm_message_t state)
  58. {
  59.         ls_info.suspend = 1;
  60.     return 0;
  61. }

  63. static int light_sensor_resume(struct platform_device *dev)
  64. {
  65.         ls_info.suspend = 0;
  66.     return 0;
  67. }
  68. #else
  69.     #define light_sensor_suspend NULL
  70.     #define light_sensor_resume NULL
  71. #endif

  73. static struct platform_driver light_sensor_driver = {
  74.     .probe = light_sensor_probe,
  75.     .resume = light_sensor_resume,
  76.     .suspend = light_sensor_suspend,
  77.     .driver    = {
  78.         .name = "light_sensor",
  79.         .owner = THIS_MODULE,
  80.     },
  81. };

  83. static void light_sensor_dev_poll(struct input_polled_dev *dev)
  84. {
  85.         int adc_val, i;

  87.     adc_val = get_s3c_adc_convert(3);
  88.     for(i = 0; i < LUX_LEVEL; i++) {
  89.         if(adc_val < sAdcValues[i])
  90.             break;
  91.     }

  93.    
  94.     
  95.     if(ls_info.lux_level != i) {
  96.         ls_info.lux_level = i;    
  97.         input_report_abs(idev, ABS_X, ls_info.lux_level);
  98.         input_sync(idev);
  99.         
  100.     }    

  102. }

  104. /* Module stuff */
  105. static int __init light_sensor_init(void)
  106. {
  107.     
  108.     int ret;

  110.     ret = platform_driver_register(&light_sensor_driver);
  111.     if (ret)
  112.         goto out;

  114.     pdev = platform_device_register_simple("light_sensor", -1, NULL, 0);
  115.     if (IS_ERR(pdev)) {
  116.         ret = PTR_ERR(pdev);
  117.         goto out_driver;
  118.     }

  120.     ret = sysfs_create_group(&pdev->dev.kobj, &light_sensor_attribute_group);
  121.     if (ret)
  122.         goto out_device;

  124.     light_sensor_idev = input_allocate_polled_device();
  125.     if (!light_sensor_idev) {
  126.         ret = -ENOMEM;
  127.         goto out_group;
  128.     }

  130.     light_sensor_idev->poll = light_sensor_dev_poll;//在hal层成功打开的时候会开始轮询
  131.     light_sensor_idev->poll_interval = POLL_INTERVAL;

  133.     /* initialize the input class */
  134.     idev = light_sensor_idev->input;
  135.     idev->name = "light_sensor";//这个名字到时和你hal写的name必须一致
  136.     idev->phys = "light_sensor/input0";
  137.     idev->id.bustype = BUS_ISA;
  138.     idev->dev.parent = &pdev->dev;
  139.     idev->evbit[0] = BIT_MASK(EV_ABS);
  140.     input_set_abs_params(idev, ABS_X,
  141.             0, LUX_LEVEL, 0, 1);

  143.     ret = input_register_polled_device(light_sensor_idev);
  144.     if (ret)
  145.         goto out_idev;

  147.     
  148.     printk(KERN_INFO "huabinbin test light_sensor: driver successfully loaded.\n");
  149.     return 0;

  151. out_idev:
  152.     input_free_polled_device(light_sensor_idev);
  153. out_group:
  154.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
  155. out_device:
  156.     platform_device_unregister(pdev);
  157. out_driver:
  158.     platform_driver_unregister(&light_sensor_driver);
  159. out:
  160.     printk(KERN_WARNING "light_sensor: driver init failed (ret=%d)!\n", ret);
  161.     return ret;
  162. }

  164. static void __exit light_sensor_exit(void)
  165. {
  166.     input_unregister_polled_device(light_sensor_idev);
  167.     input_free_polled_device(light_sensor_idev);
  168.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
  169.     platform_device_unregister(pdev);
  170.     platform_driver_unregister(&light_sensor_driver);    

  172.     printk(KERN_INFO "light_sensor: driver unloaded.\n");
  173. }

  175. module_init(light_sensor_init);
  176. module_exit(light_sensor_exit);

 

经过实际测试，上面的代码有严重的问题，具体代码更新如下：

点击(此处)折叠或打开

  1. #include <linux/platform_device.h>
  2. #include <linux/input-polldev.h>
  3. #include <linux/kernel.h>
  4. #include <linux/module.h>
  5. #include <mach/adc.h>
  6. #include <linux/kthread.h>
  7. #include <linux/delay.h>
  8. //#include <linux/saradc.h>

  10. #define POLL_INTERVAL    993     /* poll for input every 2s*/
  11. #define LUX_LEVEL    3            /* 0~4 report 5 levels*/
  12. #define LUX_MAX 3300

  14. static struct platform_device *pdev;
  15. static struct input_dev *idev;
  16. static struct input_polled_dev *light_sensor_idev;
  17. static int32_t enable_als(uint32_t enable);
  18. static struct completion thread_completion;
  19. static bool bThreadRunning;
  20. /*define for polling thread*/
  21. static int polling_function(void* arg);
  22. static struct task_struct *polling_tsk;

  24. static const int sAdcValues[LUX_LEVEL] = {
  25.     200,
  26.       1000,
  27.     2300,
  28.     3400,
  29. };

  31. #define SAMPLE_NUM 10

  33. static int Sample_value[SAMPLE_NUM];

  35. struct light_sensor_info {
  36.     int lux_level;
  37.     int suspend;
  38. };
  39. static struct light_sensor_info ls_info;

  41. /* Sysfs Files */
  42. static ssize_t light_sensor_enable_show(struct device *dev,
  43.                  struct device_attribute *attr, char *buf)
  44. {
  45.     //return sprintf(buf, "(%d)\n",get_s3c_adc_convert(3));
  46.     return sprintf(buf, "%d\n", bThreadRunning);
  47. }

  49. static ssize_t light_sensor_enable_store(struct device *dev,
  50.                  struct device_attribute *attr, char *buf,size_t len)
  51. {
  52.     uint32_t value = simple_strtoul(buf, NULL, 10);
  53.    printk("huabinbin test : Enable LS : %d\n",value);
  54.     enable_als(value);
  55.     return len;
  56. }

  58. static DEVICE_ATTR(ls_enable, 0666, light_sensor_enable_show, light_sensor_enable_store);

  60. static struct attribute *light_sensor_attributes[] = {
  61.     &dev_attr_ls_enable.attr,
  62.     NULL,
  63. };

  65. static struct attribute_group light_sensor_attribute_group = {
  66.     .attrs = light_sensor_attributes,
  67. };

  69. static void sample_vol(unsigned int vol)
  70. {
  71.     int i = 0;

  73.     for(i = 0; i < SAMPLE_NUM -1; i++)
  74.     Sample_value[i] = Sample_value[i+1];
  75.     Sample_value[SAMPLE_NUM - 1]=vol;
  76.     return;
  77. }

  79. static int get_lux_average()
  80. {
  81.     int i,sum = 0;

  83.     for(i = 0; i < SAMPLE_NUM-1; i++)
  84.         sum += Sample_value[i];

  86.     //printk("hbb test %s adc_val = %d\n",__func__,sum / SAMPLE_NUM);
  87.     return (sum / SAMPLE_NUM);
  88. }

  90. static int polling_function(void* arg)
  91. {
  92.     int adc_val, i;
  93.     init_completion(&thread_completion);

  95.     while (1)
  96.     {
  97.         adc_val = get_s3c_adc_convert(3);
  98.         //printk("hbb test %s adc_val = %d\n",__func__,adc_val);
  99.         sample_vol(adc_val);
  100.         #if 0
  101.         
  102.         for(i = 0; i <= LUX_LEVEL; i++) {
  103.             if(adc_val < sAdcValues[i])
  104.                 break;
  105.         }

  107.         if(ls_info.lux_level != i) {
  108.             ls_info.lux_level = i;    
  109.             //input_report_abs(idev, ABS_X, ls_info.lux_level);
  110.             input_report_abs(idev, ABS_MISC, ls_info.lux_level);
  111.             input_sync(idev);
  112.             
  113.             printk(KERN_INFO "light_sensor: light_sensor_dev_poll lux_level = %d\n",sAdcValues[ls_info.lux_level]);
  114.         }    
  115.         #else
  116.         input_report_abs(idev, ABS_MISC,get_lux_average());
  117.         input_sync(idev);
  118.         #endif
  119.         if (bThreadRunning == false)
  120.             break;
  121.         msleep(POLL_INTERVAL);

  123.     };
  124.     complete(&thread_completion);
  125.     return 0;
  126. }

  128. static int32_t enable_als(uint32_t enable)
  129. {
  130.     int32_t ret;
  131.     if (enable)
  132.     {

  134.         if (bThreadRunning == 0)
  135.         {
  136.             bThreadRunning = 1;
  137.             polling_tsk = kthread_run(polling_function,NULL,"ls_polling");
  138.         }
  139.         else
  140.         {
  141.          printk("huabinbin test : thread has running\n");
  142.         }
  143.     }
  144.     else
  145.     {
  146.         if (bThreadRunning)
  147.         {
  148.             bThreadRunning = false;
  149.             wait_for_completion(&thread_completion);
  150.             polling_tsk = NULL;
  151.         }
  152.     }
  153.     return ret;
  154. }

  156. /* Device model stuff */
  157. static int light_sensor_probe(struct platform_device *dev)
  158. {
  159.     printk(KERN_INFO "light_sensor: device successfully initialized.\n");
  160.     return 0;
  161. }

  163. #ifdef CONFIG_PM
  164. static int light_sensor_suspend(struct platform_device *dev, pm_message_t state)
  165. {
  166.         ls_info.suspend = 1;
  167.     return 0;
  168. }

  170. static int light_sensor_resume(struct platform_device *dev)
  171. {
  172.         ls_info.suspend = 0;
  173.     return 0;
  174. }
  175. #else
  176.     #define light_sensor_suspend NULL
  177.     #define light_sensor_resume NULL
  178. #endif

  180. static struct platform_driver light_sensor_driver = {
  181.     .probe = light_sensor_probe,
  182.     .resume = light_sensor_resume,
  183.     .suspend = light_sensor_suspend,
  184.     .driver    = {
  185.         .name = "light_sensor",
  186.         .owner = THIS_MODULE,
  187.     },
  188. };

  190. static void light_sensor_dev_poll(struct input_polled_dev *dev)
  191. {
  192.     //printk("huabinbin test light_sensor_dev_poll get adc %d\n",get_s3c_adc_convert(3));
  193.     int adc_val, i;

  195.     adc_val = get_s3c_adc_convert(3);
  196.     for(i = 0; i < LUX_LEVEL; i++) {
  197.         if(adc_val < sAdcValues[i])
  198.             break;
  199.     }

  201.     //printk("huabinbin test get adc %d\n",get_s3c_adc_convert(3));
  202.     
  203.     if(ls_info.lux_level != i) {
  204.         ls_info.lux_level = i;    
  205.         input_report_abs(idev, ABS_X, ls_info.lux_level);
  206.         input_sync(idev);
  207.         
  208.         //printk(KERN_INFO "light_sensor: light_sensor_dev_poll lux_level = %d\n",sAdcValues[ls_info.lux_level]);
  209.     }    

  211. }

  213. /* Module stuff */
  214. static int __init light_sensor_init(void)
  215. {
  216.     
  217.     int ret;

  219.     ret = platform_driver_register(&light_sensor_driver);
  220.     if (ret)
  221.         goto out;

  223.     pdev = platform_device_register_simple("light_sensor", -1, NULL, 0);
  224.     if (IS_ERR(pdev)) {
  225.         ret = PTR_ERR(pdev);
  226.         goto out_driver;
  227.     }

  229.     ret = sysfs_create_group(&pdev->dev.kobj, &light_sensor_attribute_group);
  230.     if (ret)
  231.         goto out_device;

  233. //    light_sensor_idev = input_allocate_polled_device();
  234. //    if (!light_sensor_idev) {
  235.     //    ret = -ENOMEM;
  236.     //    goto out_group;
  237.     //}

  239.     bThreadRunning = false;
  240.     
  241.     //light_sensor_idev->poll = light_sensor_dev_poll;
  242.     //light_sensor_idev->poll_interval = POLL_INTERVAL;

  244.     /* initialize the input class */
  245.     //idev = light_sensor_idev->input;
  246.     idev = input_allocate_device();
  247.     idev->name = "light_sensor";
  248.     idev->phys = "light_sensor/input0";
  249.     idev->id.bustype = BUS_ISA;
  250.     idev->dev.parent = &pdev->dev;
  251.     idev->evbit[0] = BIT_MASK(EV_ABS);
  252.     //input_set_abs_params(idev, ABS_MISC,0, LUX_LEVEL, 0, 1);
  253.     input_set_abs_params(idev, ABS_MISC,0, LUX_MAX, 0, 1);

  255.     ret = input_register_device(idev);
  256.     if (ret)
  257.         goto out_idev;

  259.     
  260.     printk(KERN_INFO "huabinbin test light_sensor: driver successfully loaded.\n");
  261.     return 0;

  263. out_idev:
  264.      input_free_device(idev);
  265. out_group:
  266.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
  267. out_device:
  268.     platform_device_unregister(pdev);
  269. out_driver:
  270.     platform_driver_unregister(&light_sensor_driver);
  271. out:
  272.     printk(KERN_WARNING "light_sensor: driver init failed (ret=%d)!\n", ret);
  273.     return ret;
  274. }

  276. static void __exit light_sensor_exit(void)
  277. {
  278.     input_unregister_polled_device(light_sensor_idev);
  279.     input_free_polled_device(light_sensor_idev);
  280.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
  281.     platform_device_unregister(pdev);
  282.     platform_driver_unregister(&light_sensor_driver);    

  284.     printk(KERN_INFO "light_sensor: driver unloaded.\n");
  285. }

  287. module_init(light_sensor_init);
  288. module_exit(light_sensor_exit);

  290. MODULE_AUTHOR("bb.hua@unistrong.com");
  291. MODULE_DESCRIPTION("Light Sensor Driver - po188");
  292. MODULE_LICENSE("GPL");


 

阅读(242) | 评论(0) | 转发(0) |
0

上一篇：Linux下高并发socket最大连接数

下一篇：linux终端中输出彩色字体(C/SHELL)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6