创客神器NanoPi
直播中

左宗棠

8年用户 31经验值
擅长:可编程逻辑
私信 关注
[经验]

【NanoPi M2试用体验】字符类按键源码

在上一贴成功点灯以后，笔者果断决定对代码进行修改，使其成为读取按键的程序。采用的是最笨的while循环查询的方法，希望对一起学习的新手们提供一定的借鉴，献丑了。
key.c:
  1. /*包含初始化宏定义的头文件,代码中的module_init和module_exit在此文件中*/
  2. #include
  3. /*包含初始化加载模块的头文件,代码中的MODULE_LICENSE在此头文件中*/
  4. #include
  5. /*三个字符设备函数*/
  6. #include
  7. /*MKDEV转换设备号数据类型的宏定义*/
  8. #include
  9. /*定义字符设备的结构体*/
  10. #include
  11. /*分配内存空间函数头文件*/
  12. #include
  13. /*包含函数device_create 结构体class等头文件*/
  14. #include

  16. #include //copy_to_user要包含这个
  17. #include
  18. #include //包含prink等函数
  19. #include //与c++相关的东西
  20. #include //Linux中申请GPIO的头文件
  21. /*自定义头文件*/
  22. #include "key.h"

  24. #include //不同平台使用的文件
  25. #include


  28. MODULE_LICENSE("Dual BSD/GPL");
  29. /*声明是开源的，没有内核版本限制*/
  30. MODULE_AUTHOR("XIE");
  31. /*声明作者*/

  33. static int key_gpios[] = {
  34.         PAD_GPIO_C + 11,
  35. };
  36. #define KEY_NUM                ARRAY_SIZE(key_gpios)


  39. int numdev_major = DEV_MAJOR;
  40. int numdev_minor = DEV_MINOR;

  42. static struct class *myclass;
  43. struct reg_dev *my_devices;

  45. /*打开操作*/
  46. static int chardevnode_open(struct inode *inode, struct file *file){
  47.         printk(KERN_EMERG "chardevnode_open is success!n");
  48.        
  49.         return 0;
  50. }
  51. /*关闭操作*/
  52. static int chardevnode_release(struct inode *inode, struct file *file){
  53.         printk(KERN_EMERG "chardevnode_release is success!n");
  54.        
  55.         return 0;
  56. }
  57. /*IO操作*/
  58. static long chardevnode_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
  59.         return 0;
  60. }

  62. ssize_t chardevnode_read(struct file *file, char __user *buf, size_t count, loff_t *f_ops){
  63.         unsigned long key_val[KEY_NUM];
  64.         int i;
  65.         for(i = 0; i < KEY_NUM; i++){
  66.                 key_val[i] = gpio_get_value(key_gpios[i]);
  67.         }
  68.         /* 读出值后，将数据传给应用程序 */
  69.         copy_to_user(buf, key_val, sizeof(key_val));

  71.         return sizeof(key_val);
  72. }

  74. ssize_t chardevnode_write(struct file *file, const char __user *buf, size_t count, loff_t *f_ops){
  75.         return 0;
  76. }

  78. loff_t chardevnode_llseek(struct file *file, loff_t offset, int ence){
  79.         return 0;
  80. }
  81. struct file_operations my_fops = {
  82.         .owner = THIS_MODULE,
  83.         .open = chardevnode_open,
  84.         .release = chardevnode_release,
  85.         .unlocked_ioctl = chardevnode_ioctl,
  86.         .read = chardevnode_read,
  87.         .write = chardevnode_write,
  88.         .llseek = chardevnode_llseek,
  89. };


  92. /*设备注册到系统*/
  93. static void reg_init_cdev(struct reg_dev *dev,int index){
  94.         int err;
  95.         int devno = MKDEV(numdev_major,numdev_minor+index);

  97.         /*数据初始化*/
  98.         cdev_init(&dev->cdev,&my_fops);
  99.         dev->cdev.owner = THIS_MODULE;
  100.        
  101.        
  102.         /*注册到系统*/
  103.         err = cdev_add(&dev->cdev,devno,1);
  104.         if(err){
  105.                 printk(KERN_EMERG "cdev_add %d is fail! %dn",index,err);
  106.         }
  107.         else{
  108.                 printk(KERN_EMERG "cdev_add %d is success!n",numdev_minor+index);
  109.         }
  110. }

  112. static int gpio_init(void){
  113.         int i=0,ret;
  114.        
  115.         for(i=0;i
  116.                 ret = gpio_request(key_gpios[i], "KEY");
  117.                 if (ret) {
  118.                         printk("%s: request GPIO %d for KEY failed, ret = %dn", DEVICE_NAME,i,ret);
  119.                         return -1;
  120.                 }
  121.                 else{
  122.                         gpio_direction_output(key_gpios[i], 1);                       
  123.                 }
  124.         }
  125.        
  126.         return 0;
  127. }


  130. static int scdev_init(void)
  131. {
  132.         int ret = 0,i;
  133.         dev_t num_dev;
  134.        
  135.        
  136.         printk(KERN_EMERG "numdev_major is %d!n",numdev_major);//主设备号
  137.         printk(KERN_EMERG "numdev_minor is %d!n",numdev_minor);//次设备号
  138.        
  139.         if(numdev_major){
  140.                 num_dev = MKDEV(numdev_major,numdev_minor);//生成设备号
  141.                 ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NAME);//向系统申请设备号（已知设备号）
  142.         }
  143.         else{
  144.                 /*动态注册设备号*/
  145.                 ret = alloc_chrdev_region(&num_dev,numdev_minor,DEVICE_MINOR_NUM,DEVICE_NAME);//向系统申请设备号（动态申请）
  146.                 /*获得主设备号*/
  147.                 numdev_major = MAJOR(num_dev);
  148.                 printk(KERN_EMERG "adev_region req %d !n",numdev_major);
  149.         }
  150.         if(ret<0){
  151.                 printk(KERN_EMERG "register_chrdev_region req %d is failed!n",numdev_major);               
  152.         }
  153.         myclass = class_create(THIS_MODULE,DEVICE_NAME);//创建设备类别文件
  154.        
  155.        
  156.         my_devices = kmalloc(DEVICE_MINOR_NUM * sizeof(struct reg_dev),GFP_KERNEL);//分配内存
  157.         if(!my_devices){
  158.                 ret = -ENOMEM;
  159.                 goto fail;
  160.         }
  161.         memset(my_devices,0,DEVICE_MINOR_NUM * sizeof(struct reg_dev));//将s中前n个字节用 ch 替换并返回 s 。
  162.        
  163.         /*设备初始化*/
  164.         for(i=0;i
  165.                 my_devices[i].data = kmalloc(REGDEV_SIZE,GFP_KERNEL);//GFP_KERNEL是一个宏，分配内核空间
  166.                 memset(my_devices[i].data,0,REGDEV_SIZE);
  167.                 /*设备注册到系统*/
  168.                 reg_init_cdev(&my_devices[i],i);
  169.                
  170.                 /*创建设备节点*/
  171.                 device_create(myclass,NULL,MKDEV(numdev_major,numdev_minor+i),NULL,DEVICE_NAME"%d",i);
  172.         }
  173.        
  174.         ret = gpio_init();
  175.         if(ret){
  176.                 printk(KERN_EMERG "gpio_init failed!n");
  177.         }       
  178.                
  179.         printk(KERN_EMERG "scdev_init!n");
  180.         /*打印信息，KERN_EMERG表示紧急信息*/
  181.         return 0;

  183. fail:
  184.         /*注销设备号*/
  185.         unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
  186.         printk(KERN_EMERG "kmalloc is fail!n");
  187.        
  188.         return ret;
  189. }

  191. static void scdev_exit(void)
  192. {
  193.         int i;
  194.         printk(KERN_EMERG "scdev_exit!n");
  195.        
  196.         /*除去字符设备*/
  197.         for(i=0;i
  198.                 cdev_del(&(my_devices[i].cdev));//这个函数会干掉cdev_map 散列表及dev本身
  199.                 /*摧毁设备节点函数d*/
  200.                 device_destroy(myclass,MKDEV(numdev_major,numdev_minor+i));
  201.         }
  202.         /*释放设备class*/
  203.         class_destroy(myclass);
  204.         /*释放内存*/
  205.         kfree(my_devices);
  206.        
  207.         /*释放GPIO*/
  208.         for(i=0;i
  209.                 gpio_free(key_gpios[i]);
  210.         }
  211.         //释放设备号       
  212.         unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
  213. }


  216. module_init(scdev_init);
  217. /*初始化函数*/
  218. module_exit(scdev_exit);
  219. /*卸载函数*/
key.h:
  1. #ifndef _CHAR_DRIVER_LEDS_H_
  2. #define _CHAR_DRIVER_LEDS_H_

  4. #ifndef DEVICE_NAME
  5. #define DEVICE_NAME "charGPIO"
  6. #endif

  8. #ifndef DEVICE_MINOR_NUM
  9. #define DEVICE_MINOR_NUM 1
  10. #endif

  12. #ifndef DEV_MAJOR
  13. #define DEV_MAJOR 0
  14. #endif

  16. #ifndef DEV_MINOR
  17. #define DEV_MINOR 0
  18. #endif

  20. #ifndef REGDEV_SIZE
  21. #define REGDEV_SIZE 3000
  22. #endif

  24. struct reg_dev
  25. {
  26.         char *data;
  27.         // unsigned long size;
  28.         struct cdev cdev;
  29. };
  30. #endif
key_test.c:
  1. #include
  2. #include
  3. #include //各种系统api如read，write,sleep
  4. #include

  6. int main()
  7. {
  8.         int fd,i;
  9.         unsigned long key_val[1];
  10.         char *lednode = "/dev/charGPIO0";

  12.         /*O_RDWR只读打开,O_NDELAY非阻塞方式*/       
  13.         if((fd = open(lednode,O_RDWR|O_NDELAY))<0){
  14.                 printf("APP open %s failed!n",lednode);
  15.         }
  16.         else
  17.                 printf("APP open %s success!n",lednode);
  18.         while(1)
  19.         {
  20.                 read(fd,key_val,sizeof(key_val));
  21.                 if(key_val[0] == 0)
  22.                         printf("button0 is setn");
  23.                 else
  24.                         printf("waiting button0n");
  25.                 sleep(1);
  26.         }
  27.        
  28.        
  29.         close(fd);
  30.         return 0;
  31. }
以上，由于是笔者是新手所以难免有疏漏或者不足，敬请各路大神指教咯

更多回帖

0 0 0

相关帖子

发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分