• 驱动开发，使用数码管显示采集的温湿度的值（取整）

    1.IIC驱动层次图（同SPI）

            前提：将核心层和总线驱动层配置进内核；

            先完成设备驱动和i2c总线驱动的绑定，让总线驱动管理到设备驱动，调用核心层API即可完成绑定，然后i2c总线驱动完成设备驱动和si7006的匹配， 最后设备驱动通过IIC控制器完成si7006设备的温湿度的采集，最后将采集的温湿度显示在数码管上；

    2.代码

    ---head.h---头文件
    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3.  
    4. #define GET_HUM _IOR('m',1,int)  //获取湿度的功能码
    5. #define GET_TEM _IOR('m',0,int)  //获取温度的功能码
    6. #define GET_TH _IOR('m',2,int)//获取数码管的功能码
    7. #endif
    ---si7006.c---温湿度驱动文件
    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/i2c.h>
    4. #include <linux/fs.h>
    5. #include <linux/uaccess.h>
    6. #include <linux/device.h>
    7. #include "head.h"
    8.  
    9. unsigned int major;
    10. struct class *cls;
    11. struct device *dev;
    12. struct i2c_client *client1;
    13.  
    14. // 封装函数读取温度和湿度
    15. int read_hum_tem(char reg)
    16. {
    17.     // 封装传输的消息
    18.     char r_buf[] = {reg};
    19.     short value;
    20.     struct i2c_msg r_msg[] = {
    21.         [0] = {
    22.             .addr = client1->addr,
    23.             .flags = 0,
    24.             .len = sizeof(r_buf),
    25.             .buf = r_buf,
    26.         },
    27.         [1] = {
    28.             .addr = client1->addr,
    29.             .flags = 1,
    30.             .len = 2,
    31.             .buf = (char *)&value,
    32.         },
    33.     };
    34.  
    35.     // 传输消息
    36.     int ret = i2c_transfer(client1->adapter, r_msg, 2);
    37.     if (ret != 2)
    38.     {
    39.         printk("传输消息失败\n");
    40.         return -EIO;
    41.     }
    42.     return value;
    43. }
    44.  
    45. // 封装操作方法
    46. int si7006_open(struct inode *inode, struct file *file)
    47. {
    48.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    49.     return 0;
    50. }
    51.  
    52. long si7006_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    53. {
    54.     int tem, hum;
    55.     int ret;
    56.     switch (cmd)
    57.     {
    58.     case GET_HUM: // 读取湿度
    59.         hum = read_hum_tem(0xE5);
    60.         ret = copy_to_user((void *)arg, &hum, 4);
    61.         if (ret)
    62.         {
    63.             printk("copy_to_user err\n");
    64.             return ret;
    65.         }
    66.         break;
    67.  
    68.     case GET_TEM: // 读取湿度
    69.         tem = read_hum_tem(0xE3);
    70.         ret = copy_to_user((void *)arg, &tem, 4);
    71.         if (ret)
    72.         {
    73.             printk("copy_to_user err\n");
    74.             return ret;
    75.         }
    76.         break;
    77.     }
    78.  
    79.     return 0;
    80. }
    81.  
    82. int si7006_close(struct inode *inode, struct file *file)
    83. {
    84.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    85.     return 0;
    86. }
    87.  
    88. // 定义操作方法结构体遍历并且初始化
    89. struct file_operations fops = {
    90.     .open = si7006_open,
    91.     .unlocked_ioctl = si7006_ioctl,
    92.     .release = si7006_close,
    93. };
    94.  
    95. // 给对象分配空间并初始化
    96. int i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
    97. {
    98.     client1 = client;
    99.     int ret;
    100.     // 字符设备驱动注册
    101.     major = register_chrdev(0, "si7006", &fops);
    102.     if (major < 0)
    103.     {
    104.         printk("注册字符设备驱动失败\n");
    105.         ret = major;
    106.         goto out1;
    107.     }
    108.     printk("注册字符设备驱动成功\n");
    109.  
    110.     // 设备节点的创建
    111.     // 向上提交目录
    112.     cls = class_create(THIS_MODULE, "si7006");
    113.     if (IS_ERR(cls))
    114.     {
    115.         printk("向上提交目录失败\n");
    116.         ret = PTR_ERR(cls);
    117.         goto out2;
    118.     }
    119.     printk("向上提交目录成功\n");
    120.  
    121.     // 向上提交设备节点
    122.     dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "si7006");
    123.     if (IS_ERR(dev))
    124.     {
    125.         printk("向上提交设备节点信息失败\n");
    126.         ret = PTR_ERR(dev);
    127.         goto out3;
    128.     }
    129.     printk("向上提交设备节点信息成功\n");
    130.  
    131.     return 0;
    132.  
    133. // 设备信息的获取
    134. out3:
    135.     class_destroy(cls);
    136. out2:
    137.     unregister_chrdev(major, "si7006");
    138. out1:
    139.     return ret;
    140. }
    141. int i2c_remove(struct i2c_client *client)
    142. {
    143.     // 设备节点的销毁
    144.     device_destroy(cls, MKDEV(major, 0));
    145.     // 设备信息的注销
    146.     class_destroy(cls);
    147.     // 字符设备驱动注销
    148.     unregister_chrdev(major, "si7006");
    149.  
    150.     return 0;
    151. }
    152.  
    153. // 设备树匹配构建
    154. struct of_device_id oftable[] = {
    155.     {
    156.         .compatible = "hqyj,si7006",
    157.     },
    158.     {},
    159. };
    160.  
    161. struct i2c_driver i2c_drv = {
    162.     .probe = i2c_probe,
    163.     .remove = i2c_remove,
    164.     .driver = {
    165.         .name = "si7006",
    166.         .of_match_table = oftable,
    167.     },
    168. };
    169.  
    170. module_i2c_driver(i2c_drv);
    171. MODULE_LICENSE("GPL");
    ---m74hc595.c---数码管驱动文件
    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/spi/spi.h>
    4. #include "head.h"
    5. unsigned int major;
    6. struct class *cls;
    7. struct device *dev;
    8. struct spi_device *spi1 = NULL;
    9. char code[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};  //数字
    10. char which[] = {0x8,0x4,0x2,0x1};  //数码管
    11.  
    12. // 封装操作方法
    13. int m74hc595_open(struct inode *inode, struct file *file)
    14. {
    15.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    16.     return 0;
    17. }
    18.  
    19. long m74hc595_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    20. {
    21.     int i,ret;
    22.     unsigned int num;
    23.     char buf[2];  //存储数字和哪一个数码管
    24.  
    25.     ret = copy_from_user(&num,(void *)arg,4);
    26.     if(ret)
    27.     {
    28.         printk("copy_from_user fail\n");
    29.         return -EIO;
    30.     }
    31.  
    32.     if(cmd == GET_TH)
    33.     {
    34.         for(i=0; i<4; i++)
    35.         {
    36.             buf[1] = code[num%10];  //1234
    37.             buf[0] = which[i];
    38.             spi_write(spi1, buf, sizeof(buf));
    39.             num /= 10;
    40.         }
    41.     }
    42.  
    43.     return 0;
    44. }
    45.  
    46. int m74hc595_close(struct inode *inode, struct file *file)
    47. {
    48.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    49.     return 0;
    50. }
    51.  
    52. // 定义操作方法结构体遍历并且初始化
    53. struct file_operations fops = {
    54.     .open = m74hc595_open,
    55.     .unlocked_ioctl = m74hc595_ioctl,
    56.     .release = m74hc595_close,
    57. };
    58.  
    59. int m74hc595_probe(struct spi_device *spi)
    60. {
    61.     spi1 = spi;
    62.     int ret;
    63.     // 字符设备驱动注册
    64.     major = register_chrdev(0, "m74hc595", &fops);
    65.     if (major < 0)
    66.     {
    67.         printk("注册字符设备驱动失败\n");
    68.         ret = major;
    69.         goto out1;
    70.     }
    71.     printk("注册字符设备驱动成功\n");
    72.  
    73.     // 设备节点的创建
    74.     // 向上提交目录
    75.     cls = class_create(THIS_MODULE, "m74hc595");
    76.     if (IS_ERR(cls))
    77.     {
    78.         printk("向上提交目录失败\n");
    79.         ret = PTR_ERR(cls);
    80.         goto out2;
    81.     }
    82.     printk("向上提交目录成功\n");
    83.  
    84.     // 向上提交设备节点
    85.     dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "m74hc595");
    86.     if (IS_ERR(dev))
    87.     {
    88.         printk("向上提交设备节点信息失败\n");
    89.         ret = PTR_ERR(dev);
    90.         goto out3;
    91.     }
    92.     printk("向上提交设备节点信息成功\n");
    93.  
    94.     return 0;
    95. out3:
    96.     class_destroy(cls);
    97. out2:
    98.     unregister_chrdev(major, "m74hc595");
    99. out1:
    100.     return ret;
    101. }
    102. int m74hc595_remove(struct spi_device *spi)
    103. {
    104.     // 设备节点的销毁
    105.     device_destroy(cls, MKDEV(major, 0));
    106.     // 设备信息的注销
    107.     class_destroy(cls);
    108.     // 字符设备驱动注销
    109.     unregister_chrdev(major, "m74hc595");
    110.  
    111.     printk("%s:%d\n", __FILE__, __LINE__);
    112.     return 0;
    113. }
    114.  
    115. // 设备树匹配表
    116. struct of_device_id of_table[] = {
    117.     {.compatible = "hqyj,m74hc595"},
    118.     {},
    119. };
    120. // 定义SPI对象并且初始化
    121. struct spi_driver m74hc595 = {
    122.     .probe = m74hc595_probe,
    123.     .remove = m74hc595_remove,
    124.     .driver = {
    125.         .name = "m74hc595",
    126.         .of_match_table = of_table,
    127.     },
    128. };
    129. // 一键注册宏
    130. module_spi_driver(m74hc595);
    131. MODULE_LICENSE("GPL");
    ---test.c---测试文件
    1. #include "head.h"
    2. #include <stdio.h>
    3. #include <sys/types.h>
    4. #include <sys/stat.h>
    5. #include <fcntl.h>
    6. #include <unistd.h>
    7. #include <stdlib.h>
    8. #include <string.h>
    9. #include <sys/ioctl.h>
    10. #include <arpa/inet.h>
    11. #include <pthread.h>
    12.  
    13. int value = 0;
    14.  
    15. void *temhum_handle(void *arg) // arg = &fd
    16. {
    17.     while (1)
    18.     {
    19.         ioctl(*((int *)arg), GET_TH, &value); // 将温湿度传递给数码管
    20.         //printf("%d\n",*((int *)arg));
    21.     }
    22.     pthread_exit(NULL);
    23. }
    24.  
    25. int main(int argc, const char *argv[])
    26. {
    27.     int tem, hum;
    28.     float tem1, hum1;
    29.     int fd1 = open("/dev/si7006", O_RDWR);
    30.     if (fd1 < 0)
    31.     {
    32.         printf("设备文件打开失败\n");
    33.         exit(-1);
    34.     }
    35.     int fd2 = open("/dev/m74hc595", O_RDWR);
    36.     if (fd2 < 0)
    37.     {
    38.         printf("设备文件打开失败\n");
    39.         exit(-1);
    40.     }
    41.  
    42.     // 采用多线程
    43.     pthread_t tid;
    44.     if (pthread_create(&tid, NULL, temhum_handle, (void *)&fd2) != 0)
    45.     {
    46.         fprintf(stderr, "pthread_create fail__%d__\n", __LINE__);
    47.         return -1;
    48.     }
    49.     pthread_detach(tid);
    50.  
    51.     while (1)
    52.     {
    53.         ioctl(fd1, GET_HUM, &hum);
    54.         ioctl(fd1, GET_TEM, &tem);
    55.         // 大小端转换
    56.         hum = ntohs(hum);
    57.         tem = ntohs(tem);
    58.         // 计算数据
    59.         hum1 = 125.0 * hum / 65536 - 6;
    60.         tem1 = 175.72 * tem / 65536 - 46.85;
    61.  
    62.         printf("tem = %f,hum = %f\n", tem1, hum1);
    63.         value = (int)tem1 * 100 + (int)hum1;
    64.  
    65.         sleep(1);
    66.     }
    67.     pthread_join(tid, NULL);
    68.  
    69.     return 0;
    70. }

    3.测试现象

  • 相关阅读:
    论文和源码解读：T2I-Adapter: Learning Adapters to Dig out More Controllable Ability
    cartographer_optimization_problem_2d
    spring学习笔记-IOC，AOP，事务管理
    MySQL学习6：索引
    Spring Security
    关于mybatis用${}会sql注入的问题
    阿里p8大佬手写web自动化测试框架教程 涵盖框架源码+视频教程以及搭建流程
    13-ROS参数的学习与使用
    关于使用图表控件LightningChart的十大常见问题及解答
    【深入浅出玩转FPGA学习4----漫谈状态机设计】
  • 原文地址：https://blog.csdn.net/weixin_46260677/article/details/133271607