LINUX 产生PPM 驱动例子

2022-11-14 15:51:28

APP：

  1. //author:DriverMonkey
  2. //phone:13410905075
  3. //mail:bookworepeng@Hotmail.com
  4. //qq:196568501
  5. #include<stdio.h>
  6. #include<string.h>
  7. #include<sys/types.h>
  8. #include<sys/stat.h>
  9. #include<fcntl.h>
  10. #include<unistd.h>
  11. #define US (1000)
  12. #define PPM_CHANEL 8
  13. #define FIX_LOW_TIME 100*US
  14. #define FIX_SYNC_TIME 5000
  15. static long long ppm_values[(PPM_CHANEL + 1)*2] =
  16. {FIX_LOW_TIME,1000*US,   // 1
  17. FIX_LOW_TIME,1000*US,    // 2
  18. FIX_LOW_TIME,1000*US,    // 3
  19. FIX_LOW_TIME,1000*US,    // 4
  20. FIX_LOW_TIME,1000*US,    // 5
  21. FIX_LOW_TIME,1000*US,    // 6
  22. FIX_LOW_TIME,1000*US,    // 7
  23. FIX_LOW_TIME,1000*US,    // 8
  24. FIX_LOW_TIME,FIX_SYNC_TIME*US, };    // 9
  25. int main(int argc,char *args[])
  26. {
  27. int fd;
  28. int channel = 0;
  29. long long value = 0;
  30. fd=open("/dev/ppm",O_WRONLY|O_CREAT,0640);
  31. if(fd < 0)
  32. return 0;
  33. if(argc > 3)
  34. return;
  35. channel = atol(args[1]);
  36. printf("input channle is: %d\n", channel);
  37. value  = atol(args[2]);
  38. printf("input value is: %d\n", (int)value );
  39. printf("old value is:%d\n",(int)ppm_values[channel*2 + 1]);
  40. ppm_values[channel*2 + 1] = value*US;
  41. printf("new value is:%d\n",(int)ppm_values[channel*2 + 1]);
  42. write(fd,ppm_values,sizeof(ppm_values));
  43. sleep(20);
  44. close(fd);
  45. }

Driver:

  1. //author:DriverMonkey
  2. //phone:13410905075
  3. //mail:bookworepeng@Hotmail.com
  4. //qq:196568501
  5. #include <linux/kernel.h>
  6. #include <linux/module.h>
  7. #include <linux/cdev.h>
  8. #include <linux/fs.h>
  9. #include <linux/device.h>
  10. #include <linux/syscalls.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/gpio.h>
  13. #include <linux/of_gpio.h>
  14. #include <linux/of_platform.h>
  15. #include <linux/uaccess.h>
  16. #include <linux/string.h>
  17. #include <mach/gpio.h>
  18. #include <mach/irqs.h>
  19. #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
  20. #define US (1000)
  21. #define PPM_CHANEL 8
  22. #define FIX_LOW_TIME 100*US
  23. struct ppm_dev
  24. {
  25. struct cdev cdev;
  26. dev_t devno;
  27. struct class *ppm_class;
  28. int message_cdev_open;
  29. };
  30. struct ppm_dev ppm_dev;
  31. static long long ppm_values[(PPM_CHANEL + 1)*2] =
  32. {FIX_LOW_TIME,1000*US,   // 1
  33. FIX_LOW_TIME,1000*US,    // 2
  34. FIX_LOW_TIME,1000*US,    // 3
  35. FIX_LOW_TIME,1000*US,    // 4
  36. FIX_LOW_TIME,1000*US,    // 5
  37. FIX_LOW_TIME,1000*US,    // 6
  38. FIX_LOW_TIME,1000*US,    // 7
  39. FIX_LOW_TIME,1000*US,    // 8
  40. FIX_LOW_TIME,5000*US, }; // 9
  41. ktime_t ktime;
  42. static struct hrtimer hr_timer;
  43. static enum hrtimer_restart hrtimer_callback(struct hrtimer *timer)
  44. {
  45. static int index = 0;
  46. static ktime_t ktime;
  47. if(index == ((PPM_CHANEL + 1)*2))
  48. index = 0;
  49. ktime.tv64 = ppm_values[index];
  50. hrtimer_forward(timer, timer->base->get_time(), ktime);
  51. index++;
  52. if(ktime.tv64 == FIX_LOW_TIME)
  53. gpio_direction_output(GPIO_TO_PIN(0,27), 0);
  54. else
  55. gpio_direction_output(GPIO_TO_PIN(0,27), 1);
  56. //printk("%d\n",(int)ktime.tv64);
  57. return HRTIMER_RESTART;
  58. }
  59. static int ppm_open(struct inode *node, struct file *fd)
  60. {
  61. int ret = 0;
  62. printk("ppm_open()++\n");
  63. ktime = ktime_set( 0, 200*1000);                   // 200us
  64. hrtimer_init( &hr_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL );
  65. hr_timer.function = &hrtimer_callback;
  66. hrtimer_start( &hr_timer, ktime, HRTIMER_MODE_REL );
  67. printk("ppm_open()--\n");
  68. return ret;
  69. }
  70. ssize_t ppm_write(struct file *pfile,
  71. const char __user *buffer,
  72. size_t size,
  73. loff_t *pnull)
  74. {
  75. printk("ppm_write()++\n");
  76. if(size != sizeof(ppm_values))
  77. return 0;
  78. copy_from_user(ppm_values, buffer, size);
  79. printk("ppm_write()--\n");
  80. return size;
  81. }
  82. static int ppm_fasync(int fd, struct file *filp, int mode)
  83. {
  84. printk("ppm_fasync()++\n");
  85. printk("ppm_fasync()--\n");
  86. return 0;
  87. }
  88. static int ppm_release(struct inode *node, struct file *fd)
  89. {
  90. printk("ppm_release()++\n");
  91. hrtimer_cancel(&hr_timer);
  92. printk("ppm_release()--\n");
  93. return 0;
  94. }
  95. struct file_operations meassage_operatons =
  96. {
  97. .owner = THIS_MODULE,
  98. .open = ppm_open,
  99. .write = ppm_write,
  100. .fasync = ppm_fasync,
  101. .release = ppm_release,
  102. };
  103. static int __init ppm_init(void)
  104. {
  105. struct ppm_dev * dev;
  106. int ret = 0;
  107. dev = &ppm_dev;
  108. alloc_chrdev_region(&dev->devno, 0, 1, "out_ppm");
  109. dev->ppm_class = class_create(THIS_MODULE, "ppm_class");
  110. if(IS_ERR(dev->ppm_class)) {
  111. printk(KERN_ERR"Err: failed in creating class./n");
  112. goto fail1;
  113. }
  114. device_create(dev->ppm_class, NULL, dev->devno, NULL, "ppm");
  115. //init irq
  116. ret = gpio_request(GPIO_TO_PIN(0,27), "ppm_inter");
  117. if(ret){
  118. printk(KERN_ERR"gpio_request() failed !\n");
  119. goto fail1;
  120. }
  121. ret = gpio_direction_output(GPIO_TO_PIN(0,27), 1);
  122. if(ret){
  123. printk(KERN_ERR"gpio_direction_input() failed !\n");
  124. goto fail2;
  125. }
  126. cdev_init(&dev->cdev, &meassage_operatons);
  127. cdev_add(&dev->cdev, dev->devno, 1);
  128. if(ret){
  129. printk(KERN_ERR"request_irq() failed ! %d\n", ret);
  130. goto fail2;
  131. }
  132. printk("ppm_to_app_init(void)--\n");
  133. return 0;
  134. fail2:
  135. gpio_free(GPIO_TO_PIN(0,27));
  136. fail1:
  137. device_destroy(dev->ppm_class, dev->devno);
  138. class_destroy(dev->ppm_class);
  139. cdev_del(&dev->cdev);
  140. unregister_chrdev_region(dev->devno, 1);
  141. return ret;
  142. }
  143. static void __exit ppm_exit(void)
  144. {
  145. struct ppm_dev *dev = &ppm_dev;
  146. // printk("ppm_to_app_exit(void)++\n");
  147. gpio_free(GPIO_TO_PIN(0,27));
  148. device_destroy(dev->ppm_class, dev->devno);
  149. class_destroy(dev->ppm_class);
  150. cdev_del(&dev->cdev);
  151. unregister_chrdev_region(dev->devno, 1);
  152. // printk("ppm_to_app_exit(void)--\n");
  153. }
  154. module_init(ppm_init);
  155. module_exit(ppm_exit);
  156. MODULE_LICENSE("GPL");
  157. MODULE_AUTHOR("Driver Monkey");
  158. MODULE_DESCRIPTION("Test ppm");
上一篇：CSS选择器之伪类选择器（交互）


下一篇：ResourceBundle （读取properties文件及中文乱码解决方法）